diff --git a/MANIFEST.in b/MANIFEST.in
index 6b2eeb618..6a67273e0 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -3,7 +3,7 @@ include dash_core_components/dash_core_components.dev.js
include dash_core_components/metadata.json
include dash_core_components/rc-slider@6.1.2.css
include dash_core_components/react-select@1.0.0-rc.3.min.css
-include dash_core_components/plotly-1.42.2.min.js
+include dash_core_components/plotly-18863-45646037.js
include dash_core_components/react-virtualized-select@3.1.0.css
include dash_core_components/react-virtualized@9.9.0.css
include dash_core_components/react-dates@12.3.0.css
diff --git a/dash_core_components/__init__.py b/dash_core_components/__init__.py
index 848115c9e..736d0690a 100644
--- a/dash_core_components/__init__.py
+++ b/dash_core_components/__init__.py
@@ -5,8 +5,9 @@
import os as _os
import sys as _sys
import dash as _dash
-
from .version import __version__
+NPM_VERSION = '0.39.0-rc4'
+
# Module imports trigger a dash.development import, need to check this first
if not hasattr(_dash, 'development'):
@@ -35,8 +36,8 @@
_js_dist = [
{
- 'external_url': 'https://cdn.plot.ly/plotly-1.42.2.min.js',
- 'relative_package_path': 'plotly-1.42.2.min.js',
+ 'external_url': 'https://18863-45646037-gh.circle-artifacts.com/0/plotly.min.js',
+ 'relative_package_path': 'plotly-18863-45646037.js',
'namespace': 'dash_core_components'
},
{
@@ -45,7 +46,7 @@
'external_url': (
'https://unpkg.com/dash-core-components@{}'
'/dash_core_components/dash_core_components.min.js'
- ).format(__version__),
+ ).format(NPM_VERSION),
'namespace': 'dash_core_components'
}
]
diff --git a/dash_core_components/dash_core_components.dev.js b/dash_core_components/dash_core_components.dev.js
index 710c83ffd..1ab977514 100644
--- a/dash_core_components/dash_core_components.dev.js
+++ b/dash_core_components/dash_core_components.dev.js
@@ -12463,7 +12463,7 @@ eval("/*! http://mths.be/repeat v0.2.0 by @mathias */\nif (!String.prototype.rep
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
-eval("/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\n\nvar stylesInDom = {};\n\nvar\tmemoize = function (fn) {\n\tvar memo;\n\n\treturn function () {\n\t\tif (typeof memo === \"undefined\") memo = fn.apply(this, arguments);\n\t\treturn memo;\n\t};\n};\n\nvar isOldIE = memoize(function () {\n\t// Test for IE <= 9 as proposed by Browserhacks\n\t// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805\n\t// Tests for existence of standard globals is to allow style-loader\n\t// to operate correctly into non-standard environments\n\t// @see https://github.com/webpack-contrib/style-loader/issues/177\n\treturn window && document && document.all && !window.atob;\n});\n\nvar getTarget = function (target) {\n return document.querySelector(target);\n};\n\nvar getElement = (function (fn) {\n\tvar memo = {};\n\n\treturn function(target) {\n // If passing function in options, then use it for resolve \"head\" element.\n // Useful for Shadow Root style i.e\n // {\n // insertInto: function () { return document.querySelector(\"#foo\").shadowRoot }\n // }\n if (typeof target === 'function') {\n return target();\n }\n if (typeof memo[target] === \"undefined\") {\n\t\t\tvar styleTarget = getTarget.call(this, target);\n\t\t\t// Special case to return head of iframe instead of iframe itself\n\t\t\tif (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n\t\t\t\ttry {\n\t\t\t\t\t// This will throw an exception if access to iframe is blocked\n\t\t\t\t\t// due to cross-origin restrictions\n\t\t\t\t\tstyleTarget = styleTarget.contentDocument.head;\n\t\t\t\t} catch(e) {\n\t\t\t\t\tstyleTarget = null;\n\t\t\t\t}\n\t\t\t}\n\t\t\tmemo[target] = styleTarget;\n\t\t}\n\t\treturn memo[target]\n\t};\n})();\n\nvar singleton = null;\nvar\tsingletonCounter = 0;\nvar\tstylesInsertedAtTop = [];\n\nvar\tfixUrls = __webpack_require__(/*! ./urls */ \"./node_modules/style-loader/lib/urls.js\");\n\nmodule.exports = function(list, options) {\n\tif (typeof DEBUG !== \"undefined\" && DEBUG) {\n\t\tif (typeof document !== \"object\") throw new Error(\"The style-loader cannot be used in a non-browser environment\");\n\t}\n\n\toptions = options || {};\n\n\toptions.attrs = typeof options.attrs === \"object\" ? options.attrs : {};\n\n\t// Force single-tag solution on IE6-9, which has a hard limit on the # of plotly-logomark'
+ }
+};
+
+},{}],3:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/transforms/aggregate');
+
+},{"../src/transforms/aggregate":1155}],4:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/bar');
+
+},{"../src/traces/bar":843}],5:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/barpolar');
+
+},{"../src/traces/barpolar":855}],6:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/box');
+
+},{"../src/traces/box":865}],7:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/components/calendars');
+
+},{"../src/components/calendars":568}],8:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/candlestick');
+
+},{"../src/traces/candlestick":874}],9:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/carpet');
+
+},{"../src/traces/carpet":893}],10:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/choropleth');
+
+},{"../src/traces/choropleth":907}],11:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/cone');
+
+},{"../src/traces/cone":915}],12:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/contour');
+
+},{"../src/traces/contour":930}],13:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/contourcarpet');
+
+},{"../src/traces/contourcarpet":941}],14:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/core');
+
+},{"../src/core":675}],15:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/transforms/filter');
+
+},{"../src/transforms/filter":1156}],16:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/transforms/groupby');
+
+},{"../src/transforms/groupby":1157}],17:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/heatmap');
+
+},{"../src/traces/heatmap":953}],18:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/heatmapgl');
+
+},{"../src/traces/heatmapgl":963}],19:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/histogram');
+
+},{"../src/traces/histogram":974}],20:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/histogram2d');
+
+},{"../src/traces/histogram2d":981}],21:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/histogram2dcontour');
+
+},{"../src/traces/histogram2dcontour":985}],22:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+var Plotly = _dereq_('./core');
+
+// traces
+Plotly.register([
+ _dereq_('./bar'),
+ _dereq_('./box'),
+ _dereq_('./heatmap'),
+ _dereq_('./histogram'),
+ _dereq_('./histogram2d'),
+ _dereq_('./histogram2dcontour'),
+ _dereq_('./pie'),
+ _dereq_('./contour'),
+ _dereq_('./scatterternary'),
+ _dereq_('./violin'),
+
+ _dereq_('./scatter3d'),
+ _dereq_('./surface'),
+ _dereq_('./mesh3d'),
+ _dereq_('./cone'),
+ _dereq_('./streamtube'),
+
+ _dereq_('./scattergeo'),
+ _dereq_('./choropleth'),
+
+ _dereq_('./scattergl'),
+ _dereq_('./splom'),
+
+ _dereq_('./pointcloud'),
+ _dereq_('./heatmapgl'),
+ _dereq_('./parcoords'),
+ _dereq_('./parcats'),
+ _dereq_('./scattermapbox'),
+
+ _dereq_('./sankey'),
+
+ _dereq_('./table'),
+
+ _dereq_('./carpet'),
+ _dereq_('./scattercarpet'),
+ _dereq_('./contourcarpet'),
+
+ _dereq_('./ohlc'),
+ _dereq_('./candlestick'),
+
+ _dereq_('./scatterpolar'),
+ _dereq_('./scatterpolargl'),
+ _dereq_('./barpolar')
+]);
+
+// transforms
+//
+// Please note that all *transform* methods are executed before
+// all *calcTransform* methods - which could possibly lead to
+// unexpected results when applying multiple transforms of different types
+// to a given trace.
+//
+// For more info, see:
+// https://github.com/plotly/plotly.js/pull/978#pullrequestreview-2403353
+//
+Plotly.register([
+ _dereq_('./aggregate'),
+ _dereq_('./filter'),
+ _dereq_('./groupby'),
+ _dereq_('./sort')
+]);
+
+// components
+Plotly.register([
+ _dereq_('./calendars')
+]);
+
+module.exports = Plotly;
+
+},{"./aggregate":3,"./bar":4,"./barpolar":5,"./box":6,"./calendars":7,"./candlestick":8,"./carpet":9,"./choropleth":10,"./cone":11,"./contour":12,"./contourcarpet":13,"./core":14,"./filter":15,"./groupby":16,"./heatmap":17,"./heatmapgl":18,"./histogram":19,"./histogram2d":20,"./histogram2dcontour":21,"./mesh3d":23,"./ohlc":24,"./parcats":25,"./parcoords":26,"./pie":27,"./pointcloud":28,"./sankey":29,"./scatter3d":30,"./scattercarpet":31,"./scattergeo":32,"./scattergl":33,"./scattermapbox":34,"./scatterpolar":35,"./scatterpolargl":36,"./scatterternary":37,"./sort":38,"./splom":39,"./streamtube":40,"./surface":41,"./table":42,"./violin":43}],23:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/mesh3d');
+
+},{"../src/traces/mesh3d":990}],24:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/ohlc');
+
+},{"../src/traces/ohlc":995}],25:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/parcats');
+
+},{"../src/traces/parcats":1004}],26:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/parcoords');
+
+},{"../src/traces/parcoords":1013}],27:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/pie');
+
+},{"../src/traces/pie":1024}],28:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/pointcloud');
+
+},{"../src/traces/pointcloud":1033}],29:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/sankey');
+
+},{"../src/traces/sankey":1039}],30:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scatter3d');
+
+},{"../src/traces/scatter3d":1075}],31:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scattercarpet');
+
+},{"../src/traces/scattercarpet":1081}],32:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scattergeo');
+
+},{"../src/traces/scattergeo":1088}],33:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scattergl');
+
+},{"../src/traces/scattergl":1096}],34:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scattermapbox');
+
+},{"../src/traces/scattermapbox":1102}],35:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scatterpolar');
+
+},{"../src/traces/scatterpolar":1109}],36:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scatterpolargl');
+
+},{"../src/traces/scatterpolargl":1113}],37:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/scatterternary');
+
+},{"../src/traces/scatterternary":1119}],38:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/transforms/sort');
+
+},{"../src/transforms/sort":1159}],39:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/splom');
+
+},{"../src/traces/splom":1124}],40:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/streamtube');
+
+},{"../src/traces/streamtube":1129}],41:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/surface');
+
+},{"../src/traces/surface":1134}],42:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/table');
+
+},{"../src/traces/table":1142}],43:[function(_dereq_,module,exports){
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = _dereq_('../src/traces/violin');
+
+},{"../src/traces/violin":1150}],44:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createCamera
+
+var now = _dereq_('right-now')
+var createView = _dereq_('3d-view')
+var mouseChange = _dereq_('mouse-change')
+var mouseWheel = _dereq_('mouse-wheel')
+var mouseOffset = _dereq_('mouse-event-offset')
+var hasPassive = _dereq_('has-passive-events')
+
+function createCamera(element, options) {
+ element = element || document.body
+ options = options || {}
+
+ var limits = [ 0.01, Infinity ]
+ if('distanceLimits' in options) {
+ limits[0] = options.distanceLimits[0]
+ limits[1] = options.distanceLimits[1]
+ }
+ if('zoomMin' in options) {
+ limits[0] = options.zoomMin
+ }
+ if('zoomMax' in options) {
+ limits[1] = options.zoomMax
+ }
+
+ var view = createView({
+ center: options.center || [0,0,0],
+ up: options.up || [0,1,0],
+ eye: options.eye || [0,0,10],
+ mode: options.mode || 'orbit',
+ distanceLimits: limits
+ })
+
+ var pmatrix = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+ var distance = 0.0
+ var width = element.clientWidth
+ var height = element.clientHeight
+
+ var camera = {
+ view: view,
+ element: element,
+ delay: options.delay || 16,
+ rotateSpeed: options.rotateSpeed || 1,
+ zoomSpeed: options.zoomSpeed || 1,
+ translateSpeed: options.translateSpeed || 1,
+ flipX: !!options.flipX,
+ flipY: !!options.flipY,
+ modes: view.modes,
+ tick: function() {
+ var t = now()
+ var delay = this.delay
+ view.idle(t-delay)
+ view.flush(t-(100+delay*2))
+ var ctime = t - 2 * delay
+ view.recalcMatrix(ctime)
+ var allEqual = true
+ var matrix = view.computedMatrix
+ for(var i=0; i<16; ++i) {
+ allEqual = allEqual && (pmatrix[i] === matrix[i])
+ pmatrix[i] = matrix[i]
+ }
+ var sizeChanged =
+ element.clientWidth === width &&
+ element.clientHeight === height
+ width = element.clientWidth
+ height = element.clientHeight
+ if(allEqual) {
+ return !sizeChanged
+ }
+ distance = Math.exp(view.computedRadius[0])
+ return true
+ },
+ lookAt: function(center, eye, up) {
+ view.lookAt(view.lastT(), center, eye, up)
+ },
+ rotate: function(pitch, yaw, roll) {
+ view.rotate(view.lastT(), pitch, yaw, roll)
+ },
+ pan: function(dx, dy, dz) {
+ view.pan(view.lastT(), dx, dy, dz)
+ },
+ translate: function(dx, dy, dz) {
+ view.translate(view.lastT(), dx, dy, dz)
+ }
+ }
+
+ Object.defineProperties(camera, {
+ matrix: {
+ get: function() {
+ return view.computedMatrix
+ },
+ set: function(mat) {
+ view.setMatrix(view.lastT(), mat)
+ return view.computedMatrix
+ },
+ enumerable: true
+ },
+ mode: {
+ get: function() {
+ return view.getMode()
+ },
+ set: function(mode) {
+ view.setMode(mode)
+ return view.getMode()
+ },
+ enumerable: true
+ },
+ center: {
+ get: function() {
+ return view.computedCenter
+ },
+ set: function(ncenter) {
+ view.lookAt(view.lastT(), ncenter)
+ return view.computedCenter
+ },
+ enumerable: true
+ },
+ eye: {
+ get: function() {
+ return view.computedEye
+ },
+ set: function(neye) {
+ view.lookAt(view.lastT(), null, neye)
+ return view.computedEye
+ },
+ enumerable: true
+ },
+ up: {
+ get: function() {
+ return view.computedUp
+ },
+ set: function(nup) {
+ view.lookAt(view.lastT(), null, null, nup)
+ return view.computedUp
+ },
+ enumerable: true
+ },
+ distance: {
+ get: function() {
+ return distance
+ },
+ set: function(d) {
+ view.setDistance(view.lastT(), d)
+ return d
+ },
+ enumerable: true
+ },
+ distanceLimits: {
+ get: function() {
+ return view.getDistanceLimits(limits)
+ },
+ set: function(v) {
+ view.setDistanceLimits(v)
+ return v
+ },
+ enumerable: true
+ }
+ })
+
+ element.addEventListener('contextmenu', function(ev) {
+ ev.preventDefault()
+ return false
+ })
+
+ var lastX = 0, lastY = 0, lastMods = {shift: false, control: false, alt: false, meta: false}
+ mouseChange(element, handleInteraction)
+
+ //enable simple touch interactions
+ element.addEventListener('touchstart', function (ev) {
+ var xy = mouseOffset(ev.changedTouches[0], element)
+ handleInteraction(0, xy[0], xy[1], lastMods)
+ handleInteraction(1, xy[0], xy[1], lastMods)
+
+ ev.preventDefault()
+ }, hasPassive ? {passive: false} : false)
+
+ element.addEventListener('touchmove', function (ev) {
+ var xy = mouseOffset(ev.changedTouches[0], element)
+ handleInteraction(1, xy[0], xy[1], lastMods)
+
+ ev.preventDefault()
+ }, hasPassive ? {passive: false} : false)
+
+ element.addEventListener('touchend', function (ev) {
+ var xy = mouseOffset(ev.changedTouches[0], element)
+ handleInteraction(0, lastX, lastY, lastMods)
+
+ ev.preventDefault()
+ }, hasPassive ? {passive: false} : false)
+
+ function handleInteraction (buttons, x, y, mods) {
+ var scale = 1.0 / element.clientHeight
+ var dx = scale * (x - lastX)
+ var dy = scale * (y - lastY)
+
+ var flipX = camera.flipX ? 1 : -1
+ var flipY = camera.flipY ? 1 : -1
+
+ var drot = Math.PI * camera.rotateSpeed
+
+ var t = now()
+
+ if(buttons & 1) {
+ if(mods.shift) {
+ view.rotate(t, 0, 0, -dx * drot)
+ } else {
+ view.rotate(t, flipX * drot * dx, -flipY * drot * dy, 0)
+ }
+ } else if(buttons & 2) {
+ view.pan(t, -camera.translateSpeed * dx * distance, camera.translateSpeed * dy * distance, 0)
+ } else if(buttons & 4) {
+ var kzoom = camera.zoomSpeed * dy / window.innerHeight * (t - view.lastT()) * 50.0
+ view.pan(t, 0, 0, distance * (Math.exp(kzoom) - 1))
+ }
+
+ lastX = x
+ lastY = y
+ lastMods = mods
+ }
+
+ mouseWheel(element, function(dx, dy, dz) {
+ var flipX = camera.flipX ? 1 : -1
+ var flipY = camera.flipY ? 1 : -1
+ var t = now()
+ if(Math.abs(dx) > Math.abs(dy)) {
+ view.rotate(t, 0, 0, -dx * flipX * Math.PI * camera.rotateSpeed / window.innerWidth)
+ } else {
+ var kzoom = camera.zoomSpeed * flipY * dy / window.innerHeight * (t - view.lastT()) / 100.0
+ view.pan(t, 0, 0, distance * (Math.exp(kzoom) - 1))
+ }
+ }, true)
+
+ return camera
+}
+
+},{"3d-view":45,"has-passive-events":394,"mouse-change":418,"mouse-event-offset":419,"mouse-wheel":421,"right-now":480}],45:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createViewController
+
+var createTurntable = _dereq_('turntable-camera-controller')
+var createOrbit = _dereq_('orbit-camera-controller')
+var createMatrix = _dereq_('matrix-camera-controller')
+
+function ViewController(controllers, mode) {
+ this._controllerNames = Object.keys(controllers)
+ this._controllerList = this._controllerNames.map(function(n) {
+ return controllers[n]
+ })
+ this._mode = mode
+ this._active = controllers[mode]
+ if(!this._active) {
+ this._mode = 'turntable'
+ this._active = controllers.turntable
+ }
+ this.modes = this._controllerNames
+ this.computedMatrix = this._active.computedMatrix
+ this.computedEye = this._active.computedEye
+ this.computedUp = this._active.computedUp
+ this.computedCenter = this._active.computedCenter
+ this.computedRadius = this._active.computedRadius
+}
+
+var proto = ViewController.prototype
+
+var COMMON_METHODS = [
+ ['flush', 1],
+ ['idle', 1],
+ ['lookAt', 4],
+ ['rotate', 4],
+ ['pan', 4],
+ ['translate', 4],
+ ['setMatrix', 2],
+ ['setDistanceLimits', 2],
+ ['setDistance', 2]
+]
+
+COMMON_METHODS.forEach(function(method) {
+ var name = method[0]
+ var argNames = []
+ for(var i=0; i 0; --iterations) {
+ relaxRightToLeft(alpha *= .99);
+ resolveCollisions();
+ relaxLeftToRight(alpha);
+ resolveCollisions();
+ }
+
+ function initializeNodeDepth() {
+ var L = d3Array.max(nodesByBreadth, function(nodes) {
+ return nodes.length;
+ });
+ var maxNodePadding = maxPaddedSpace * size[1] / (L - 1);
+ if(nodePadding > maxNodePadding) nodePadding = maxNodePadding;
+ var ky = d3Array.min(nodesByBreadth, function(nodes) {
+ return (size[1] - (nodes.length - 1) * nodePadding) / d3Array.sum(nodes, value);
+ });
+
+ nodesByBreadth.forEach(function(nodes) {
+ nodes.forEach(function(node, i) {
+ node.y = i;
+ node.dy = node.value * ky;
+ });
+ });
+
+ links.forEach(function(link) {
+ link.dy = link.value * ky;
+ });
+ }
+
+ function relaxLeftToRight(alpha) {
+ nodesByBreadth.forEach(function(nodes) {
+ nodes.forEach(function(node) {
+ if (node.targetLinks.length) {
+ var y = d3Array.sum(node.targetLinks, weightedSource) / d3Array.sum(node.targetLinks, value);
+ node.y += (y - center(node)) * alpha;
+ }
+ });
+ });
+
+ function weightedSource(link) {
+ return center(link.source) * link.value;
+ }
+ }
+
+ function relaxRightToLeft(alpha) {
+ nodesByBreadth.slice().reverse().forEach(function(nodes) {
+ nodes.forEach(function(node) {
+ if (node.sourceLinks.length) {
+ var y = d3Array.sum(node.sourceLinks, weightedTarget) / d3Array.sum(node.sourceLinks, value);
+ node.y += (y - center(node)) * alpha;
+ }
+ });
+ });
+
+ function weightedTarget(link) {
+ return center(link.target) * link.value;
+ }
+ }
+
+ function resolveCollisions() {
+ nodesByBreadth.forEach(function(nodes) {
+ var node,
+ dy,
+ y0 = 0,
+ n = nodes.length,
+ i;
+
+ // Push any overlapping nodes down.
+ nodes.sort(ascendingDepth);
+ for (i = 0; i < n; ++i) {
+ node = nodes[i];
+ dy = y0 - node.y;
+ if (dy > 0) node.y += dy;
+ y0 = node.y + node.dy + nodePadding;
+ }
+
+ // If the bottommost node goes outside the bounds, push it back up.
+ dy = y0 - nodePadding - size[1];
+ if (dy > 0) {
+ y0 = node.y -= dy;
+
+ // Push any overlapping nodes back up.
+ for (i = n - 2; i >= 0; --i) {
+ node = nodes[i];
+ dy = node.y + node.dy + nodePadding - y0;
+ if (dy > 0) node.y -= dy;
+ y0 = node.y;
+ }
+ }
+ });
+ }
+
+ function ascendingDepth(a, b) {
+ return a.y - b.y;
+ }
+ }
+
+ function computeLinkDepths() {
+ nodes.forEach(function(node) {
+ node.sourceLinks.sort(ascendingTargetDepth);
+ node.targetLinks.sort(ascendingSourceDepth);
+ });
+ nodes.forEach(function(node) {
+ var sy = 0, ty = 0;
+ node.sourceLinks.forEach(function(link) {
+ link.sy = sy;
+ sy += link.dy;
+ });
+ node.targetLinks.forEach(function(link) {
+ link.ty = ty;
+ ty += link.dy;
+ });
+ });
+
+ function ascendingSourceDepth(a, b) {
+ return (a.source.y - b.source.y) || (a.originalIndex - b.originalIndex);
+ }
+
+ function ascendingTargetDepth(a, b) {
+ return (a.target.y - b.target.y) || (a.originalIndex - b.originalIndex);
+ }
+ }
+
+ function center(node) {
+ return node.y + node.dy / 2;
+ }
+
+ function value(link) {
+ return link.value;
+ }
+
+ return sankey;
+};
+
+exports.sankey = sankey;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{"d3-array":140,"d3-collection":141,"d3-interpolate":145}],47:[function(_dereq_,module,exports){
+'use strict'
+
+var weakMap = typeof WeakMap === 'undefined' ? _dereq_('weak-map') : WeakMap
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+
+var TriangleCache = new weakMap()
+
+function createABigTriangle(gl) {
+
+ var triangleVAO = TriangleCache.get(gl)
+ var handle = triangleVAO && (triangleVAO._triangleBuffer.handle || triangleVAO._triangleBuffer.buffer)
+ if(!handle || !gl.isBuffer(handle)) {
+ var buf = createBuffer(gl, new Float32Array([-1, -1, -1, 4, 4, -1]))
+ triangleVAO = createVAO(gl, [
+ { buffer: buf,
+ type: gl.FLOAT,
+ size: 2
+ }
+ ])
+ triangleVAO._triangleBuffer = buf
+ TriangleCache.set(gl, triangleVAO)
+ }
+ triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, 3)
+ triangleVAO.unbind()
+}
+
+module.exports = createABigTriangle
+
+},{"gl-buffer":230,"gl-vao":310,"weak-map":529}],48:[function(_dereq_,module,exports){
+
+module.exports = absolutize
+
+/**
+ * redefine `path` with absolute coordinates
+ *
+ * @param {Array} path
+ * @return {Array}
+ */
+
+function absolutize(path){
+ var startX = 0
+ var startY = 0
+ var x = 0
+ var y = 0
+
+ return path.map(function(seg){
+ seg = seg.slice()
+ var type = seg[0]
+ var command = type.toUpperCase()
+
+ // is relative
+ if (type != command) {
+ seg[0] = command
+ switch (type) {
+ case 'a':
+ seg[6] += x
+ seg[7] += y
+ break
+ case 'v':
+ seg[1] += y
+ break
+ case 'h':
+ seg[1] += x
+ break
+ default:
+ for (var i = 1; i < seg.length;) {
+ seg[i++] += x
+ seg[i++] += y
+ }
+ }
+ }
+
+ // update cursor state
+ switch (command) {
+ case 'Z':
+ x = startX
+ y = startY
+ break
+ case 'H':
+ x = seg[1]
+ break
+ case 'V':
+ y = seg[1]
+ break
+ case 'M':
+ x = startX = seg[1]
+ y = startY = seg[2]
+ break
+ default:
+ x = seg[seg.length - 2]
+ y = seg[seg.length - 1]
+ }
+
+ return seg
+ })
+}
+
+},{}],49:[function(_dereq_,module,exports){
+var padLeft = _dereq_('pad-left')
+
+module.exports = addLineNumbers
+function addLineNumbers (string, start, delim) {
+ start = typeof start === 'number' ? start : 1
+ delim = delim || ': '
+
+ var lines = string.split(/\r?\n/)
+ var totalDigits = String(lines.length + start - 1).length
+ return lines.map(function (line, i) {
+ var c = i + start
+ var digits = String(c).length
+ var prefix = padLeft(c, totalDigits - digits)
+ return prefix + delim + line
+ }).join('\n')
+}
+
+},{"pad-left":440}],50:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = affineHull
+
+var orient = _dereq_('robust-orientation')
+
+function linearlyIndependent(points, d) {
+ var nhull = new Array(d+1)
+ for(var i=0; i max) max = arr[i];
+ if (arr[i] < min) min = arr[i];
+ }
+
+ bounds[offset] = min
+ bounds[dim + offset] = max
+ }
+
+ return bounds;
+}
+
+},{}],54:[function(_dereq_,module,exports){
+'use strict'
+
+var getBounds = _dereq_('array-bounds')
+
+module.exports = normalize;
+
+function normalize (arr, dim, bounds) {
+ if (!arr || arr.length == null) throw Error('Argument should be an array')
+
+ if (dim == null) dim = 1
+ if (bounds == null) bounds = getBounds(arr, dim)
+
+ for (var offset = 0; offset < dim; offset++) {
+ var max = bounds[dim + offset], min = bounds[offset], i = offset, l = arr.length;
+
+ if (max === Infinity && min === -Infinity) {
+ for (i = offset; i < l; i+=dim) {
+ arr[i] = arr[i] === max ? 1 : arr[i] === min ? 0 : .5
+ }
+ }
+ else if (max === Infinity) {
+ for (i = offset; i < l; i+=dim) {
+ arr[i] = arr[i] === max ? 1 : 0
+ }
+ }
+ else if (min === -Infinity) {
+ for (i = offset; i < l; i+=dim) {
+ arr[i] = arr[i] === min ? 0 : 1
+ }
+ }
+ else {
+ var range = max - min
+ for (i = offset; i < l; i+=dim) {
+ arr[i] = range === 0 ? .5 : (arr[i] - min) / range
+ }
+ }
+ }
+
+ return arr;
+}
+
+},{"array-bounds":53}],55:[function(_dereq_,module,exports){
+
+module.exports = function newArray(start, end) {
+ var n0 = typeof start === 'number',
+ n1 = typeof end === 'number'
+
+ if (n0 && !n1) {
+ end = start
+ start = 0
+ } else if (!n0 && !n1) {
+ start = 0
+ end = 0
+ }
+
+ start = start|0
+ end = end|0
+ var len = end-start
+ if (len<0)
+ throw new Error('array length must be positive')
+
+ var a = new Array(len)
+ for (var i=0, c=start; i
+ * @license MIT
+ */
+function compare(a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ var x = a.length;
+ var y = b.length;
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i];
+ y = b[i];
+ break;
+ }
+ }
+
+ if (x < y) {
+ return -1;
+ }
+ if (y < x) {
+ return 1;
+ }
+ return 0;
+}
+function isBuffer(b) {
+ if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
+ return global.Buffer.isBuffer(b);
+ }
+ return !!(b != null && b._isBuffer);
+}
+
+// based on node assert, original notice:
+
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var util = _dereq_('util/');
+var hasOwn = Object.prototype.hasOwnProperty;
+var pSlice = Array.prototype.slice;
+var functionsHaveNames = (function () {
+ return function foo() {}.name === 'foo';
+}());
+function pToString (obj) {
+ return Object.prototype.toString.call(obj);
+}
+function isView(arrbuf) {
+ if (isBuffer(arrbuf)) {
+ return false;
+ }
+ if (typeof global.ArrayBuffer !== 'function') {
+ return false;
+ }
+ if (typeof ArrayBuffer.isView === 'function') {
+ return ArrayBuffer.isView(arrbuf);
+ }
+ if (!arrbuf) {
+ return false;
+ }
+ if (arrbuf instanceof DataView) {
+ return true;
+ }
+ if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
+ return true;
+ }
+ return false;
+}
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = module.exports = ok;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+// actual: actual,
+// expected: expected })
+
+var regex = /\s*function\s+([^\(\s]*)\s*/;
+// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
+function getName(func) {
+ if (!util.isFunction(func)) {
+ return;
+ }
+ if (functionsHaveNames) {
+ return func.name;
+ }
+ var str = func.toString();
+ var match = str.match(regex);
+ return match && match[1];
+}
+assert.AssertionError = function AssertionError(options) {
+ this.name = 'AssertionError';
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+ if (options.message) {
+ this.message = options.message;
+ this.generatedMessage = false;
+ } else {
+ this.message = getMessage(this);
+ this.generatedMessage = true;
+ }
+ var stackStartFunction = options.stackStartFunction || fail;
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, stackStartFunction);
+ } else {
+ // non v8 browsers so we can have a stacktrace
+ var err = new Error();
+ if (err.stack) {
+ var out = err.stack;
+
+ // try to strip useless frames
+ var fn_name = getName(stackStartFunction);
+ var idx = out.indexOf('\n' + fn_name);
+ if (idx >= 0) {
+ // once we have located the function frame
+ // we need to strip out everything before it (and its line)
+ var next_line = out.indexOf('\n', idx + 1);
+ out = out.substring(next_line + 1);
+ }
+
+ this.stack = out;
+ }
+ }
+};
+
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
+
+function truncate(s, n) {
+ if (typeof s === 'string') {
+ return s.length < n ? s : s.slice(0, n);
+ } else {
+ return s;
+ }
+}
+function inspect(something) {
+ if (functionsHaveNames || !util.isFunction(something)) {
+ return util.inspect(something);
+ }
+ var rawname = getName(something);
+ var name = rawname ? ': ' + rawname : '';
+ return '[Function' + name + ']';
+}
+function getMessage(self) {
+ return truncate(inspect(self.actual), 128) + ' ' +
+ self.operator + ' ' +
+ truncate(inspect(self.expected), 128);
+}
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+ throw new assert.AssertionError({
+ message: message,
+ actual: actual,
+ expected: expected,
+ operator: operator,
+ stackStartFunction: stackStartFunction
+ });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, !!guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+function ok(value, message) {
+ if (!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+ if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+ if (actual == expected) {
+ fail(actual, expected, message, '!=', assert.notEqual);
+ }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+ }
+};
+
+assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
+ }
+};
+
+function _deepEqual(actual, expected, strict, memos) {
+ // 7.1. All identical values are equivalent, as determined by ===.
+ if (actual === expected) {
+ return true;
+ } else if (isBuffer(actual) && isBuffer(expected)) {
+ return compare(actual, expected) === 0;
+
+ // 7.2. If the expected value is a Date object, the actual value is
+ // equivalent if it is also a Date object that refers to the same time.
+ } else if (util.isDate(actual) && util.isDate(expected)) {
+ return actual.getTime() === expected.getTime();
+
+ // 7.3 If the expected value is a RegExp object, the actual value is
+ // equivalent if it is also a RegExp object with the same source and
+ // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+ } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+ return actual.source === expected.source &&
+ actual.global === expected.global &&
+ actual.multiline === expected.multiline &&
+ actual.lastIndex === expected.lastIndex &&
+ actual.ignoreCase === expected.ignoreCase;
+
+ // 7.4. Other pairs that do not both pass typeof value == 'object',
+ // equivalence is determined by ==.
+ } else if ((actual === null || typeof actual !== 'object') &&
+ (expected === null || typeof expected !== 'object')) {
+ return strict ? actual === expected : actual == expected;
+
+ // If both values are instances of typed arrays, wrap their underlying
+ // ArrayBuffers in a Buffer each to increase performance
+ // This optimization requires the arrays to have the same type as checked by
+ // Object.prototype.toString (aka pToString). Never perform binary
+ // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
+ // bit patterns are not identical.
+ } else if (isView(actual) && isView(expected) &&
+ pToString(actual) === pToString(expected) &&
+ !(actual instanceof Float32Array ||
+ actual instanceof Float64Array)) {
+ return compare(new Uint8Array(actual.buffer),
+ new Uint8Array(expected.buffer)) === 0;
+
+ // 7.5 For all other Object pairs, including Array objects, equivalence is
+ // determined by having the same number of owned properties (as verified
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
+ // (although not necessarily the same order), equivalent values for every
+ // corresponding key, and an identical 'prototype' property. Note: this
+ // accounts for both named and indexed properties on Arrays.
+ } else if (isBuffer(actual) !== isBuffer(expected)) {
+ return false;
+ } else {
+ memos = memos || {actual: [], expected: []};
+
+ var actualIndex = memos.actual.indexOf(actual);
+ if (actualIndex !== -1) {
+ if (actualIndex === memos.expected.indexOf(expected)) {
+ return true;
+ }
+ }
+
+ memos.actual.push(actual);
+ memos.expected.push(expected);
+
+ return objEquiv(actual, expected, strict, memos);
+ }
+}
+
+function isArguments(object) {
+ return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv(a, b, strict, actualVisitedObjects) {
+ if (a === null || a === undefined || b === null || b === undefined)
+ return false;
+ // if one is a primitive, the other must be same
+ if (util.isPrimitive(a) || util.isPrimitive(b))
+ return a === b;
+ if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+ return false;
+ var aIsArgs = isArguments(a);
+ var bIsArgs = isArguments(b);
+ if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+ return false;
+ if (aIsArgs) {
+ a = pSlice.call(a);
+ b = pSlice.call(b);
+ return _deepEqual(a, b, strict);
+ }
+ var ka = objectKeys(a);
+ var kb = objectKeys(b);
+ var key, i;
+ // having the same number of owned properties (keys incorporates
+ // hasOwnProperty)
+ if (ka.length !== kb.length)
+ return false;
+ //the same set of keys (although not necessarily the same order),
+ ka.sort();
+ kb.sort();
+ //~~~cheap key test
+ for (i = ka.length - 1; i >= 0; i--) {
+ if (ka[i] !== kb[i])
+ return false;
+ }
+ //equivalent values for every corresponding key, and
+ //~~~possibly expensive deep test
+ for (i = ka.length - 1; i >= 0; i--) {
+ key = ka[i];
+ if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
+ return false;
+ }
+ return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
+ }
+};
+
+assert.notDeepStrictEqual = notDeepStrictEqual;
+function notDeepStrictEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
+ }
+}
+
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+ if (actual !== expected) {
+ fail(actual, expected, message, '===', assert.strictEqual);
+ }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+ if (actual === expected) {
+ fail(actual, expected, message, '!==', assert.notStrictEqual);
+ }
+};
+
+function expectedException(actual, expected) {
+ if (!actual || !expected) {
+ return false;
+ }
+
+ if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+ return expected.test(actual);
+ }
+
+ try {
+ if (actual instanceof expected) {
+ return true;
+ }
+ } catch (e) {
+ // Ignore. The instanceof check doesn't work for arrow functions.
+ }
+
+ if (Error.isPrototypeOf(expected)) {
+ return false;
+ }
+
+ return expected.call({}, actual) === true;
+}
+
+function _tryBlock(block) {
+ var error;
+ try {
+ block();
+ } catch (e) {
+ error = e;
+ }
+ return error;
+}
+
+function _throws(shouldThrow, block, expected, message) {
+ var actual;
+
+ if (typeof block !== 'function') {
+ throw new TypeError('"block" argument must be a function');
+ }
+
+ if (typeof expected === 'string') {
+ message = expected;
+ expected = null;
+ }
+
+ actual = _tryBlock(block);
+
+ message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+ (message ? ' ' + message : '.');
+
+ if (shouldThrow && !actual) {
+ fail(actual, expected, 'Missing expected exception' + message);
+ }
+
+ var userProvidedMessage = typeof message === 'string';
+ var isUnwantedException = !shouldThrow && util.isError(actual);
+ var isUnexpectedException = !shouldThrow && actual && !expected;
+
+ if ((isUnwantedException &&
+ userProvidedMessage &&
+ expectedException(actual, expected)) ||
+ isUnexpectedException) {
+ fail(actual, expected, 'Got unwanted exception' + message);
+ }
+
+ if ((shouldThrow && actual && expected &&
+ !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+ throw actual;
+ }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+ _throws(true, block, error, message);
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+ _throws(false, block, error, message);
+};
+
+assert.ifError = function(err) { if (err) throw err; };
+
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ if (hasOwn.call(obj, key)) keys.push(key);
+ }
+ return keys;
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"util/":59}],57:[function(_dereq_,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],58:[function(_dereq_,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],59:[function(_dereq_,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = _dereq_('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = _dereq_('inherits');
+
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,_dereq_('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./support/isBuffer":58,"_process":465,"inherits":57}],60:[function(_dereq_,module,exports){
+module.exports = function _atob(str) {
+ return atob(str)
+}
+
+},{}],61:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = barycentric
+
+var solve = _dereq_('robust-linear-solve')
+
+function reduce(x) {
+ var r = 0
+ for(var i=0; i 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
+
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+}
+
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ for (var i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
+ }
+
+ return arr
+}
+
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
+
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
+
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(
+ uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
+ ))
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
+
+ return parts.join('')
+}
+
+},{}],63:[function(_dereq_,module,exports){
+'use strict'
+
+var rationalize = _dereq_('./lib/rationalize')
+
+module.exports = add
+
+function add(a, b) {
+ return rationalize(
+ a[0].mul(b[1]).add(b[0].mul(a[1])),
+ a[1].mul(b[1]))
+}
+
+},{"./lib/rationalize":73}],64:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = cmp
+
+function cmp(a, b) {
+ return a[0].mul(b[1]).cmp(b[0].mul(a[1]))
+}
+
+},{}],65:[function(_dereq_,module,exports){
+'use strict'
+
+var rationalize = _dereq_('./lib/rationalize')
+
+module.exports = div
+
+function div(a, b) {
+ return rationalize(a[0].mul(b[1]), a[1].mul(b[0]))
+}
+
+},{"./lib/rationalize":73}],66:[function(_dereq_,module,exports){
+'use strict'
+
+var isRat = _dereq_('./is-rat')
+var isBN = _dereq_('./lib/is-bn')
+var num2bn = _dereq_('./lib/num-to-bn')
+var str2bn = _dereq_('./lib/str-to-bn')
+var rationalize = _dereq_('./lib/rationalize')
+var div = _dereq_('./div')
+
+module.exports = makeRational
+
+function makeRational(numer, denom) {
+ if(isRat(numer)) {
+ if(denom) {
+ return div(numer, makeRational(denom))
+ }
+ return [numer[0].clone(), numer[1].clone()]
+ }
+ var shift = 0
+ var a, b
+ if(isBN(numer)) {
+ a = numer.clone()
+ } else if(typeof numer === 'string') {
+ a = str2bn(numer)
+ } else if(numer === 0) {
+ return [num2bn(0), num2bn(1)]
+ } else if(numer === Math.floor(numer)) {
+ a = num2bn(numer)
+ } else {
+ while(numer !== Math.floor(numer)) {
+ numer = numer * Math.pow(2, 256)
+ shift -= 256
+ }
+ a = num2bn(numer)
+ }
+ if(isRat(denom)) {
+ a.mul(denom[1])
+ b = denom[0].clone()
+ } else if(isBN(denom)) {
+ b = denom.clone()
+ } else if(typeof denom === 'string') {
+ b = str2bn(denom)
+ } else if(!denom) {
+ b = num2bn(1)
+ } else if(denom === Math.floor(denom)) {
+ b = num2bn(denom)
+ } else {
+ while(denom !== Math.floor(denom)) {
+ denom = denom * Math.pow(2, 256)
+ shift += 256
+ }
+ b = num2bn(denom)
+ }
+ if(shift > 0) {
+ a = a.ushln(shift)
+ } else if(shift < 0) {
+ b = b.ushln(-shift)
+ }
+ return rationalize(a, b)
+}
+
+},{"./div":65,"./is-rat":67,"./lib/is-bn":71,"./lib/num-to-bn":72,"./lib/rationalize":73,"./lib/str-to-bn":74}],67:[function(_dereq_,module,exports){
+'use strict'
+
+var isBN = _dereq_('./lib/is-bn')
+
+module.exports = isRat
+
+function isRat(x) {
+ return Array.isArray(x) && x.length === 2 && isBN(x[0]) && isBN(x[1])
+}
+
+},{"./lib/is-bn":71}],68:[function(_dereq_,module,exports){
+'use strict'
+
+var BN = _dereq_('bn.js')
+
+module.exports = sign
+
+function sign (x) {
+ return x.cmp(new BN(0))
+}
+
+},{"bn.js":82}],69:[function(_dereq_,module,exports){
+'use strict'
+
+var sign = _dereq_('./bn-sign')
+
+module.exports = bn2num
+
+//TODO: Make this better
+function bn2num(b) {
+ var l = b.length
+ var words = b.words
+ var out = 0
+ if (l === 1) {
+ out = words[0]
+ } else if (l === 2) {
+ out = words[0] + (words[1] * 0x4000000)
+ } else {
+ for (var i = 0; i < l; i++) {
+ var w = words[i]
+ out += w * Math.pow(0x4000000, i)
+ }
+ }
+ return sign(b) * out
+}
+
+},{"./bn-sign":68}],70:[function(_dereq_,module,exports){
+'use strict'
+
+var db = _dereq_('double-bits')
+var ctz = _dereq_('bit-twiddle').countTrailingZeros
+
+module.exports = ctzNumber
+
+//Counts the number of trailing zeros
+function ctzNumber(x) {
+ var l = ctz(db.lo(x))
+ if(l < 32) {
+ return l
+ }
+ var h = ctz(db.hi(x))
+ if(h > 20) {
+ return 52
+ }
+ return h + 32
+}
+
+},{"bit-twiddle":80,"double-bits":152}],71:[function(_dereq_,module,exports){
+'use strict'
+
+var BN = _dereq_('bn.js')
+
+module.exports = isBN
+
+//Test if x is a bignumber
+//FIXME: obviously this is the wrong way to do it
+function isBN(x) {
+ return x && typeof x === 'object' && Boolean(x.words)
+}
+
+},{"bn.js":82}],72:[function(_dereq_,module,exports){
+'use strict'
+
+var BN = _dereq_('bn.js')
+var db = _dereq_('double-bits')
+
+module.exports = num2bn
+
+function num2bn(x) {
+ var e = db.exponent(x)
+ if(e < 52) {
+ return new BN(x)
+ } else {
+ return (new BN(x * Math.pow(2, 52-e))).ushln(e-52)
+ }
+}
+
+},{"bn.js":82,"double-bits":152}],73:[function(_dereq_,module,exports){
+'use strict'
+
+var num2bn = _dereq_('./num-to-bn')
+var sign = _dereq_('./bn-sign')
+
+module.exports = rationalize
+
+function rationalize(numer, denom) {
+ var snumer = sign(numer)
+ var sdenom = sign(denom)
+ if(snumer === 0) {
+ return [num2bn(0), num2bn(1)]
+ }
+ if(sdenom === 0) {
+ return [num2bn(0), num2bn(0)]
+ }
+ if(sdenom < 0) {
+ numer = numer.neg()
+ denom = denom.neg()
+ }
+ var d = numer.gcd(denom)
+ if(d.cmpn(1)) {
+ return [ numer.div(d), denom.div(d) ]
+ }
+ return [ numer, denom ]
+}
+
+},{"./bn-sign":68,"./num-to-bn":72}],74:[function(_dereq_,module,exports){
+'use strict'
+
+var BN = _dereq_('bn.js')
+
+module.exports = str2BN
+
+function str2BN(x) {
+ return new BN(x)
+}
+
+},{"bn.js":82}],75:[function(_dereq_,module,exports){
+'use strict'
+
+var rationalize = _dereq_('./lib/rationalize')
+
+module.exports = mul
+
+function mul(a, b) {
+ return rationalize(a[0].mul(b[0]), a[1].mul(b[1]))
+}
+
+},{"./lib/rationalize":73}],76:[function(_dereq_,module,exports){
+'use strict'
+
+var bnsign = _dereq_('./lib/bn-sign')
+
+module.exports = sign
+
+function sign(x) {
+ return bnsign(x[0]) * bnsign(x[1])
+}
+
+},{"./lib/bn-sign":68}],77:[function(_dereq_,module,exports){
+'use strict'
+
+var rationalize = _dereq_('./lib/rationalize')
+
+module.exports = sub
+
+function sub(a, b) {
+ return rationalize(a[0].mul(b[1]).sub(a[1].mul(b[0])), a[1].mul(b[1]))
+}
+
+},{"./lib/rationalize":73}],78:[function(_dereq_,module,exports){
+'use strict'
+
+var bn2num = _dereq_('./lib/bn-to-num')
+var ctz = _dereq_('./lib/ctz')
+
+module.exports = roundRat
+
+// Round a rational to the closest float
+function roundRat (f) {
+ var a = f[0]
+ var b = f[1]
+ if (a.cmpn(0) === 0) {
+ return 0
+ }
+ var h = a.abs().divmod(b.abs())
+ var iv = h.div
+ var x = bn2num(iv)
+ var ir = h.mod
+ var sgn = (a.negative !== b.negative) ? -1 : 1
+ if (ir.cmpn(0) === 0) {
+ return sgn * x
+ }
+ if (x) {
+ var s = ctz(x) + 4
+ var y = bn2num(ir.ushln(s).divRound(b))
+ return sgn * (x + y * Math.pow(2, -s))
+ } else {
+ var ybits = b.bitLength() - ir.bitLength() + 53
+ var y = bn2num(ir.ushln(ybits).divRound(b))
+ if (ybits < 1023) {
+ return sgn * y * Math.pow(2, -ybits)
+ }
+ y *= Math.pow(2, -1023)
+ return sgn * y * Math.pow(2, 1023 - ybits)
+ }
+}
+
+},{"./lib/bn-to-num":69,"./lib/ctz":70}],79:[function(_dereq_,module,exports){
+"use strict"
+
+function compileSearch(funcName, predicate, reversed, extraArgs, useNdarray, earlyOut) {
+ var code = [
+ "function ", funcName, "(a,l,h,", extraArgs.join(","), "){",
+earlyOut ? "" : "var i=", (reversed ? "l-1" : "h+1"),
+";while(l<=h){\
+var m=(l+h)>>>1,x=a", useNdarray ? ".get(m)" : "[m]"]
+ if(earlyOut) {
+ if(predicate.indexOf("c") < 0) {
+ code.push(";if(x===y){return m}else if(x<=y){")
+ } else {
+ code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){")
+ }
+ } else {
+ code.push(";if(", predicate, "){i=m;")
+ }
+ if(reversed) {
+ code.push("l=m+1}else{h=m-1}")
+ } else {
+ code.push("h=m-1}else{l=m+1}")
+ }
+ code.push("}")
+ if(earlyOut) {
+ code.push("return -1};")
+ } else {
+ code.push("return i};")
+ }
+ return code.join("")
+}
+
+function compileBoundsSearch(predicate, reversed, suffix, earlyOut) {
+ var result = new Function([
+ compileSearch("A", "x" + predicate + "y", reversed, ["y"], false, earlyOut),
+ compileSearch("B", "x" + predicate + "y", reversed, ["y"], true, earlyOut),
+ compileSearch("P", "c(x,y)" + predicate + "0", reversed, ["y", "c"], false, earlyOut),
+ compileSearch("Q", "c(x,y)" + predicate + "0", reversed, ["y", "c"], true, earlyOut),
+"function dispatchBsearch", suffix, "(a,y,c,l,h){\
+if(a.shape){\
+if(typeof(c)==='function'){\
+return Q(a,(l===undefined)?0:l|0,(h===undefined)?a.shape[0]-1:h|0,y,c)\
+}else{\
+return B(a,(c===undefined)?0:c|0,(l===undefined)?a.shape[0]-1:l|0,y)\
+}}else{\
+if(typeof(c)==='function'){\
+return P(a,(l===undefined)?0:l|0,(h===undefined)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===undefined)?0:c|0,(l===undefined)?a.length-1:l|0,y)\
+}}}\
+return dispatchBsearch", suffix].join(""))
+ return result()
+}
+
+module.exports = {
+ ge: compileBoundsSearch(">=", false, "GE"),
+ gt: compileBoundsSearch(">", false, "GT"),
+ lt: compileBoundsSearch("<", true, "LT"),
+ le: compileBoundsSearch("<=", true, "LE"),
+ eq: compileBoundsSearch("-", true, "EQ", true)
+}
+
+},{}],80:[function(_dereq_,module,exports){
+/**
+ * Bit twiddling hacks for JavaScript.
+ *
+ * Author: Mikola Lysenko
+ *
+ * Ported from Stanford bit twiddling hack library:
+ * http://graphics.stanford.edu/~seander/bithacks.html
+ */
+
+"use strict"; "use restrict";
+
+//Number of bits in an integer
+var INT_BITS = 32;
+
+//Constants
+exports.INT_BITS = INT_BITS;
+exports.INT_MAX = 0x7fffffff;
+exports.INT_MIN = -1<<(INT_BITS-1);
+
+//Returns -1, 0, +1 depending on sign of x
+exports.sign = function(v) {
+ return (v > 0) - (v < 0);
+}
+
+//Computes absolute value of integer
+exports.abs = function(v) {
+ var mask = v >> (INT_BITS-1);
+ return (v ^ mask) - mask;
+}
+
+//Computes minimum of integers x and y
+exports.min = function(x, y) {
+ return y ^ ((x ^ y) & -(x < y));
+}
+
+//Computes maximum of integers x and y
+exports.max = function(x, y) {
+ return x ^ ((x ^ y) & -(x < y));
+}
+
+//Checks if a number is a power of two
+exports.isPow2 = function(v) {
+ return !(v & (v-1)) && (!!v);
+}
+
+//Computes log base 2 of v
+exports.log2 = function(v) {
+ var r, shift;
+ r = (v > 0xFFFF) << 4; v >>>= r;
+ shift = (v > 0xFF ) << 3; v >>>= shift; r |= shift;
+ shift = (v > 0xF ) << 2; v >>>= shift; r |= shift;
+ shift = (v > 0x3 ) << 1; v >>>= shift; r |= shift;
+ return r | (v >> 1);
+}
+
+//Computes log base 10 of v
+exports.log10 = function(v) {
+ return (v >= 1000000000) ? 9 : (v >= 100000000) ? 8 : (v >= 10000000) ? 7 :
+ (v >= 1000000) ? 6 : (v >= 100000) ? 5 : (v >= 10000) ? 4 :
+ (v >= 1000) ? 3 : (v >= 100) ? 2 : (v >= 10) ? 1 : 0;
+}
+
+//Counts number of bits
+exports.popCount = function(v) {
+ v = v - ((v >>> 1) & 0x55555555);
+ v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
+ return ((v + (v >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;
+}
+
+//Counts number of trailing zeros
+function countTrailingZeros(v) {
+ var c = 32;
+ v &= -v;
+ if (v) c--;
+ if (v & 0x0000FFFF) c -= 16;
+ if (v & 0x00FF00FF) c -= 8;
+ if (v & 0x0F0F0F0F) c -= 4;
+ if (v & 0x33333333) c -= 2;
+ if (v & 0x55555555) c -= 1;
+ return c;
+}
+exports.countTrailingZeros = countTrailingZeros;
+
+//Rounds to next power of 2
+exports.nextPow2 = function(v) {
+ v += v === 0;
+ --v;
+ v |= v >>> 1;
+ v |= v >>> 2;
+ v |= v >>> 4;
+ v |= v >>> 8;
+ v |= v >>> 16;
+ return v + 1;
+}
+
+//Rounds down to previous power of 2
+exports.prevPow2 = function(v) {
+ v |= v >>> 1;
+ v |= v >>> 2;
+ v |= v >>> 4;
+ v |= v >>> 8;
+ v |= v >>> 16;
+ return v - (v>>>1);
+}
+
+//Computes parity of word
+exports.parity = function(v) {
+ v ^= v >>> 16;
+ v ^= v >>> 8;
+ v ^= v >>> 4;
+ v &= 0xf;
+ return (0x6996 >>> v) & 1;
+}
+
+var REVERSE_TABLE = new Array(256);
+
+(function(tab) {
+ for(var i=0; i<256; ++i) {
+ var v = i, r = i, s = 7;
+ for (v >>>= 1; v; v >>>= 1) {
+ r <<= 1;
+ r |= v & 1;
+ --s;
+ }
+ tab[i] = (r << s) & 0xff;
+ }
+})(REVERSE_TABLE);
+
+//Reverse bits in a 32 bit word
+exports.reverse = function(v) {
+ return (REVERSE_TABLE[ v & 0xff] << 24) |
+ (REVERSE_TABLE[(v >>> 8) & 0xff] << 16) |
+ (REVERSE_TABLE[(v >>> 16) & 0xff] << 8) |
+ REVERSE_TABLE[(v >>> 24) & 0xff];
+}
+
+//Interleave bits of 2 coordinates with 16 bits. Useful for fast quadtree codes
+exports.interleave2 = function(x, y) {
+ x &= 0xFFFF;
+ x = (x | (x << 8)) & 0x00FF00FF;
+ x = (x | (x << 4)) & 0x0F0F0F0F;
+ x = (x | (x << 2)) & 0x33333333;
+ x = (x | (x << 1)) & 0x55555555;
+
+ y &= 0xFFFF;
+ y = (y | (y << 8)) & 0x00FF00FF;
+ y = (y | (y << 4)) & 0x0F0F0F0F;
+ y = (y | (y << 2)) & 0x33333333;
+ y = (y | (y << 1)) & 0x55555555;
+
+ return x | (y << 1);
+}
+
+//Extracts the nth interleaved component
+exports.deinterleave2 = function(v, n) {
+ v = (v >>> n) & 0x55555555;
+ v = (v | (v >>> 1)) & 0x33333333;
+ v = (v | (v >>> 2)) & 0x0F0F0F0F;
+ v = (v | (v >>> 4)) & 0x00FF00FF;
+ v = (v | (v >>> 16)) & 0x000FFFF;
+ return (v << 16) >> 16;
+}
+
+
+//Interleave bits of 3 coordinates, each with 10 bits. Useful for fast octree codes
+exports.interleave3 = function(x, y, z) {
+ x &= 0x3FF;
+ x = (x | (x<<16)) & 4278190335;
+ x = (x | (x<<8)) & 251719695;
+ x = (x | (x<<4)) & 3272356035;
+ x = (x | (x<<2)) & 1227133513;
+
+ y &= 0x3FF;
+ y = (y | (y<<16)) & 4278190335;
+ y = (y | (y<<8)) & 251719695;
+ y = (y | (y<<4)) & 3272356035;
+ y = (y | (y<<2)) & 1227133513;
+ x |= (y << 1);
+
+ z &= 0x3FF;
+ z = (z | (z<<16)) & 4278190335;
+ z = (z | (z<<8)) & 251719695;
+ z = (z | (z<<4)) & 3272356035;
+ z = (z | (z<<2)) & 1227133513;
+
+ return x | (z << 2);
+}
+
+//Extracts nth interleaved component of a 3-tuple
+exports.deinterleave3 = function(v, n) {
+ v = (v >>> n) & 1227133513;
+ v = (v | (v>>>2)) & 3272356035;
+ v = (v | (v>>>4)) & 251719695;
+ v = (v | (v>>>8)) & 4278190335;
+ v = (v | (v>>>16)) & 0x3FF;
+ return (v<<22)>>22;
+}
+
+//Computes next combination in colexicographic order (this is mistakenly called nextPermutation on the bit twiddling hacks page)
+exports.nextCombination = function(v) {
+ var t = v | (v - 1);
+ return (t + 1) | (((~t & -~t) - 1) >>> (countTrailingZeros(v) + 1));
+}
+
+
+},{}],81:[function(_dereq_,module,exports){
+'use strict'
+
+var clamp = _dereq_('clamp')
+
+module.exports = calcSDF
+
+var INF = 1e20;
+
+function calcSDF(src, options) {
+ if (!options) options = {}
+
+ var cutoff = options.cutoff == null ? 0.25 : options.cutoff
+ var radius = options.radius == null ? 8 : options.radius
+ var channel = options.channel || 0
+ var w, h, size, data, intData, stride, ctx, canvas, imgData, i, l
+
+ // handle image container
+ if (ArrayBuffer.isView(src) || Array.isArray(src)) {
+ if (!options.width || !options.height) throw Error('For raw data width and height should be provided by options')
+ w = options.width, h = options.height
+ data = src
+
+ if (!options.stride) stride = Math.floor(src.length / w / h)
+ else stride = options.stride
+ }
+ else {
+ if (window.HTMLCanvasElement && src instanceof window.HTMLCanvasElement) {
+ canvas = src
+ ctx = canvas.getContext('2d')
+ w = canvas.width, h = canvas.height
+ imgData = ctx.getImageData(0, 0, w, h)
+ data = imgData.data
+ stride = 4
+ }
+ else if (window.CanvasRenderingContext2D && src instanceof window.CanvasRenderingContext2D) {
+ canvas = src.canvas
+ ctx = src
+ w = canvas.width, h = canvas.height
+ imgData = ctx.getImageData(0, 0, w, h)
+ data = imgData.data
+ stride = 4
+ }
+ else if (window.ImageData && src instanceof window.ImageData) {
+ imgData = src
+ w = src.width, h = src.height
+ data = imgData.data
+ stride = 4
+ }
+ }
+
+ size = Math.max(w, h)
+
+ //convert int data to floats
+ if ((window.Uint8ClampedArray && data instanceof window.Uint8ClampedArray) || (window.Uint8Array && data instanceof window.Uint8Array)) {
+ intData = data
+ data = Array(w*h)
+
+ for (i = 0, l = intData.length; i < l; i++) {
+ data[i] = intData[i*stride + channel] / 255
+ }
+ }
+ else {
+ if (stride !== 1) throw Error('Raw data can have only 1 value per pixel')
+ }
+
+ // temporary arrays for the distance transform
+ var gridOuter = Array(w * h)
+ var gridInner = Array(w * h)
+ var f = Array(size)
+ var d = Array(size)
+ var z = Array(size + 1)
+ var v = Array(size)
+
+ for (i = 0, l = w * h; i < l; i++) {
+ var a = data[i]
+ gridOuter[i] = a === 1 ? 0 : a === 0 ? INF : Math.pow(Math.max(0, 0.5 - a), 2)
+ gridInner[i] = a === 1 ? INF : a === 0 ? 0 : Math.pow(Math.max(0, a - 0.5), 2)
+ }
+
+ edt(gridOuter, w, h, f, d, v, z)
+ edt(gridInner, w, h, f, d, v, z)
+
+ var dist = window.Float32Array ? new Float32Array(w * h) : new Array(w * h)
+
+ for (i = 0, l = w*h; i < l; i++) {
+ dist[i] = clamp(1 - ( (gridOuter[i] - gridInner[i]) / radius + cutoff), 0, 1)
+ }
+
+ return dist
+}
+
+// 2D Euclidean distance transform by Felzenszwalb & Huttenlocher https://cs.brown.edu/~pff/dt/
+function edt(data, width, height, f, d, v, z) {
+ for (var x = 0; x < width; x++) {
+ for (var y = 0; y < height; y++) {
+ f[y] = data[y * width + x]
+ }
+ edt1d(f, d, v, z, height)
+ for (y = 0; y < height; y++) {
+ data[y * width + x] = d[y]
+ }
+ }
+ for (y = 0; y < height; y++) {
+ for (x = 0; x < width; x++) {
+ f[x] = data[y * width + x]
+ }
+ edt1d(f, d, v, z, width)
+ for (x = 0; x < width; x++) {
+ data[y * width + x] = Math.sqrt(d[x])
+ }
+ }
+}
+
+// 1D squared distance transform
+function edt1d(f, d, v, z, n) {
+ v[0] = 0;
+ z[0] = -INF
+ z[1] = +INF
+
+ for (var q = 1, k = 0; q < n; q++) {
+ var s = ((f[q] + q * q) - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
+ while (s <= z[k]) {
+ k--
+ s = ((f[q] + q * q) - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
+ }
+ k++
+ v[k] = q
+ z[k] = s
+ z[k + 1] = +INF
+ }
+
+ for (q = 0, k = 0; q < n; q++) {
+ while (z[k + 1] < q) k++
+ d[q] = (q - v[k]) * (q - v[k]) + f[v[k]]
+ }
+}
+
+},{"clamp":103}],82:[function(_dereq_,module,exports){
+(function (module, exports) {
+ 'use strict';
+
+ // Utils
+ function assert (val, msg) {
+ if (!val) throw new Error(msg || 'Assertion failed');
+ }
+
+ // Could use `inherits` module, but don't want to move from single file
+ // architecture yet.
+ function inherits (ctor, superCtor) {
+ ctor.super_ = superCtor;
+ var TempCtor = function () {};
+ TempCtor.prototype = superCtor.prototype;
+ ctor.prototype = new TempCtor();
+ ctor.prototype.constructor = ctor;
+ }
+
+ // BN
+
+ function BN (number, base, endian) {
+ if (BN.isBN(number)) {
+ return number;
+ }
+
+ this.negative = 0;
+ this.words = null;
+ this.length = 0;
+
+ // Reduction context
+ this.red = null;
+
+ if (number !== null) {
+ if (base === 'le' || base === 'be') {
+ endian = base;
+ base = 10;
+ }
+
+ this._init(number || 0, base || 10, endian || 'be');
+ }
+ }
+ if (typeof module === 'object') {
+ module.exports = BN;
+ } else {
+ exports.BN = BN;
+ }
+
+ BN.BN = BN;
+ BN.wordSize = 26;
+
+ var Buffer;
+ try {
+ Buffer = _dereq_('buffer').Buffer;
+ } catch (e) {
+ }
+
+ BN.isBN = function isBN (num) {
+ if (num instanceof BN) {
+ return true;
+ }
+
+ return num !== null && typeof num === 'object' &&
+ num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+ };
+
+ BN.max = function max (left, right) {
+ if (left.cmp(right) > 0) return left;
+ return right;
+ };
+
+ BN.min = function min (left, right) {
+ if (left.cmp(right) < 0) return left;
+ return right;
+ };
+
+ BN.prototype._init = function init (number, base, endian) {
+ if (typeof number === 'number') {
+ return this._initNumber(number, base, endian);
+ }
+
+ if (typeof number === 'object') {
+ return this._initArray(number, base, endian);
+ }
+
+ if (base === 'hex') {
+ base = 16;
+ }
+ assert(base === (base | 0) && base >= 2 && base <= 36);
+
+ number = number.toString().replace(/\s+/g, '');
+ var start = 0;
+ if (number[0] === '-') {
+ start++;
+ }
+
+ if (base === 16) {
+ this._parseHex(number, start);
+ } else {
+ this._parseBase(number, base, start);
+ }
+
+ if (number[0] === '-') {
+ this.negative = 1;
+ }
+
+ this.strip();
+
+ if (endian !== 'le') return;
+
+ this._initArray(this.toArray(), base, endian);
+ };
+
+ BN.prototype._initNumber = function _initNumber (number, base, endian) {
+ if (number < 0) {
+ this.negative = 1;
+ number = -number;
+ }
+ if (number < 0x4000000) {
+ this.words = [ number & 0x3ffffff ];
+ this.length = 1;
+ } else if (number < 0x10000000000000) {
+ this.words = [
+ number & 0x3ffffff,
+ (number / 0x4000000) & 0x3ffffff
+ ];
+ this.length = 2;
+ } else {
+ assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
+ this.words = [
+ number & 0x3ffffff,
+ (number / 0x4000000) & 0x3ffffff,
+ 1
+ ];
+ this.length = 3;
+ }
+
+ if (endian !== 'le') return;
+
+ // Reverse the bytes
+ this._initArray(this.toArray(), base, endian);
+ };
+
+ BN.prototype._initArray = function _initArray (number, base, endian) {
+ // Perhaps a Uint8Array
+ assert(typeof number.length === 'number');
+ if (number.length <= 0) {
+ this.words = [ 0 ];
+ this.length = 1;
+ return this;
+ }
+
+ this.length = Math.ceil(number.length / 3);
+ this.words = new Array(this.length);
+ for (var i = 0; i < this.length; i++) {
+ this.words[i] = 0;
+ }
+
+ var j, w;
+ var off = 0;
+ if (endian === 'be') {
+ for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+ w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
+ this.words[j] |= (w << off) & 0x3ffffff;
+ this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+ off += 24;
+ if (off >= 26) {
+ off -= 26;
+ j++;
+ }
+ }
+ } else if (endian === 'le') {
+ for (i = 0, j = 0; i < number.length; i += 3) {
+ w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
+ this.words[j] |= (w << off) & 0x3ffffff;
+ this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
+ off += 24;
+ if (off >= 26) {
+ off -= 26;
+ j++;
+ }
+ }
+ }
+ return this.strip();
+ };
+
+ function parseHex (str, start, end) {
+ var r = 0;
+ var len = Math.min(str.length, end);
+ for (var i = start; i < len; i++) {
+ var c = str.charCodeAt(i) - 48;
+
+ r <<= 4;
+
+ // 'a' - 'f'
+ if (c >= 49 && c <= 54) {
+ r |= c - 49 + 0xa;
+
+ // 'A' - 'F'
+ } else if (c >= 17 && c <= 22) {
+ r |= c - 17 + 0xa;
+
+ // '0' - '9'
+ } else {
+ r |= c & 0xf;
+ }
+ }
+ return r;
+ }
+
+ BN.prototype._parseHex = function _parseHex (number, start) {
+ // Create possibly bigger array to ensure that it fits the number
+ this.length = Math.ceil((number.length - start) / 6);
+ this.words = new Array(this.length);
+ for (var i = 0; i < this.length; i++) {
+ this.words[i] = 0;
+ }
+
+ var j, w;
+ // Scan 24-bit chunks and add them to the number
+ var off = 0;
+ for (i = number.length - 6, j = 0; i >= start; i -= 6) {
+ w = parseHex(number, i, i + 6);
+ this.words[j] |= (w << off) & 0x3ffffff;
+ // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
+ this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+ off += 24;
+ if (off >= 26) {
+ off -= 26;
+ j++;
+ }
+ }
+ if (i + 6 !== start) {
+ w = parseHex(number, start, i + 6);
+ this.words[j] |= (w << off) & 0x3ffffff;
+ this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
+ }
+ this.strip();
+ };
+
+ function parseBase (str, start, end, mul) {
+ var r = 0;
+ var len = Math.min(str.length, end);
+ for (var i = start; i < len; i++) {
+ var c = str.charCodeAt(i) - 48;
+
+ r *= mul;
+
+ // 'a'
+ if (c >= 49) {
+ r += c - 49 + 0xa;
+
+ // 'A'
+ } else if (c >= 17) {
+ r += c - 17 + 0xa;
+
+ // '0' - '9'
+ } else {
+ r += c;
+ }
+ }
+ return r;
+ }
+
+ BN.prototype._parseBase = function _parseBase (number, base, start) {
+ // Initialize as zero
+ this.words = [ 0 ];
+ this.length = 1;
+
+ // Find length of limb in base
+ for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
+ limbLen++;
+ }
+ limbLen--;
+ limbPow = (limbPow / base) | 0;
+
+ var total = number.length - start;
+ var mod = total % limbLen;
+ var end = Math.min(total, total - mod) + start;
+
+ var word = 0;
+ for (var i = start; i < end; i += limbLen) {
+ word = parseBase(number, i, i + limbLen, base);
+
+ this.imuln(limbPow);
+ if (this.words[0] + word < 0x4000000) {
+ this.words[0] += word;
+ } else {
+ this._iaddn(word);
+ }
+ }
+
+ if (mod !== 0) {
+ var pow = 1;
+ word = parseBase(number, i, number.length, base);
+
+ for (i = 0; i < mod; i++) {
+ pow *= base;
+ }
+
+ this.imuln(pow);
+ if (this.words[0] + word < 0x4000000) {
+ this.words[0] += word;
+ } else {
+ this._iaddn(word);
+ }
+ }
+ };
+
+ BN.prototype.copy = function copy (dest) {
+ dest.words = new Array(this.length);
+ for (var i = 0; i < this.length; i++) {
+ dest.words[i] = this.words[i];
+ }
+ dest.length = this.length;
+ dest.negative = this.negative;
+ dest.red = this.red;
+ };
+
+ BN.prototype.clone = function clone () {
+ var r = new BN(null);
+ this.copy(r);
+ return r;
+ };
+
+ BN.prototype._expand = function _expand (size) {
+ while (this.length < size) {
+ this.words[this.length++] = 0;
+ }
+ return this;
+ };
+
+ // Remove leading `0` from `this`
+ BN.prototype.strip = function strip () {
+ while (this.length > 1 && this.words[this.length - 1] === 0) {
+ this.length--;
+ }
+ return this._normSign();
+ };
+
+ BN.prototype._normSign = function _normSign () {
+ // -0 = 0
+ if (this.length === 1 && this.words[0] === 0) {
+ this.negative = 0;
+ }
+ return this;
+ };
+
+ BN.prototype.inspect = function inspect () {
+ return (this.red ? '';
+ };
+
+ /*
+
+ var zeros = [];
+ var groupSizes = [];
+ var groupBases = [];
+
+ var s = '';
+ var i = -1;
+ while (++i < BN.wordSize) {
+ zeros[i] = s;
+ s += '0';
+ }
+ groupSizes[0] = 0;
+ groupSizes[1] = 0;
+ groupBases[0] = 0;
+ groupBases[1] = 0;
+ var base = 2 - 1;
+ while (++base < 36 + 1) {
+ var groupSize = 0;
+ var groupBase = 1;
+ while (groupBase < (1 << BN.wordSize) / base) {
+ groupBase *= base;
+ groupSize += 1;
+ }
+ groupSizes[base] = groupSize;
+ groupBases[base] = groupBase;
+ }
+
+ */
+
+ var zeros = [
+ '',
+ '0',
+ '00',
+ '000',
+ '0000',
+ '00000',
+ '000000',
+ '0000000',
+ '00000000',
+ '000000000',
+ '0000000000',
+ '00000000000',
+ '000000000000',
+ '0000000000000',
+ '00000000000000',
+ '000000000000000',
+ '0000000000000000',
+ '00000000000000000',
+ '000000000000000000',
+ '0000000000000000000',
+ '00000000000000000000',
+ '000000000000000000000',
+ '0000000000000000000000',
+ '00000000000000000000000',
+ '000000000000000000000000',
+ '0000000000000000000000000'
+ ];
+
+ var groupSizes = [
+ 0, 0,
+ 25, 16, 12, 11, 10, 9, 8,
+ 8, 7, 7, 7, 7, 6, 6,
+ 6, 6, 6, 6, 6, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5
+ ];
+
+ var groupBases = [
+ 0, 0,
+ 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
+ 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
+ 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
+ 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
+ 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
+ ];
+
+ BN.prototype.toString = function toString (base, padding) {
+ base = base || 10;
+ padding = padding | 0 || 1;
+
+ var out;
+ if (base === 16 || base === 'hex') {
+ out = '';
+ var off = 0;
+ var carry = 0;
+ for (var i = 0; i < this.length; i++) {
+ var w = this.words[i];
+ var word = (((w << off) | carry) & 0xffffff).toString(16);
+ carry = (w >>> (24 - off)) & 0xffffff;
+ if (carry !== 0 || i !== this.length - 1) {
+ out = zeros[6 - word.length] + word + out;
+ } else {
+ out = word + out;
+ }
+ off += 2;
+ if (off >= 26) {
+ off -= 26;
+ i--;
+ }
+ }
+ if (carry !== 0) {
+ out = carry.toString(16) + out;
+ }
+ while (out.length % padding !== 0) {
+ out = '0' + out;
+ }
+ if (this.negative !== 0) {
+ out = '-' + out;
+ }
+ return out;
+ }
+
+ if (base === (base | 0) && base >= 2 && base <= 36) {
+ // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
+ var groupSize = groupSizes[base];
+ // var groupBase = Math.pow(base, groupSize);
+ var groupBase = groupBases[base];
+ out = '';
+ var c = this.clone();
+ c.negative = 0;
+ while (!c.isZero()) {
+ var r = c.modn(groupBase).toString(base);
+ c = c.idivn(groupBase);
+
+ if (!c.isZero()) {
+ out = zeros[groupSize - r.length] + r + out;
+ } else {
+ out = r + out;
+ }
+ }
+ if (this.isZero()) {
+ out = '0' + out;
+ }
+ while (out.length % padding !== 0) {
+ out = '0' + out;
+ }
+ if (this.negative !== 0) {
+ out = '-' + out;
+ }
+ return out;
+ }
+
+ assert(false, 'Base should be between 2 and 36');
+ };
+
+ BN.prototype.toNumber = function toNumber () {
+ var ret = this.words[0];
+ if (this.length === 2) {
+ ret += this.words[1] * 0x4000000;
+ } else if (this.length === 3 && this.words[2] === 0x01) {
+ // NOTE: at this stage it is known that the top bit is set
+ ret += 0x10000000000000 + (this.words[1] * 0x4000000);
+ } else if (this.length > 2) {
+ assert(false, 'Number can only safely store up to 53 bits');
+ }
+ return (this.negative !== 0) ? -ret : ret;
+ };
+
+ BN.prototype.toJSON = function toJSON () {
+ return this.toString(16);
+ };
+
+ BN.prototype.toBuffer = function toBuffer (endian, length) {
+ assert(typeof Buffer !== 'undefined');
+ return this.toArrayLike(Buffer, endian, length);
+ };
+
+ BN.prototype.toArray = function toArray (endian, length) {
+ return this.toArrayLike(Array, endian, length);
+ };
+
+ BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
+ var byteLength = this.byteLength();
+ var reqLength = length || Math.max(1, byteLength);
+ assert(byteLength <= reqLength, 'byte array longer than desired length');
+ assert(reqLength > 0, 'Requested array length <= 0');
+
+ this.strip();
+ var littleEndian = endian === 'le';
+ var res = new ArrayType(reqLength);
+
+ var b, i;
+ var q = this.clone();
+ if (!littleEndian) {
+ // Assume big-endian
+ for (i = 0; i < reqLength - byteLength; i++) {
+ res[i] = 0;
+ }
+
+ for (i = 0; !q.isZero(); i++) {
+ b = q.andln(0xff);
+ q.iushrn(8);
+
+ res[reqLength - i - 1] = b;
+ }
+ } else {
+ for (i = 0; !q.isZero(); i++) {
+ b = q.andln(0xff);
+ q.iushrn(8);
+
+ res[i] = b;
+ }
+
+ for (; i < reqLength; i++) {
+ res[i] = 0;
+ }
+ }
+
+ return res;
+ };
+
+ if (Math.clz32) {
+ BN.prototype._countBits = function _countBits (w) {
+ return 32 - Math.clz32(w);
+ };
+ } else {
+ BN.prototype._countBits = function _countBits (w) {
+ var t = w;
+ var r = 0;
+ if (t >= 0x1000) {
+ r += 13;
+ t >>>= 13;
+ }
+ if (t >= 0x40) {
+ r += 7;
+ t >>>= 7;
+ }
+ if (t >= 0x8) {
+ r += 4;
+ t >>>= 4;
+ }
+ if (t >= 0x02) {
+ r += 2;
+ t >>>= 2;
+ }
+ return r + t;
+ };
+ }
+
+ BN.prototype._zeroBits = function _zeroBits (w) {
+ // Short-cut
+ if (w === 0) return 26;
+
+ var t = w;
+ var r = 0;
+ if ((t & 0x1fff) === 0) {
+ r += 13;
+ t >>>= 13;
+ }
+ if ((t & 0x7f) === 0) {
+ r += 7;
+ t >>>= 7;
+ }
+ if ((t & 0xf) === 0) {
+ r += 4;
+ t >>>= 4;
+ }
+ if ((t & 0x3) === 0) {
+ r += 2;
+ t >>>= 2;
+ }
+ if ((t & 0x1) === 0) {
+ r++;
+ }
+ return r;
+ };
+
+ // Return number of used bits in a BN
+ BN.prototype.bitLength = function bitLength () {
+ var w = this.words[this.length - 1];
+ var hi = this._countBits(w);
+ return (this.length - 1) * 26 + hi;
+ };
+
+ function toBitArray (num) {
+ var w = new Array(num.bitLength());
+
+ for (var bit = 0; bit < w.length; bit++) {
+ var off = (bit / 26) | 0;
+ var wbit = bit % 26;
+
+ w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
+ }
+
+ return w;
+ }
+
+ // Number of trailing zero bits
+ BN.prototype.zeroBits = function zeroBits () {
+ if (this.isZero()) return 0;
+
+ var r = 0;
+ for (var i = 0; i < this.length; i++) {
+ var b = this._zeroBits(this.words[i]);
+ r += b;
+ if (b !== 26) break;
+ }
+ return r;
+ };
+
+ BN.prototype.byteLength = function byteLength () {
+ return Math.ceil(this.bitLength() / 8);
+ };
+
+ BN.prototype.toTwos = function toTwos (width) {
+ if (this.negative !== 0) {
+ return this.abs().inotn(width).iaddn(1);
+ }
+ return this.clone();
+ };
+
+ BN.prototype.fromTwos = function fromTwos (width) {
+ if (this.testn(width - 1)) {
+ return this.notn(width).iaddn(1).ineg();
+ }
+ return this.clone();
+ };
+
+ BN.prototype.isNeg = function isNeg () {
+ return this.negative !== 0;
+ };
+
+ // Return negative clone of `this`
+ BN.prototype.neg = function neg () {
+ return this.clone().ineg();
+ };
+
+ BN.prototype.ineg = function ineg () {
+ if (!this.isZero()) {
+ this.negative ^= 1;
+ }
+
+ return this;
+ };
+
+ // Or `num` with `this` in-place
+ BN.prototype.iuor = function iuor (num) {
+ while (this.length < num.length) {
+ this.words[this.length++] = 0;
+ }
+
+ for (var i = 0; i < num.length; i++) {
+ this.words[i] = this.words[i] | num.words[i];
+ }
+
+ return this.strip();
+ };
+
+ BN.prototype.ior = function ior (num) {
+ assert((this.negative | num.negative) === 0);
+ return this.iuor(num);
+ };
+
+ // Or `num` with `this`
+ BN.prototype.or = function or (num) {
+ if (this.length > num.length) return this.clone().ior(num);
+ return num.clone().ior(this);
+ };
+
+ BN.prototype.uor = function uor (num) {
+ if (this.length > num.length) return this.clone().iuor(num);
+ return num.clone().iuor(this);
+ };
+
+ // And `num` with `this` in-place
+ BN.prototype.iuand = function iuand (num) {
+ // b = min-length(num, this)
+ var b;
+ if (this.length > num.length) {
+ b = num;
+ } else {
+ b = this;
+ }
+
+ for (var i = 0; i < b.length; i++) {
+ this.words[i] = this.words[i] & num.words[i];
+ }
+
+ this.length = b.length;
+
+ return this.strip();
+ };
+
+ BN.prototype.iand = function iand (num) {
+ assert((this.negative | num.negative) === 0);
+ return this.iuand(num);
+ };
+
+ // And `num` with `this`
+ BN.prototype.and = function and (num) {
+ if (this.length > num.length) return this.clone().iand(num);
+ return num.clone().iand(this);
+ };
+
+ BN.prototype.uand = function uand (num) {
+ if (this.length > num.length) return this.clone().iuand(num);
+ return num.clone().iuand(this);
+ };
+
+ // Xor `num` with `this` in-place
+ BN.prototype.iuxor = function iuxor (num) {
+ // a.length > b.length
+ var a;
+ var b;
+ if (this.length > num.length) {
+ a = this;
+ b = num;
+ } else {
+ a = num;
+ b = this;
+ }
+
+ for (var i = 0; i < b.length; i++) {
+ this.words[i] = a.words[i] ^ b.words[i];
+ }
+
+ if (this !== a) {
+ for (; i < a.length; i++) {
+ this.words[i] = a.words[i];
+ }
+ }
+
+ this.length = a.length;
+
+ return this.strip();
+ };
+
+ BN.prototype.ixor = function ixor (num) {
+ assert((this.negative | num.negative) === 0);
+ return this.iuxor(num);
+ };
+
+ // Xor `num` with `this`
+ BN.prototype.xor = function xor (num) {
+ if (this.length > num.length) return this.clone().ixor(num);
+ return num.clone().ixor(this);
+ };
+
+ BN.prototype.uxor = function uxor (num) {
+ if (this.length > num.length) return this.clone().iuxor(num);
+ return num.clone().iuxor(this);
+ };
+
+ // Not ``this`` with ``width`` bitwidth
+ BN.prototype.inotn = function inotn (width) {
+ assert(typeof width === 'number' && width >= 0);
+
+ var bytesNeeded = Math.ceil(width / 26) | 0;
+ var bitsLeft = width % 26;
+
+ // Extend the buffer with leading zeroes
+ this._expand(bytesNeeded);
+
+ if (bitsLeft > 0) {
+ bytesNeeded--;
+ }
+
+ // Handle complete words
+ for (var i = 0; i < bytesNeeded; i++) {
+ this.words[i] = ~this.words[i] & 0x3ffffff;
+ }
+
+ // Handle the residue
+ if (bitsLeft > 0) {
+ this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
+ }
+
+ // And remove leading zeroes
+ return this.strip();
+ };
+
+ BN.prototype.notn = function notn (width) {
+ return this.clone().inotn(width);
+ };
+
+ // Set `bit` of `this`
+ BN.prototype.setn = function setn (bit, val) {
+ assert(typeof bit === 'number' && bit >= 0);
+
+ var off = (bit / 26) | 0;
+ var wbit = bit % 26;
+
+ this._expand(off + 1);
+
+ if (val) {
+ this.words[off] = this.words[off] | (1 << wbit);
+ } else {
+ this.words[off] = this.words[off] & ~(1 << wbit);
+ }
+
+ return this.strip();
+ };
+
+ // Add `num` to `this` in-place
+ BN.prototype.iadd = function iadd (num) {
+ var r;
+
+ // negative + positive
+ if (this.negative !== 0 && num.negative === 0) {
+ this.negative = 0;
+ r = this.isub(num);
+ this.negative ^= 1;
+ return this._normSign();
+
+ // positive + negative
+ } else if (this.negative === 0 && num.negative !== 0) {
+ num.negative = 0;
+ r = this.isub(num);
+ num.negative = 1;
+ return r._normSign();
+ }
+
+ // a.length > b.length
+ var a, b;
+ if (this.length > num.length) {
+ a = this;
+ b = num;
+ } else {
+ a = num;
+ b = this;
+ }
+
+ var carry = 0;
+ for (var i = 0; i < b.length; i++) {
+ r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+ this.words[i] = r & 0x3ffffff;
+ carry = r >>> 26;
+ }
+ for (; carry !== 0 && i < a.length; i++) {
+ r = (a.words[i] | 0) + carry;
+ this.words[i] = r & 0x3ffffff;
+ carry = r >>> 26;
+ }
+
+ this.length = a.length;
+ if (carry !== 0) {
+ this.words[this.length] = carry;
+ this.length++;
+ // Copy the rest of the words
+ } else if (a !== this) {
+ for (; i < a.length; i++) {
+ this.words[i] = a.words[i];
+ }
+ }
+
+ return this;
+ };
+
+ // Add `num` to `this`
+ BN.prototype.add = function add (num) {
+ var res;
+ if (num.negative !== 0 && this.negative === 0) {
+ num.negative = 0;
+ res = this.sub(num);
+ num.negative ^= 1;
+ return res;
+ } else if (num.negative === 0 && this.negative !== 0) {
+ this.negative = 0;
+ res = num.sub(this);
+ this.negative = 1;
+ return res;
+ }
+
+ if (this.length > num.length) return this.clone().iadd(num);
+
+ return num.clone().iadd(this);
+ };
+
+ // Subtract `num` from `this` in-place
+ BN.prototype.isub = function isub (num) {
+ // this - (-num) = this + num
+ if (num.negative !== 0) {
+ num.negative = 0;
+ var r = this.iadd(num);
+ num.negative = 1;
+ return r._normSign();
+
+ // -this - num = -(this + num)
+ } else if (this.negative !== 0) {
+ this.negative = 0;
+ this.iadd(num);
+ this.negative = 1;
+ return this._normSign();
+ }
+
+ // At this point both numbers are positive
+ var cmp = this.cmp(num);
+
+ // Optimization - zeroify
+ if (cmp === 0) {
+ this.negative = 0;
+ this.length = 1;
+ this.words[0] = 0;
+ return this;
+ }
+
+ // a > b
+ var a, b;
+ if (cmp > 0) {
+ a = this;
+ b = num;
+ } else {
+ a = num;
+ b = this;
+ }
+
+ var carry = 0;
+ for (var i = 0; i < b.length; i++) {
+ r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+ carry = r >> 26;
+ this.words[i] = r & 0x3ffffff;
+ }
+ for (; carry !== 0 && i < a.length; i++) {
+ r = (a.words[i] | 0) + carry;
+ carry = r >> 26;
+ this.words[i] = r & 0x3ffffff;
+ }
+
+ // Copy rest of the words
+ if (carry === 0 && i < a.length && a !== this) {
+ for (; i < a.length; i++) {
+ this.words[i] = a.words[i];
+ }
+ }
+
+ this.length = Math.max(this.length, i);
+
+ if (a !== this) {
+ this.negative = 1;
+ }
+
+ return this.strip();
+ };
+
+ // Subtract `num` from `this`
+ BN.prototype.sub = function sub (num) {
+ return this.clone().isub(num);
+ };
+
+ function smallMulTo (self, num, out) {
+ out.negative = num.negative ^ self.negative;
+ var len = (self.length + num.length) | 0;
+ out.length = len;
+ len = (len - 1) | 0;
+
+ // Peel one iteration (compiler can't do it, because of code complexity)
+ var a = self.words[0] | 0;
+ var b = num.words[0] | 0;
+ var r = a * b;
+
+ var lo = r & 0x3ffffff;
+ var carry = (r / 0x4000000) | 0;
+ out.words[0] = lo;
+
+ for (var k = 1; k < len; k++) {
+ // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+ // note that ncarry could be >= 0x3ffffff
+ var ncarry = carry >>> 26;
+ var rword = carry & 0x3ffffff;
+ var maxJ = Math.min(k, num.length - 1);
+ for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+ var i = (k - j) | 0;
+ a = self.words[i] | 0;
+ b = num.words[j] | 0;
+ r = a * b + rword;
+ ncarry += (r / 0x4000000) | 0;
+ rword = r & 0x3ffffff;
+ }
+ out.words[k] = rword | 0;
+ carry = ncarry | 0;
+ }
+ if (carry !== 0) {
+ out.words[k] = carry | 0;
+ } else {
+ out.length--;
+ }
+
+ return out.strip();
+ }
+
+ // TODO(indutny): it may be reasonable to omit it for users who don't need
+ // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
+ // multiplication (like elliptic secp256k1).
+ var comb10MulTo = function comb10MulTo (self, num, out) {
+ var a = self.words;
+ var b = num.words;
+ var o = out.words;
+ var c = 0;
+ var lo;
+ var mid;
+ var hi;
+ var a0 = a[0] | 0;
+ var al0 = a0 & 0x1fff;
+ var ah0 = a0 >>> 13;
+ var a1 = a[1] | 0;
+ var al1 = a1 & 0x1fff;
+ var ah1 = a1 >>> 13;
+ var a2 = a[2] | 0;
+ var al2 = a2 & 0x1fff;
+ var ah2 = a2 >>> 13;
+ var a3 = a[3] | 0;
+ var al3 = a3 & 0x1fff;
+ var ah3 = a3 >>> 13;
+ var a4 = a[4] | 0;
+ var al4 = a4 & 0x1fff;
+ var ah4 = a4 >>> 13;
+ var a5 = a[5] | 0;
+ var al5 = a5 & 0x1fff;
+ var ah5 = a5 >>> 13;
+ var a6 = a[6] | 0;
+ var al6 = a6 & 0x1fff;
+ var ah6 = a6 >>> 13;
+ var a7 = a[7] | 0;
+ var al7 = a7 & 0x1fff;
+ var ah7 = a7 >>> 13;
+ var a8 = a[8] | 0;
+ var al8 = a8 & 0x1fff;
+ var ah8 = a8 >>> 13;
+ var a9 = a[9] | 0;
+ var al9 = a9 & 0x1fff;
+ var ah9 = a9 >>> 13;
+ var b0 = b[0] | 0;
+ var bl0 = b0 & 0x1fff;
+ var bh0 = b0 >>> 13;
+ var b1 = b[1] | 0;
+ var bl1 = b1 & 0x1fff;
+ var bh1 = b1 >>> 13;
+ var b2 = b[2] | 0;
+ var bl2 = b2 & 0x1fff;
+ var bh2 = b2 >>> 13;
+ var b3 = b[3] | 0;
+ var bl3 = b3 & 0x1fff;
+ var bh3 = b3 >>> 13;
+ var b4 = b[4] | 0;
+ var bl4 = b4 & 0x1fff;
+ var bh4 = b4 >>> 13;
+ var b5 = b[5] | 0;
+ var bl5 = b5 & 0x1fff;
+ var bh5 = b5 >>> 13;
+ var b6 = b[6] | 0;
+ var bl6 = b6 & 0x1fff;
+ var bh6 = b6 >>> 13;
+ var b7 = b[7] | 0;
+ var bl7 = b7 & 0x1fff;
+ var bh7 = b7 >>> 13;
+ var b8 = b[8] | 0;
+ var bl8 = b8 & 0x1fff;
+ var bh8 = b8 >>> 13;
+ var b9 = b[9] | 0;
+ var bl9 = b9 & 0x1fff;
+ var bh9 = b9 >>> 13;
+
+ out.negative = self.negative ^ num.negative;
+ out.length = 19;
+ /* k = 0 */
+ lo = Math.imul(al0, bl0);
+ mid = Math.imul(al0, bh0);
+ mid = (mid + Math.imul(ah0, bl0)) | 0;
+ hi = Math.imul(ah0, bh0);
+ var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
+ w0 &= 0x3ffffff;
+ /* k = 1 */
+ lo = Math.imul(al1, bl0);
+ mid = Math.imul(al1, bh0);
+ mid = (mid + Math.imul(ah1, bl0)) | 0;
+ hi = Math.imul(ah1, bh0);
+ lo = (lo + Math.imul(al0, bl1)) | 0;
+ mid = (mid + Math.imul(al0, bh1)) | 0;
+ mid = (mid + Math.imul(ah0, bl1)) | 0;
+ hi = (hi + Math.imul(ah0, bh1)) | 0;
+ var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
+ w1 &= 0x3ffffff;
+ /* k = 2 */
+ lo = Math.imul(al2, bl0);
+ mid = Math.imul(al2, bh0);
+ mid = (mid + Math.imul(ah2, bl0)) | 0;
+ hi = Math.imul(ah2, bh0);
+ lo = (lo + Math.imul(al1, bl1)) | 0;
+ mid = (mid + Math.imul(al1, bh1)) | 0;
+ mid = (mid + Math.imul(ah1, bl1)) | 0;
+ hi = (hi + Math.imul(ah1, bh1)) | 0;
+ lo = (lo + Math.imul(al0, bl2)) | 0;
+ mid = (mid + Math.imul(al0, bh2)) | 0;
+ mid = (mid + Math.imul(ah0, bl2)) | 0;
+ hi = (hi + Math.imul(ah0, bh2)) | 0;
+ var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
+ w2 &= 0x3ffffff;
+ /* k = 3 */
+ lo = Math.imul(al3, bl0);
+ mid = Math.imul(al3, bh0);
+ mid = (mid + Math.imul(ah3, bl0)) | 0;
+ hi = Math.imul(ah3, bh0);
+ lo = (lo + Math.imul(al2, bl1)) | 0;
+ mid = (mid + Math.imul(al2, bh1)) | 0;
+ mid = (mid + Math.imul(ah2, bl1)) | 0;
+ hi = (hi + Math.imul(ah2, bh1)) | 0;
+ lo = (lo + Math.imul(al1, bl2)) | 0;
+ mid = (mid + Math.imul(al1, bh2)) | 0;
+ mid = (mid + Math.imul(ah1, bl2)) | 0;
+ hi = (hi + Math.imul(ah1, bh2)) | 0;
+ lo = (lo + Math.imul(al0, bl3)) | 0;
+ mid = (mid + Math.imul(al0, bh3)) | 0;
+ mid = (mid + Math.imul(ah0, bl3)) | 0;
+ hi = (hi + Math.imul(ah0, bh3)) | 0;
+ var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
+ w3 &= 0x3ffffff;
+ /* k = 4 */
+ lo = Math.imul(al4, bl0);
+ mid = Math.imul(al4, bh0);
+ mid = (mid + Math.imul(ah4, bl0)) | 0;
+ hi = Math.imul(ah4, bh0);
+ lo = (lo + Math.imul(al3, bl1)) | 0;
+ mid = (mid + Math.imul(al3, bh1)) | 0;
+ mid = (mid + Math.imul(ah3, bl1)) | 0;
+ hi = (hi + Math.imul(ah3, bh1)) | 0;
+ lo = (lo + Math.imul(al2, bl2)) | 0;
+ mid = (mid + Math.imul(al2, bh2)) | 0;
+ mid = (mid + Math.imul(ah2, bl2)) | 0;
+ hi = (hi + Math.imul(ah2, bh2)) | 0;
+ lo = (lo + Math.imul(al1, bl3)) | 0;
+ mid = (mid + Math.imul(al1, bh3)) | 0;
+ mid = (mid + Math.imul(ah1, bl3)) | 0;
+ hi = (hi + Math.imul(ah1, bh3)) | 0;
+ lo = (lo + Math.imul(al0, bl4)) | 0;
+ mid = (mid + Math.imul(al0, bh4)) | 0;
+ mid = (mid + Math.imul(ah0, bl4)) | 0;
+ hi = (hi + Math.imul(ah0, bh4)) | 0;
+ var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
+ w4 &= 0x3ffffff;
+ /* k = 5 */
+ lo = Math.imul(al5, bl0);
+ mid = Math.imul(al5, bh0);
+ mid = (mid + Math.imul(ah5, bl0)) | 0;
+ hi = Math.imul(ah5, bh0);
+ lo = (lo + Math.imul(al4, bl1)) | 0;
+ mid = (mid + Math.imul(al4, bh1)) | 0;
+ mid = (mid + Math.imul(ah4, bl1)) | 0;
+ hi = (hi + Math.imul(ah4, bh1)) | 0;
+ lo = (lo + Math.imul(al3, bl2)) | 0;
+ mid = (mid + Math.imul(al3, bh2)) | 0;
+ mid = (mid + Math.imul(ah3, bl2)) | 0;
+ hi = (hi + Math.imul(ah3, bh2)) | 0;
+ lo = (lo + Math.imul(al2, bl3)) | 0;
+ mid = (mid + Math.imul(al2, bh3)) | 0;
+ mid = (mid + Math.imul(ah2, bl3)) | 0;
+ hi = (hi + Math.imul(ah2, bh3)) | 0;
+ lo = (lo + Math.imul(al1, bl4)) | 0;
+ mid = (mid + Math.imul(al1, bh4)) | 0;
+ mid = (mid + Math.imul(ah1, bl4)) | 0;
+ hi = (hi + Math.imul(ah1, bh4)) | 0;
+ lo = (lo + Math.imul(al0, bl5)) | 0;
+ mid = (mid + Math.imul(al0, bh5)) | 0;
+ mid = (mid + Math.imul(ah0, bl5)) | 0;
+ hi = (hi + Math.imul(ah0, bh5)) | 0;
+ var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
+ w5 &= 0x3ffffff;
+ /* k = 6 */
+ lo = Math.imul(al6, bl0);
+ mid = Math.imul(al6, bh0);
+ mid = (mid + Math.imul(ah6, bl0)) | 0;
+ hi = Math.imul(ah6, bh0);
+ lo = (lo + Math.imul(al5, bl1)) | 0;
+ mid = (mid + Math.imul(al5, bh1)) | 0;
+ mid = (mid + Math.imul(ah5, bl1)) | 0;
+ hi = (hi + Math.imul(ah5, bh1)) | 0;
+ lo = (lo + Math.imul(al4, bl2)) | 0;
+ mid = (mid + Math.imul(al4, bh2)) | 0;
+ mid = (mid + Math.imul(ah4, bl2)) | 0;
+ hi = (hi + Math.imul(ah4, bh2)) | 0;
+ lo = (lo + Math.imul(al3, bl3)) | 0;
+ mid = (mid + Math.imul(al3, bh3)) | 0;
+ mid = (mid + Math.imul(ah3, bl3)) | 0;
+ hi = (hi + Math.imul(ah3, bh3)) | 0;
+ lo = (lo + Math.imul(al2, bl4)) | 0;
+ mid = (mid + Math.imul(al2, bh4)) | 0;
+ mid = (mid + Math.imul(ah2, bl4)) | 0;
+ hi = (hi + Math.imul(ah2, bh4)) | 0;
+ lo = (lo + Math.imul(al1, bl5)) | 0;
+ mid = (mid + Math.imul(al1, bh5)) | 0;
+ mid = (mid + Math.imul(ah1, bl5)) | 0;
+ hi = (hi + Math.imul(ah1, bh5)) | 0;
+ lo = (lo + Math.imul(al0, bl6)) | 0;
+ mid = (mid + Math.imul(al0, bh6)) | 0;
+ mid = (mid + Math.imul(ah0, bl6)) | 0;
+ hi = (hi + Math.imul(ah0, bh6)) | 0;
+ var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
+ w6 &= 0x3ffffff;
+ /* k = 7 */
+ lo = Math.imul(al7, bl0);
+ mid = Math.imul(al7, bh0);
+ mid = (mid + Math.imul(ah7, bl0)) | 0;
+ hi = Math.imul(ah7, bh0);
+ lo = (lo + Math.imul(al6, bl1)) | 0;
+ mid = (mid + Math.imul(al6, bh1)) | 0;
+ mid = (mid + Math.imul(ah6, bl1)) | 0;
+ hi = (hi + Math.imul(ah6, bh1)) | 0;
+ lo = (lo + Math.imul(al5, bl2)) | 0;
+ mid = (mid + Math.imul(al5, bh2)) | 0;
+ mid = (mid + Math.imul(ah5, bl2)) | 0;
+ hi = (hi + Math.imul(ah5, bh2)) | 0;
+ lo = (lo + Math.imul(al4, bl3)) | 0;
+ mid = (mid + Math.imul(al4, bh3)) | 0;
+ mid = (mid + Math.imul(ah4, bl3)) | 0;
+ hi = (hi + Math.imul(ah4, bh3)) | 0;
+ lo = (lo + Math.imul(al3, bl4)) | 0;
+ mid = (mid + Math.imul(al3, bh4)) | 0;
+ mid = (mid + Math.imul(ah3, bl4)) | 0;
+ hi = (hi + Math.imul(ah3, bh4)) | 0;
+ lo = (lo + Math.imul(al2, bl5)) | 0;
+ mid = (mid + Math.imul(al2, bh5)) | 0;
+ mid = (mid + Math.imul(ah2, bl5)) | 0;
+ hi = (hi + Math.imul(ah2, bh5)) | 0;
+ lo = (lo + Math.imul(al1, bl6)) | 0;
+ mid = (mid + Math.imul(al1, bh6)) | 0;
+ mid = (mid + Math.imul(ah1, bl6)) | 0;
+ hi = (hi + Math.imul(ah1, bh6)) | 0;
+ lo = (lo + Math.imul(al0, bl7)) | 0;
+ mid = (mid + Math.imul(al0, bh7)) | 0;
+ mid = (mid + Math.imul(ah0, bl7)) | 0;
+ hi = (hi + Math.imul(ah0, bh7)) | 0;
+ var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
+ w7 &= 0x3ffffff;
+ /* k = 8 */
+ lo = Math.imul(al8, bl0);
+ mid = Math.imul(al8, bh0);
+ mid = (mid + Math.imul(ah8, bl0)) | 0;
+ hi = Math.imul(ah8, bh0);
+ lo = (lo + Math.imul(al7, bl1)) | 0;
+ mid = (mid + Math.imul(al7, bh1)) | 0;
+ mid = (mid + Math.imul(ah7, bl1)) | 0;
+ hi = (hi + Math.imul(ah7, bh1)) | 0;
+ lo = (lo + Math.imul(al6, bl2)) | 0;
+ mid = (mid + Math.imul(al6, bh2)) | 0;
+ mid = (mid + Math.imul(ah6, bl2)) | 0;
+ hi = (hi + Math.imul(ah6, bh2)) | 0;
+ lo = (lo + Math.imul(al5, bl3)) | 0;
+ mid = (mid + Math.imul(al5, bh3)) | 0;
+ mid = (mid + Math.imul(ah5, bl3)) | 0;
+ hi = (hi + Math.imul(ah5, bh3)) | 0;
+ lo = (lo + Math.imul(al4, bl4)) | 0;
+ mid = (mid + Math.imul(al4, bh4)) | 0;
+ mid = (mid + Math.imul(ah4, bl4)) | 0;
+ hi = (hi + Math.imul(ah4, bh4)) | 0;
+ lo = (lo + Math.imul(al3, bl5)) | 0;
+ mid = (mid + Math.imul(al3, bh5)) | 0;
+ mid = (mid + Math.imul(ah3, bl5)) | 0;
+ hi = (hi + Math.imul(ah3, bh5)) | 0;
+ lo = (lo + Math.imul(al2, bl6)) | 0;
+ mid = (mid + Math.imul(al2, bh6)) | 0;
+ mid = (mid + Math.imul(ah2, bl6)) | 0;
+ hi = (hi + Math.imul(ah2, bh6)) | 0;
+ lo = (lo + Math.imul(al1, bl7)) | 0;
+ mid = (mid + Math.imul(al1, bh7)) | 0;
+ mid = (mid + Math.imul(ah1, bl7)) | 0;
+ hi = (hi + Math.imul(ah1, bh7)) | 0;
+ lo = (lo + Math.imul(al0, bl8)) | 0;
+ mid = (mid + Math.imul(al0, bh8)) | 0;
+ mid = (mid + Math.imul(ah0, bl8)) | 0;
+ hi = (hi + Math.imul(ah0, bh8)) | 0;
+ var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
+ w8 &= 0x3ffffff;
+ /* k = 9 */
+ lo = Math.imul(al9, bl0);
+ mid = Math.imul(al9, bh0);
+ mid = (mid + Math.imul(ah9, bl0)) | 0;
+ hi = Math.imul(ah9, bh0);
+ lo = (lo + Math.imul(al8, bl1)) | 0;
+ mid = (mid + Math.imul(al8, bh1)) | 0;
+ mid = (mid + Math.imul(ah8, bl1)) | 0;
+ hi = (hi + Math.imul(ah8, bh1)) | 0;
+ lo = (lo + Math.imul(al7, bl2)) | 0;
+ mid = (mid + Math.imul(al7, bh2)) | 0;
+ mid = (mid + Math.imul(ah7, bl2)) | 0;
+ hi = (hi + Math.imul(ah7, bh2)) | 0;
+ lo = (lo + Math.imul(al6, bl3)) | 0;
+ mid = (mid + Math.imul(al6, bh3)) | 0;
+ mid = (mid + Math.imul(ah6, bl3)) | 0;
+ hi = (hi + Math.imul(ah6, bh3)) | 0;
+ lo = (lo + Math.imul(al5, bl4)) | 0;
+ mid = (mid + Math.imul(al5, bh4)) | 0;
+ mid = (mid + Math.imul(ah5, bl4)) | 0;
+ hi = (hi + Math.imul(ah5, bh4)) | 0;
+ lo = (lo + Math.imul(al4, bl5)) | 0;
+ mid = (mid + Math.imul(al4, bh5)) | 0;
+ mid = (mid + Math.imul(ah4, bl5)) | 0;
+ hi = (hi + Math.imul(ah4, bh5)) | 0;
+ lo = (lo + Math.imul(al3, bl6)) | 0;
+ mid = (mid + Math.imul(al3, bh6)) | 0;
+ mid = (mid + Math.imul(ah3, bl6)) | 0;
+ hi = (hi + Math.imul(ah3, bh6)) | 0;
+ lo = (lo + Math.imul(al2, bl7)) | 0;
+ mid = (mid + Math.imul(al2, bh7)) | 0;
+ mid = (mid + Math.imul(ah2, bl7)) | 0;
+ hi = (hi + Math.imul(ah2, bh7)) | 0;
+ lo = (lo + Math.imul(al1, bl8)) | 0;
+ mid = (mid + Math.imul(al1, bh8)) | 0;
+ mid = (mid + Math.imul(ah1, bl8)) | 0;
+ hi = (hi + Math.imul(ah1, bh8)) | 0;
+ lo = (lo + Math.imul(al0, bl9)) | 0;
+ mid = (mid + Math.imul(al0, bh9)) | 0;
+ mid = (mid + Math.imul(ah0, bl9)) | 0;
+ hi = (hi + Math.imul(ah0, bh9)) | 0;
+ var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
+ w9 &= 0x3ffffff;
+ /* k = 10 */
+ lo = Math.imul(al9, bl1);
+ mid = Math.imul(al9, bh1);
+ mid = (mid + Math.imul(ah9, bl1)) | 0;
+ hi = Math.imul(ah9, bh1);
+ lo = (lo + Math.imul(al8, bl2)) | 0;
+ mid = (mid + Math.imul(al8, bh2)) | 0;
+ mid = (mid + Math.imul(ah8, bl2)) | 0;
+ hi = (hi + Math.imul(ah8, bh2)) | 0;
+ lo = (lo + Math.imul(al7, bl3)) | 0;
+ mid = (mid + Math.imul(al7, bh3)) | 0;
+ mid = (mid + Math.imul(ah7, bl3)) | 0;
+ hi = (hi + Math.imul(ah7, bh3)) | 0;
+ lo = (lo + Math.imul(al6, bl4)) | 0;
+ mid = (mid + Math.imul(al6, bh4)) | 0;
+ mid = (mid + Math.imul(ah6, bl4)) | 0;
+ hi = (hi + Math.imul(ah6, bh4)) | 0;
+ lo = (lo + Math.imul(al5, bl5)) | 0;
+ mid = (mid + Math.imul(al5, bh5)) | 0;
+ mid = (mid + Math.imul(ah5, bl5)) | 0;
+ hi = (hi + Math.imul(ah5, bh5)) | 0;
+ lo = (lo + Math.imul(al4, bl6)) | 0;
+ mid = (mid + Math.imul(al4, bh6)) | 0;
+ mid = (mid + Math.imul(ah4, bl6)) | 0;
+ hi = (hi + Math.imul(ah4, bh6)) | 0;
+ lo = (lo + Math.imul(al3, bl7)) | 0;
+ mid = (mid + Math.imul(al3, bh7)) | 0;
+ mid = (mid + Math.imul(ah3, bl7)) | 0;
+ hi = (hi + Math.imul(ah3, bh7)) | 0;
+ lo = (lo + Math.imul(al2, bl8)) | 0;
+ mid = (mid + Math.imul(al2, bh8)) | 0;
+ mid = (mid + Math.imul(ah2, bl8)) | 0;
+ hi = (hi + Math.imul(ah2, bh8)) | 0;
+ lo = (lo + Math.imul(al1, bl9)) | 0;
+ mid = (mid + Math.imul(al1, bh9)) | 0;
+ mid = (mid + Math.imul(ah1, bl9)) | 0;
+ hi = (hi + Math.imul(ah1, bh9)) | 0;
+ var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
+ w10 &= 0x3ffffff;
+ /* k = 11 */
+ lo = Math.imul(al9, bl2);
+ mid = Math.imul(al9, bh2);
+ mid = (mid + Math.imul(ah9, bl2)) | 0;
+ hi = Math.imul(ah9, bh2);
+ lo = (lo + Math.imul(al8, bl3)) | 0;
+ mid = (mid + Math.imul(al8, bh3)) | 0;
+ mid = (mid + Math.imul(ah8, bl3)) | 0;
+ hi = (hi + Math.imul(ah8, bh3)) | 0;
+ lo = (lo + Math.imul(al7, bl4)) | 0;
+ mid = (mid + Math.imul(al7, bh4)) | 0;
+ mid = (mid + Math.imul(ah7, bl4)) | 0;
+ hi = (hi + Math.imul(ah7, bh4)) | 0;
+ lo = (lo + Math.imul(al6, bl5)) | 0;
+ mid = (mid + Math.imul(al6, bh5)) | 0;
+ mid = (mid + Math.imul(ah6, bl5)) | 0;
+ hi = (hi + Math.imul(ah6, bh5)) | 0;
+ lo = (lo + Math.imul(al5, bl6)) | 0;
+ mid = (mid + Math.imul(al5, bh6)) | 0;
+ mid = (mid + Math.imul(ah5, bl6)) | 0;
+ hi = (hi + Math.imul(ah5, bh6)) | 0;
+ lo = (lo + Math.imul(al4, bl7)) | 0;
+ mid = (mid + Math.imul(al4, bh7)) | 0;
+ mid = (mid + Math.imul(ah4, bl7)) | 0;
+ hi = (hi + Math.imul(ah4, bh7)) | 0;
+ lo = (lo + Math.imul(al3, bl8)) | 0;
+ mid = (mid + Math.imul(al3, bh8)) | 0;
+ mid = (mid + Math.imul(ah3, bl8)) | 0;
+ hi = (hi + Math.imul(ah3, bh8)) | 0;
+ lo = (lo + Math.imul(al2, bl9)) | 0;
+ mid = (mid + Math.imul(al2, bh9)) | 0;
+ mid = (mid + Math.imul(ah2, bl9)) | 0;
+ hi = (hi + Math.imul(ah2, bh9)) | 0;
+ var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
+ w11 &= 0x3ffffff;
+ /* k = 12 */
+ lo = Math.imul(al9, bl3);
+ mid = Math.imul(al9, bh3);
+ mid = (mid + Math.imul(ah9, bl3)) | 0;
+ hi = Math.imul(ah9, bh3);
+ lo = (lo + Math.imul(al8, bl4)) | 0;
+ mid = (mid + Math.imul(al8, bh4)) | 0;
+ mid = (mid + Math.imul(ah8, bl4)) | 0;
+ hi = (hi + Math.imul(ah8, bh4)) | 0;
+ lo = (lo + Math.imul(al7, bl5)) | 0;
+ mid = (mid + Math.imul(al7, bh5)) | 0;
+ mid = (mid + Math.imul(ah7, bl5)) | 0;
+ hi = (hi + Math.imul(ah7, bh5)) | 0;
+ lo = (lo + Math.imul(al6, bl6)) | 0;
+ mid = (mid + Math.imul(al6, bh6)) | 0;
+ mid = (mid + Math.imul(ah6, bl6)) | 0;
+ hi = (hi + Math.imul(ah6, bh6)) | 0;
+ lo = (lo + Math.imul(al5, bl7)) | 0;
+ mid = (mid + Math.imul(al5, bh7)) | 0;
+ mid = (mid + Math.imul(ah5, bl7)) | 0;
+ hi = (hi + Math.imul(ah5, bh7)) | 0;
+ lo = (lo + Math.imul(al4, bl8)) | 0;
+ mid = (mid + Math.imul(al4, bh8)) | 0;
+ mid = (mid + Math.imul(ah4, bl8)) | 0;
+ hi = (hi + Math.imul(ah4, bh8)) | 0;
+ lo = (lo + Math.imul(al3, bl9)) | 0;
+ mid = (mid + Math.imul(al3, bh9)) | 0;
+ mid = (mid + Math.imul(ah3, bl9)) | 0;
+ hi = (hi + Math.imul(ah3, bh9)) | 0;
+ var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
+ w12 &= 0x3ffffff;
+ /* k = 13 */
+ lo = Math.imul(al9, bl4);
+ mid = Math.imul(al9, bh4);
+ mid = (mid + Math.imul(ah9, bl4)) | 0;
+ hi = Math.imul(ah9, bh4);
+ lo = (lo + Math.imul(al8, bl5)) | 0;
+ mid = (mid + Math.imul(al8, bh5)) | 0;
+ mid = (mid + Math.imul(ah8, bl5)) | 0;
+ hi = (hi + Math.imul(ah8, bh5)) | 0;
+ lo = (lo + Math.imul(al7, bl6)) | 0;
+ mid = (mid + Math.imul(al7, bh6)) | 0;
+ mid = (mid + Math.imul(ah7, bl6)) | 0;
+ hi = (hi + Math.imul(ah7, bh6)) | 0;
+ lo = (lo + Math.imul(al6, bl7)) | 0;
+ mid = (mid + Math.imul(al6, bh7)) | 0;
+ mid = (mid + Math.imul(ah6, bl7)) | 0;
+ hi = (hi + Math.imul(ah6, bh7)) | 0;
+ lo = (lo + Math.imul(al5, bl8)) | 0;
+ mid = (mid + Math.imul(al5, bh8)) | 0;
+ mid = (mid + Math.imul(ah5, bl8)) | 0;
+ hi = (hi + Math.imul(ah5, bh8)) | 0;
+ lo = (lo + Math.imul(al4, bl9)) | 0;
+ mid = (mid + Math.imul(al4, bh9)) | 0;
+ mid = (mid + Math.imul(ah4, bl9)) | 0;
+ hi = (hi + Math.imul(ah4, bh9)) | 0;
+ var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
+ w13 &= 0x3ffffff;
+ /* k = 14 */
+ lo = Math.imul(al9, bl5);
+ mid = Math.imul(al9, bh5);
+ mid = (mid + Math.imul(ah9, bl5)) | 0;
+ hi = Math.imul(ah9, bh5);
+ lo = (lo + Math.imul(al8, bl6)) | 0;
+ mid = (mid + Math.imul(al8, bh6)) | 0;
+ mid = (mid + Math.imul(ah8, bl6)) | 0;
+ hi = (hi + Math.imul(ah8, bh6)) | 0;
+ lo = (lo + Math.imul(al7, bl7)) | 0;
+ mid = (mid + Math.imul(al7, bh7)) | 0;
+ mid = (mid + Math.imul(ah7, bl7)) | 0;
+ hi = (hi + Math.imul(ah7, bh7)) | 0;
+ lo = (lo + Math.imul(al6, bl8)) | 0;
+ mid = (mid + Math.imul(al6, bh8)) | 0;
+ mid = (mid + Math.imul(ah6, bl8)) | 0;
+ hi = (hi + Math.imul(ah6, bh8)) | 0;
+ lo = (lo + Math.imul(al5, bl9)) | 0;
+ mid = (mid + Math.imul(al5, bh9)) | 0;
+ mid = (mid + Math.imul(ah5, bl9)) | 0;
+ hi = (hi + Math.imul(ah5, bh9)) | 0;
+ var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
+ w14 &= 0x3ffffff;
+ /* k = 15 */
+ lo = Math.imul(al9, bl6);
+ mid = Math.imul(al9, bh6);
+ mid = (mid + Math.imul(ah9, bl6)) | 0;
+ hi = Math.imul(ah9, bh6);
+ lo = (lo + Math.imul(al8, bl7)) | 0;
+ mid = (mid + Math.imul(al8, bh7)) | 0;
+ mid = (mid + Math.imul(ah8, bl7)) | 0;
+ hi = (hi + Math.imul(ah8, bh7)) | 0;
+ lo = (lo + Math.imul(al7, bl8)) | 0;
+ mid = (mid + Math.imul(al7, bh8)) | 0;
+ mid = (mid + Math.imul(ah7, bl8)) | 0;
+ hi = (hi + Math.imul(ah7, bh8)) | 0;
+ lo = (lo + Math.imul(al6, bl9)) | 0;
+ mid = (mid + Math.imul(al6, bh9)) | 0;
+ mid = (mid + Math.imul(ah6, bl9)) | 0;
+ hi = (hi + Math.imul(ah6, bh9)) | 0;
+ var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
+ w15 &= 0x3ffffff;
+ /* k = 16 */
+ lo = Math.imul(al9, bl7);
+ mid = Math.imul(al9, bh7);
+ mid = (mid + Math.imul(ah9, bl7)) | 0;
+ hi = Math.imul(ah9, bh7);
+ lo = (lo + Math.imul(al8, bl8)) | 0;
+ mid = (mid + Math.imul(al8, bh8)) | 0;
+ mid = (mid + Math.imul(ah8, bl8)) | 0;
+ hi = (hi + Math.imul(ah8, bh8)) | 0;
+ lo = (lo + Math.imul(al7, bl9)) | 0;
+ mid = (mid + Math.imul(al7, bh9)) | 0;
+ mid = (mid + Math.imul(ah7, bl9)) | 0;
+ hi = (hi + Math.imul(ah7, bh9)) | 0;
+ var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
+ w16 &= 0x3ffffff;
+ /* k = 17 */
+ lo = Math.imul(al9, bl8);
+ mid = Math.imul(al9, bh8);
+ mid = (mid + Math.imul(ah9, bl8)) | 0;
+ hi = Math.imul(ah9, bh8);
+ lo = (lo + Math.imul(al8, bl9)) | 0;
+ mid = (mid + Math.imul(al8, bh9)) | 0;
+ mid = (mid + Math.imul(ah8, bl9)) | 0;
+ hi = (hi + Math.imul(ah8, bh9)) | 0;
+ var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
+ w17 &= 0x3ffffff;
+ /* k = 18 */
+ lo = Math.imul(al9, bl9);
+ mid = Math.imul(al9, bh9);
+ mid = (mid + Math.imul(ah9, bl9)) | 0;
+ hi = Math.imul(ah9, bh9);
+ var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
+ c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
+ w18 &= 0x3ffffff;
+ o[0] = w0;
+ o[1] = w1;
+ o[2] = w2;
+ o[3] = w3;
+ o[4] = w4;
+ o[5] = w5;
+ o[6] = w6;
+ o[7] = w7;
+ o[8] = w8;
+ o[9] = w9;
+ o[10] = w10;
+ o[11] = w11;
+ o[12] = w12;
+ o[13] = w13;
+ o[14] = w14;
+ o[15] = w15;
+ o[16] = w16;
+ o[17] = w17;
+ o[18] = w18;
+ if (c !== 0) {
+ o[19] = c;
+ out.length++;
+ }
+ return out;
+ };
+
+ // Polyfill comb
+ if (!Math.imul) {
+ comb10MulTo = smallMulTo;
+ }
+
+ function bigMulTo (self, num, out) {
+ out.negative = num.negative ^ self.negative;
+ out.length = self.length + num.length;
+
+ var carry = 0;
+ var hncarry = 0;
+ for (var k = 0; k < out.length - 1; k++) {
+ // Sum all words with the same `i + j = k` and accumulate `ncarry`,
+ // note that ncarry could be >= 0x3ffffff
+ var ncarry = hncarry;
+ hncarry = 0;
+ var rword = carry & 0x3ffffff;
+ var maxJ = Math.min(k, num.length - 1);
+ for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+ var i = k - j;
+ var a = self.words[i] | 0;
+ var b = num.words[j] | 0;
+ var r = a * b;
+
+ var lo = r & 0x3ffffff;
+ ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
+ lo = (lo + rword) | 0;
+ rword = lo & 0x3ffffff;
+ ncarry = (ncarry + (lo >>> 26)) | 0;
+
+ hncarry += ncarry >>> 26;
+ ncarry &= 0x3ffffff;
+ }
+ out.words[k] = rword;
+ carry = ncarry;
+ ncarry = hncarry;
+ }
+ if (carry !== 0) {
+ out.words[k] = carry;
+ } else {
+ out.length--;
+ }
+
+ return out.strip();
+ }
+
+ function jumboMulTo (self, num, out) {
+ var fftm = new FFTM();
+ return fftm.mulp(self, num, out);
+ }
+
+ BN.prototype.mulTo = function mulTo (num, out) {
+ var res;
+ var len = this.length + num.length;
+ if (this.length === 10 && num.length === 10) {
+ res = comb10MulTo(this, num, out);
+ } else if (len < 63) {
+ res = smallMulTo(this, num, out);
+ } else if (len < 1024) {
+ res = bigMulTo(this, num, out);
+ } else {
+ res = jumboMulTo(this, num, out);
+ }
+
+ return res;
+ };
+
+ // Cooley-Tukey algorithm for FFT
+ // slightly revisited to rely on looping instead of recursion
+
+ function FFTM (x, y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ FFTM.prototype.makeRBT = function makeRBT (N) {
+ var t = new Array(N);
+ var l = BN.prototype._countBits(N) - 1;
+ for (var i = 0; i < N; i++) {
+ t[i] = this.revBin(i, l, N);
+ }
+
+ return t;
+ };
+
+ // Returns binary-reversed representation of `x`
+ FFTM.prototype.revBin = function revBin (x, l, N) {
+ if (x === 0 || x === N - 1) return x;
+
+ var rb = 0;
+ for (var i = 0; i < l; i++) {
+ rb |= (x & 1) << (l - i - 1);
+ x >>= 1;
+ }
+
+ return rb;
+ };
+
+ // Performs "tweedling" phase, therefore 'emulating'
+ // behaviour of the recursive algorithm
+ FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
+ for (var i = 0; i < N; i++) {
+ rtws[i] = rws[rbt[i]];
+ itws[i] = iws[rbt[i]];
+ }
+ };
+
+ FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
+ this.permute(rbt, rws, iws, rtws, itws, N);
+
+ for (var s = 1; s < N; s <<= 1) {
+ var l = s << 1;
+
+ var rtwdf = Math.cos(2 * Math.PI / l);
+ var itwdf = Math.sin(2 * Math.PI / l);
+
+ for (var p = 0; p < N; p += l) {
+ var rtwdf_ = rtwdf;
+ var itwdf_ = itwdf;
+
+ for (var j = 0; j < s; j++) {
+ var re = rtws[p + j];
+ var ie = itws[p + j];
+
+ var ro = rtws[p + j + s];
+ var io = itws[p + j + s];
+
+ var rx = rtwdf_ * ro - itwdf_ * io;
+
+ io = rtwdf_ * io + itwdf_ * ro;
+ ro = rx;
+
+ rtws[p + j] = re + ro;
+ itws[p + j] = ie + io;
+
+ rtws[p + j + s] = re - ro;
+ itws[p + j + s] = ie - io;
+
+ /* jshint maxdepth : false */
+ if (j !== l) {
+ rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+
+ itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+ rtwdf_ = rx;
+ }
+ }
+ }
+ }
+ };
+
+ FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
+ var N = Math.max(m, n) | 1;
+ var odd = N & 1;
+ var i = 0;
+ for (N = N / 2 | 0; N; N = N >>> 1) {
+ i++;
+ }
+
+ return 1 << i + 1 + odd;
+ };
+
+ FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
+ if (N <= 1) return;
+
+ for (var i = 0; i < N / 2; i++) {
+ var t = rws[i];
+
+ rws[i] = rws[N - i - 1];
+ rws[N - i - 1] = t;
+
+ t = iws[i];
+
+ iws[i] = -iws[N - i - 1];
+ iws[N - i - 1] = -t;
+ }
+ };
+
+ FFTM.prototype.normalize13b = function normalize13b (ws, N) {
+ var carry = 0;
+ for (var i = 0; i < N / 2; i++) {
+ var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
+ Math.round(ws[2 * i] / N) +
+ carry;
+
+ ws[i] = w & 0x3ffffff;
+
+ if (w < 0x4000000) {
+ carry = 0;
+ } else {
+ carry = w / 0x4000000 | 0;
+ }
+ }
+
+ return ws;
+ };
+
+ FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
+ var carry = 0;
+ for (var i = 0; i < len; i++) {
+ carry = carry + (ws[i] | 0);
+
+ rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
+ rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
+ }
+
+ // Pad with zeroes
+ for (i = 2 * len; i < N; ++i) {
+ rws[i] = 0;
+ }
+
+ assert(carry === 0);
+ assert((carry & ~0x1fff) === 0);
+ };
+
+ FFTM.prototype.stub = function stub (N) {
+ var ph = new Array(N);
+ for (var i = 0; i < N; i++) {
+ ph[i] = 0;
+ }
+
+ return ph;
+ };
+
+ FFTM.prototype.mulp = function mulp (x, y, out) {
+ var N = 2 * this.guessLen13b(x.length, y.length);
+
+ var rbt = this.makeRBT(N);
+
+ var _ = this.stub(N);
+
+ var rws = new Array(N);
+ var rwst = new Array(N);
+ var iwst = new Array(N);
+
+ var nrws = new Array(N);
+ var nrwst = new Array(N);
+ var niwst = new Array(N);
+
+ var rmws = out.words;
+ rmws.length = N;
+
+ this.convert13b(x.words, x.length, rws, N);
+ this.convert13b(y.words, y.length, nrws, N);
+
+ this.transform(rws, _, rwst, iwst, N, rbt);
+ this.transform(nrws, _, nrwst, niwst, N, rbt);
+
+ for (var i = 0; i < N; i++) {
+ var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
+ iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
+ rwst[i] = rx;
+ }
+
+ this.conjugate(rwst, iwst, N);
+ this.transform(rwst, iwst, rmws, _, N, rbt);
+ this.conjugate(rmws, _, N);
+ this.normalize13b(rmws, N);
+
+ out.negative = x.negative ^ y.negative;
+ out.length = x.length + y.length;
+ return out.strip();
+ };
+
+ // Multiply `this` by `num`
+ BN.prototype.mul = function mul (num) {
+ var out = new BN(null);
+ out.words = new Array(this.length + num.length);
+ return this.mulTo(num, out);
+ };
+
+ // Multiply employing FFT
+ BN.prototype.mulf = function mulf (num) {
+ var out = new BN(null);
+ out.words = new Array(this.length + num.length);
+ return jumboMulTo(this, num, out);
+ };
+
+ // In-place Multiplication
+ BN.prototype.imul = function imul (num) {
+ return this.clone().mulTo(num, this);
+ };
+
+ BN.prototype.imuln = function imuln (num) {
+ assert(typeof num === 'number');
+ assert(num < 0x4000000);
+
+ // Carry
+ var carry = 0;
+ for (var i = 0; i < this.length; i++) {
+ var w = (this.words[i] | 0) * num;
+ var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
+ carry >>= 26;
+ carry += (w / 0x4000000) | 0;
+ // NOTE: lo is 27bit maximum
+ carry += lo >>> 26;
+ this.words[i] = lo & 0x3ffffff;
+ }
+
+ if (carry !== 0) {
+ this.words[i] = carry;
+ this.length++;
+ }
+
+ return this;
+ };
+
+ BN.prototype.muln = function muln (num) {
+ return this.clone().imuln(num);
+ };
+
+ // `this` * `this`
+ BN.prototype.sqr = function sqr () {
+ return this.mul(this);
+ };
+
+ // `this` * `this` in-place
+ BN.prototype.isqr = function isqr () {
+ return this.imul(this.clone());
+ };
+
+ // Math.pow(`this`, `num`)
+ BN.prototype.pow = function pow (num) {
+ var w = toBitArray(num);
+ if (w.length === 0) return new BN(1);
+
+ // Skip leading zeroes
+ var res = this;
+ for (var i = 0; i < w.length; i++, res = res.sqr()) {
+ if (w[i] !== 0) break;
+ }
+
+ if (++i < w.length) {
+ for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+ if (w[i] === 0) continue;
+
+ res = res.mul(q);
+ }
+ }
+
+ return res;
+ };
+
+ // Shift-left in-place
+ BN.prototype.iushln = function iushln (bits) {
+ assert(typeof bits === 'number' && bits >= 0);
+ var r = bits % 26;
+ var s = (bits - r) / 26;
+ var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
+ var i;
+
+ if (r !== 0) {
+ var carry = 0;
+
+ for (i = 0; i < this.length; i++) {
+ var newCarry = this.words[i] & carryMask;
+ var c = ((this.words[i] | 0) - newCarry) << r;
+ this.words[i] = c | carry;
+ carry = newCarry >>> (26 - r);
+ }
+
+ if (carry) {
+ this.words[i] = carry;
+ this.length++;
+ }
+ }
+
+ if (s !== 0) {
+ for (i = this.length - 1; i >= 0; i--) {
+ this.words[i + s] = this.words[i];
+ }
+
+ for (i = 0; i < s; i++) {
+ this.words[i] = 0;
+ }
+
+ this.length += s;
+ }
+
+ return this.strip();
+ };
+
+ BN.prototype.ishln = function ishln (bits) {
+ // TODO(indutny): implement me
+ assert(this.negative === 0);
+ return this.iushln(bits);
+ };
+
+ // Shift-right in-place
+ // NOTE: `hint` is a lowest bit before trailing zeroes
+ // NOTE: if `extended` is present - it will be filled with destroyed bits
+ BN.prototype.iushrn = function iushrn (bits, hint, extended) {
+ assert(typeof bits === 'number' && bits >= 0);
+ var h;
+ if (hint) {
+ h = (hint - (hint % 26)) / 26;
+ } else {
+ h = 0;
+ }
+
+ var r = bits % 26;
+ var s = Math.min((bits - r) / 26, this.length);
+ var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+ var maskedWords = extended;
+
+ h -= s;
+ h = Math.max(0, h);
+
+ // Extended mode, copy masked part
+ if (maskedWords) {
+ for (var i = 0; i < s; i++) {
+ maskedWords.words[i] = this.words[i];
+ }
+ maskedWords.length = s;
+ }
+
+ if (s === 0) {
+ // No-op, we should not move anything at all
+ } else if (this.length > s) {
+ this.length -= s;
+ for (i = 0; i < this.length; i++) {
+ this.words[i] = this.words[i + s];
+ }
+ } else {
+ this.words[0] = 0;
+ this.length = 1;
+ }
+
+ var carry = 0;
+ for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+ var word = this.words[i] | 0;
+ this.words[i] = (carry << (26 - r)) | (word >>> r);
+ carry = word & mask;
+ }
+
+ // Push carried bits as a mask
+ if (maskedWords && carry !== 0) {
+ maskedWords.words[maskedWords.length++] = carry;
+ }
+
+ if (this.length === 0) {
+ this.words[0] = 0;
+ this.length = 1;
+ }
+
+ return this.strip();
+ };
+
+ BN.prototype.ishrn = function ishrn (bits, hint, extended) {
+ // TODO(indutny): implement me
+ assert(this.negative === 0);
+ return this.iushrn(bits, hint, extended);
+ };
+
+ // Shift-left
+ BN.prototype.shln = function shln (bits) {
+ return this.clone().ishln(bits);
+ };
+
+ BN.prototype.ushln = function ushln (bits) {
+ return this.clone().iushln(bits);
+ };
+
+ // Shift-right
+ BN.prototype.shrn = function shrn (bits) {
+ return this.clone().ishrn(bits);
+ };
+
+ BN.prototype.ushrn = function ushrn (bits) {
+ return this.clone().iushrn(bits);
+ };
+
+ // Test if n bit is set
+ BN.prototype.testn = function testn (bit) {
+ assert(typeof bit === 'number' && bit >= 0);
+ var r = bit % 26;
+ var s = (bit - r) / 26;
+ var q = 1 << r;
+
+ // Fast case: bit is much higher than all existing words
+ if (this.length <= s) return false;
+
+ // Check bit and return
+ var w = this.words[s];
+
+ return !!(w & q);
+ };
+
+ // Return only lowers bits of number (in-place)
+ BN.prototype.imaskn = function imaskn (bits) {
+ assert(typeof bits === 'number' && bits >= 0);
+ var r = bits % 26;
+ var s = (bits - r) / 26;
+
+ assert(this.negative === 0, 'imaskn works only with positive numbers');
+
+ if (this.length <= s) {
+ return this;
+ }
+
+ if (r !== 0) {
+ s++;
+ }
+ this.length = Math.min(s, this.length);
+
+ if (r !== 0) {
+ var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
+ this.words[this.length - 1] &= mask;
+ }
+
+ return this.strip();
+ };
+
+ // Return only lowers bits of number
+ BN.prototype.maskn = function maskn (bits) {
+ return this.clone().imaskn(bits);
+ };
+
+ // Add plain number `num` to `this`
+ BN.prototype.iaddn = function iaddn (num) {
+ assert(typeof num === 'number');
+ assert(num < 0x4000000);
+ if (num < 0) return this.isubn(-num);
+
+ // Possible sign change
+ if (this.negative !== 0) {
+ if (this.length === 1 && (this.words[0] | 0) < num) {
+ this.words[0] = num - (this.words[0] | 0);
+ this.negative = 0;
+ return this;
+ }
+
+ this.negative = 0;
+ this.isubn(num);
+ this.negative = 1;
+ return this;
+ }
+
+ // Add without checks
+ return this._iaddn(num);
+ };
+
+ BN.prototype._iaddn = function _iaddn (num) {
+ this.words[0] += num;
+
+ // Carry
+ for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
+ this.words[i] -= 0x4000000;
+ if (i === this.length - 1) {
+ this.words[i + 1] = 1;
+ } else {
+ this.words[i + 1]++;
+ }
+ }
+ this.length = Math.max(this.length, i + 1);
+
+ return this;
+ };
+
+ // Subtract plain number `num` from `this`
+ BN.prototype.isubn = function isubn (num) {
+ assert(typeof num === 'number');
+ assert(num < 0x4000000);
+ if (num < 0) return this.iaddn(-num);
+
+ if (this.negative !== 0) {
+ this.negative = 0;
+ this.iaddn(num);
+ this.negative = 1;
+ return this;
+ }
+
+ this.words[0] -= num;
+
+ if (this.length === 1 && this.words[0] < 0) {
+ this.words[0] = -this.words[0];
+ this.negative = 1;
+ } else {
+ // Carry
+ for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+ this.words[i] += 0x4000000;
+ this.words[i + 1] -= 1;
+ }
+ }
+
+ return this.strip();
+ };
+
+ BN.prototype.addn = function addn (num) {
+ return this.clone().iaddn(num);
+ };
+
+ BN.prototype.subn = function subn (num) {
+ return this.clone().isubn(num);
+ };
+
+ BN.prototype.iabs = function iabs () {
+ this.negative = 0;
+
+ return this;
+ };
+
+ BN.prototype.abs = function abs () {
+ return this.clone().iabs();
+ };
+
+ BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
+ var len = num.length + shift;
+ var i;
+
+ this._expand(len);
+
+ var w;
+ var carry = 0;
+ for (i = 0; i < num.length; i++) {
+ w = (this.words[i + shift] | 0) + carry;
+ var right = (num.words[i] | 0) * mul;
+ w -= right & 0x3ffffff;
+ carry = (w >> 26) - ((right / 0x4000000) | 0);
+ this.words[i + shift] = w & 0x3ffffff;
+ }
+ for (; i < this.length - shift; i++) {
+ w = (this.words[i + shift] | 0) + carry;
+ carry = w >> 26;
+ this.words[i + shift] = w & 0x3ffffff;
+ }
+
+ if (carry === 0) return this.strip();
+
+ // Subtraction overflow
+ assert(carry === -1);
+ carry = 0;
+ for (i = 0; i < this.length; i++) {
+ w = -(this.words[i] | 0) + carry;
+ carry = w >> 26;
+ this.words[i] = w & 0x3ffffff;
+ }
+ this.negative = 1;
+
+ return this.strip();
+ };
+
+ BN.prototype._wordDiv = function _wordDiv (num, mode) {
+ var shift = this.length - num.length;
+
+ var a = this.clone();
+ var b = num;
+
+ // Normalize
+ var bhi = b.words[b.length - 1] | 0;
+ var bhiBits = this._countBits(bhi);
+ shift = 26 - bhiBits;
+ if (shift !== 0) {
+ b = b.ushln(shift);
+ a.iushln(shift);
+ bhi = b.words[b.length - 1] | 0;
+ }
+
+ // Initialize quotient
+ var m = a.length - b.length;
+ var q;
+
+ if (mode !== 'mod') {
+ q = new BN(null);
+ q.length = m + 1;
+ q.words = new Array(q.length);
+ for (var i = 0; i < q.length; i++) {
+ q.words[i] = 0;
+ }
+ }
+
+ var diff = a.clone()._ishlnsubmul(b, 1, m);
+ if (diff.negative === 0) {
+ a = diff;
+ if (q) {
+ q.words[m] = 1;
+ }
+ }
+
+ for (var j = m - 1; j >= 0; j--) {
+ var qj = (a.words[b.length + j] | 0) * 0x4000000 +
+ (a.words[b.length + j - 1] | 0);
+
+ // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
+ // (0x7ffffff)
+ qj = Math.min((qj / bhi) | 0, 0x3ffffff);
+
+ a._ishlnsubmul(b, qj, j);
+ while (a.negative !== 0) {
+ qj--;
+ a.negative = 0;
+ a._ishlnsubmul(b, 1, j);
+ if (!a.isZero()) {
+ a.negative ^= 1;
+ }
+ }
+ if (q) {
+ q.words[j] = qj;
+ }
+ }
+ if (q) {
+ q.strip();
+ }
+ a.strip();
+
+ // Denormalize
+ if (mode !== 'div' && shift !== 0) {
+ a.iushrn(shift);
+ }
+
+ return {
+ div: q || null,
+ mod: a
+ };
+ };
+
+ // NOTE: 1) `mode` can be set to `mod` to request mod only,
+ // to `div` to request div only, or be absent to
+ // request both div & mod
+ // 2) `positive` is true if unsigned mod is requested
+ BN.prototype.divmod = function divmod (num, mode, positive) {
+ assert(!num.isZero());
+
+ if (this.isZero()) {
+ return {
+ div: new BN(0),
+ mod: new BN(0)
+ };
+ }
+
+ var div, mod, res;
+ if (this.negative !== 0 && num.negative === 0) {
+ res = this.neg().divmod(num, mode);
+
+ if (mode !== 'mod') {
+ div = res.div.neg();
+ }
+
+ if (mode !== 'div') {
+ mod = res.mod.neg();
+ if (positive && mod.negative !== 0) {
+ mod.iadd(num);
+ }
+ }
+
+ return {
+ div: div,
+ mod: mod
+ };
+ }
+
+ if (this.negative === 0 && num.negative !== 0) {
+ res = this.divmod(num.neg(), mode);
+
+ if (mode !== 'mod') {
+ div = res.div.neg();
+ }
+
+ return {
+ div: div,
+ mod: res.mod
+ };
+ }
+
+ if ((this.negative & num.negative) !== 0) {
+ res = this.neg().divmod(num.neg(), mode);
+
+ if (mode !== 'div') {
+ mod = res.mod.neg();
+ if (positive && mod.negative !== 0) {
+ mod.isub(num);
+ }
+ }
+
+ return {
+ div: res.div,
+ mod: mod
+ };
+ }
+
+ // Both numbers are positive at this point
+
+ // Strip both numbers to approximate shift value
+ if (num.length > this.length || this.cmp(num) < 0) {
+ return {
+ div: new BN(0),
+ mod: this
+ };
+ }
+
+ // Very short reduction
+ if (num.length === 1) {
+ if (mode === 'div') {
+ return {
+ div: this.divn(num.words[0]),
+ mod: null
+ };
+ }
+
+ if (mode === 'mod') {
+ return {
+ div: null,
+ mod: new BN(this.modn(num.words[0]))
+ };
+ }
+
+ return {
+ div: this.divn(num.words[0]),
+ mod: new BN(this.modn(num.words[0]))
+ };
+ }
+
+ return this._wordDiv(num, mode);
+ };
+
+ // Find `this` / `num`
+ BN.prototype.div = function div (num) {
+ return this.divmod(num, 'div', false).div;
+ };
+
+ // Find `this` % `num`
+ BN.prototype.mod = function mod (num) {
+ return this.divmod(num, 'mod', false).mod;
+ };
+
+ BN.prototype.umod = function umod (num) {
+ return this.divmod(num, 'mod', true).mod;
+ };
+
+ // Find Round(`this` / `num`)
+ BN.prototype.divRound = function divRound (num) {
+ var dm = this.divmod(num);
+
+ // Fast case - exact division
+ if (dm.mod.isZero()) return dm.div;
+
+ var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+
+ var half = num.ushrn(1);
+ var r2 = num.andln(1);
+ var cmp = mod.cmp(half);
+
+ // Round down
+ if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+
+ // Round up
+ return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+ };
+
+ BN.prototype.modn = function modn (num) {
+ assert(num <= 0x3ffffff);
+ var p = (1 << 26) % num;
+
+ var acc = 0;
+ for (var i = this.length - 1; i >= 0; i--) {
+ acc = (p * acc + (this.words[i] | 0)) % num;
+ }
+
+ return acc;
+ };
+
+ // In-place division by number
+ BN.prototype.idivn = function idivn (num) {
+ assert(num <= 0x3ffffff);
+
+ var carry = 0;
+ for (var i = this.length - 1; i >= 0; i--) {
+ var w = (this.words[i] | 0) + carry * 0x4000000;
+ this.words[i] = (w / num) | 0;
+ carry = w % num;
+ }
+
+ return this.strip();
+ };
+
+ BN.prototype.divn = function divn (num) {
+ return this.clone().idivn(num);
+ };
+
+ BN.prototype.egcd = function egcd (p) {
+ assert(p.negative === 0);
+ assert(!p.isZero());
+
+ var x = this;
+ var y = p.clone();
+
+ if (x.negative !== 0) {
+ x = x.umod(p);
+ } else {
+ x = x.clone();
+ }
+
+ // A * x + B * y = x
+ var A = new BN(1);
+ var B = new BN(0);
+
+ // C * x + D * y = y
+ var C = new BN(0);
+ var D = new BN(1);
+
+ var g = 0;
+
+ while (x.isEven() && y.isEven()) {
+ x.iushrn(1);
+ y.iushrn(1);
+ ++g;
+ }
+
+ var yp = y.clone();
+ var xp = x.clone();
+
+ while (!x.isZero()) {
+ for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+ if (i > 0) {
+ x.iushrn(i);
+ while (i-- > 0) {
+ if (A.isOdd() || B.isOdd()) {
+ A.iadd(yp);
+ B.isub(xp);
+ }
+
+ A.iushrn(1);
+ B.iushrn(1);
+ }
+ }
+
+ for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+ if (j > 0) {
+ y.iushrn(j);
+ while (j-- > 0) {
+ if (C.isOdd() || D.isOdd()) {
+ C.iadd(yp);
+ D.isub(xp);
+ }
+
+ C.iushrn(1);
+ D.iushrn(1);
+ }
+ }
+
+ if (x.cmp(y) >= 0) {
+ x.isub(y);
+ A.isub(C);
+ B.isub(D);
+ } else {
+ y.isub(x);
+ C.isub(A);
+ D.isub(B);
+ }
+ }
+
+ return {
+ a: C,
+ b: D,
+ gcd: y.iushln(g)
+ };
+ };
+
+ // This is reduced incarnation of the binary EEA
+ // above, designated to invert members of the
+ // _prime_ fields F(p) at a maximal speed
+ BN.prototype._invmp = function _invmp (p) {
+ assert(p.negative === 0);
+ assert(!p.isZero());
+
+ var a = this;
+ var b = p.clone();
+
+ if (a.negative !== 0) {
+ a = a.umod(p);
+ } else {
+ a = a.clone();
+ }
+
+ var x1 = new BN(1);
+ var x2 = new BN(0);
+
+ var delta = b.clone();
+
+ while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+ for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+ if (i > 0) {
+ a.iushrn(i);
+ while (i-- > 0) {
+ if (x1.isOdd()) {
+ x1.iadd(delta);
+ }
+
+ x1.iushrn(1);
+ }
+ }
+
+ for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+ if (j > 0) {
+ b.iushrn(j);
+ while (j-- > 0) {
+ if (x2.isOdd()) {
+ x2.iadd(delta);
+ }
+
+ x2.iushrn(1);
+ }
+ }
+
+ if (a.cmp(b) >= 0) {
+ a.isub(b);
+ x1.isub(x2);
+ } else {
+ b.isub(a);
+ x2.isub(x1);
+ }
+ }
+
+ var res;
+ if (a.cmpn(1) === 0) {
+ res = x1;
+ } else {
+ res = x2;
+ }
+
+ if (res.cmpn(0) < 0) {
+ res.iadd(p);
+ }
+
+ return res;
+ };
+
+ BN.prototype.gcd = function gcd (num) {
+ if (this.isZero()) return num.abs();
+ if (num.isZero()) return this.abs();
+
+ var a = this.clone();
+ var b = num.clone();
+ a.negative = 0;
+ b.negative = 0;
+
+ // Remove common factor of two
+ for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+ a.iushrn(1);
+ b.iushrn(1);
+ }
+
+ do {
+ while (a.isEven()) {
+ a.iushrn(1);
+ }
+ while (b.isEven()) {
+ b.iushrn(1);
+ }
+
+ var r = a.cmp(b);
+ if (r < 0) {
+ // Swap `a` and `b` to make `a` always bigger than `b`
+ var t = a;
+ a = b;
+ b = t;
+ } else if (r === 0 || b.cmpn(1) === 0) {
+ break;
+ }
+
+ a.isub(b);
+ } while (true);
+
+ return b.iushln(shift);
+ };
+
+ // Invert number in the field F(num)
+ BN.prototype.invm = function invm (num) {
+ return this.egcd(num).a.umod(num);
+ };
+
+ BN.prototype.isEven = function isEven () {
+ return (this.words[0] & 1) === 0;
+ };
+
+ BN.prototype.isOdd = function isOdd () {
+ return (this.words[0] & 1) === 1;
+ };
+
+ // And first word and num
+ BN.prototype.andln = function andln (num) {
+ return this.words[0] & num;
+ };
+
+ // Increment at the bit position in-line
+ BN.prototype.bincn = function bincn (bit) {
+ assert(typeof bit === 'number');
+ var r = bit % 26;
+ var s = (bit - r) / 26;
+ var q = 1 << r;
+
+ // Fast case: bit is much higher than all existing words
+ if (this.length <= s) {
+ this._expand(s + 1);
+ this.words[s] |= q;
+ return this;
+ }
+
+ // Add bit and propagate, if needed
+ var carry = q;
+ for (var i = s; carry !== 0 && i < this.length; i++) {
+ var w = this.words[i] | 0;
+ w += carry;
+ carry = w >>> 26;
+ w &= 0x3ffffff;
+ this.words[i] = w;
+ }
+ if (carry !== 0) {
+ this.words[i] = carry;
+ this.length++;
+ }
+ return this;
+ };
+
+ BN.prototype.isZero = function isZero () {
+ return this.length === 1 && this.words[0] === 0;
+ };
+
+ BN.prototype.cmpn = function cmpn (num) {
+ var negative = num < 0;
+
+ if (this.negative !== 0 && !negative) return -1;
+ if (this.negative === 0 && negative) return 1;
+
+ this.strip();
+
+ var res;
+ if (this.length > 1) {
+ res = 1;
+ } else {
+ if (negative) {
+ num = -num;
+ }
+
+ assert(num <= 0x3ffffff, 'Number is too big');
+
+ var w = this.words[0] | 0;
+ res = w === num ? 0 : w < num ? -1 : 1;
+ }
+ if (this.negative !== 0) return -res | 0;
+ return res;
+ };
+
+ // Compare two numbers and return:
+ // 1 - if `this` > `num`
+ // 0 - if `this` == `num`
+ // -1 - if `this` < `num`
+ BN.prototype.cmp = function cmp (num) {
+ if (this.negative !== 0 && num.negative === 0) return -1;
+ if (this.negative === 0 && num.negative !== 0) return 1;
+
+ var res = this.ucmp(num);
+ if (this.negative !== 0) return -res | 0;
+ return res;
+ };
+
+ // Unsigned comparison
+ BN.prototype.ucmp = function ucmp (num) {
+ // At this point both numbers have the same sign
+ if (this.length > num.length) return 1;
+ if (this.length < num.length) return -1;
+
+ var res = 0;
+ for (var i = this.length - 1; i >= 0; i--) {
+ var a = this.words[i] | 0;
+ var b = num.words[i] | 0;
+
+ if (a === b) continue;
+ if (a < b) {
+ res = -1;
+ } else if (a > b) {
+ res = 1;
+ }
+ break;
+ }
+ return res;
+ };
+
+ BN.prototype.gtn = function gtn (num) {
+ return this.cmpn(num) === 1;
+ };
+
+ BN.prototype.gt = function gt (num) {
+ return this.cmp(num) === 1;
+ };
+
+ BN.prototype.gten = function gten (num) {
+ return this.cmpn(num) >= 0;
+ };
+
+ BN.prototype.gte = function gte (num) {
+ return this.cmp(num) >= 0;
+ };
+
+ BN.prototype.ltn = function ltn (num) {
+ return this.cmpn(num) === -1;
+ };
+
+ BN.prototype.lt = function lt (num) {
+ return this.cmp(num) === -1;
+ };
+
+ BN.prototype.lten = function lten (num) {
+ return this.cmpn(num) <= 0;
+ };
+
+ BN.prototype.lte = function lte (num) {
+ return this.cmp(num) <= 0;
+ };
+
+ BN.prototype.eqn = function eqn (num) {
+ return this.cmpn(num) === 0;
+ };
+
+ BN.prototype.eq = function eq (num) {
+ return this.cmp(num) === 0;
+ };
+
+ //
+ // A reduce context, could be using montgomery or something better, depending
+ // on the `m` itself.
+ //
+ BN.red = function red (num) {
+ return new Red(num);
+ };
+
+ BN.prototype.toRed = function toRed (ctx) {
+ assert(!this.red, 'Already a number in reduction context');
+ assert(this.negative === 0, 'red works only with positives');
+ return ctx.convertTo(this)._forceRed(ctx);
+ };
+
+ BN.prototype.fromRed = function fromRed () {
+ assert(this.red, 'fromRed works only with numbers in reduction context');
+ return this.red.convertFrom(this);
+ };
+
+ BN.prototype._forceRed = function _forceRed (ctx) {
+ this.red = ctx;
+ return this;
+ };
+
+ BN.prototype.forceRed = function forceRed (ctx) {
+ assert(!this.red, 'Already a number in reduction context');
+ return this._forceRed(ctx);
+ };
+
+ BN.prototype.redAdd = function redAdd (num) {
+ assert(this.red, 'redAdd works only with red numbers');
+ return this.red.add(this, num);
+ };
+
+ BN.prototype.redIAdd = function redIAdd (num) {
+ assert(this.red, 'redIAdd works only with red numbers');
+ return this.red.iadd(this, num);
+ };
+
+ BN.prototype.redSub = function redSub (num) {
+ assert(this.red, 'redSub works only with red numbers');
+ return this.red.sub(this, num);
+ };
+
+ BN.prototype.redISub = function redISub (num) {
+ assert(this.red, 'redISub works only with red numbers');
+ return this.red.isub(this, num);
+ };
+
+ BN.prototype.redShl = function redShl (num) {
+ assert(this.red, 'redShl works only with red numbers');
+ return this.red.shl(this, num);
+ };
+
+ BN.prototype.redMul = function redMul (num) {
+ assert(this.red, 'redMul works only with red numbers');
+ this.red._verify2(this, num);
+ return this.red.mul(this, num);
+ };
+
+ BN.prototype.redIMul = function redIMul (num) {
+ assert(this.red, 'redMul works only with red numbers');
+ this.red._verify2(this, num);
+ return this.red.imul(this, num);
+ };
+
+ BN.prototype.redSqr = function redSqr () {
+ assert(this.red, 'redSqr works only with red numbers');
+ this.red._verify1(this);
+ return this.red.sqr(this);
+ };
+
+ BN.prototype.redISqr = function redISqr () {
+ assert(this.red, 'redISqr works only with red numbers');
+ this.red._verify1(this);
+ return this.red.isqr(this);
+ };
+
+ // Square root over p
+ BN.prototype.redSqrt = function redSqrt () {
+ assert(this.red, 'redSqrt works only with red numbers');
+ this.red._verify1(this);
+ return this.red.sqrt(this);
+ };
+
+ BN.prototype.redInvm = function redInvm () {
+ assert(this.red, 'redInvm works only with red numbers');
+ this.red._verify1(this);
+ return this.red.invm(this);
+ };
+
+ // Return negative clone of `this` % `red modulo`
+ BN.prototype.redNeg = function redNeg () {
+ assert(this.red, 'redNeg works only with red numbers');
+ this.red._verify1(this);
+ return this.red.neg(this);
+ };
+
+ BN.prototype.redPow = function redPow (num) {
+ assert(this.red && !num.red, 'redPow(normalNum)');
+ this.red._verify1(this);
+ return this.red.pow(this, num);
+ };
+
+ // Prime numbers with efficient reduction
+ var primes = {
+ k256: null,
+ p224: null,
+ p192: null,
+ p25519: null
+ };
+
+ // Pseudo-Mersenne prime
+ function MPrime (name, p) {
+ // P = 2 ^ N - K
+ this.name = name;
+ this.p = new BN(p, 16);
+ this.n = this.p.bitLength();
+ this.k = new BN(1).iushln(this.n).isub(this.p);
+
+ this.tmp = this._tmp();
+ }
+
+ MPrime.prototype._tmp = function _tmp () {
+ var tmp = new BN(null);
+ tmp.words = new Array(Math.ceil(this.n / 13));
+ return tmp;
+ };
+
+ MPrime.prototype.ireduce = function ireduce (num) {
+ // Assumes that `num` is less than `P^2`
+ // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
+ var r = num;
+ var rlen;
+
+ do {
+ this.split(r, this.tmp);
+ r = this.imulK(r);
+ r = r.iadd(this.tmp);
+ rlen = r.bitLength();
+ } while (rlen > this.n);
+
+ var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+ if (cmp === 0) {
+ r.words[0] = 0;
+ r.length = 1;
+ } else if (cmp > 0) {
+ r.isub(this.p);
+ } else {
+ r.strip();
+ }
+
+ return r;
+ };
+
+ MPrime.prototype.split = function split (input, out) {
+ input.iushrn(this.n, 0, out);
+ };
+
+ MPrime.prototype.imulK = function imulK (num) {
+ return num.imul(this.k);
+ };
+
+ function K256 () {
+ MPrime.call(
+ this,
+ 'k256',
+ 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
+ }
+ inherits(K256, MPrime);
+
+ K256.prototype.split = function split (input, output) {
+ // 256 = 9 * 26 + 22
+ var mask = 0x3fffff;
+
+ var outLen = Math.min(input.length, 9);
+ for (var i = 0; i < outLen; i++) {
+ output.words[i] = input.words[i];
+ }
+ output.length = outLen;
+
+ if (input.length <= 9) {
+ input.words[0] = 0;
+ input.length = 1;
+ return;
+ }
+
+ // Shift by 9 limbs
+ var prev = input.words[9];
+ output.words[output.length++] = prev & mask;
+
+ for (i = 10; i < input.length; i++) {
+ var next = input.words[i] | 0;
+ input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);
+ prev = next;
+ }
+ prev >>>= 22;
+ input.words[i - 10] = prev;
+ if (prev === 0 && input.length > 10) {
+ input.length -= 10;
+ } else {
+ input.length -= 9;
+ }
+ };
+
+ K256.prototype.imulK = function imulK (num) {
+ // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
+ num.words[num.length] = 0;
+ num.words[num.length + 1] = 0;
+ num.length += 2;
+
+ // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
+ var lo = 0;
+ for (var i = 0; i < num.length; i++) {
+ var w = num.words[i] | 0;
+ lo += w * 0x3d1;
+ num.words[i] = lo & 0x3ffffff;
+ lo = w * 0x40 + ((lo / 0x4000000) | 0);
+ }
+
+ // Fast length reduction
+ if (num.words[num.length - 1] === 0) {
+ num.length--;
+ if (num.words[num.length - 1] === 0) {
+ num.length--;
+ }
+ }
+ return num;
+ };
+
+ function P224 () {
+ MPrime.call(
+ this,
+ 'p224',
+ 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
+ }
+ inherits(P224, MPrime);
+
+ function P192 () {
+ MPrime.call(
+ this,
+ 'p192',
+ 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
+ }
+ inherits(P192, MPrime);
+
+ function P25519 () {
+ // 2 ^ 255 - 19
+ MPrime.call(
+ this,
+ '25519',
+ '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
+ }
+ inherits(P25519, MPrime);
+
+ P25519.prototype.imulK = function imulK (num) {
+ // K = 0x13
+ var carry = 0;
+ for (var i = 0; i < num.length; i++) {
+ var hi = (num.words[i] | 0) * 0x13 + carry;
+ var lo = hi & 0x3ffffff;
+ hi >>>= 26;
+
+ num.words[i] = lo;
+ carry = hi;
+ }
+ if (carry !== 0) {
+ num.words[num.length++] = carry;
+ }
+ return num;
+ };
+
+ // Exported mostly for testing purposes, use plain name instead
+ BN._prime = function prime (name) {
+ // Cached version of prime
+ if (primes[name]) return primes[name];
+
+ var prime;
+ if (name === 'k256') {
+ prime = new K256();
+ } else if (name === 'p224') {
+ prime = new P224();
+ } else if (name === 'p192') {
+ prime = new P192();
+ } else if (name === 'p25519') {
+ prime = new P25519();
+ } else {
+ throw new Error('Unknown prime ' + name);
+ }
+ primes[name] = prime;
+
+ return prime;
+ };
+
+ //
+ // Base reduction engine
+ //
+ function Red (m) {
+ if (typeof m === 'string') {
+ var prime = BN._prime(m);
+ this.m = prime.p;
+ this.prime = prime;
+ } else {
+ assert(m.gtn(1), 'modulus must be greater than 1');
+ this.m = m;
+ this.prime = null;
+ }
+ }
+
+ Red.prototype._verify1 = function _verify1 (a) {
+ assert(a.negative === 0, 'red works only with positives');
+ assert(a.red, 'red works only with red numbers');
+ };
+
+ Red.prototype._verify2 = function _verify2 (a, b) {
+ assert((a.negative | b.negative) === 0, 'red works only with positives');
+ assert(a.red && a.red === b.red,
+ 'red works only with red numbers');
+ };
+
+ Red.prototype.imod = function imod (a) {
+ if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+ return a.umod(this.m)._forceRed(this);
+ };
+
+ Red.prototype.neg = function neg (a) {
+ if (a.isZero()) {
+ return a.clone();
+ }
+
+ return this.m.sub(a)._forceRed(this);
+ };
+
+ Red.prototype.add = function add (a, b) {
+ this._verify2(a, b);
+
+ var res = a.add(b);
+ if (res.cmp(this.m) >= 0) {
+ res.isub(this.m);
+ }
+ return res._forceRed(this);
+ };
+
+ Red.prototype.iadd = function iadd (a, b) {
+ this._verify2(a, b);
+
+ var res = a.iadd(b);
+ if (res.cmp(this.m) >= 0) {
+ res.isub(this.m);
+ }
+ return res;
+ };
+
+ Red.prototype.sub = function sub (a, b) {
+ this._verify2(a, b);
+
+ var res = a.sub(b);
+ if (res.cmpn(0) < 0) {
+ res.iadd(this.m);
+ }
+ return res._forceRed(this);
+ };
+
+ Red.prototype.isub = function isub (a, b) {
+ this._verify2(a, b);
+
+ var res = a.isub(b);
+ if (res.cmpn(0) < 0) {
+ res.iadd(this.m);
+ }
+ return res;
+ };
+
+ Red.prototype.shl = function shl (a, num) {
+ this._verify1(a);
+ return this.imod(a.ushln(num));
+ };
+
+ Red.prototype.imul = function imul (a, b) {
+ this._verify2(a, b);
+ return this.imod(a.imul(b));
+ };
+
+ Red.prototype.mul = function mul (a, b) {
+ this._verify2(a, b);
+ return this.imod(a.mul(b));
+ };
+
+ Red.prototype.isqr = function isqr (a) {
+ return this.imul(a, a.clone());
+ };
+
+ Red.prototype.sqr = function sqr (a) {
+ return this.mul(a, a);
+ };
+
+ Red.prototype.sqrt = function sqrt (a) {
+ if (a.isZero()) return a.clone();
+
+ var mod3 = this.m.andln(3);
+ assert(mod3 % 2 === 1);
+
+ // Fast case
+ if (mod3 === 3) {
+ var pow = this.m.add(new BN(1)).iushrn(2);
+ return this.pow(a, pow);
+ }
+
+ // Tonelli-Shanks algorithm (Totally unoptimized and slow)
+ //
+ // Find Q and S, that Q * 2 ^ S = (P - 1)
+ var q = this.m.subn(1);
+ var s = 0;
+ while (!q.isZero() && q.andln(1) === 0) {
+ s++;
+ q.iushrn(1);
+ }
+ assert(!q.isZero());
+
+ var one = new BN(1).toRed(this);
+ var nOne = one.redNeg();
+
+ // Find quadratic non-residue
+ // NOTE: Max is such because of generalized Riemann hypothesis.
+ var lpow = this.m.subn(1).iushrn(1);
+ var z = this.m.bitLength();
+ z = new BN(2 * z * z).toRed(this);
+
+ while (this.pow(z, lpow).cmp(nOne) !== 0) {
+ z.redIAdd(nOne);
+ }
+
+ var c = this.pow(z, q);
+ var r = this.pow(a, q.addn(1).iushrn(1));
+ var t = this.pow(a, q);
+ var m = s;
+ while (t.cmp(one) !== 0) {
+ var tmp = t;
+ for (var i = 0; tmp.cmp(one) !== 0; i++) {
+ tmp = tmp.redSqr();
+ }
+ assert(i < m);
+ var b = this.pow(c, new BN(1).iushln(m - i - 1));
+
+ r = r.redMul(b);
+ c = b.redSqr();
+ t = t.redMul(c);
+ m = i;
+ }
+
+ return r;
+ };
+
+ Red.prototype.invm = function invm (a) {
+ var inv = a._invmp(this.m);
+ if (inv.negative !== 0) {
+ inv.negative = 0;
+ return this.imod(inv).redNeg();
+ } else {
+ return this.imod(inv);
+ }
+ };
+
+ Red.prototype.pow = function pow (a, num) {
+ if (num.isZero()) return new BN(1).toRed(this);
+ if (num.cmpn(1) === 0) return a.clone();
+
+ var windowSize = 4;
+ var wnd = new Array(1 << windowSize);
+ wnd[0] = new BN(1).toRed(this);
+ wnd[1] = a;
+ for (var i = 2; i < wnd.length; i++) {
+ wnd[i] = this.mul(wnd[i - 1], a);
+ }
+
+ var res = wnd[0];
+ var current = 0;
+ var currentLen = 0;
+ var start = num.bitLength() % 26;
+ if (start === 0) {
+ start = 26;
+ }
+
+ for (i = num.length - 1; i >= 0; i--) {
+ var word = num.words[i];
+ for (var j = start - 1; j >= 0; j--) {
+ var bit = (word >> j) & 1;
+ if (res !== wnd[0]) {
+ res = this.sqr(res);
+ }
+
+ if (bit === 0 && current === 0) {
+ currentLen = 0;
+ continue;
+ }
+
+ current <<= 1;
+ current |= bit;
+ currentLen++;
+ if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+
+ res = this.mul(res, wnd[current]);
+ currentLen = 0;
+ current = 0;
+ }
+ start = 26;
+ }
+
+ return res;
+ };
+
+ Red.prototype.convertTo = function convertTo (num) {
+ var r = num.umod(this.m);
+
+ return r === num ? r.clone() : r;
+ };
+
+ Red.prototype.convertFrom = function convertFrom (num) {
+ var res = num.clone();
+ res.red = null;
+ return res;
+ };
+
+ //
+ // Montgomery method engine
+ //
+
+ BN.mont = function mont (num) {
+ return new Mont(num);
+ };
+
+ function Mont (m) {
+ Red.call(this, m);
+
+ this.shift = this.m.bitLength();
+ if (this.shift % 26 !== 0) {
+ this.shift += 26 - (this.shift % 26);
+ }
+
+ this.r = new BN(1).iushln(this.shift);
+ this.r2 = this.imod(this.r.sqr());
+ this.rinv = this.r._invmp(this.m);
+
+ this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+ this.minv = this.minv.umod(this.r);
+ this.minv = this.r.sub(this.minv);
+ }
+ inherits(Mont, Red);
+
+ Mont.prototype.convertTo = function convertTo (num) {
+ return this.imod(num.ushln(this.shift));
+ };
+
+ Mont.prototype.convertFrom = function convertFrom (num) {
+ var r = this.imod(num.mul(this.rinv));
+ r.red = null;
+ return r;
+ };
+
+ Mont.prototype.imul = function imul (a, b) {
+ if (a.isZero() || b.isZero()) {
+ a.words[0] = 0;
+ a.length = 1;
+ return a;
+ }
+
+ var t = a.imul(b);
+ var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+ var u = t.isub(c).iushrn(this.shift);
+ var res = u;
+
+ if (u.cmp(this.m) >= 0) {
+ res = u.isub(this.m);
+ } else if (u.cmpn(0) < 0) {
+ res = u.iadd(this.m);
+ }
+
+ return res._forceRed(this);
+ };
+
+ Mont.prototype.mul = function mul (a, b) {
+ if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+
+ var t = a.mul(b);
+ var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+ var u = t.isub(c).iushrn(this.shift);
+ var res = u;
+ if (u.cmp(this.m) >= 0) {
+ res = u.isub(this.m);
+ } else if (u.cmpn(0) < 0) {
+ res = u.iadd(this.m);
+ }
+
+ return res._forceRed(this);
+ };
+
+ Mont.prototype.invm = function invm (a) {
+ // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
+ var res = this.imod(a._invmp(this.m).mul(this.r2));
+ return res._forceRed(this);
+ };
+})(typeof module === 'undefined' || module, this);
+
+},{"buffer":91}],83:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = boundary
+
+function boundary (cells) {
+ var i, j, k
+ var n = cells.length
+ var sz = 0
+ for (i = 0; i < n; ++i) {
+ sz += cells[i].length
+ }
+ var result = new Array(sz)
+ var ptr = 0
+ for (i = 0; i < n; ++i) {
+ var c = cells[i]
+ var d = c.length
+ for (j = 0; j < d; ++j) {
+ var b = result[ptr++] = new Array(d - 1)
+ var p = 0
+ for (k = 0; k < d; ++k) {
+ if (k === j) {
+ continue
+ }
+ b[p++] = c[k]
+ }
+ if (j & 1) {
+ var tmp = b[1]
+ b[1] = b[0]
+ b[0] = tmp
+ }
+ }
+ }
+ return result
+}
+
+},{}],84:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = boxIntersectWrapper
+
+var pool = _dereq_('typedarray-pool')
+var sweep = _dereq_('./lib/sweep')
+var boxIntersectIter = _dereq_('./lib/intersect')
+
+function boxEmpty(d, box) {
+ for(var j=0; j>>1
+ if(d <= 0) {
+ return
+ }
+
+ var retval
+
+ //Convert red boxes
+ var redList = pool.mallocDouble(2*d*n)
+ var redIds = pool.mallocInt32(n)
+ n = convertBoxes(red, d, redList, redIds)
+
+ if(n > 0) {
+ if(d === 1 && full) {
+ //Special case: 1d complete
+ sweep.init(n)
+ retval = sweep.sweepComplete(
+ d, visit,
+ 0, n, redList, redIds,
+ 0, n, redList, redIds)
+ } else {
+
+ //Convert blue boxes
+ var blueList = pool.mallocDouble(2*d*m)
+ var blueIds = pool.mallocInt32(m)
+ m = convertBoxes(blue, d, blueList, blueIds)
+
+ if(m > 0) {
+ sweep.init(n+m)
+
+ if(d === 1) {
+ //Special case: 1d bipartite
+ retval = sweep.sweepBipartite(
+ d, visit,
+ 0, n, redList, redIds,
+ 0, m, blueList, blueIds)
+ } else {
+ //General case: d>1
+ retval = boxIntersectIter(
+ d, visit, full,
+ n, redList, redIds,
+ m, blueList, blueIds)
+ }
+
+ pool.free(blueList)
+ pool.free(blueIds)
+ }
+ }
+
+ pool.free(redList)
+ pool.free(redIds)
+ }
+
+ return retval
+}
+
+
+var RESULT
+
+function appendItem(i,j) {
+ RESULT.push([i,j])
+}
+
+function intersectFullArray(x) {
+ RESULT = []
+ boxIntersect(x, x, appendItem, true)
+ return RESULT
+}
+
+function intersectBipartiteArray(x, y) {
+ RESULT = []
+ boxIntersect(x, y, appendItem, false)
+ return RESULT
+}
+
+//User-friendly wrapper, handle full input and no-visitor cases
+function boxIntersectWrapper(arg0, arg1, arg2) {
+ var result
+ switch(arguments.length) {
+ case 1:
+ return intersectFullArray(arg0)
+ case 2:
+ if(typeof arg1 === 'function') {
+ return boxIntersect(arg0, arg0, arg1, true)
+ } else {
+ return intersectBipartiteArray(arg0, arg1)
+ }
+ case 3:
+ return boxIntersect(arg0, arg1, arg2, false)
+ default:
+ throw new Error('box-intersect: Invalid arguments')
+ }
+}
+},{"./lib/intersect":86,"./lib/sweep":90,"typedarray-pool":522}],85:[function(_dereq_,module,exports){
+'use strict'
+
+var DIMENSION = 'd'
+var AXIS = 'ax'
+var VISIT = 'vv'
+var FLIP = 'fp'
+
+var ELEM_SIZE = 'es'
+
+var RED_START = 'rs'
+var RED_END = 're'
+var RED_BOXES = 'rb'
+var RED_INDEX = 'ri'
+var RED_PTR = 'rp'
+
+var BLUE_START = 'bs'
+var BLUE_END = 'be'
+var BLUE_BOXES = 'bb'
+var BLUE_INDEX = 'bi'
+var BLUE_PTR = 'bp'
+
+var RETVAL = 'rv'
+
+var INNER_LABEL = 'Q'
+
+var ARGS = [
+ DIMENSION,
+ AXIS,
+ VISIT,
+ RED_START,
+ RED_END,
+ RED_BOXES,
+ RED_INDEX,
+ BLUE_START,
+ BLUE_END,
+ BLUE_BOXES,
+ BLUE_INDEX
+]
+
+function generateBruteForce(redMajor, flip, full) {
+ var funcName = 'bruteForce' +
+ (redMajor ? 'Red' : 'Blue') +
+ (flip ? 'Flip' : '') +
+ (full ? 'Full' : '')
+
+ var code = ['function ', funcName, '(', ARGS.join(), '){',
+ 'var ', ELEM_SIZE, '=2*', DIMENSION, ';']
+
+ var redLoop =
+ 'for(var i=' + RED_START + ',' + RED_PTR + '=' + ELEM_SIZE + '*' + RED_START + ';' +
+ 'i<' + RED_END +';' +
+ '++i,' + RED_PTR + '+=' + ELEM_SIZE + '){' +
+ 'var x0=' + RED_BOXES + '[' + AXIS + '+' + RED_PTR + '],' +
+ 'x1=' + RED_BOXES + '[' + AXIS + '+' + RED_PTR + '+' + DIMENSION + '],' +
+ 'xi=' + RED_INDEX + '[i];'
+
+ var blueLoop =
+ 'for(var j=' + BLUE_START + ',' + BLUE_PTR + '=' + ELEM_SIZE + '*' + BLUE_START + ';' +
+ 'j<' + BLUE_END + ';' +
+ '++j,' + BLUE_PTR + '+=' + ELEM_SIZE + '){' +
+ 'var y0=' + BLUE_BOXES + '[' + AXIS + '+' + BLUE_PTR + '],' +
+ (full ? 'y1=' + BLUE_BOXES + '[' + AXIS + '+' + BLUE_PTR + '+' + DIMENSION + '],' : '') +
+ 'yi=' + BLUE_INDEX + '[j];'
+
+ if(redMajor) {
+ code.push(redLoop, INNER_LABEL, ':', blueLoop)
+ } else {
+ code.push(blueLoop, INNER_LABEL, ':', redLoop)
+ }
+
+ if(full) {
+ code.push('if(y1' +
+ BLUE_END + '-' + BLUE_START + '){')
+
+ if(full) {
+ invoke(true, false)
+ code.push('}else{')
+ invoke(false, false)
+ } else {
+ code.push('if(' + FLIP + '){')
+ invoke(true, true)
+ code.push('}else{')
+ invoke(true, false)
+ code.push('}}else{if(' + FLIP + '){')
+ invoke(false, true)
+ code.push('}else{')
+ invoke(false, false)
+ code.push('}')
+ }
+ code.push('}}return ' + funcName)
+
+ var codeStr = prefix.join('') + code.join('')
+ var proc = new Function(codeStr)
+ return proc()
+}
+
+
+exports.partial = bruteForcePlanner(false)
+exports.full = bruteForcePlanner(true)
+},{}],86:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = boxIntersectIter
+
+var pool = _dereq_('typedarray-pool')
+var bits = _dereq_('bit-twiddle')
+var bruteForce = _dereq_('./brute')
+var bruteForcePartial = bruteForce.partial
+var bruteForceFull = bruteForce.full
+var sweep = _dereq_('./sweep')
+var findMedian = _dereq_('./median')
+var genPartition = _dereq_('./partition')
+
+//Twiddle parameters
+var BRUTE_FORCE_CUTOFF = 128 //Cut off for brute force search
+var SCAN_CUTOFF = (1<<22) //Cut off for two way scan
+var SCAN_COMPLETE_CUTOFF = (1<<22)
+
+//Partition functions
+var partitionInteriorContainsInterval = genPartition(
+ '!(lo>=p0)&&!(p1>=hi)',
+ ['p0', 'p1'])
+
+var partitionStartEqual = genPartition(
+ 'lo===p0',
+ ['p0'])
+
+var partitionStartLessThan = genPartition(
+ 'lo 0) {
+ top -= 1
+
+ var iptr = top * IFRAME_SIZE
+ var axis = BOX_ISTACK[iptr]
+ var redStart = BOX_ISTACK[iptr+1]
+ var redEnd = BOX_ISTACK[iptr+2]
+ var blueStart = BOX_ISTACK[iptr+3]
+ var blueEnd = BOX_ISTACK[iptr+4]
+ var state = BOX_ISTACK[iptr+5]
+
+ var dptr = top * DFRAME_SIZE
+ var lo = BOX_DSTACK[dptr]
+ var hi = BOX_DSTACK[dptr+1]
+
+ //Unpack state info
+ var flip = (state & 1)
+ var full = !!(state & 16)
+
+ //Unpack indices
+ var red = xBoxes
+ var redIndex = xIndex
+ var blue = yBoxes
+ var blueIndex = yIndex
+ if(flip) {
+ red = yBoxes
+ redIndex = yIndex
+ blue = xBoxes
+ blueIndex = xIndex
+ }
+
+ if(state & 2) {
+ redEnd = partitionStartLessThan(
+ d, axis,
+ redStart, redEnd, red, redIndex,
+ hi)
+ if(redStart >= redEnd) {
+ continue
+ }
+ }
+ if(state & 4) {
+ redStart = partitionEndLessThanEqual(
+ d, axis,
+ redStart, redEnd, red, redIndex,
+ lo)
+ if(redStart >= redEnd) {
+ continue
+ }
+ }
+
+ var redCount = redEnd - redStart
+ var blueCount = blueEnd - blueStart
+
+ if(full) {
+ if(d * redCount * (redCount + blueCount) < SCAN_COMPLETE_CUTOFF) {
+ retval = sweep.scanComplete(
+ d, axis, visit,
+ redStart, redEnd, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ continue
+ }
+ } else {
+ if(d * Math.min(redCount, blueCount) < BRUTE_FORCE_CUTOFF) {
+ //If input small, then use brute force
+ retval = bruteForcePartial(
+ d, axis, visit, flip,
+ redStart, redEnd, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ continue
+ } else if(d * redCount * blueCount < SCAN_CUTOFF) {
+ //If input medium sized, then use sweep and prune
+ retval = sweep.scanBipartite(
+ d, axis, visit, flip,
+ redStart, redEnd, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ continue
+ }
+ }
+
+ //First, find all red intervals whose interior contains (lo,hi)
+ var red0 = partitionInteriorContainsInterval(
+ d, axis,
+ redStart, redEnd, red, redIndex,
+ lo, hi)
+
+ //Lower dimensional case
+ if(redStart < red0) {
+
+ if(d * (red0 - redStart) < BRUTE_FORCE_CUTOFF) {
+ //Special case for small inputs: use brute force
+ retval = bruteForceFull(
+ d, axis+1, visit,
+ redStart, red0, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ } else if(axis === d-2) {
+ if(flip) {
+ retval = sweep.sweepBipartite(
+ d, visit,
+ blueStart, blueEnd, blue, blueIndex,
+ redStart, red0, red, redIndex)
+ } else {
+ retval = sweep.sweepBipartite(
+ d, visit,
+ redStart, red0, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex)
+ }
+ if(retval !== void 0) {
+ return retval
+ }
+ } else {
+ iterPush(top++,
+ axis+1,
+ redStart, red0,
+ blueStart, blueEnd,
+ flip,
+ -Infinity, Infinity)
+ iterPush(top++,
+ axis+1,
+ blueStart, blueEnd,
+ redStart, red0,
+ flip^1,
+ -Infinity, Infinity)
+ }
+ }
+
+ //Divide and conquer phase
+ if(red0 < redEnd) {
+
+ //Cut blue into 3 parts:
+ //
+ // Points < mid point
+ // Points = mid point
+ // Points > mid point
+ //
+ var blue0 = findMedian(
+ d, axis,
+ blueStart, blueEnd, blue, blueIndex)
+ var mid = blue[elemSize * blue0 + axis]
+ var blue1 = partitionStartEqual(
+ d, axis,
+ blue0, blueEnd, blue, blueIndex,
+ mid)
+
+ //Right case
+ if(blue1 < blueEnd) {
+ iterPush(top++,
+ axis,
+ red0, redEnd,
+ blue1, blueEnd,
+ (flip|4) + (full ? 16 : 0),
+ mid, hi)
+ }
+
+ //Left case
+ if(blueStart < blue0) {
+ iterPush(top++,
+ axis,
+ red0, redEnd,
+ blueStart, blue0,
+ (flip|2) + (full ? 16 : 0),
+ lo, mid)
+ }
+
+ //Center case (the hard part)
+ if(blue0 + 1 === blue1) {
+ //Optimization: Range with exactly 1 point, use a brute force scan
+ if(full) {
+ retval = onePointFull(
+ d, axis, visit,
+ red0, redEnd, red, redIndex,
+ blue0, blue, blueIndex[blue0])
+ } else {
+ retval = onePointPartial(
+ d, axis, visit, flip,
+ red0, redEnd, red, redIndex,
+ blue0, blue, blueIndex[blue0])
+ }
+ if(retval !== void 0) {
+ return retval
+ }
+ } else if(blue0 < blue1) {
+ var red1
+ if(full) {
+ //If full intersection, need to handle special case
+ red1 = partitionContainsPoint(
+ d, axis,
+ red0, redEnd, red, redIndex,
+ mid)
+ if(red0 < red1) {
+ var redX = partitionStartEqual(
+ d, axis,
+ red0, red1, red, redIndex,
+ mid)
+ if(axis === d-2) {
+ //Degenerate sweep intersection:
+ // [red0, redX] with [blue0, blue1]
+ if(red0 < redX) {
+ retval = sweep.sweepComplete(
+ d, visit,
+ red0, redX, red, redIndex,
+ blue0, blue1, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ }
+
+ //Normal sweep intersection:
+ // [redX, red1] with [blue0, blue1]
+ if(redX < red1) {
+ retval = sweep.sweepBipartite(
+ d, visit,
+ redX, red1, red, redIndex,
+ blue0, blue1, blue, blueIndex)
+ if(retval !== void 0) {
+ return retval
+ }
+ }
+ } else {
+ if(red0 < redX) {
+ iterPush(top++,
+ axis+1,
+ red0, redX,
+ blue0, blue1,
+ 16,
+ -Infinity, Infinity)
+ }
+ if(redX < red1) {
+ iterPush(top++,
+ axis+1,
+ redX, red1,
+ blue0, blue1,
+ 0,
+ -Infinity, Infinity)
+ iterPush(top++,
+ axis+1,
+ blue0, blue1,
+ redX, red1,
+ 1,
+ -Infinity, Infinity)
+ }
+ }
+ }
+ } else {
+ if(flip) {
+ red1 = partitionContainsPointProper(
+ d, axis,
+ red0, redEnd, red, redIndex,
+ mid)
+ } else {
+ red1 = partitionContainsPoint(
+ d, axis,
+ red0, redEnd, red, redIndex,
+ mid)
+ }
+ if(red0 < red1) {
+ if(axis === d-2) {
+ if(flip) {
+ retval = sweep.sweepBipartite(
+ d, visit,
+ blue0, blue1, blue, blueIndex,
+ red0, red1, red, redIndex)
+ } else {
+ retval = sweep.sweepBipartite(
+ d, visit,
+ red0, red1, red, redIndex,
+ blue0, blue1, blue, blueIndex)
+ }
+ } else {
+ iterPush(top++,
+ axis+1,
+ red0, red1,
+ blue0, blue1,
+ flip,
+ -Infinity, Infinity)
+ iterPush(top++,
+ axis+1,
+ blue0, blue1,
+ red0, red1,
+ flip^1,
+ -Infinity, Infinity)
+ }
+ }
+ }
+ }
+ }
+ }
+}
+},{"./brute":85,"./median":87,"./partition":88,"./sweep":90,"bit-twiddle":80,"typedarray-pool":522}],87:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = findMedian
+
+var genPartition = _dereq_('./partition')
+
+var partitionStartLessThan = genPartition('lostart && boxes[ptr+axis] > x;
+ --j, ptr-=elemSize) {
+ //Swap
+ var aPtr = ptr
+ var bPtr = ptr+elemSize
+ for(var k=0; k>> 1)
+ var elemSize = 2*d
+ var pivot = mid
+ var value = boxes[elemSize*mid+axis]
+
+ while(lo < hi) {
+ if(hi - lo < PARTITION_THRESHOLD) {
+ insertionSort(d, axis, lo, hi, boxes, ids)
+ value = boxes[elemSize*mid+axis]
+ break
+ }
+
+ //Select pivot using median-of-3
+ var count = hi - lo
+ var pivot0 = (Math.random()*count+lo)|0
+ var value0 = boxes[elemSize*pivot0 + axis]
+ var pivot1 = (Math.random()*count+lo)|0
+ var value1 = boxes[elemSize*pivot1 + axis]
+ var pivot2 = (Math.random()*count+lo)|0
+ var value2 = boxes[elemSize*pivot2 + axis]
+ if(value0 <= value1) {
+ if(value2 >= value1) {
+ pivot = pivot1
+ value = value1
+ } else if(value0 >= value2) {
+ pivot = pivot0
+ value = value0
+ } else {
+ pivot = pivot2
+ value = value2
+ }
+ } else {
+ if(value1 >= value2) {
+ pivot = pivot1
+ value = value1
+ } else if(value2 >= value0) {
+ pivot = pivot0
+ value = value0
+ } else {
+ pivot = pivot2
+ value = value2
+ }
+ }
+
+ //Swap pivot to end of array
+ var aPtr = elemSize * (hi-1)
+ var bPtr = elemSize * pivot
+ for(var i=0; i= 0) {
+ reads.push('lo=e[k+n]')
+ }
+ if(predicate.indexOf('hi') >= 0) {
+ reads.push('hi=e[k+o]')
+ }
+ fargs.push(
+ code.replace('_', reads.join())
+ .replace('$', predicate))
+ return Function.apply(void 0, fargs)
+}
+},{}],89:[function(_dereq_,module,exports){
+'use strict';
+
+//This code is extracted from ndarray-sort
+//It is inlined here as a temporary workaround
+
+module.exports = wrapper;
+
+var INSERT_SORT_CUTOFF = 32
+
+function wrapper(data, n0) {
+ if (n0 <= 4*INSERT_SORT_CUTOFF) {
+ insertionSort(0, n0 - 1, data);
+ } else {
+ quickSort(0, n0 - 1, data);
+ }
+}
+
+function insertionSort(left, right, data) {
+ var ptr = 2*(left+1)
+ for(var i=left+1; i<=right; ++i) {
+ var a = data[ptr++]
+ var b = data[ptr++]
+ var j = i
+ var jptr = ptr-2
+ while(j-- > left) {
+ var x = data[jptr-2]
+ var y = data[jptr-1]
+ if(x < a) {
+ break
+ } else if(x === a && y < b) {
+ break
+ }
+ data[jptr] = x
+ data[jptr+1] = y
+ jptr -= 2
+ }
+ data[jptr] = a
+ data[jptr+1] = b
+ }
+}
+
+function swap(i, j, data) {
+ i *= 2
+ j *= 2
+ var x = data[i]
+ var y = data[i+1]
+ data[i] = data[j]
+ data[i+1] = data[j+1]
+ data[j] = x
+ data[j+1] = y
+}
+
+function move(i, j, data) {
+ i *= 2
+ j *= 2
+ data[i] = data[j]
+ data[i+1] = data[j+1]
+}
+
+function rotate(i, j, k, data) {
+ i *= 2
+ j *= 2
+ k *= 2
+ var x = data[i]
+ var y = data[i+1]
+ data[i] = data[j]
+ data[i+1] = data[j+1]
+ data[j] = data[k]
+ data[j+1] = data[k+1]
+ data[k] = x
+ data[k+1] = y
+}
+
+function shufflePivot(i, j, px, py, data) {
+ i *= 2
+ j *= 2
+ data[i] = data[j]
+ data[j] = px
+ data[i+1] = data[j+1]
+ data[j+1] = py
+}
+
+function compare(i, j, data) {
+ i *= 2
+ j *= 2
+ var x = data[i],
+ y = data[j]
+ if(x < y) {
+ return false
+ } else if(x === y) {
+ return data[i+1] > data[j+1]
+ }
+ return true
+}
+
+function comparePivot(i, y, b, data) {
+ i *= 2
+ var x = data[i]
+ if(x < y) {
+ return true
+ } else if(x === y) {
+ return data[i+1] < b
+ }
+ return false
+}
+
+function quickSort(left, right, data) {
+ var sixth = (right - left + 1) / 6 | 0,
+ index1 = left + sixth,
+ index5 = right - sixth,
+ index3 = left + right >> 1,
+ index2 = index3 - sixth,
+ index4 = index3 + sixth,
+ el1 = index1,
+ el2 = index2,
+ el3 = index3,
+ el4 = index4,
+ el5 = index5,
+ less = left + 1,
+ great = right - 1,
+ tmp = 0
+ if(compare(el1, el2, data)) {
+ tmp = el1
+ el1 = el2
+ el2 = tmp
+ }
+ if(compare(el4, el5, data)) {
+ tmp = el4
+ el4 = el5
+ el5 = tmp
+ }
+ if(compare(el1, el3, data)) {
+ tmp = el1
+ el1 = el3
+ el3 = tmp
+ }
+ if(compare(el2, el3, data)) {
+ tmp = el2
+ el2 = el3
+ el3 = tmp
+ }
+ if(compare(el1, el4, data)) {
+ tmp = el1
+ el1 = el4
+ el4 = tmp
+ }
+ if(compare(el3, el4, data)) {
+ tmp = el3
+ el3 = el4
+ el4 = tmp
+ }
+ if(compare(el2, el5, data)) {
+ tmp = el2
+ el2 = el5
+ el5 = tmp
+ }
+ if(compare(el2, el3, data)) {
+ tmp = el2
+ el2 = el3
+ el3 = tmp
+ }
+ if(compare(el4, el5, data)) {
+ tmp = el4
+ el4 = el5
+ el5 = tmp
+ }
+
+ var pivot1X = data[2*el2]
+ var pivot1Y = data[2*el2+1]
+ var pivot2X = data[2*el4]
+ var pivot2Y = data[2*el4+1]
+
+ var ptr0 = 2 * el1;
+ var ptr2 = 2 * el3;
+ var ptr4 = 2 * el5;
+ var ptr5 = 2 * index1;
+ var ptr6 = 2 * index3;
+ var ptr7 = 2 * index5;
+ for (var i1 = 0; i1 < 2; ++i1) {
+ var x = data[ptr0+i1];
+ var y = data[ptr2+i1];
+ var z = data[ptr4+i1];
+ data[ptr5+i1] = x;
+ data[ptr6+i1] = y;
+ data[ptr7+i1] = z;
+ }
+
+ move(index2, left, data)
+ move(index4, right, data)
+ for (var k = less; k <= great; ++k) {
+ if (comparePivot(k, pivot1X, pivot1Y, data)) {
+ if (k !== less) {
+ swap(k, less, data)
+ }
+ ++less;
+ } else {
+ if (!comparePivot(k, pivot2X, pivot2Y, data)) {
+ while (true) {
+ if (!comparePivot(great, pivot2X, pivot2Y, data)) {
+ if (--great < k) {
+ break;
+ }
+ continue;
+ } else {
+ if (comparePivot(great, pivot1X, pivot1Y, data)) {
+ rotate(k, less, great, data)
+ ++less;
+ --great;
+ } else {
+ swap(k, great, data)
+ --great;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ shufflePivot(left, less-1, pivot1X, pivot1Y, data)
+ shufflePivot(right, great+1, pivot2X, pivot2Y, data)
+ if (less - 2 - left <= INSERT_SORT_CUTOFF) {
+ insertionSort(left, less - 2, data);
+ } else {
+ quickSort(left, less - 2, data);
+ }
+ if (right - (great + 2) <= INSERT_SORT_CUTOFF) {
+ insertionSort(great + 2, right, data);
+ } else {
+ quickSort(great + 2, right, data);
+ }
+ if (great - less <= INSERT_SORT_CUTOFF) {
+ insertionSort(less, great, data);
+ } else {
+ quickSort(less, great, data);
+ }
+}
+},{}],90:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = {
+ init: sqInit,
+ sweepBipartite: sweepBipartite,
+ sweepComplete: sweepComplete,
+ scanBipartite: scanBipartite,
+ scanComplete: scanComplete
+}
+
+var pool = _dereq_('typedarray-pool')
+var bits = _dereq_('bit-twiddle')
+var isort = _dereq_('./sort')
+
+//Flag for blue
+var BLUE_FLAG = (1<<28)
+
+//1D sweep event queue stuff (use pool to save space)
+var INIT_CAPACITY = 1024
+var RED_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY)
+var RED_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY)
+var BLUE_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY)
+var BLUE_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY)
+var COMMON_SWEEP_QUEUE = pool.mallocInt32(INIT_CAPACITY)
+var COMMON_SWEEP_INDEX = pool.mallocInt32(INIT_CAPACITY)
+var SWEEP_EVENTS = pool.mallocDouble(INIT_CAPACITY * 8)
+
+//Reserves memory for the 1D sweep data structures
+function sqInit(count) {
+ var rcount = bits.nextPow2(count)
+ if(RED_SWEEP_QUEUE.length < rcount) {
+ pool.free(RED_SWEEP_QUEUE)
+ RED_SWEEP_QUEUE = pool.mallocInt32(rcount)
+ }
+ if(RED_SWEEP_INDEX.length < rcount) {
+ pool.free(RED_SWEEP_INDEX)
+ RED_SWEEP_INDEX = pool.mallocInt32(rcount)
+ }
+ if(BLUE_SWEEP_QUEUE.length < rcount) {
+ pool.free(BLUE_SWEEP_QUEUE)
+ BLUE_SWEEP_QUEUE = pool.mallocInt32(rcount)
+ }
+ if(BLUE_SWEEP_INDEX.length < rcount) {
+ pool.free(BLUE_SWEEP_INDEX)
+ BLUE_SWEEP_INDEX = pool.mallocInt32(rcount)
+ }
+ if(COMMON_SWEEP_QUEUE.length < rcount) {
+ pool.free(COMMON_SWEEP_QUEUE)
+ COMMON_SWEEP_QUEUE = pool.mallocInt32(rcount)
+ }
+ if(COMMON_SWEEP_INDEX.length < rcount) {
+ pool.free(COMMON_SWEEP_INDEX)
+ COMMON_SWEEP_INDEX = pool.mallocInt32(rcount)
+ }
+ var eventLength = 8 * rcount
+ if(SWEEP_EVENTS.length < eventLength) {
+ pool.free(SWEEP_EVENTS)
+ SWEEP_EVENTS = pool.mallocDouble(eventLength)
+ }
+}
+
+//Remove an item from the active queue in O(1)
+function sqPop(queue, index, count, item) {
+ var idx = index[item]
+ var top = queue[count-1]
+ queue[idx] = top
+ index[top] = idx
+}
+
+//Insert an item into the active queue in O(1)
+function sqPush(queue, index, count, item) {
+ queue[count] = item
+ index[item] = count
+}
+
+//Recursion base case: use 1D sweep algorithm
+function sweepBipartite(
+ d, visit,
+ redStart, redEnd, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex) {
+
+ //store events as pairs [coordinate, idx]
+ //
+ // red create: -(idx+1)
+ // red destroy: idx
+ // blue create: -(idx+BLUE_FLAG)
+ // blue destroy: idx+BLUE_FLAG
+ //
+ var ptr = 0
+ var elemSize = 2*d
+ var istart = d-1
+ var iend = elemSize-1
+
+ for(var i=redStart; iright
+ var n = ptr >>> 1
+ isort(SWEEP_EVENTS, n)
+
+ var redActive = 0
+ var blueActive = 0
+ for(var i=0; i= BLUE_FLAG) {
+ //blue destroy event
+ e = (e-BLUE_FLAG)|0
+ sqPop(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive--, e)
+ } else if(e >= 0) {
+ //red destroy event
+ sqPop(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive--, e)
+ } else if(e <= -BLUE_FLAG) {
+ //blue create event
+ e = (-e-BLUE_FLAG)|0
+ for(var j=0; jright
+ var n = ptr >>> 1
+ isort(SWEEP_EVENTS, n)
+
+ var redActive = 0
+ var blueActive = 0
+ var commonActive = 0
+ for(var i=0; i>1) === (SWEEP_EVENTS[2*i+3]>>1)) {
+ color = 2
+ i += 1
+ }
+
+ if(e < 0) {
+ //Create event
+ var id = -(e>>1) - 1
+
+ //Intersect with common
+ for(var j=0; j>1) - 1
+ if(color === 0) {
+ //Red
+ sqPop(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive--, id)
+ } else if(color === 1) {
+ //Blue
+ sqPop(BLUE_SWEEP_QUEUE, BLUE_SWEEP_INDEX, blueActive--, id)
+ } else if(color === 2) {
+ //Both
+ sqPop(COMMON_SWEEP_QUEUE, COMMON_SWEEP_INDEX, commonActive--, id)
+ }
+ }
+ }
+}
+
+//Sweep and prune/scanline algorithm:
+// Scan along axis, detect intersections
+// Brute force all boxes along axis
+function scanBipartite(
+ d, axis, visit, flip,
+ redStart, redEnd, red, redIndex,
+ blueStart, blueEnd, blue, blueIndex) {
+
+ var ptr = 0
+ var elemSize = 2*d
+ var istart = axis
+ var iend = axis+d
+
+ var redShift = 1
+ var blueShift = 1
+ if(flip) {
+ blueShift = BLUE_FLAG
+ } else {
+ redShift = BLUE_FLAG
+ }
+
+ for(var i=redStart; iright
+ var n = ptr >>> 1
+ isort(SWEEP_EVENTS, n)
+
+ var redActive = 0
+ for(var i=0; i= BLUE_FLAG) {
+ isRed = !flip
+ idx -= BLUE_FLAG
+ } else {
+ isRed = !!flip
+ idx -= 1
+ }
+ if(isRed) {
+ sqPush(RED_SWEEP_QUEUE, RED_SWEEP_INDEX, redActive++, idx)
+ } else {
+ var blueId = blueIndex[idx]
+ var bluePtr = elemSize * idx
+
+ var b0 = blue[bluePtr+axis+1]
+ var b1 = blue[bluePtr+axis+1+d]
+
+red_loop:
+ for(var j=0; jright
+ var n = ptr >>> 1
+ isort(SWEEP_EVENTS, n)
+
+ var redActive = 0
+ for(var i=0; i= BLUE_FLAG) {
+ RED_SWEEP_QUEUE[redActive++] = idx - BLUE_FLAG
+ } else {
+ idx -= 1
+ var blueId = blueIndex[idx]
+ var bluePtr = elemSize * idx
+
+ var b0 = blue[bluePtr+axis+1]
+ var b1 = blue[bluePtr+axis+1+d]
+
+red_loop:
+ for(var j=0; j=0; --j) {
+ if(RED_SWEEP_QUEUE[j] === idx) {
+ for(var k=j+1; k 1)
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ // At least give some kind of context to the user
+ var err = new Error('Unhandled "error" event. (' + er + ')');
+ err.context = er;
+ throw err;
+ }
+ return false;
+ }
+
+ handler = events[type];
+
+ if (!handler)
+ return false;
+
+ var isFn = typeof handler === 'function';
+ len = arguments.length;
+ switch (len) {
+ // fast cases
+ case 1:
+ emitNone(handler, isFn, this);
+ break;
+ case 2:
+ emitOne(handler, isFn, this, arguments[1]);
+ break;
+ case 3:
+ emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+ break;
+ case 4:
+ emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+ break;
+ // slower
+ default:
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ emitMany(handler, isFn, this, args);
+ }
+
+ return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
+
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+
+ events = target._events;
+ if (!events) {
+ events = target._events = objectCreate(null);
+ target._eventsCount = 0;
+ } else {
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (events.newListener) {
+ target.emit('newListener', type,
+ listener.listener ? listener.listener : listener);
+
+ // Re-assign `events` because a newListener handler could have caused the
+ // this._events to be assigned to a new object
+ events = target._events;
+ }
+ existing = events[type];
+ }
+
+ if (!existing) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ existing = events[type] = listener;
+ ++target._eventsCount;
+ } else {
+ if (typeof existing === 'function') {
+ // Adding the second element, need to change to array.
+ existing = events[type] =
+ prepend ? [listener, existing] : [existing, listener];
+ } else {
+ // If we've already got an array, just append.
+ if (prepend) {
+ existing.unshift(listener);
+ } else {
+ existing.push(listener);
+ }
+ }
+
+ // Check for listener leak
+ if (!existing.warned) {
+ m = $getMaxListeners(target);
+ if (m && m > 0 && existing.length > m) {
+ existing.warned = true;
+ var w = new Error('Possible EventEmitter memory leak detected. ' +
+ existing.length + ' "' + String(type) + '" listeners ' +
+ 'added. Use emitter.setMaxListeners() to ' +
+ 'increase limit.');
+ w.name = 'MaxListenersExceededWarning';
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ if (typeof console === 'object' && console.warn) {
+ console.warn('%s: %s', w.name, w.message);
+ }
+ }
+ }
+ }
+
+ return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+ function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+
+function onceWrapper() {
+ if (!this.fired) {
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
+ switch (arguments.length) {
+ case 0:
+ return this.listener.call(this.target);
+ case 1:
+ return this.listener.call(this.target, arguments[0]);
+ case 2:
+ return this.listener.call(this.target, arguments[0], arguments[1]);
+ case 3:
+ return this.listener.call(this.target, arguments[0], arguments[1],
+ arguments[2]);
+ default:
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; ++i)
+ args[i] = arguments[i];
+ this.listener.apply(this.target, args);
+ }
+ }
+}
+
+function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+ var wrapped = bind.call(onceWrapper, state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+ function prependOnceListener(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+ function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
+
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+
+ events = this._events;
+ if (!events)
+ return this;
+
+ list = events[type];
+ if (!list)
+ return this;
+
+ if (list === listener || list.listener === listener) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else {
+ delete events[type];
+ if (events.removeListener)
+ this.emit('removeListener', type, list.listener || listener);
+ }
+ } else if (typeof list !== 'function') {
+ position = -1;
+
+ for (i = list.length - 1; i >= 0; i--) {
+ if (list[i] === listener || list[i].listener === listener) {
+ originalListener = list[i].listener;
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (position === 0)
+ list.shift();
+ else
+ spliceOne(list, position);
+
+ if (list.length === 1)
+ events[type] = list[0];
+
+ if (events.removeListener)
+ this.emit('removeListener', type, originalListener || listener);
+ }
+
+ return this;
+ };
+
+EventEmitter.prototype.removeAllListeners =
+ function removeAllListeners(type) {
+ var listeners, events, i;
+
+ events = this._events;
+ if (!events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!events.removeListener) {
+ if (arguments.length === 0) {
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ } else if (events[type]) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else
+ delete events[type];
+ }
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ var keys = objectKeys(events);
+ var key;
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ return this;
+ }
+
+ listeners = events[type];
+
+ if (typeof listeners === 'function') {
+ this.removeListener(type, listeners);
+ } else if (listeners) {
+ // LIFO order
+ for (i = listeners.length - 1; i >= 0; i--) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
+
+ return this;
+ };
+
+function _listeners(target, type, unwrap) {
+ var events = target._events;
+
+ if (!events)
+ return [];
+
+ var evlistener = events[type];
+ if (!evlistener)
+ return [];
+
+ if (typeof evlistener === 'function')
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+ return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ if (typeof emitter.listenerCount === 'function') {
+ return emitter.listenerCount(type);
+ } else {
+ return listenerCount.call(emitter, type);
+ }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+ var events = this._events;
+
+ if (events) {
+ var evlistener = events[type];
+
+ if (typeof evlistener === 'function') {
+ return 1;
+ } else if (evlistener) {
+ return evlistener.length;
+ }
+ }
+
+ return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
+
+// About 1.5x faster than the two-arg version of Array#splice().
+function spliceOne(list, index) {
+ for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+ list[i] = list[k];
+ list.pop();
+}
+
+function arrayClone(arr, n) {
+ var copy = new Array(n);
+ for (var i = 0; i < n; ++i)
+ copy[i] = arr[i];
+ return copy;
+}
+
+function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
+ for (var i = 0; i < ret.length; ++i) {
+ ret[i] = arr[i].listener || arr[i];
+ }
+ return ret;
+}
+
+function objectCreatePolyfill(proto) {
+ var F = function() {};
+ F.prototype = proto;
+ return new F;
+}
+function objectKeysPolyfill(obj) {
+ var keys = [];
+ for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
+ keys.push(k);
+ }
+ return k;
+}
+function functionBindPolyfill(context) {
+ var fn = this;
+ return function () {
+ return fn.apply(context, arguments);
+ };
+}
+
+},{}],93:[function(_dereq_,module,exports){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @license MIT
+ */
+/* eslint-disable no-proto */
+
+'use strict'
+
+var base64 = _dereq_('base64-js')
+var ieee754 = _dereq_('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
+
+var K_MAX_LENGTH = 0x7fffffff
+exports.kMaxLength = K_MAX_LENGTH
+
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Print warning and recommend using `buffer` v4.x which has an Object
+ * implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+ typeof console.error === 'function') {
+ console.error(
+ 'This browser lacks typed array (Uint8Array) support which is required by ' +
+ '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+ )
+}
+
+function typedArraySupport () {
+ // Can typed array instances can be augmented?
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
+ return arr.foo() === 42
+ } catch (e) {
+ return false
+ }
+}
+
+Object.defineProperty(Buffer.prototype, 'parent', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.buffer
+ }
+})
+
+Object.defineProperty(Buffer.prototype, 'offset', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.byteOffset
+ }
+})
+
+function createBuffer (length) {
+ if (length > K_MAX_LENGTH) {
+ throw new RangeError('The value "' + length + '" is invalid for option "size"')
+ }
+ // Return an augmented `Uint8Array` instance
+ var buf = new Uint8Array(length)
+ buf.__proto__ = Buffer.prototype
+ return buf
+}
+
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
+
+function Buffer (arg, encodingOrOffset, length) {
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new TypeError(
+ 'The "string" argument must be of type string. Received type number'
+ )
+ }
+ return allocUnsafe(arg)
+ }
+ return from(arg, encodingOrOffset, length)
+}
+
+// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+if (typeof Symbol !== 'undefined' && Symbol.species != null &&
+ Buffer[Symbol.species] === Buffer) {
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true,
+ enumerable: false,
+ writable: false
+ })
+}
+
+Buffer.poolSize = 8192 // not used by this implementation
+
+function from (value, encodingOrOffset, length) {
+ if (typeof value === 'string') {
+ return fromString(value, encodingOrOffset)
+ }
+
+ if (ArrayBuffer.isView(value)) {
+ return fromArrayLike(value)
+ }
+
+ if (value == null) {
+ throw TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+ }
+
+ if (isInstance(value, ArrayBuffer) ||
+ (value && isInstance(value.buffer, ArrayBuffer))) {
+ return fromArrayBuffer(value, encodingOrOffset, length)
+ }
+
+ if (typeof value === 'number') {
+ throw new TypeError(
+ 'The "value" argument must not be of type number. Received type number'
+ )
+ }
+
+ var valueOf = value.valueOf && value.valueOf()
+ if (valueOf != null && valueOf !== value) {
+ return Buffer.from(valueOf, encodingOrOffset, length)
+ }
+
+ var b = fromObject(value)
+ if (b) return b
+
+ if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+ typeof value[Symbol.toPrimitive] === 'function') {
+ return Buffer.from(
+ value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+ )
+ }
+
+ throw new TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+}
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(value, encodingOrOffset, length)
+}
+
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Buffer.prototype.__proto__ = Uint8Array.prototype
+Buffer.__proto__ = Uint8Array
+
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be of type number')
+ } else if (size < 0) {
+ throw new RangeError('The value "' + size + '" is invalid for option "size"')
+ }
+}
+
+function alloc (size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(size)
+ }
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(size).fill(fill, encoding)
+ : createBuffer(size).fill(fill)
+ }
+ return createBuffer(size)
+}
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(size, fill, encoding)
+}
+
+function allocUnsafe (size) {
+ assertSize(size)
+ return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(size)
+}
+
+function fromString (string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
+ }
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+
+ var length = byteLength(string, encoding) | 0
+ var buf = createBuffer(length)
+
+ var actual = buf.write(string, encoding)
+
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ buf = buf.slice(0, actual)
+ }
+
+ return buf
+}
+
+function fromArrayLike (array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ var buf = createBuffer(length)
+ for (var i = 0; i < length; i += 1) {
+ buf[i] = array[i] & 255
+ }
+ return buf
+}
+
+function fromArrayBuffer (array, byteOffset, length) {
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('"offset" is outside of buffer bounds')
+ }
+
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('"length" is outside of buffer bounds')
+ }
+
+ var buf
+ if (byteOffset === undefined && length === undefined) {
+ buf = new Uint8Array(array)
+ } else if (length === undefined) {
+ buf = new Uint8Array(array, byteOffset)
+ } else {
+ buf = new Uint8Array(array, byteOffset, length)
+ }
+
+ // Return an augmented `Uint8Array` instance
+ buf.__proto__ = Buffer.prototype
+ return buf
+}
+
+function fromObject (obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ var buf = createBuffer(len)
+
+ if (buf.length === 0) {
+ return buf
+ }
+
+ obj.copy(buf, 0, 0, len)
+ return buf
+ }
+
+ if (obj.length !== undefined) {
+ if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+ return createBuffer(0)
+ }
+ return fromArrayLike(obj)
+ }
+
+ if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+ return fromArrayLike(obj.data)
+ }
+}
+
+function checked (length) {
+ // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= K_MAX_LENGTH) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+ }
+ return length | 0
+}
+
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
+ }
+ return Buffer.alloc(+length)
+}
+
+Buffer.isBuffer = function isBuffer (b) {
+ return b != null && b._isBuffer === true &&
+ b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+}
+
+Buffer.compare = function compare (a, b) {
+ if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+ if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError(
+ 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+ )
+ }
+
+ if (a === b) return 0
+
+ var x = a.length
+ var y = b.length
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.concat = function concat (list, length) {
+ if (!Array.isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+
+ if (list.length === 0) {
+ return Buffer.alloc(0)
+ }
+
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
+ }
+ }
+
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (isInstance(buf, Uint8Array)) {
+ buf = Buffer.from(buf)
+ }
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
+ }
+ return buffer
+}
+
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
+ }
+ if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+ return string.byteLength
+ }
+ if (typeof string !== 'string') {
+ throw new TypeError(
+ 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+ 'Received type ' + typeof string
+ )
+ }
+
+ var len = string.length
+ var mustMatch = (arguments.length > 2 && arguments[2] === true)
+ if (!mustMatch && len === 0) return 0
+
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) {
+ return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
+ }
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+Buffer.byteLength = byteLength
+
+function slowToString (encoding, start, end) {
+ var loweredCase = false
+
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
+
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
+
+ if (end === undefined || end > this.length) {
+ end = this.length
+ }
+
+ if (end <= 0) {
+ return ''
+ }
+
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
+
+ if (end <= start) {
+ return ''
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
+
+ case 'ascii':
+ return asciiSlice(this, start, end)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
+
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+Buffer.prototype._isBuffer = true
+
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
+}
+
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
+ }
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
+ }
+ return this
+}
+
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
+ }
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
+ }
+ return this
+}
+
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
+
+Buffer.prototype.toString = function toString () {
+ var length = this.length
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
+
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+ if (this.length > max) str += ' ... '
+ return ''
+}
+
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (isInstance(target, Uint8Array)) {
+ target = Buffer.from(target, target.offset, target.byteLength)
+ }
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError(
+ 'The "target" argument must be one of type Buffer or Uint8Array. ' +
+ 'Received type ' + (typeof target)
+ )
+ }
+
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
+
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
+ }
+
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
+ }
+
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
+
+ if (this === target) return 0
+
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
+ }
+
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
+
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (numberIsNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
+ }
+
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
+
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
+ }
+
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+ } else {
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+ }
+ }
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
+ }
+
+ throw new TypeError('val must be string, number or Buffer')
+}
+
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+ } else {
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
+ }
+ }
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
+ }
+
+ return -1
+}
+
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
+
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
+
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+}
+
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ var strLen = string.length
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (numberIsNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
+}
+
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
+
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
+
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
+
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
+
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset >>> 0
+ if (isFinite(length)) {
+ length = length >>> 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
+
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
+
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
+ }
+
+ if (!encoding) encoding = 'utf8'
+
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
+
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
+
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
+
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
+
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
+ }
+}
+
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
+
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
+
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
+
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
+
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
+
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
+
+ return decodeCodePointsArray(res)
+}
+
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
+
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
+
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
+
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
+}
+
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
+
+function hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+ }
+ return res
+}
+
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
+
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
+
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
+
+ if (end < start) end = start
+
+ var newBuf = this.subarray(start, end)
+ // Return an augmented `Uint8Array` instance
+ newBuf.__proto__ = Buffer.prototype
+ return newBuf
+}
+
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
+
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
+}
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
+}
+
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
+
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
+
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
+
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
+
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
+
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+ return val
+}
+
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
+
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
+
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
+
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
+
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
+
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
+
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
+
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
+
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
+
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
+}
+
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ return offset + 4
+}
+
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
+
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
+
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
+
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
+
+ return offset + byteLength
+}
+
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
+
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
+
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
+}
+
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ return offset + 4
+}
+
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
+
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
+
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
+
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
+
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
+
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
+
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
+ }
+
+ var len = end - start
+
+ if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+ // Use built-in when available, missing from IE11
+ this.copyWithin(targetStart, start, end)
+ } else if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (var i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, end),
+ targetStart
+ )
+ }
+
+ return len
+}
+
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if ((encoding === 'utf8' && code < 128) ||
+ encoding === 'latin1') {
+ // Fast path: If `val` fits into a single byte, use that numeric value.
+ val = code
+ }
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
+ }
+
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
+ }
+
+ if (end <= start) {
+ return this
+ }
+
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
+
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
+ }
+ } else {
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : Buffer.from(val, encoding)
+ var len = bytes.length
+ if (len === 0) {
+ throw new TypeError('The value "' + val +
+ '" is invalid for argument "value"')
+ }
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
+ }
+
+ return this
+}
+
+// HELPER FUNCTIONS
+// ================
+
+var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+function base64clean (str) {
+ // Node takes equal signs as end of the Base64 encoding
+ str = str.split('=')[0]
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = str.trim().replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
+ }
+ return str
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
+
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
+
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
+
+ // valid lead
+ leadSurrogate = codePoint
+
+ continue
+ }
+
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
+
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ }
+
+ leadSurrogate = null
+
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else {
+ throw new Error('Invalid code point')
+ }
+ }
+
+ return bytes
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
+
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
+
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+// the `instanceof` check but they should be treated as of that type.
+// See: https://github.com/feross/buffer/issues/166
+function isInstance (obj, type) {
+ return obj instanceof type ||
+ (obj != null && obj.constructor != null && obj.constructor.name != null &&
+ obj.constructor.name === type.name)
+}
+function numberIsNaN (obj) {
+ // For IE11 support
+ return obj !== obj // eslint-disable-line no-self-compare
+}
+
+},{"base64-js":62,"ieee754":395}],94:[function(_dereq_,module,exports){
+'use strict'
+
+var monotoneTriangulate = _dereq_('./lib/monotone')
+var makeIndex = _dereq_('./lib/triangulation')
+var delaunayFlip = _dereq_('./lib/delaunay')
+var filterTriangulation = _dereq_('./lib/filter')
+
+module.exports = cdt2d
+
+function canonicalizeEdge(e) {
+ return [Math.min(e[0], e[1]), Math.max(e[0], e[1])]
+}
+
+function compareEdge(a, b) {
+ return a[0]-b[0] || a[1]-b[1]
+}
+
+function canonicalizeEdges(edges) {
+ return edges.map(canonicalizeEdge).sort(compareEdge)
+}
+
+function getDefault(options, property, dflt) {
+ if(property in options) {
+ return options[property]
+ }
+ return dflt
+}
+
+function cdt2d(points, edges, options) {
+
+ if(!Array.isArray(edges)) {
+ options = edges || {}
+ edges = []
+ } else {
+ options = options || {}
+ edges = edges || []
+ }
+
+ //Parse out options
+ var delaunay = !!getDefault(options, 'delaunay', true)
+ var interior = !!getDefault(options, 'interior', true)
+ var exterior = !!getDefault(options, 'exterior', true)
+ var infinity = !!getDefault(options, 'infinity', false)
+
+ //Handle trivial case
+ if((!interior && !exterior) || points.length === 0) {
+ return []
+ }
+
+ //Construct initial triangulation
+ var cells = monotoneTriangulate(points, edges)
+
+ //If delaunay refinement needed, then improve quality by edge flipping
+ if(delaunay || interior !== exterior || infinity) {
+
+ //Index all of the cells to support fast neighborhood queries
+ var triangulation = makeIndex(points.length, canonicalizeEdges(edges))
+ for(var i=0; i 0) {
+ var b = stack.pop()
+ var a = stack.pop()
+
+ //Find opposite pairs
+ var x = -1, y = -1
+ var star = stars[a]
+ for(var i=1; i= 0) {
+ continue
+ }
+
+ //Flip the edge
+ triangulation.flip(a, b)
+
+ //Test flipping neighboring edges
+ testFlip(points, triangulation, stack, x, a, y)
+ testFlip(points, triangulation, stack, a, y, x)
+ testFlip(points, triangulation, stack, y, b, x)
+ testFlip(points, triangulation, stack, b, x, y)
+ }
+}
+
+},{"binary-search-bounds":99,"robust-in-sphere":484}],96:[function(_dereq_,module,exports){
+'use strict'
+
+var bsearch = _dereq_('binary-search-bounds')
+
+module.exports = classifyFaces
+
+function FaceIndex(cells, neighbor, constraint, flags, active, next, boundary) {
+ this.cells = cells
+ this.neighbor = neighbor
+ this.flags = flags
+ this.constraint = constraint
+ this.active = active
+ this.next = next
+ this.boundary = boundary
+}
+
+var proto = FaceIndex.prototype
+
+function compareCell(a, b) {
+ return a[0] - b[0] ||
+ a[1] - b[1] ||
+ a[2] - b[2]
+}
+
+proto.locate = (function() {
+ var key = [0,0,0]
+ return function(a, b, c) {
+ var x = a, y = b, z = c
+ if(b < c) {
+ if(b < a) {
+ x = b
+ y = c
+ z = a
+ }
+ } else if(c < a) {
+ x = c
+ y = a
+ z = b
+ }
+ if(x < 0) {
+ return -1
+ }
+ key[0] = x
+ key[1] = y
+ key[2] = z
+ return bsearch.eq(this.cells, key, compareCell)
+ }
+})()
+
+function indexCells(triangulation, infinity) {
+ //First get cells and canonicalize
+ var cells = triangulation.cells()
+ var nc = cells.length
+ for(var i=0; i 0 || next.length > 0) {
+ while(active.length > 0) {
+ var t = active.pop()
+ if(flags[t] === -side) {
+ continue
+ }
+ flags[t] = side
+ var c = cells[t]
+ for(var j=0; j<3; ++j) {
+ var f = neighbor[3*t+j]
+ if(f >= 0 && flags[f] === 0) {
+ if(constraint[3*t+j]) {
+ next.push(f)
+ } else {
+ active.push(f)
+ flags[f] = side
+ }
+ }
+ }
+ }
+
+ //Swap arrays and loop
+ var tmp = next
+ next = active
+ active = tmp
+ next.length = 0
+ side = -side
+ }
+
+ var result = filterCells(cells, flags, target)
+ if(infinity) {
+ return result.concat(index.boundary)
+ }
+ return result
+}
+
+},{"binary-search-bounds":99}],97:[function(_dereq_,module,exports){
+'use strict'
+
+var bsearch = _dereq_('binary-search-bounds')
+var orient = _dereq_('robust-orientation')[3]
+
+var EVENT_POINT = 0
+var EVENT_END = 1
+var EVENT_START = 2
+
+module.exports = monotoneTriangulate
+
+//A partial convex hull fragment, made of two unimonotone polygons
+function PartialHull(a, b, idx, lowerIds, upperIds) {
+ this.a = a
+ this.b = b
+ this.idx = idx
+ this.lowerIds = lowerIds
+ this.upperIds = upperIds
+}
+
+//An event in the sweep line procedure
+function Event(a, b, type, idx) {
+ this.a = a
+ this.b = b
+ this.type = type
+ this.idx = idx
+}
+
+//This is used to compare events for the sweep line procedure
+// Points are:
+// 1. sorted lexicographically
+// 2. sorted by type (point < end < start)
+// 3. segments sorted by winding order
+// 4. sorted by index
+function compareEvent(a, b) {
+ var d =
+ (a.a[0] - b.a[0]) ||
+ (a.a[1] - b.a[1]) ||
+ (a.type - b.type)
+ if(d) { return d }
+ if(a.type !== EVENT_POINT) {
+ d = orient(a.a, a.b, b.b)
+ if(d) { return d }
+ }
+ return a.idx - b.idx
+}
+
+function testPoint(hull, p) {
+ return orient(hull.a, hull.b, p)
+}
+
+function addPoint(cells, hulls, points, p, idx) {
+ var lo = bsearch.lt(hulls, p, testPoint)
+ var hi = bsearch.gt(hulls, p, testPoint)
+ for(var i=lo; i 1 && orient(
+ points[lowerIds[m-2]],
+ points[lowerIds[m-1]],
+ p) > 0) {
+ cells.push(
+ [lowerIds[m-1],
+ lowerIds[m-2],
+ idx])
+ m -= 1
+ }
+ lowerIds.length = m
+ lowerIds.push(idx)
+
+ //Insert p into upper hull
+ var upperIds = hull.upperIds
+ var m = upperIds.length
+ while(m > 1 && orient(
+ points[upperIds[m-2]],
+ points[upperIds[m-1]],
+ p) < 0) {
+ cells.push(
+ [upperIds[m-2],
+ upperIds[m-1],
+ idx])
+ m -= 1
+ }
+ upperIds.length = m
+ upperIds.push(idx)
+ }
+}
+
+function findSplit(hull, edge) {
+ var d
+ if(hull.a[0] < edge.a[0]) {
+ d = orient(hull.a, hull.b, edge.a)
+ } else {
+ d = orient(edge.b, edge.a, hull.a)
+ }
+ if(d) { return d }
+ if(edge.b[0] < hull.b[0]) {
+ d = orient(hull.a, hull.b, edge.b)
+ } else {
+ d = orient(edge.b, edge.a, hull.b)
+ }
+ return d || hull.idx - edge.idx
+}
+
+function splitHulls(hulls, points, event) {
+ var splitIdx = bsearch.le(hulls, event, findSplit)
+ var hull = hulls[splitIdx]
+ var upperIds = hull.upperIds
+ var x = upperIds[upperIds.length-1]
+ hull.upperIds = [x]
+ hulls.splice(splitIdx+1, 0,
+ new PartialHull(event.a, event.b, event.idx, [x], upperIds))
+}
+
+
+function mergeHulls(hulls, points, event) {
+ //Swap pointers for merge search
+ var tmp = event.a
+ event.a = event.b
+ event.b = tmp
+ var mergeIdx = bsearch.eq(hulls, event, findSplit)
+ var upper = hulls[mergeIdx]
+ var lower = hulls[mergeIdx-1]
+ lower.upperIds = upper.upperIds
+ hulls.splice(mergeIdx, 1)
+}
+
+
+function monotoneTriangulate(points, edges) {
+
+ var numPoints = points.length
+ var numEdges = edges.length
+
+ var events = []
+
+ //Create point events
+ for(var i=0; i b[0]) {
+ events.push(
+ new Event(b, a, EVENT_START, i),
+ new Event(a, b, EVENT_END, i))
+ }
+ }
+
+ //Sort events
+ events.sort(compareEvent)
+
+ //Initialize hull
+ var minX = events[0].a[0] - (1 + Math.abs(events[0].a[0])) * Math.pow(2, -52)
+ var hull = [ new PartialHull([minX, 1], [minX, 0], -1, [], [], [], []) ]
+
+ //Process events in order
+ var cells = []
+ for(var i=0, numEvents=events.length; i= 0
+ }
+})()
+
+proto.removeTriangle = function(i, j, k) {
+ var stars = this.stars
+ removePair(stars[i], j, k)
+ removePair(stars[j], k, i)
+ removePair(stars[k], i, j)
+}
+
+proto.addTriangle = function(i, j, k) {
+ var stars = this.stars
+ stars[i].push(j, k)
+ stars[j].push(k, i)
+ stars[k].push(i, j)
+}
+
+proto.opposite = function(j, i) {
+ var list = this.stars[i]
+ for(var k=1, n=list.length; k>>1,x=a[m]"]
+ if(earlyOut) {
+ if(predicate.indexOf("c") < 0) {
+ code.push(";if(x===y){return m}else if(x<=y){")
+ } else {
+ code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){")
+ }
+ } else {
+ code.push(";if(", predicate, "){i=m;")
+ }
+ if(reversed) {
+ code.push("l=m+1}else{h=m-1}")
+ } else {
+ code.push("h=m-1}else{l=m+1}")
+ }
+ code.push("}")
+ if(earlyOut) {
+ code.push("return -1};")
+ } else {
+ code.push("return i};")
+ }
+ return code.join("")
+}
+
+function compileBoundsSearch(predicate, reversed, suffix, earlyOut) {
+ var result = new Function([
+ compileSearch("A", "x" + predicate + "y", reversed, ["y"], earlyOut),
+ compileSearch("P", "c(x,y)" + predicate + "0", reversed, ["y", "c"], earlyOut),
+"function dispatchBsearch", suffix, "(a,y,c,l,h){\
+if(typeof(c)==='function'){\
+return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
+}}\
+return dispatchBsearch", suffix].join(""))
+ return result()
+}
+
+module.exports = {
+ ge: compileBoundsSearch(">=", false, "GE"),
+ gt: compileBoundsSearch(">", false, "GT"),
+ lt: compileBoundsSearch("<", true, "LT"),
+ le: compileBoundsSearch("<=", true, "LE"),
+ eq: compileBoundsSearch("-", true, "EQ", true)
+}
+
+},{}],100:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = orientation
+
+function orientation(s) {
+ var p = 1
+ for(var i=1; i max ? max : value)
+ : (value < max ? max : value > min ? min : value)
+}
+
+},{}],104:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = cleanPSLG
+
+var UnionFind = _dereq_('union-find')
+var boxIntersect = _dereq_('box-intersect')
+var segseg = _dereq_('robust-segment-intersect')
+var rat = _dereq_('big-rat')
+var ratCmp = _dereq_('big-rat/cmp')
+var ratToFloat = _dereq_('big-rat/to-float')
+var ratVec = _dereq_('rat-vec')
+var nextafter = _dereq_('nextafter')
+
+var solveIntersection = _dereq_('./lib/rat-seg-intersect')
+
+// Bounds on a rational number when rounded to a float
+function boundRat (r) {
+ var f = ratToFloat(r)
+ return [
+ nextafter(f, -Infinity),
+ nextafter(f, Infinity)
+ ]
+}
+
+// Convert a list of edges in a pslg to bounding boxes
+function boundEdges (points, edges) {
+ var bounds = new Array(edges.length)
+ for (var i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ var a = points[e[0]]
+ var b = points[e[1]]
+ bounds[i] = [
+ nextafter(Math.min(a[0], b[0]), -Infinity),
+ nextafter(Math.min(a[1], b[1]), -Infinity),
+ nextafter(Math.max(a[0], b[0]), Infinity),
+ nextafter(Math.max(a[1], b[1]), Infinity)
+ ]
+ }
+ return bounds
+}
+
+// Convert a list of points into bounding boxes by duplicating coords
+function boundPoints (points) {
+ var bounds = new Array(points.length)
+ for (var i = 0; i < points.length; ++i) {
+ var p = points[i]
+ bounds[i] = [
+ nextafter(p[0], -Infinity),
+ nextafter(p[1], -Infinity),
+ nextafter(p[0], Infinity),
+ nextafter(p[1], Infinity)
+ ]
+ }
+ return bounds
+}
+
+// Find all pairs of crossing edges in a pslg (given edge bounds)
+function getCrossings (points, edges, edgeBounds) {
+ var result = []
+ boxIntersect(edgeBounds, function (i, j) {
+ var e = edges[i]
+ var f = edges[j]
+ if (e[0] === f[0] || e[0] === f[1] ||
+ e[1] === f[0] || e[1] === f[1]) {
+ return
+ }
+ var a = points[e[0]]
+ var b = points[e[1]]
+ var c = points[f[0]]
+ var d = points[f[1]]
+ if (segseg(a, b, c, d)) {
+ result.push([i, j])
+ }
+ })
+ return result
+}
+
+// Find all pairs of crossing vertices in a pslg (given edge/vert bounds)
+function getTJunctions (points, edges, edgeBounds, vertBounds) {
+ var result = []
+ boxIntersect(edgeBounds, vertBounds, function (i, v) {
+ var e = edges[i]
+ if (e[0] === v || e[1] === v) {
+ return
+ }
+ var p = points[v]
+ var a = points[e[0]]
+ var b = points[e[1]]
+ if (segseg(a, b, p, p)) {
+ result.push([i, v])
+ }
+ })
+ return result
+}
+
+// Cut edges along crossings/tjunctions
+function cutEdges (floatPoints, edges, crossings, junctions, useColor) {
+ var i, e
+
+ // Convert crossings into tjunctions by constructing rational points
+ var ratPoints = floatPoints.map(function(p) {
+ return [
+ rat(p[0]),
+ rat(p[1])
+ ]
+ })
+ for (i = 0; i < crossings.length; ++i) {
+ var crossing = crossings[i]
+ e = crossing[0]
+ var f = crossing[1]
+ var ee = edges[e]
+ var ef = edges[f]
+ var x = solveIntersection(
+ ratVec(floatPoints[ee[0]]),
+ ratVec(floatPoints[ee[1]]),
+ ratVec(floatPoints[ef[0]]),
+ ratVec(floatPoints[ef[1]]))
+ if (!x) {
+ // Segments are parallel, should already be handled by t-junctions
+ continue
+ }
+ var idx = floatPoints.length
+ floatPoints.push([ratToFloat(x[0]), ratToFloat(x[1])])
+ ratPoints.push(x)
+ junctions.push([e, idx], [f, idx])
+ }
+
+ // Sort tjunctions
+ junctions.sort(function (a, b) {
+ if (a[0] !== b[0]) {
+ return a[0] - b[0]
+ }
+ var u = ratPoints[a[1]]
+ var v = ratPoints[b[1]]
+ return ratCmp(u[0], v[0]) || ratCmp(u[1], v[1])
+ })
+
+ // Split edges along junctions
+ for (i = junctions.length - 1; i >= 0; --i) {
+ var junction = junctions[i]
+ e = junction[0]
+
+ var edge = edges[e]
+ var s = edge[0]
+ var t = edge[1]
+
+ // Check if edge is not lexicographically sorted
+ var a = floatPoints[s]
+ var b = floatPoints[t]
+ if (((a[0] - b[0]) || (a[1] - b[1])) < 0) {
+ var tmp = s
+ s = t
+ t = tmp
+ }
+
+ // Split leading edge
+ edge[0] = s
+ var last = edge[1] = junction[1]
+
+ // If we are grouping edges by color, remember to track data
+ var color
+ if (useColor) {
+ color = edge[2]
+ }
+
+ // Split other edges
+ while (i > 0 && junctions[i - 1][0] === e) {
+ var junction = junctions[--i]
+ var next = junction[1]
+ if (useColor) {
+ edges.push([last, next, color])
+ } else {
+ edges.push([last, next])
+ }
+ last = next
+ }
+
+ // Add final edge
+ if (useColor) {
+ edges.push([last, t, color])
+ } else {
+ edges.push([last, t])
+ }
+ }
+
+ // Return constructed rational points
+ return ratPoints
+}
+
+// Merge overlapping points
+function dedupPoints (floatPoints, ratPoints, floatBounds) {
+ var numPoints = ratPoints.length
+ var uf = new UnionFind(numPoints)
+
+ // Compute rational bounds
+ var bounds = []
+ for (var i = 0; i < ratPoints.length; ++i) {
+ var p = ratPoints[i]
+ var xb = boundRat(p[0])
+ var yb = boundRat(p[1])
+ bounds.push([
+ nextafter(xb[0], -Infinity),
+ nextafter(yb[0], -Infinity),
+ nextafter(xb[1], Infinity),
+ nextafter(yb[1], Infinity)
+ ])
+ }
+
+ // Link all points with over lapping boxes
+ boxIntersect(bounds, function (i, j) {
+ uf.link(i, j)
+ })
+
+ // Do 1 pass over points to combine points in label sets
+ var noDupes = true
+ var labels = new Array(numPoints)
+ for (var i = 0; i < numPoints; ++i) {
+ var j = uf.find(i)
+ if (j !== i) {
+ // Clear no-dupes flag, zero out label
+ noDupes = false
+ // Make each point the top-left point from its cell
+ floatPoints[j] = [
+ Math.min(floatPoints[i][0], floatPoints[j][0]),
+ Math.min(floatPoints[i][1], floatPoints[j][1])
+ ]
+ }
+ }
+
+ // If no duplicates, return null to signal termination
+ if (noDupes) {
+ return null
+ }
+
+ var ptr = 0
+ for (var i = 0; i < numPoints; ++i) {
+ var j = uf.find(i)
+ if (j === i) {
+ labels[i] = ptr
+ floatPoints[ptr++] = floatPoints[i]
+ } else {
+ labels[i] = -1
+ }
+ }
+
+ floatPoints.length = ptr
+
+ // Do a second pass to fix up missing labels
+ for (var i = 0; i < numPoints; ++i) {
+ if (labels[i] < 0) {
+ labels[i] = labels[uf.find(i)]
+ }
+ }
+
+ // Return resulting union-find data structure
+ return labels
+}
+
+function compareLex2 (a, b) { return (a[0] - b[0]) || (a[1] - b[1]) }
+function compareLex3 (a, b) {
+ var d = (a[0] - b[0]) || (a[1] - b[1])
+ if (d) {
+ return d
+ }
+ if (a[2] < b[2]) {
+ return -1
+ } else if (a[2] > b[2]) {
+ return 1
+ }
+ return 0
+}
+
+// Remove duplicate edge labels
+function dedupEdges (edges, labels, useColor) {
+ if (edges.length === 0) {
+ return
+ }
+ if (labels) {
+ for (var i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ var a = labels[e[0]]
+ var b = labels[e[1]]
+ e[0] = Math.min(a, b)
+ e[1] = Math.max(a, b)
+ }
+ } else {
+ for (var i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ var a = e[0]
+ var b = e[1]
+ e[0] = Math.min(a, b)
+ e[1] = Math.max(a, b)
+ }
+ }
+ if (useColor) {
+ edges.sort(compareLex3)
+ } else {
+ edges.sort(compareLex2)
+ }
+ var ptr = 1
+ for (var i = 1; i < edges.length; ++i) {
+ var prev = edges[i - 1]
+ var next = edges[i]
+ if (next[0] === prev[0] && next[1] === prev[1] &&
+ (!useColor || next[2] === prev[2])) {
+ continue
+ }
+ edges[ptr++] = next
+ }
+ edges.length = ptr
+}
+
+function preRound (points, edges, useColor) {
+ var labels = dedupPoints(points, [], boundPoints(points))
+ dedupEdges(edges, labels, useColor)
+ return !!labels
+}
+
+// Repeat until convergence
+function snapRound (points, edges, useColor) {
+ // 1. find edge crossings
+ var edgeBounds = boundEdges(points, edges)
+ var crossings = getCrossings(points, edges, edgeBounds)
+
+ // 2. find t-junctions
+ var vertBounds = boundPoints(points)
+ var tjunctions = getTJunctions(points, edges, edgeBounds, vertBounds)
+
+ // 3. cut edges, construct rational points
+ var ratPoints = cutEdges(points, edges, crossings, tjunctions, useColor)
+
+ // 4. dedupe verts
+ var labels = dedupPoints(points, ratPoints, vertBounds)
+
+ // 5. dedupe edges
+ dedupEdges(edges, labels, useColor)
+
+ // 6. check termination
+ if (!labels) {
+ return (crossings.length > 0 || tjunctions.length > 0)
+ }
+
+ // More iterations necessary
+ return true
+}
+
+// Main loop, runs PSLG clean up until completion
+function cleanPSLG (points, edges, colors) {
+ // If using colors, augment edges with color data
+ var prevEdges
+ if (colors) {
+ prevEdges = edges
+ var augEdges = new Array(edges.length)
+ for (var i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ augEdges[i] = [e[0], e[1], colors[i]]
+ }
+ edges = augEdges
+ }
+
+ // First round: remove duplicate edges and points
+ var modified = preRound(points, edges, !!colors)
+
+ // Run snap rounding until convergence
+ while (snapRound(points, edges, !!colors)) {
+ modified = true
+ }
+
+ // Strip color tags
+ if (!!colors && modified) {
+ prevEdges.length = 0
+ colors.length = 0
+ for (var i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ prevEdges.push([e[0], e[1]])
+ colors.push(e[2])
+ }
+ }
+
+ return modified
+}
+
+},{"./lib/rat-seg-intersect":105,"big-rat":66,"big-rat/cmp":64,"big-rat/to-float":78,"box-intersect":84,"nextafter":434,"rat-vec":469,"robust-segment-intersect":489,"union-find":523}],105:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = solveIntersection
+
+var ratMul = _dereq_('big-rat/mul')
+var ratDiv = _dereq_('big-rat/div')
+var ratSub = _dereq_('big-rat/sub')
+var ratSign = _dereq_('big-rat/sign')
+var rvSub = _dereq_('rat-vec/sub')
+var rvAdd = _dereq_('rat-vec/add')
+var rvMuls = _dereq_('rat-vec/muls')
+
+function ratPerp (a, b) {
+ return ratSub(ratMul(a[0], b[1]), ratMul(a[1], b[0]))
+}
+
+// Solve for intersection
+// x = a + t (b-a)
+// (x - c) ^ (d-c) = 0
+// (t * (b-a) + (a-c) ) ^ (d-c) = 0
+// t * (b-a)^(d-c) = (d-c)^(a-c)
+// t = (d-c)^(a-c) / (b-a)^(d-c)
+
+function solveIntersection (a, b, c, d) {
+ var ba = rvSub(b, a)
+ var dc = rvSub(d, c)
+
+ var baXdc = ratPerp(ba, dc)
+
+ if (ratSign(baXdc) === 0) {
+ return null
+ }
+
+ var ac = rvSub(a, c)
+ var dcXac = ratPerp(dc, ac)
+
+ var t = ratDiv(dcXac, baXdc)
+ var s = rvMuls(ba, t)
+ var r = rvAdd(a, s)
+
+ return r
+}
+
+},{"big-rat/div":65,"big-rat/mul":75,"big-rat/sign":76,"big-rat/sub":77,"rat-vec/add":468,"rat-vec/muls":470,"rat-vec/sub":471}],106:[function(_dereq_,module,exports){
+/** @module color-id */
+
+'use strict'
+
+var clamp = _dereq_('clamp')
+
+module.exports = toNumber
+module.exports.to = toNumber
+module.exports.from = fromNumber
+
+function toNumber (rgba, normalized) {
+ if(normalized == null) normalized = true
+
+ var r = rgba[0], g = rgba[1], b = rgba[2], a = rgba[3]
+
+ if (a == null) a = normalized ? 1 : 255
+
+ if (normalized) {
+ r *= 255
+ g *= 255
+ b *= 255
+ a *= 255
+ }
+
+ r = clamp(r, 0, 255) & 0xFF
+ g = clamp(g, 0, 255) & 0xFF
+ b = clamp(b, 0, 255) & 0xFF
+ a = clamp(a, 0, 255) & 0xFF
+
+ //hi-order shift converts to -1, so we can't use <<24
+ var n = (r * 0x01000000) + (g << 16) + (b << 8) + (a)
+
+ return n
+}
+
+function fromNumber (n, normalized) {
+ n = +n
+
+ var r = n >>> 24
+ var g = (n & 0x00ff0000) >>> 16
+ var b = (n & 0x0000ff00) >>> 8
+ var a = n & 0x000000ff
+
+ if (normalized === false) return [r, g, b, a]
+
+ return [r/255, g/255, b/255, a/255]
+}
+
+},{"clamp":103}],107:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+};
+
+},{}],108:[function(_dereq_,module,exports){
+/** @module color-normalize */
+
+'use strict'
+
+var rgba = _dereq_('color-rgba')
+var clamp = _dereq_('clamp')
+var dtype = _dereq_('dtype')
+
+module.exports = function normalize (color, type) {
+ if (type === 'float' || !type) type = 'array'
+ if (type === 'uint') type = 'uint8'
+ if (type === 'uint_clamped') type = 'uint8_clamped'
+ var Ctor = dtype(type)
+ var output = new Ctor(4)
+
+ var normalize = type !== 'uint8' && type !== 'uint8_clamped'
+
+ // attempt to parse non-array arguments
+ if (!color.length || typeof color === 'string') {
+ color = rgba(color)
+ color[0] /= 255
+ color[1] /= 255
+ color[2] /= 255
+ }
+
+ // 0, 1 are possible contradictory values for Arrays:
+ // [1,1,1] input gives [1,1,1] output instead of [1/255,1/255,1/255], which may be collision if input is meant to be uint.
+ // converting [1,1,1] to [1/255,1/255,1/255] in case of float input gives larger mistake since [1,1,1] float is frequent edge value, whereas [0,1,1], [1,1,1] etc. uint inputs are relatively rare
+ if (isInt(color)) {
+ output[0] = color[0]
+ output[1] = color[1]
+ output[2] = color[2]
+ output[3] = color[3] != null ? color[3] : 255
+
+ if (normalize) {
+ output[0] /= 255
+ output[1] /= 255
+ output[2] /= 255
+ output[3] /= 255
+ }
+
+ return output
+ }
+
+ if (!normalize) {
+ output[0] = clamp(Math.floor(color[0] * 255), 0, 255)
+ output[1] = clamp(Math.floor(color[1] * 255), 0, 255)
+ output[2] = clamp(Math.floor(color[2] * 255), 0, 255)
+ output[3] = color[3] == null ? 255 : clamp(Math.floor(color[3] * 255), 0, 255)
+ } else {
+ output[0] = color[0]
+ output[1] = color[1]
+ output[2] = color[2]
+ output[3] = color[3] != null ? color[3] : 1
+ }
+
+ return output
+}
+
+function isInt(color) {
+ if (color instanceof Uint8Array || color instanceof Uint8ClampedArray) return true
+
+ if (Array.isArray(color) &&
+ (color[0] > 1 || color[0] === 0) &&
+ (color[1] > 1 || color[1] === 0) &&
+ (color[2] > 1 || color[2] === 0) &&
+ (!color[3] || color[3] > 1)
+ ) return true
+
+ return false
+}
+
+},{"clamp":103,"color-rgba":110,"dtype":154}],109:[function(_dereq_,module,exports){
+(function (global){
+/**
+ * @module color-parse
+ */
+
+'use strict'
+
+var names = _dereq_('color-name')
+var isObject = _dereq_('is-plain-obj')
+var defined = _dereq_('defined')
+
+module.exports = parse
+
+/**
+ * Base hues
+ * http://dev.w3.org/csswg/css-color/#typedef-named-hue
+ */
+//FIXME: use external hue detector
+var baseHues = {
+ red: 0,
+ orange: 60,
+ yellow: 120,
+ green: 180,
+ blue: 240,
+ purple: 300
+}
+
+/**
+ * Parse color from the string passed
+ *
+ * @return {Object} A space indicator `space`, an array `values` and `alpha`
+ */
+function parse (cstr) {
+ var m, parts = [], alpha = 1, space
+
+ if (typeof cstr === 'string') {
+ //keyword
+ if (names[cstr]) {
+ parts = names[cstr].slice()
+ space = 'rgb'
+ }
+
+ //reserved words
+ else if (cstr === 'transparent') {
+ alpha = 0
+ space = 'rgb'
+ parts = [0,0,0]
+ }
+
+ //hex
+ else if (/^#[A-Fa-f0-9]+$/.test(cstr)) {
+ var base = cstr.slice(1)
+ var size = base.length
+ var isShort = size <= 4
+ alpha = 1
+
+ if (isShort) {
+ parts = [
+ parseInt(base[0] + base[0], 16),
+ parseInt(base[1] + base[1], 16),
+ parseInt(base[2] + base[2], 16)
+ ]
+ if (size === 4) {
+ alpha = parseInt(base[3] + base[3], 16) / 255
+ }
+ }
+ else {
+ parts = [
+ parseInt(base[0] + base[1], 16),
+ parseInt(base[2] + base[3], 16),
+ parseInt(base[4] + base[5], 16)
+ ]
+ if (size === 8) {
+ alpha = parseInt(base[6] + base[7], 16) / 255
+ }
+ }
+
+ if (!parts[0]) parts[0] = 0
+ if (!parts[1]) parts[1] = 0
+ if (!parts[2]) parts[2] = 0
+
+ space = 'rgb'
+ }
+
+ //color space
+ else if (m = /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(cstr)) {
+ var name = m[1]
+ var base = name.replace(/a$/, '')
+ space = base
+ var size = base === 'cmyk' ? 4 : base === 'gray' ? 1 : 3
+ parts = m[2].trim()
+ .split(/\s*,\s*/)
+ .map(function (x, i) {
+ //
+ if (/%$/.test(x)) {
+ //alpha
+ if (i === size) return parseFloat(x) / 100
+ //rgb
+ if (base === 'rgb') return parseFloat(x) * 255 / 100
+ return parseFloat(x)
+ }
+ //hue
+ else if (base[i] === 'h') {
+ //
+ if (/deg$/.test(x)) {
+ return parseFloat(x)
+ }
+ //
+ else if (baseHues[x] !== undefined) {
+ return baseHues[x]
+ }
+ }
+ return parseFloat(x)
+ })
+
+ if (name === base) parts.push(1)
+ alpha = parts[size] === undefined ? 1 : parts[size]
+ parts = parts.slice(0, size)
+ }
+
+ //named channels case
+ else if (cstr.length > 10 && /[0-9](?:\s|\/)/.test(cstr)) {
+ parts = cstr.match(/([0-9]+)/g).map(function (value) {
+ return parseFloat(value)
+ })
+
+ space = cstr.match(/([a-z])/ig).join('').toLowerCase()
+ }
+ }
+
+ //numeric case
+ else if (!isNaN(cstr)) {
+ space = 'rgb'
+ parts = [cstr >>> 16, (cstr & 0x00ff00) >>> 8, cstr & 0x0000ff]
+ }
+
+ //object case - detects css cases of rgb and hsl
+ else if (isObject(cstr)) {
+ var r = defined(cstr.r, cstr.red, cstr.R, null)
+
+ if (r !== null) {
+ space = 'rgb'
+ parts = [
+ r,
+ defined(cstr.g, cstr.green, cstr.G),
+ defined(cstr.b, cstr.blue, cstr.B)
+ ]
+ }
+ else {
+ space = 'hsl'
+ parts = [
+ defined(cstr.h, cstr.hue, cstr.H),
+ defined(cstr.s, cstr.saturation, cstr.S),
+ defined(cstr.l, cstr.lightness, cstr.L, cstr.b, cstr.brightness)
+ ]
+ }
+
+ alpha = defined(cstr.a, cstr.alpha, cstr.opacity, 1)
+
+ if (cstr.opacity != null) alpha /= 100
+ }
+
+ //array
+ else if (Array.isArray(cstr) || global.ArrayBuffer && ArrayBuffer.isView && ArrayBuffer.isView(cstr)) {
+ parts = [cstr[0], cstr[1], cstr[2]]
+ space = 'rgb'
+ alpha = cstr.length === 4 ? cstr[3] : 1
+ }
+
+ return {
+ space: space,
+ values: parts,
+ alpha: alpha
+ }
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"color-name":107,"defined":149,"is-plain-obj":405}],110:[function(_dereq_,module,exports){
+/** @module color-rgba */
+
+'use strict'
+
+var parse = _dereq_('color-parse')
+var hsl = _dereq_('color-space/hsl')
+var clamp = _dereq_('clamp')
+
+module.exports = function rgba (color) {
+ var values, i, l
+
+ //attempt to parse non-array arguments
+ var parsed = parse(color)
+
+ if (!parsed.space) return []
+
+ values = Array(3)
+ values[0] = clamp(parsed.values[0], 0, 255)
+ values[1] = clamp(parsed.values[1], 0, 255)
+ values[2] = clamp(parsed.values[2], 0, 255)
+
+ if (parsed.space[0] === 'h') {
+ values = hsl.rgb(values)
+ }
+
+ values.push(clamp(parsed.alpha, 0, 1))
+
+ return values
+}
+
+},{"clamp":103,"color-parse":109,"color-space/hsl":111}],111:[function(_dereq_,module,exports){
+/**
+ * @module color-space/hsl
+ */
+'use strict'
+
+var rgb = _dereq_('./rgb');
+
+module.exports = {
+ name: 'hsl',
+ min: [0,0,0],
+ max: [360,100,100],
+ channel: ['hue', 'saturation', 'lightness'],
+ alias: ['HSL'],
+
+ rgb: function(hsl) {
+ var h = hsl[0] / 360,
+ s = hsl[1] / 100,
+ l = hsl[2] / 100,
+ t1, t2, t3, rgb, val;
+
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ }
+ else {
+ t2 = l + s - l * s;
+ }
+ t1 = 2 * l - t2;
+
+ rgb = [0, 0, 0];
+ for (var i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * - (i - 1);
+ if (t3 < 0) {
+ t3++;
+ }
+ else if (t3 > 1) {
+ t3--;
+ }
+
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ }
+ else if (2 * t3 < 1) {
+ val = t2;
+ }
+ else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ }
+ else {
+ val = t1;
+ }
+
+ rgb[i] = val * 255;
+ }
+
+ return rgb;
+ }
+};
+
+
+//extend rgb
+rgb.hsl = function(rgb) {
+ var r = rgb[0]/255,
+ g = rgb[1]/255,
+ b = rgb[2]/255,
+ min = Math.min(r, g, b),
+ max = Math.max(r, g, b),
+ delta = max - min,
+ h, s, l;
+
+ if (max === min) {
+ h = 0;
+ }
+ else if (r === max) {
+ h = (g - b) / delta;
+ }
+ else if (g === max) {
+ h = 2 + (b - r) / delta;
+ }
+ else if (b === max) {
+ h = 4 + (r - g)/ delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ l = (min + max) / 2;
+
+ if (max === min) {
+ s = 0;
+ }
+ else if (l <= 0.5) {
+ s = delta / (max + min);
+ }
+ else {
+ s = delta / (2 - max - min);
+ }
+
+ return [h, s * 100, l * 100];
+};
+
+},{"./rgb":112}],112:[function(_dereq_,module,exports){
+/**
+ * RGB space.
+ *
+ * @module color-space/rgb
+ */
+'use strict'
+
+module.exports = {
+ name: 'rgb',
+ min: [0,0,0],
+ max: [255,255,255],
+ channel: ['red', 'green', 'blue'],
+ alias: ['RGB']
+};
+
+},{}],113:[function(_dereq_,module,exports){
+module.exports={
+ "jet":[{"index":0,"rgb":[0,0,131]},{"index":0.125,"rgb":[0,60,170]},{"index":0.375,"rgb":[5,255,255]},{"index":0.625,"rgb":[255,255,0]},{"index":0.875,"rgb":[250,0,0]},{"index":1,"rgb":[128,0,0]}],
+
+ "hsv":[{"index":0,"rgb":[255,0,0]},{"index":0.169,"rgb":[253,255,2]},{"index":0.173,"rgb":[247,255,2]},{"index":0.337,"rgb":[0,252,4]},{"index":0.341,"rgb":[0,252,10]},{"index":0.506,"rgb":[1,249,255]},{"index":0.671,"rgb":[2,0,253]},{"index":0.675,"rgb":[8,0,253]},{"index":0.839,"rgb":[255,0,251]},{"index":0.843,"rgb":[255,0,245]},{"index":1,"rgb":[255,0,6]}],
+
+ "hot":[{"index":0,"rgb":[0,0,0]},{"index":0.3,"rgb":[230,0,0]},{"index":0.6,"rgb":[255,210,0]},{"index":1,"rgb":[255,255,255]}],
+
+ "cool":[{"index":0,"rgb":[0,255,255]},{"index":1,"rgb":[255,0,255]}],
+
+ "spring":[{"index":0,"rgb":[255,0,255]},{"index":1,"rgb":[255,255,0]}],
+
+ "summer":[{"index":0,"rgb":[0,128,102]},{"index":1,"rgb":[255,255,102]}],
+
+ "autumn":[{"index":0,"rgb":[255,0,0]},{"index":1,"rgb":[255,255,0]}],
+
+ "winter":[{"index":0,"rgb":[0,0,255]},{"index":1,"rgb":[0,255,128]}],
+
+ "bone":[{"index":0,"rgb":[0,0,0]},{"index":0.376,"rgb":[84,84,116]},{"index":0.753,"rgb":[169,200,200]},{"index":1,"rgb":[255,255,255]}],
+
+ "copper":[{"index":0,"rgb":[0,0,0]},{"index":0.804,"rgb":[255,160,102]},{"index":1,"rgb":[255,199,127]}],
+
+ "greys":[{"index":0,"rgb":[0,0,0]},{"index":1,"rgb":[255,255,255]}],
+
+ "yignbu":[{"index":0,"rgb":[8,29,88]},{"index":0.125,"rgb":[37,52,148]},{"index":0.25,"rgb":[34,94,168]},{"index":0.375,"rgb":[29,145,192]},{"index":0.5,"rgb":[65,182,196]},{"index":0.625,"rgb":[127,205,187]},{"index":0.75,"rgb":[199,233,180]},{"index":0.875,"rgb":[237,248,217]},{"index":1,"rgb":[255,255,217]}],
+
+ "greens":[{"index":0,"rgb":[0,68,27]},{"index":0.125,"rgb":[0,109,44]},{"index":0.25,"rgb":[35,139,69]},{"index":0.375,"rgb":[65,171,93]},{"index":0.5,"rgb":[116,196,118]},{"index":0.625,"rgb":[161,217,155]},{"index":0.75,"rgb":[199,233,192]},{"index":0.875,"rgb":[229,245,224]},{"index":1,"rgb":[247,252,245]}],
+
+ "yiorrd":[{"index":0,"rgb":[128,0,38]},{"index":0.125,"rgb":[189,0,38]},{"index":0.25,"rgb":[227,26,28]},{"index":0.375,"rgb":[252,78,42]},{"index":0.5,"rgb":[253,141,60]},{"index":0.625,"rgb":[254,178,76]},{"index":0.75,"rgb":[254,217,118]},{"index":0.875,"rgb":[255,237,160]},{"index":1,"rgb":[255,255,204]}],
+
+ "bluered":[{"index":0,"rgb":[0,0,255]},{"index":1,"rgb":[255,0,0]}],
+
+ "rdbu":[{"index":0,"rgb":[5,10,172]},{"index":0.35,"rgb":[106,137,247]},{"index":0.5,"rgb":[190,190,190]},{"index":0.6,"rgb":[220,170,132]},{"index":0.7,"rgb":[230,145,90]},{"index":1,"rgb":[178,10,28]}],
+
+ "picnic":[{"index":0,"rgb":[0,0,255]},{"index":0.1,"rgb":[51,153,255]},{"index":0.2,"rgb":[102,204,255]},{"index":0.3,"rgb":[153,204,255]},{"index":0.4,"rgb":[204,204,255]},{"index":0.5,"rgb":[255,255,255]},{"index":0.6,"rgb":[255,204,255]},{"index":0.7,"rgb":[255,153,255]},{"index":0.8,"rgb":[255,102,204]},{"index":0.9,"rgb":[255,102,102]},{"index":1,"rgb":[255,0,0]}],
+
+ "rainbow":[{"index":0,"rgb":[150,0,90]},{"index":0.125,"rgb":[0,0,200]},{"index":0.25,"rgb":[0,25,255]},{"index":0.375,"rgb":[0,152,255]},{"index":0.5,"rgb":[44,255,150]},{"index":0.625,"rgb":[151,255,0]},{"index":0.75,"rgb":[255,234,0]},{"index":0.875,"rgb":[255,111,0]},{"index":1,"rgb":[255,0,0]}],
+
+ "portland":[{"index":0,"rgb":[12,51,131]},{"index":0.25,"rgb":[10,136,186]},{"index":0.5,"rgb":[242,211,56]},{"index":0.75,"rgb":[242,143,56]},{"index":1,"rgb":[217,30,30]}],
+
+ "blackbody":[{"index":0,"rgb":[0,0,0]},{"index":0.2,"rgb":[230,0,0]},{"index":0.4,"rgb":[230,210,0]},{"index":0.7,"rgb":[255,255,255]},{"index":1,"rgb":[160,200,255]}],
+
+ "earth":[{"index":0,"rgb":[0,0,130]},{"index":0.1,"rgb":[0,180,180]},{"index":0.2,"rgb":[40,210,40]},{"index":0.4,"rgb":[230,230,50]},{"index":0.6,"rgb":[120,70,20]},{"index":1,"rgb":[255,255,255]}],
+
+ "electric":[{"index":0,"rgb":[0,0,0]},{"index":0.15,"rgb":[30,0,100]},{"index":0.4,"rgb":[120,0,100]},{"index":0.6,"rgb":[160,90,0]},{"index":0.8,"rgb":[230,200,0]},{"index":1,"rgb":[255,250,220]}],
+
+ "alpha": [{"index":0, "rgb": [255,255,255,0]},{"index":1, "rgb": [255,255,255,1]}],
+
+ "viridis": [{"index":0,"rgb":[68,1,84]},{"index":0.13,"rgb":[71,44,122]},{"index":0.25,"rgb":[59,81,139]},{"index":0.38,"rgb":[44,113,142]},{"index":0.5,"rgb":[33,144,141]},{"index":0.63,"rgb":[39,173,129]},{"index":0.75,"rgb":[92,200,99]},{"index":0.88,"rgb":[170,220,50]},{"index":1,"rgb":[253,231,37]}],
+
+ "inferno": [{"index":0,"rgb":[0,0,4]},{"index":0.13,"rgb":[31,12,72]},{"index":0.25,"rgb":[85,15,109]},{"index":0.38,"rgb":[136,34,106]},{"index":0.5,"rgb":[186,54,85]},{"index":0.63,"rgb":[227,89,51]},{"index":0.75,"rgb":[249,140,10]},{"index":0.88,"rgb":[249,201,50]},{"index":1,"rgb":[252,255,164]}],
+
+ "magma": [{"index":0,"rgb":[0,0,4]},{"index":0.13,"rgb":[28,16,68]},{"index":0.25,"rgb":[79,18,123]},{"index":0.38,"rgb":[129,37,129]},{"index":0.5,"rgb":[181,54,122]},{"index":0.63,"rgb":[229,80,100]},{"index":0.75,"rgb":[251,135,97]},{"index":0.88,"rgb":[254,194,135]},{"index":1,"rgb":[252,253,191]}],
+
+ "plasma": [{"index":0,"rgb":[13,8,135]},{"index":0.13,"rgb":[75,3,161]},{"index":0.25,"rgb":[125,3,168]},{"index":0.38,"rgb":[168,34,150]},{"index":0.5,"rgb":[203,70,121]},{"index":0.63,"rgb":[229,107,93]},{"index":0.75,"rgb":[248,148,65]},{"index":0.88,"rgb":[253,195,40]},{"index":1,"rgb":[240,249,33]}],
+
+ "warm": [{"index":0,"rgb":[125,0,179]},{"index":0.13,"rgb":[172,0,187]},{"index":0.25,"rgb":[219,0,170]},{"index":0.38,"rgb":[255,0,130]},{"index":0.5,"rgb":[255,63,74]},{"index":0.63,"rgb":[255,123,0]},{"index":0.75,"rgb":[234,176,0]},{"index":0.88,"rgb":[190,228,0]},{"index":1,"rgb":[147,255,0]}],
+
+ "cool": [{"index":0,"rgb":[125,0,179]},{"index":0.13,"rgb":[116,0,218]},{"index":0.25,"rgb":[98,74,237]},{"index":0.38,"rgb":[68,146,231]},{"index":0.5,"rgb":[0,204,197]},{"index":0.63,"rgb":[0,247,146]},{"index":0.75,"rgb":[0,255,88]},{"index":0.88,"rgb":[40,255,8]},{"index":1,"rgb":[147,255,0]}],
+
+ "rainbow-soft": [{"index":0,"rgb":[125,0,179]},{"index":0.1,"rgb":[199,0,180]},{"index":0.2,"rgb":[255,0,121]},{"index":0.3,"rgb":[255,108,0]},{"index":0.4,"rgb":[222,194,0]},{"index":0.5,"rgb":[150,255,0]},{"index":0.6,"rgb":[0,255,55]},{"index":0.7,"rgb":[0,246,150]},{"index":0.8,"rgb":[50,167,222]},{"index":0.9,"rgb":[103,51,235]},{"index":1,"rgb":[124,0,186]}],
+
+ "bathymetry": [{"index":0,"rgb":[40,26,44]},{"index":0.13,"rgb":[59,49,90]},{"index":0.25,"rgb":[64,76,139]},{"index":0.38,"rgb":[63,110,151]},{"index":0.5,"rgb":[72,142,158]},{"index":0.63,"rgb":[85,174,163]},{"index":0.75,"rgb":[120,206,163]},{"index":0.88,"rgb":[187,230,172]},{"index":1,"rgb":[253,254,204]}],
+
+ "cdom": [{"index":0,"rgb":[47,15,62]},{"index":0.13,"rgb":[87,23,86]},{"index":0.25,"rgb":[130,28,99]},{"index":0.38,"rgb":[171,41,96]},{"index":0.5,"rgb":[206,67,86]},{"index":0.63,"rgb":[230,106,84]},{"index":0.75,"rgb":[242,149,103]},{"index":0.88,"rgb":[249,193,135]},{"index":1,"rgb":[254,237,176]}],
+
+ "chlorophyll": [{"index":0,"rgb":[18,36,20]},{"index":0.13,"rgb":[25,63,41]},{"index":0.25,"rgb":[24,91,59]},{"index":0.38,"rgb":[13,119,72]},{"index":0.5,"rgb":[18,148,80]},{"index":0.63,"rgb":[80,173,89]},{"index":0.75,"rgb":[132,196,122]},{"index":0.88,"rgb":[175,221,162]},{"index":1,"rgb":[215,249,208]}],
+
+ "density": [{"index":0,"rgb":[54,14,36]},{"index":0.13,"rgb":[89,23,80]},{"index":0.25,"rgb":[110,45,132]},{"index":0.38,"rgb":[120,77,178]},{"index":0.5,"rgb":[120,113,213]},{"index":0.63,"rgb":[115,151,228]},{"index":0.75,"rgb":[134,185,227]},{"index":0.88,"rgb":[177,214,227]},{"index":1,"rgb":[230,241,241]}],
+
+ "freesurface-blue": [{"index":0,"rgb":[30,4,110]},{"index":0.13,"rgb":[47,14,176]},{"index":0.25,"rgb":[41,45,236]},{"index":0.38,"rgb":[25,99,212]},{"index":0.5,"rgb":[68,131,200]},{"index":0.63,"rgb":[114,156,197]},{"index":0.75,"rgb":[157,181,203]},{"index":0.88,"rgb":[200,208,216]},{"index":1,"rgb":[241,237,236]}],
+
+ "freesurface-red": [{"index":0,"rgb":[60,9,18]},{"index":0.13,"rgb":[100,17,27]},{"index":0.25,"rgb":[142,20,29]},{"index":0.38,"rgb":[177,43,27]},{"index":0.5,"rgb":[192,87,63]},{"index":0.63,"rgb":[205,125,105]},{"index":0.75,"rgb":[216,162,148]},{"index":0.88,"rgb":[227,199,193]},{"index":1,"rgb":[241,237,236]}],
+
+ "oxygen": [{"index":0,"rgb":[64,5,5]},{"index":0.13,"rgb":[106,6,15]},{"index":0.25,"rgb":[144,26,7]},{"index":0.38,"rgb":[168,64,3]},{"index":0.5,"rgb":[188,100,4]},{"index":0.63,"rgb":[206,136,11]},{"index":0.75,"rgb":[220,174,25]},{"index":0.88,"rgb":[231,215,44]},{"index":1,"rgb":[248,254,105]}],
+
+ "par": [{"index":0,"rgb":[51,20,24]},{"index":0.13,"rgb":[90,32,35]},{"index":0.25,"rgb":[129,44,34]},{"index":0.38,"rgb":[159,68,25]},{"index":0.5,"rgb":[182,99,19]},{"index":0.63,"rgb":[199,134,22]},{"index":0.75,"rgb":[212,171,35]},{"index":0.88,"rgb":[221,210,54]},{"index":1,"rgb":[225,253,75]}],
+
+ "phase": [{"index":0,"rgb":[145,105,18]},{"index":0.13,"rgb":[184,71,38]},{"index":0.25,"rgb":[186,58,115]},{"index":0.38,"rgb":[160,71,185]},{"index":0.5,"rgb":[110,97,218]},{"index":0.63,"rgb":[50,123,164]},{"index":0.75,"rgb":[31,131,110]},{"index":0.88,"rgb":[77,129,34]},{"index":1,"rgb":[145,105,18]}],
+
+ "salinity": [{"index":0,"rgb":[42,24,108]},{"index":0.13,"rgb":[33,50,162]},{"index":0.25,"rgb":[15,90,145]},{"index":0.38,"rgb":[40,118,137]},{"index":0.5,"rgb":[59,146,135]},{"index":0.63,"rgb":[79,175,126]},{"index":0.75,"rgb":[120,203,104]},{"index":0.88,"rgb":[193,221,100]},{"index":1,"rgb":[253,239,154]}],
+
+ "temperature": [{"index":0,"rgb":[4,35,51]},{"index":0.13,"rgb":[23,51,122]},{"index":0.25,"rgb":[85,59,157]},{"index":0.38,"rgb":[129,79,143]},{"index":0.5,"rgb":[175,95,130]},{"index":0.63,"rgb":[222,112,101]},{"index":0.75,"rgb":[249,146,66]},{"index":0.88,"rgb":[249,196,65]},{"index":1,"rgb":[232,250,91]}],
+
+ "turbidity": [{"index":0,"rgb":[34,31,27]},{"index":0.13,"rgb":[65,50,41]},{"index":0.25,"rgb":[98,69,52]},{"index":0.38,"rgb":[131,89,57]},{"index":0.5,"rgb":[161,112,59]},{"index":0.63,"rgb":[185,140,66]},{"index":0.75,"rgb":[202,174,88]},{"index":0.88,"rgb":[216,209,126]},{"index":1,"rgb":[233,246,171]}],
+
+ "velocity-blue": [{"index":0,"rgb":[17,32,64]},{"index":0.13,"rgb":[35,52,116]},{"index":0.25,"rgb":[29,81,156]},{"index":0.38,"rgb":[31,113,162]},{"index":0.5,"rgb":[50,144,169]},{"index":0.63,"rgb":[87,173,176]},{"index":0.75,"rgb":[149,196,189]},{"index":0.88,"rgb":[203,221,211]},{"index":1,"rgb":[254,251,230]}],
+
+ "velocity-green": [{"index":0,"rgb":[23,35,19]},{"index":0.13,"rgb":[24,64,38]},{"index":0.25,"rgb":[11,95,45]},{"index":0.38,"rgb":[39,123,35]},{"index":0.5,"rgb":[95,146,12]},{"index":0.63,"rgb":[152,165,18]},{"index":0.75,"rgb":[201,186,69]},{"index":0.88,"rgb":[233,216,137]},{"index":1,"rgb":[255,253,205]}],
+
+ "cubehelix": [{"index":0,"rgb":[0,0,0]},{"index":0.07,"rgb":[22,5,59]},{"index":0.13,"rgb":[60,4,105]},{"index":0.2,"rgb":[109,1,135]},{"index":0.27,"rgb":[161,0,147]},{"index":0.33,"rgb":[210,2,142]},{"index":0.4,"rgb":[251,11,123]},{"index":0.47,"rgb":[255,29,97]},{"index":0.53,"rgb":[255,54,69]},{"index":0.6,"rgb":[255,85,46]},{"index":0.67,"rgb":[255,120,34]},{"index":0.73,"rgb":[255,157,37]},{"index":0.8,"rgb":[241,191,57]},{"index":0.87,"rgb":[224,220,93]},{"index":0.93,"rgb":[218,241,142]},{"index":1,"rgb":[227,253,198]}]
+};
+
+},{}],114:[function(_dereq_,module,exports){
+/*
+ * Ben Postlethwaite
+ * January 2013
+ * License MIT
+ */
+'use strict';
+
+var colorScale = _dereq_('./colorScale');
+var lerp = _dereq_('lerp')
+
+module.exports = createColormap;
+
+function createColormap (spec) {
+ /*
+ * Default Options
+ */
+ var indicies, rgba, fromrgba, torgba,
+ nsteps, cmap, colormap, format,
+ nshades, colors, alpha, index, i,
+ r = [],
+ g = [],
+ b = [],
+ a = [];
+
+ if ( !spec ) spec = {};
+
+ nshades = (spec.nshades || 72) - 1;
+ format = spec.format || 'hex';
+
+ colormap = spec.colormap;
+ if (!colormap) colormap = 'jet';
+
+ if (typeof colormap === 'string') {
+ colormap = colormap.toLowerCase();
+
+ if (!colorScale[colormap]) {
+ throw Error(colormap + ' not a supported colorscale');
+ }
+
+ cmap = colorScale[colormap];
+
+ } else if (Array.isArray(colormap)) {
+ cmap = colormap.slice();
+
+ } else {
+ throw Error('unsupported colormap option', colormap);
+ }
+
+ if (cmap.length > nshades) {
+ throw new Error(
+ colormap+' map requires nshades to be at least size '+cmap.length
+ );
+ }
+
+ if (!Array.isArray(spec.alpha)) {
+
+ if (typeof spec.alpha === 'number') {
+ alpha = [spec.alpha, spec.alpha];
+
+ } else {
+ alpha = [1, 1];
+ }
+
+ } else if (spec.alpha.length !== 2) {
+ alpha = [1, 1];
+
+ } else {
+ alpha = spec.alpha.slice();
+ }
+
+ // map index points from 0..1 to 0..n-1
+ indicies = cmap.map(function(c) {
+ return Math.round(c.index * nshades);
+ });
+
+ // Add alpha channel to the map
+ alpha[0] = Math.min(Math.max(alpha[0], 0), 1);
+ alpha[1] = Math.min(Math.max(alpha[1], 0), 1);
+
+ var steps = cmap.map(function(c, i) {
+ var index = cmap[i].index
+
+ var rgba = cmap[i].rgb.slice();
+
+ // if user supplies their own map use it
+ if (rgba.length === 4 && rgba[3] >= 0 && rgba[3] <= 1) {
+ return rgba
+ }
+ rgba[3] = alpha[0] + (alpha[1] - alpha[0])*index;
+
+ return rgba
+ })
+
+
+ /*
+ * map increasing linear values between indicies to
+ * linear steps in colorvalues
+ */
+ var colors = []
+ for (i = 0; i < indicies.length-1; ++i) {
+ nsteps = indicies[i+1] - indicies[i];
+ fromrgba = steps[i];
+ torgba = steps[i+1];
+
+ for (var j = 0; j < nsteps; j++) {
+ var amt = j / nsteps
+ colors.push([
+ Math.round(lerp(fromrgba[0], torgba[0], amt)),
+ Math.round(lerp(fromrgba[1], torgba[1], amt)),
+ Math.round(lerp(fromrgba[2], torgba[2], amt)),
+ lerp(fromrgba[3], torgba[3], amt)
+ ])
+ }
+ }
+
+ //add 1 step as last value
+ colors.push(cmap[cmap.length - 1].rgb.concat(alpha[1]))
+
+ if (format === 'hex') colors = colors.map( rgb2hex );
+ else if (format === 'rgbaString') colors = colors.map( rgbaStr );
+ else if (format === 'float') colors = colors.map( rgb2float );
+
+ return colors;
+};
+
+function rgb2float (rgba) {
+ return [
+ rgba[0] / 255,
+ rgba[1] / 255,
+ rgba[2] / 255,
+ rgba[3]
+ ]
+}
+
+function rgb2hex (rgba) {
+ var dig, hex = '#';
+ for (var i = 0; i < 3; ++i) {
+ dig = rgba[i];
+ dig = dig.toString(16);
+ hex += ('00' + dig).substr( dig.length );
+ }
+ return hex;
+}
+
+function rgbaStr (rgba) {
+ return 'rgba(' + rgba.join(',') + ')';
+}
+
+},{"./colorScale":113,"lerp":408}],115:[function(_dereq_,module,exports){
+"use strict"
+
+module.exports = compareAngle
+
+var orient = _dereq_("robust-orientation")
+var sgn = _dereq_("signum")
+var twoSum = _dereq_("two-sum")
+var robustProduct = _dereq_("robust-product")
+var robustSum = _dereq_("robust-sum")
+
+function testInterior(a, b, c) {
+ var x0 = twoSum(a[0], -b[0])
+ var y0 = twoSum(a[1], -b[1])
+ var x1 = twoSum(c[0], -b[0])
+ var y1 = twoSum(c[1], -b[1])
+
+ var d = robustSum(
+ robustProduct(x0, x1),
+ robustProduct(y0, y1))
+
+ return d[d.length-1] >= 0
+}
+
+function compareAngle(a, b, c, d) {
+ var bcd = orient(b, c, d)
+ if(bcd === 0) {
+ //Handle degenerate cases
+ var sabc = sgn(orient(a, b, c))
+ var sabd = sgn(orient(a, b, d))
+ if(sabc === sabd) {
+ if(sabc === 0) {
+ var ic = testInterior(a, b, c)
+ var id = testInterior(a, b, d)
+ if(ic === id) {
+ return 0
+ } else if(ic) {
+ return 1
+ } else {
+ return -1
+ }
+ }
+ return 0
+ } else if(sabd === 0) {
+ if(sabc > 0) {
+ return -1
+ } else if(testInterior(a, b, d)) {
+ return -1
+ } else {
+ return 1
+ }
+ } else if(sabc === 0) {
+ if(sabd > 0) {
+ return 1
+ } else if(testInterior(a, b, c)) {
+ return 1
+ } else {
+ return -1
+ }
+ }
+ return sgn(sabd - sabc)
+ }
+ var abc = orient(a, b, c)
+ if(abc > 0) {
+ if(bcd > 0 && orient(a, b, d) > 0) {
+ return 1
+ }
+ return -1
+ } else if(abc < 0) {
+ if(bcd > 0 || orient(a, b, d) > 0) {
+ return 1
+ }
+ return -1
+ } else {
+ var abd = orient(a, b, d)
+ if(abd > 0) {
+ return 1
+ } else {
+ if(testInterior(a, b, c)) {
+ return 1
+ } else {
+ return -1
+ }
+ }
+ }
+}
+},{"robust-orientation":486,"robust-product":487,"robust-sum":491,"signum":492,"two-sum":521}],116:[function(_dereq_,module,exports){
+module.exports = compareCells
+
+var min = Math.min
+
+function compareInt(a, b) {
+ return a - b
+}
+
+function compareCells(a, b) {
+ var n = a.length
+ , t = a.length - b.length
+ if(t) {
+ return t
+ }
+ switch(n) {
+ case 0:
+ return 0
+ case 1:
+ return a[0] - b[0]
+ case 2:
+ return (a[0]+a[1]-b[0]-b[1]) ||
+ min(a[0],a[1]) - min(b[0],b[1])
+ case 3:
+ var l1 = a[0]+a[1]
+ , m1 = b[0]+b[1]
+ t = l1+a[2] - (m1+b[2])
+ if(t) {
+ return t
+ }
+ var l0 = min(a[0], a[1])
+ , m0 = min(b[0], b[1])
+ return min(l0, a[2]) - min(m0, b[2]) ||
+ min(l0+a[2], l1) - min(m0+b[2], m1)
+ case 4:
+ var aw=a[0], ax=a[1], ay=a[2], az=a[3]
+ , bw=b[0], bx=b[1], by=b[2], bz=b[3]
+ return (aw+ax+ay+az)-(bw+bx+by+bz) ||
+ min(aw,ax,ay,az)-min(bw,bx,by,bz,bw) ||
+ min(aw+ax,aw+ay,aw+az,ax+ay,ax+az,ay+az) -
+ min(bw+bx,bw+by,bw+bz,bx+by,bx+bz,by+bz) ||
+ min(aw+ax+ay,aw+ax+az,aw+ay+az,ax+ay+az) -
+ min(bw+bx+by,bw+bx+bz,bw+by+bz,bx+by+bz)
+ default:
+ var as = a.slice().sort(compareInt)
+ var bs = b.slice().sort(compareInt)
+ for(var i=0; i points[hi][0]) {
+ hi = i
+ }
+ }
+ if(lo < hi) {
+ return [[lo], [hi]]
+ } else if(lo > hi) {
+ return [[hi], [lo]]
+ } else {
+ return [[lo]]
+ }
+}
+},{}],120:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = convexHull2D
+
+var monotoneHull = _dereq_('monotone-convex-hull-2d')
+
+function convexHull2D(points) {
+ var hull = monotoneHull(points)
+ var h = hull.length
+ if(h <= 2) {
+ return []
+ }
+ var edges = new Array(h)
+ var a = hull[h-1]
+ for(var i=0; i= front[k]) {
+ x += 1
+ }
+ }
+ c[j] = x
+ }
+ }
+ }
+ return cells
+}
+
+function convexHullnD(points, d) {
+ try {
+ return ich(points, true)
+ } catch(e) {
+ //If point set is degenerate, try to find a basis and rerun it
+ var ah = aff(points)
+ if(ah.length <= d) {
+ //No basis, no try
+ return []
+ }
+ var npoints = permute(points, ah)
+ var nhull = ich(npoints, true)
+ return invPermute(nhull, ah)
+ }
+}
+},{"affine-hull":50,"incremental-convex-hull":396}],122:[function(_dereq_,module,exports){
+module.exports = {
+ AFG: 'afghan',
+ ALA: '\\b\\wland',
+ ALB: 'albania',
+ DZA: 'algeria',
+ ASM: '^(?=.*americ).*samoa',
+ AND: 'andorra',
+ AGO: 'angola',
+ AIA: 'anguill?a',
+ ATA: 'antarctica',
+ ATG: 'antigua',
+ ARG: 'argentin',
+ ARM: 'armenia',
+ ABW: '^(?!.*bonaire).*\\baruba',
+ AUS: 'australia',
+ AUT: '^(?!.*hungary).*austria|\\baustri.*\\bemp',
+ AZE: 'azerbaijan',
+ BHS: 'bahamas',
+ BHR: 'bahrain',
+ BGD: 'bangladesh|^(?=.*east).*paki?stan',
+ BRB: 'barbados',
+ BLR: 'belarus|byelo',
+ BEL: '^(?!.*luxem).*belgium',
+ BLZ: 'belize|^(?=.*british).*honduras',
+ BEN: 'benin|dahome',
+ BMU: 'bermuda',
+ BTN: 'bhutan',
+ BOL: 'bolivia',
+ BES: '^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\bbes.?islands',
+ BIH: 'herzegovina|bosnia',
+ BWA: 'botswana|bechuana',
+ BVT: 'bouvet',
+ BRA: 'brazil',
+ IOT: 'british.?indian.?ocean',
+ BRN: 'brunei',
+ BGR: 'bulgaria',
+ BFA: 'burkina|\\bfaso|upper.?volta',
+ BDI: 'burundi',
+ CPV: 'verde',
+ KHM: 'cambodia|kampuchea|khmer',
+ CMR: 'cameroon',
+ CAN: 'canada',
+ CYM: 'cayman',
+ CAF: '\\bcentral.african.republic',
+ TCD: '\\bchad',
+ CHL: '\\bchile',
+ CHN: '^(?!.*\\bmac)(?!.*\\bhong)(?!.*\\btai)(?!.*\\brep).*china|^(?=.*peo)(?=.*rep).*china',
+ CXR: 'christmas',
+ CCK: '\\bcocos|keeling',
+ COL: 'colombia',
+ COM: 'comoro',
+ COG: '^(?!.*\\bdem)(?!.*\\bd[\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\bcongo',
+ COK: '\\bcook',
+ CRI: 'costa.?rica',
+ CIV: 'ivoire|ivory',
+ HRV: 'croatia',
+ CUB: '\\bcuba',
+ CUW: '^(?!.*bonaire).*\\bcura(c|ç)ao',
+ CYP: 'cyprus',
+ CSK: 'czechoslovakia',
+ CZE: '^(?=.*rep).*czech|czechia|bohemia',
+ COD: '\\bdem.*congo|congo.*\\bdem|congo.*\\bd[\\.]?r|\\bd[\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc',
+ DNK: 'denmark',
+ DJI: 'djibouti',
+ DMA: 'dominica(?!n)',
+ DOM: 'dominican.rep',
+ ECU: 'ecuador',
+ EGY: 'egypt',
+ SLV: 'el.?salvador',
+ GNQ: 'guine.*eq|eq.*guine|^(?=.*span).*guinea',
+ ERI: 'eritrea',
+ EST: 'estonia',
+ ETH: 'ethiopia|abyssinia',
+ FLK: 'falkland|malvinas',
+ FRO: 'faroe|faeroe',
+ FJI: 'fiji',
+ FIN: 'finland',
+ FRA: '^(?!.*\\bdep)(?!.*martinique).*france|french.?republic|\\bgaul',
+ GUF: '^(?=.*french).*guiana',
+ PYF: 'french.?polynesia|tahiti',
+ ATF: 'french.?southern',
+ GAB: 'gabon',
+ GMB: 'gambia',
+ GEO: '^(?!.*south).*georgia',
+ DDR: 'german.?democratic.?republic|democratic.?republic.*germany|east.germany',
+ DEU: '^(?!.*east).*germany|^(?=.*\\bfed.*\\brep).*german',
+ GHA: 'ghana|gold.?coast',
+ GIB: 'gibraltar',
+ GRC: 'greece|hellenic|hellas',
+ GRL: 'greenland',
+ GRD: 'grenada',
+ GLP: 'guadeloupe',
+ GUM: '\\bguam',
+ GTM: 'guatemala',
+ GGY: 'guernsey',
+ GIN: '^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea',
+ GNB: 'bissau|^(?=.*portu).*guinea',
+ GUY: 'guyana|british.?guiana',
+ HTI: 'haiti',
+ HMD: 'heard.*mcdonald',
+ VAT: 'holy.?see|vatican|papal.?st',
+ HND: '^(?!.*brit).*honduras',
+ HKG: 'hong.?kong',
+ HUN: '^(?!.*austr).*hungary',
+ ISL: 'iceland',
+ IND: 'india(?!.*ocea)',
+ IDN: 'indonesia',
+ IRN: '\\biran|persia',
+ IRQ: '\\biraq|mesopotamia',
+ IRL: '(^ireland)|(^republic.*ireland)',
+ IMN: '^(?=.*isle).*\\bman',
+ ISR: 'israel',
+ ITA: 'italy',
+ JAM: 'jamaica',
+ JPN: 'japan',
+ JEY: 'jersey',
+ JOR: 'jordan',
+ KAZ: 'kazak',
+ KEN: 'kenya|british.?east.?africa|east.?africa.?prot',
+ KIR: 'kiribati',
+ PRK: '^(?=.*democrat|people|north|d.*p.*.r).*\\bkorea|dprk|korea.*(d.*p.*r)',
+ KWT: 'kuwait',
+ KGZ: 'kyrgyz|kirghiz',
+ LAO: '\\blaos?\\b',
+ LVA: 'latvia',
+ LBN: 'lebanon',
+ LSO: 'lesotho|basuto',
+ LBR: 'liberia',
+ LBY: 'libya',
+ LIE: 'liechtenstein',
+ LTU: 'lithuania',
+ LUX: '^(?!.*belg).*luxem',
+ MAC: 'maca(o|u)',
+ MDG: 'madagascar|malagasy',
+ MWI: 'malawi|nyasa',
+ MYS: 'malaysia',
+ MDV: 'maldive',
+ MLI: '\\bmali\\b',
+ MLT: '\\bmalta',
+ MHL: 'marshall',
+ MTQ: 'martinique',
+ MRT: 'mauritania',
+ MUS: 'mauritius',
+ MYT: '\\bmayotte',
+ MEX: '\\bmexic',
+ FSM: 'fed.*micronesia|micronesia.*fed',
+ MCO: 'monaco',
+ MNG: 'mongolia',
+ MNE: '^(?!.*serbia).*montenegro',
+ MSR: 'montserrat',
+ MAR: 'morocco|\\bmaroc',
+ MOZ: 'mozambique',
+ MMR: 'myanmar|burma',
+ NAM: 'namibia',
+ NRU: 'nauru',
+ NPL: 'nepal',
+ NLD: '^(?!.*\\bant)(?!.*\\bcarib).*netherlands',
+ ANT: '^(?=.*\\bant).*(nether|dutch)',
+ NCL: 'new.?caledonia',
+ NZL: 'new.?zealand',
+ NIC: 'nicaragua',
+ NER: '\\bniger(?!ia)',
+ NGA: 'nigeria',
+ NIU: 'niue',
+ NFK: 'norfolk',
+ MNP: 'mariana',
+ NOR: 'norway',
+ OMN: '\\boman|trucial',
+ PAK: '^(?!.*east).*paki?stan',
+ PLW: 'palau',
+ PSE: 'palestin|\\bgaza|west.?bank',
+ PAN: 'panama',
+ PNG: 'papua|new.?guinea',
+ PRY: 'paraguay',
+ PER: 'peru',
+ PHL: 'philippines',
+ PCN: 'pitcairn',
+ POL: 'poland',
+ PRT: 'portugal',
+ PRI: 'puerto.?rico',
+ QAT: 'qatar',
+ KOR: '^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\bkorea(?!.*d.*p.*r)',
+ MDA: 'moldov|b(a|e)ssarabia',
+ REU: 'r(e|é)union',
+ ROU: 'r(o|u|ou)mania',
+ RUS: '\\brussia|soviet.?union|u\\.?s\\.?s\\.?r|socialist.?republics',
+ RWA: 'rwanda',
+ BLM: 'barth(e|é)lemy',
+ SHN: 'helena',
+ KNA: 'kitts|\\bnevis',
+ LCA: '\\blucia',
+ MAF: '^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)',
+ SPM: 'miquelon',
+ VCT: 'vincent',
+ WSM: '^(?!.*amer).*samoa',
+ SMR: 'san.?marino',
+ STP: '\\bs(a|ã)o.?tom(e|é)',
+ SAU: '\\bsa\\w*.?arabia',
+ SEN: 'senegal',
+ SRB: '^(?!.*monte).*serbia',
+ SYC: 'seychell',
+ SLE: 'sierra',
+ SGP: 'singapore',
+ SXM: '^(?!.*martin)(?!.*saba).*maarten',
+ SVK: '^(?!.*cze).*slovak',
+ SVN: 'slovenia',
+ SLB: 'solomon',
+ SOM: 'somali',
+ ZAF: 'south.africa|s\\\\..?africa',
+ SGS: 'south.?georgia|sandwich',
+ SSD: '\\bs\\w*.?sudan',
+ ESP: 'spain',
+ LKA: 'sri.?lanka|ceylon',
+ SDN: '^(?!.*\\bs(?!u)).*sudan',
+ SUR: 'surinam|dutch.?guiana',
+ SJM: 'svalbard',
+ SWZ: 'swaziland',
+ SWE: 'sweden',
+ CHE: 'switz|swiss',
+ SYR: 'syria',
+ TWN: 'taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china',
+ TJK: 'tajik',
+ THA: 'thailand|\\bsiam',
+ MKD: 'macedonia|fyrom',
+ TLS: '^(?=.*leste).*timor|^(?=.*east).*timor',
+ TGO: 'togo',
+ TKL: 'tokelau',
+ TON: 'tonga',
+ TTO: 'trinidad|tobago',
+ TUN: 'tunisia',
+ TUR: 'turkey',
+ TKM: 'turkmen',
+ TCA: 'turks',
+ TUV: 'tuvalu',
+ UGA: 'uganda',
+ UKR: 'ukrain',
+ ARE: 'emirates|^u\\.?a\\.?e\\.?$|united.?arab.?em',
+ GBR: 'united.?kingdom|britain|^u\\.?k\\.?$',
+ TZA: 'tanzania',
+ USA: 'united.?states\\b(?!.*islands)|\\bu\\.?s\\.?a\\.?\\b|^\\s*u\\.?s\\.?\\b(?!.*islands)',
+ UMI: 'minor.?outlying.?is',
+ URY: 'uruguay',
+ UZB: 'uzbek',
+ VUT: 'vanuatu|new.?hebrides',
+ VEN: 'venezuela',
+ VNM: '^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam',
+ VGB: '^(?=.*\\bu\\.?\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin',
+ VIR: '^(?=.*\\bu\\.?\\s?s).*virgin|^(?=.*states).*virgin',
+ WLF: 'futuna|wallis',
+ ESH: 'western.sahara',
+ YEM: '^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\bp\\.?d\\.?r).*yemen',
+ YMD: '^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\bp\\.?d\\.?r).*yemen',
+ YUG: 'yugoslavia',
+ ZMB: 'zambia|northern.?rhodesia',
+ EAZ: 'zanzibar',
+ ZWE: 'zimbabwe|^(?!.*northern).*rhodesia'
+}
+
+},{}],123:[function(_dereq_,module,exports){
+module.exports=[
+ "xx-small",
+ "x-small",
+ "small",
+ "medium",
+ "large",
+ "x-large",
+ "xx-large",
+ "larger",
+ "smaller"
+]
+
+},{}],124:[function(_dereq_,module,exports){
+module.exports=[
+ "normal",
+ "condensed",
+ "semi-condensed",
+ "extra-condensed",
+ "ultra-condensed",
+ "expanded",
+ "semi-expanded",
+ "extra-expanded",
+ "ultra-expanded"
+]
+
+},{}],125:[function(_dereq_,module,exports){
+module.exports=[
+ "normal",
+ "italic",
+ "oblique"
+]
+
+},{}],126:[function(_dereq_,module,exports){
+module.exports=[
+ "normal",
+ "bold",
+ "bolder",
+ "lighter",
+ "100",
+ "200",
+ "300",
+ "400",
+ "500",
+ "600",
+ "700",
+ "800",
+ "900"
+]
+
+},{}],127:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = {
+ parse: _dereq_('./parse'),
+ stringify: _dereq_('./stringify')
+}
+
+},{"./parse":129,"./stringify":130}],128:[function(_dereq_,module,exports){
+'use strict'
+
+var sizes = _dereq_('css-font-size-keywords')
+
+module.exports = {
+ isSize: function isSize(value) {
+ return /^[\d\.]/.test(value)
+ || value.indexOf('/') !== -1
+ || sizes.indexOf(value) !== -1
+ }
+}
+
+},{"css-font-size-keywords":123}],129:[function(_dereq_,module,exports){
+'use strict'
+
+var unquote = _dereq_('unquote')
+var globalKeywords = _dereq_('css-global-keywords')
+var systemFontKeywords = _dereq_('css-system-font-keywords')
+var fontWeightKeywords = _dereq_('css-font-weight-keywords')
+var fontStyleKeywords = _dereq_('css-font-style-keywords')
+var fontStretchKeywords = _dereq_('css-font-stretch-keywords')
+var splitBy = _dereq_('string-split-by')
+var isSize = _dereq_('./lib/util').isSize
+
+
+module.exports = parseFont
+
+
+var cache = parseFont.cache = {}
+
+
+function parseFont (value) {
+ if (typeof value !== 'string') throw new Error('Font argument must be a string.')
+
+ if (cache[value]) return cache[value]
+
+ if (value === '') {
+ throw new Error('Cannot parse an empty string.')
+ }
+
+ if (systemFontKeywords.indexOf(value) !== -1) {
+ return cache[value] = {system: value}
+ }
+
+ var font = {
+ style: 'normal',
+ variant: 'normal',
+ weight: 'normal',
+ stretch: 'normal',
+ lineHeight: 'normal',
+ size: '1rem',
+ family: ['serif']
+ }
+
+ var tokens = splitBy(value, /\s+/)
+ var token
+
+ while (token = tokens.shift()) {
+ if (globalKeywords.indexOf(token) !== -1) {
+ ['style', 'variant', 'weight', 'stretch'].forEach(function(prop) {
+ font[prop] = token
+ })
+
+ return cache[value] = font
+ }
+
+ if (fontStyleKeywords.indexOf(token) !== -1) {
+ font.style = token
+ continue
+ }
+
+ if (token === 'normal' || token === 'small-caps') {
+ font.variant = token
+ continue
+ }
+
+ if (fontStretchKeywords.indexOf(token) !== -1) {
+ font.stretch = token
+ continue
+ }
+
+ if (fontWeightKeywords.indexOf(token) !== -1) {
+ font.weight = token
+ continue
+ }
+
+
+ if (isSize(token)) {
+ var parts = splitBy(token, '/')
+ font.size = parts[0]
+ if (parts[1] != null) {
+ font.lineHeight = parseLineHeight(parts[1])
+ }
+ else if (tokens[0] === '/') {
+ tokens.shift()
+ font.lineHeight = parseLineHeight(tokens.shift())
+ }
+
+ if (!tokens.length) {
+ throw new Error('Missing required font-family.')
+ }
+ font.family = splitBy(tokens.join(' '), /\s*,\s*/).map(unquote)
+
+ return cache[value] = font
+ }
+
+ throw new Error('Unknown or unsupported font token: ' + token)
+ }
+
+ throw new Error('Missing required font-size.')
+}
+
+
+function parseLineHeight(value) {
+ var parsed = parseFloat(value)
+ if (parsed.toString() === value) {
+ return parsed
+ }
+ return value
+}
+
+},{"./lib/util":128,"css-font-stretch-keywords":124,"css-font-style-keywords":125,"css-font-weight-keywords":126,"css-global-keywords":131,"css-system-font-keywords":132,"string-split-by":505,"unquote":525}],130:[function(_dereq_,module,exports){
+'use strict'
+
+var pick = _dereq_('pick-by-alias')
+var isSize = _dereq_('./lib/util').isSize
+
+var globals = a2o(_dereq_('css-global-keywords'))
+var systems = a2o(_dereq_('css-system-font-keywords'))
+var weights = a2o(_dereq_('css-font-weight-keywords'))
+var styles = a2o(_dereq_('css-font-style-keywords'))
+var stretches = a2o(_dereq_('css-font-stretch-keywords'))
+
+var variants = {'normal': 1, 'small-caps': 1}
+var fams = {
+ 'serif': 1,
+ 'sans-serif': 1,
+ 'monospace': 1,
+ 'cursive': 1,
+ 'fantasy': 1,
+ 'system-ui': 1
+}
+
+var defaults = {
+ style: 'normal',
+ variant: 'normal',
+ weight: 'normal',
+ stretch: 'normal',
+ size: '1rem',
+ lineHeight: 'normal',
+ family: 'serif'
+}
+
+module.exports = function stringifyFont (o) {
+ o = pick(o, {
+ style: 'style fontstyle fontStyle font-style slope distinction',
+ variant: 'variant font-variant fontVariant fontvariant var capitalization',
+ weight: 'weight w font-weight fontWeight fontweight',
+ stretch: 'stretch font-stretch fontStretch fontstretch width',
+ size: 'size s font-size fontSize fontsize height em emSize',
+ lineHeight: 'lh line-height lineHeight lineheight leading',
+ family: 'font family fontFamily font-family fontfamily type typeface face',
+ system: 'system reserved default global',
+ })
+
+ if (o.system) {
+ if (o.system) verify(o.system, systems)
+ return o.system
+ }
+
+ verify(o.style, styles)
+ verify(o.variant, variants)
+ verify(o.weight, weights)
+ verify(o.stretch, stretches)
+
+ // default root value is medium, but by default it's inherited
+ if (o.size == null) o.size = defaults.size
+ if (typeof o.size === 'number') o.size += 'px'
+
+ if (!isSize) throw Error('Bad size value `' + o.size + '`')
+
+ // many user-agents use serif, we don't detect that for consistency
+ if (!o.family) o.family = defaults.family
+ if (Array.isArray(o.family)) {
+ if (!o.family.length) o.family = [defaults.family]
+ o.family = o.family.map(function (f) {
+ return fams[f] ? f : '"' + f + '"'
+ }).join(', ')
+ }
+
+ // [ [ <'font-style'> || || <'font-weight'> || <'font-stretch'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ]
+ var result = []
+
+ result.push(o.style)
+ if (o.variant !== o.style) result.push(o.variant)
+
+ if (o.weight !== o.variant &&
+ o.weight !== o.style) result.push(o.weight)
+
+ if (o.stretch !== o.weight &&
+ o.stretch !== o.variant &&
+ o.stretch !== o.style) result.push(o.stretch)
+
+ result.push(o.size + (o.lineHeight == null || o.lineHeight === 'normal' || (o.lineHeight + '' === '1') ? '' : ('/' + o.lineHeight)))
+ result.push(o.family)
+
+ return result.filter(Boolean).join(' ')
+}
+
+function verify (value, values) {
+ if (value && !values[value] && !globals[value]) throw Error('Unknown keyword `' + value +'`')
+
+ return value
+}
+
+
+// ['a', 'b'] -> {a: true, b: true}
+function a2o (a) {
+ var o = {}
+ for (var i = 0; i < a.length; i++) {
+ o[a[i]] = 1
+ }
+ return o
+}
+
+},{"./lib/util":128,"css-font-stretch-keywords":124,"css-font-style-keywords":125,"css-font-weight-keywords":126,"css-global-keywords":131,"css-system-font-keywords":132,"pick-by-alias":448}],131:[function(_dereq_,module,exports){
+module.exports=[
+ "inherit",
+ "initial",
+ "unset"
+]
+
+},{}],132:[function(_dereq_,module,exports){
+module.exports=[
+ "caption",
+ "icon",
+ "menu",
+ "message-box",
+ "small-caption",
+ "status-bar"
+]
+
+},{}],133:[function(_dereq_,module,exports){
+"use strict"
+
+function dcubicHermite(p0, v0, p1, v1, t, f) {
+ var dh00 = 6*t*t-6*t,
+ dh10 = 3*t*t-4*t + 1,
+ dh01 = -6*t*t+6*t,
+ dh11 = 3*t*t-2*t
+ if(p0.length) {
+ if(!f) {
+ f = new Array(p0.length)
+ }
+ for(var i=p0.length-1; i>=0; --i) {
+ f[i] = dh00*p0[i] + dh10*v0[i] + dh01*p1[i] + dh11*v1[i]
+ }
+ return f
+ }
+ return dh00*p0 + dh10*v0 + dh01*p1[i] + dh11*v1
+}
+
+function cubicHermite(p0, v0, p1, v1, t, f) {
+ var ti = (t-1), t2 = t*t, ti2 = ti*ti,
+ h00 = (1+2*t)*ti2,
+ h10 = t*ti2,
+ h01 = t2*(3-2*t),
+ h11 = t2*ti
+ if(p0.length) {
+ if(!f) {
+ f = new Array(p0.length)
+ }
+ for(var i=p0.length-1; i>=0; --i) {
+ f[i] = h00*p0[i] + h10*v0[i] + h01*p1[i] + h11*v1[i]
+ }
+ return f
+ }
+ return h00*p0 + h10*v0 + h01*p1 + h11*v1
+}
+
+module.exports = cubicHermite
+module.exports.derivative = dcubicHermite
+},{}],134:[function(_dereq_,module,exports){
+"use strict"
+
+var createThunk = _dereq_("./lib/thunk.js")
+
+function Procedure() {
+ this.argTypes = []
+ this.shimArgs = []
+ this.arrayArgs = []
+ this.arrayBlockIndices = []
+ this.scalarArgs = []
+ this.offsetArgs = []
+ this.offsetArgIndex = []
+ this.indexArgs = []
+ this.shapeArgs = []
+ this.funcName = ""
+ this.pre = null
+ this.body = null
+ this.post = null
+ this.debug = false
+}
+
+function compileCwise(user_args) {
+ //Create procedure
+ var proc = new Procedure()
+
+ //Parse blocks
+ proc.pre = user_args.pre
+ proc.body = user_args.body
+ proc.post = user_args.post
+
+ //Parse arguments
+ var proc_args = user_args.args.slice(0)
+ proc.argTypes = proc_args
+ for(var i=0; i0) {
+ throw new Error("cwise: pre() block may not reference array args")
+ }
+ if(i < proc.post.args.length && proc.post.args[i].count>0) {
+ throw new Error("cwise: post() block may not reference array args")
+ }
+ } else if(arg_type === "scalar") {
+ proc.scalarArgs.push(i)
+ proc.shimArgs.push("scalar" + i)
+ } else if(arg_type === "index") {
+ proc.indexArgs.push(i)
+ if(i < proc.pre.args.length && proc.pre.args[i].count > 0) {
+ throw new Error("cwise: pre() block may not reference array index")
+ }
+ if(i < proc.body.args.length && proc.body.args[i].lvalue) {
+ throw new Error("cwise: body() block may not write to array index")
+ }
+ if(i < proc.post.args.length && proc.post.args[i].count > 0) {
+ throw new Error("cwise: post() block may not reference array index")
+ }
+ } else if(arg_type === "shape") {
+ proc.shapeArgs.push(i)
+ if(i < proc.pre.args.length && proc.pre.args[i].lvalue) {
+ throw new Error("cwise: pre() block may not write to array shape")
+ }
+ if(i < proc.body.args.length && proc.body.args[i].lvalue) {
+ throw new Error("cwise: body() block may not write to array shape")
+ }
+ if(i < proc.post.args.length && proc.post.args[i].lvalue) {
+ throw new Error("cwise: post() block may not write to array shape")
+ }
+ } else if(typeof arg_type === "object" && arg_type.offset) {
+ proc.argTypes[i] = "offset"
+ proc.offsetArgs.push({ array: arg_type.array, offset:arg_type.offset })
+ proc.offsetArgIndex.push(i)
+ } else {
+ throw new Error("cwise: Unknown argument type " + proc_args[i])
+ }
+ }
+
+ //Make sure at least one array argument was specified
+ if(proc.arrayArgs.length <= 0) {
+ throw new Error("cwise: No array arguments specified")
+ }
+
+ //Make sure arguments are correct
+ if(proc.pre.args.length > proc_args.length) {
+ throw new Error("cwise: Too many arguments in pre() block")
+ }
+ if(proc.body.args.length > proc_args.length) {
+ throw new Error("cwise: Too many arguments in body() block")
+ }
+ if(proc.post.args.length > proc_args.length) {
+ throw new Error("cwise: Too many arguments in post() block")
+ }
+
+ //Check debug flag
+ proc.debug = !!user_args.printCode || !!user_args.debug
+
+ //Retrieve name
+ proc.funcName = user_args.funcName || "cwise"
+
+ //Read in block size
+ proc.blockSize = user_args.blockSize || 64
+
+ return createThunk(proc)
+}
+
+module.exports = compileCwise
+
+},{"./lib/thunk.js":136}],135:[function(_dereq_,module,exports){
+"use strict"
+
+var uniq = _dereq_("uniq")
+
+// This function generates very simple loops analogous to how you typically traverse arrays (the outermost loop corresponds to the slowest changing index, the innermost loop to the fastest changing index)
+// TODO: If two arrays have the same strides (and offsets) there is potential for decreasing the number of "pointers" and related variables. The drawback is that the type signature would become more specific and that there would thus be less potential for caching, but it might still be worth it, especially when dealing with large numbers of arguments.
+function innerFill(order, proc, body) {
+ var dimension = order.length
+ , nargs = proc.arrayArgs.length
+ , has_index = proc.indexArgs.length>0
+ , code = []
+ , vars = []
+ , idx=0, pidx=0, i, j
+ for(i=0; i 0) {
+ code.push("var " + vars.join(","))
+ }
+ //Scan loop
+ for(i=dimension-1; i>=0; --i) { // Start at largest stride and work your way inwards
+ idx = order[i]
+ code.push(["for(i",i,"=0;i",i," 0) {
+ code.push(["index[",pidx,"]-=s",pidx].join(""))
+ }
+ code.push(["++index[",idx,"]"].join(""))
+ }
+ code.push("}")
+ }
+ return code.join("\n")
+}
+
+// Generate "outer" loops that loop over blocks of data, applying "inner" loops to the blocks by manipulating the local variables in such a way that the inner loop only "sees" the current block.
+// TODO: If this is used, then the previous declaration (done by generateCwiseOp) of s* is essentially unnecessary.
+// I believe the s* are not used elsewhere (in particular, I don't think they're used in the pre/post parts and "shape" is defined independently), so it would be possible to make defining the s* dependent on what loop method is being used.
+function outerFill(matched, order, proc, body) {
+ var dimension = order.length
+ , nargs = proc.arrayArgs.length
+ , blockSize = proc.blockSize
+ , has_index = proc.indexArgs.length > 0
+ , code = []
+ for(var i=0; i0;){"].join("")) // Iterate back to front
+ code.push(["if(j",i,"<",blockSize,"){"].join("")) // Either decrease j by blockSize (s = blockSize), or set it to zero (after setting s = j).
+ code.push(["s",order[i],"=j",i].join(""))
+ code.push(["j",i,"=0"].join(""))
+ code.push(["}else{s",order[i],"=",blockSize].join(""))
+ code.push(["j",i,"-=",blockSize,"}"].join(""))
+ if(has_index) {
+ code.push(["index[",order[i],"]=j",i].join(""))
+ }
+ }
+ for(var i=0; i 0) {
+ allEqual = allEqual && summary[i] === summary[i-1]
+ }
+ }
+ if(allEqual) {
+ return summary[0]
+ }
+ return summary.join("")
+}
+
+//Generates a cwise operator
+function generateCWiseOp(proc, typesig) {
+
+ //Compute dimension
+ // Arrays get put first in typesig, and there are two entries per array (dtype and order), so this gets the number of dimensions in the first array arg.
+ var dimension = (typesig[1].length - Math.abs(proc.arrayBlockIndices[0]))|0
+ var orders = new Array(proc.arrayArgs.length)
+ var dtypes = new Array(proc.arrayArgs.length)
+ for(var i=0; i 0) {
+ vars.push("shape=SS.slice(0)") // Makes the shape over which we iterate available to the user defined functions (so you can use width/height for example)
+ }
+ if(proc.indexArgs.length > 0) {
+ // Prepare an array to keep track of the (logical) indices, initialized to dimension zeroes.
+ var zeros = new Array(dimension)
+ for(var i=0; i 0) {
+ code.push("var " + vars.join(","))
+ }
+ for(var i=0; i 3) {
+ code.push(processBlock(proc.pre, proc, dtypes))
+ }
+
+ //Process body
+ var body = processBlock(proc.body, proc, dtypes)
+ var matched = countMatches(loopOrders)
+ if(matched < dimension) {
+ code.push(outerFill(matched, loopOrders[0], proc, body)) // TODO: Rather than passing loopOrders[0], it might be interesting to look at passing an order that represents the majority of the arguments for example.
+ } else {
+ code.push(innerFill(loopOrders[0], proc, body))
+ }
+
+ //Inline epilog
+ if(proc.post.body.length > 3) {
+ code.push(processBlock(proc.post, proc, dtypes))
+ }
+
+ if(proc.debug) {
+ console.log("-----Generated cwise routine for ", typesig, ":\n" + code.join("\n") + "\n----------")
+ }
+
+ var loopName = [(proc.funcName||"unnamed"), "_cwise_loop_", orders[0].join("s"),"m",matched,typeSummary(dtypes)].join("")
+ var f = new Function(["function ",loopName,"(", arglist.join(","),"){", code.join("\n"),"} return ", loopName].join(""))
+ return f()
+}
+module.exports = generateCWiseOp
+
+},{"uniq":524}],136:[function(_dereq_,module,exports){
+"use strict"
+
+// The function below is called when constructing a cwise function object, and does the following:
+// A function object is constructed which accepts as argument a compilation function and returns another function.
+// It is this other function that is eventually returned by createThunk, and this function is the one that actually
+// checks whether a certain pattern of arguments has already been used before and compiles new loops as needed.
+// The compilation passed to the first function object is used for compiling new functions.
+// Once this function object is created, it is called with compile as argument, where the first argument of compile
+// is bound to "proc" (essentially containing a preprocessed version of the user arguments to cwise).
+// So createThunk roughly works like this:
+// function createThunk(proc) {
+// var thunk = function(compileBound) {
+// var CACHED = {}
+// return function(arrays and scalars) {
+// if (dtype and order of arrays in CACHED) {
+// var func = CACHED[dtype and order of arrays]
+// } else {
+// var func = CACHED[dtype and order of arrays] = compileBound(dtype and order of arrays)
+// }
+// return func(arrays and scalars)
+// }
+// }
+// return thunk(compile.bind1(proc))
+// }
+
+var compile = _dereq_("./compile.js")
+
+function createThunk(proc) {
+ var code = ["'use strict'", "var CACHED={}"]
+ var vars = []
+ var thunkName = proc.funcName + "_cwise_thunk"
+
+ //Build thunk
+ code.push(["return function ", thunkName, "(", proc.shimArgs.join(","), "){"].join(""))
+ var typesig = []
+ var string_typesig = []
+ var proc_args = [["array",proc.arrayArgs[0],".shape.slice(", // Slice shape so that we only retain the shape over which we iterate (which gets passed to the cwise operator as SS).
+ Math.max(0,proc.arrayBlockIndices[0]),proc.arrayBlockIndices[0]<0?(","+proc.arrayBlockIndices[0]+")"):")"].join("")]
+ var shapeLengthConditions = [], shapeConditions = []
+ // Process array arguments
+ for(var i=0; i0) { // Gather conditions to check for shape equality (ignoring block indices)
+ shapeLengthConditions.push("array" + proc.arrayArgs[0] + ".shape.length===array" + j + ".shape.length+" + (Math.abs(proc.arrayBlockIndices[0])-Math.abs(proc.arrayBlockIndices[i])))
+ shapeConditions.push("array" + proc.arrayArgs[0] + ".shape[shapeIndex+" + Math.max(0,proc.arrayBlockIndices[0]) + "]===array" + j + ".shape[shapeIndex+" + Math.max(0,proc.arrayBlockIndices[i]) + "]")
+ }
+ }
+ // Check for shape equality
+ if (proc.arrayArgs.length > 1) {
+ code.push("if (!(" + shapeLengthConditions.join(" && ") + ")) throw new Error('cwise: Arrays do not all have the same dimensionality!')")
+ code.push("for(var shapeIndex=array" + proc.arrayArgs[0] + ".shape.length-" + Math.abs(proc.arrayBlockIndices[0]) + "; shapeIndex-->0;) {")
+ code.push("if (!(" + shapeConditions.join(" && ") + ")) throw new Error('cwise: Arrays do not all have the same shape!')")
+ code.push("}")
+ }
+ // Process scalar arguments
+ for(var i=0; i b ? 1 : a >= b ? 0 : NaN;
+}
+
+function bisector(compare) {
+ if (compare.length === 1) compare = ascendingComparator(compare);
+ return {
+ left: function(a, x, lo, hi) {
+ if (lo == null) lo = 0;
+ if (hi == null) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) < 0) lo = mid + 1;
+ else hi = mid;
+ }
+ return lo;
+ },
+ right: function(a, x, lo, hi) {
+ if (lo == null) lo = 0;
+ if (hi == null) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) > 0) hi = mid;
+ else lo = mid + 1;
+ }
+ return lo;
+ }
+ };
+}
+
+function ascendingComparator(f) {
+ return function(d, x) {
+ return ascending(f(d), x);
+ };
+}
+
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+
+function pairs(array, f) {
+ if (f == null) f = pair;
+ var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
+ while (i < n) pairs[i] = f(p, p = array[++i]);
+ return pairs;
+}
+
+function pair(a, b) {
+ return [a, b];
+}
+
+function cross(values0, values1, reduce) {
+ var n0 = values0.length,
+ n1 = values1.length,
+ values = new Array(n0 * n1),
+ i0,
+ i1,
+ i,
+ value0;
+
+ if (reduce == null) reduce = pair;
+
+ for (i0 = i = 0; i0 < n0; ++i0) {
+ for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
+ values[i] = reduce(value0, values1[i1]);
+ }
+ }
+
+ return values;
+}
+
+function descending(a, b) {
+ return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+function number(x) {
+ return x === null ? NaN : +x;
+}
+
+function variance(values, valueof) {
+ var n = values.length,
+ m = 0,
+ i = -1,
+ mean = 0,
+ value,
+ delta,
+ sum = 0;
+
+ if (valueof == null) {
+ while (++i < n) {
+ if (!isNaN(value = number(values[i]))) {
+ delta = value - mean;
+ mean += delta / ++m;
+ sum += delta * (value - mean);
+ }
+ }
+ }
+
+ else {
+ while (++i < n) {
+ if (!isNaN(value = number(valueof(values[i], i, values)))) {
+ delta = value - mean;
+ mean += delta / ++m;
+ sum += delta * (value - mean);
+ }
+ }
+ }
+
+ if (m > 1) return sum / (m - 1);
+}
+
+function deviation(array, f) {
+ var v = variance(array, f);
+ return v ? Math.sqrt(v) : v;
+}
+
+function extent(values, valueof) {
+ var n = values.length,
+ i = -1,
+ value,
+ min,
+ max;
+
+ if (valueof == null) {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = values[i]) != null && value >= value) {
+ min = max = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = values[i]) != null) {
+ if (min > value) min = value;
+ if (max < value) max = value;
+ }
+ }
+ }
+ }
+ }
+
+ else {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = valueof(values[i], i, values)) != null && value >= value) {
+ min = max = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = valueof(values[i], i, values)) != null) {
+ if (min > value) min = value;
+ if (max < value) max = value;
+ }
+ }
+ }
+ }
+ }
+
+ return [min, max];
+}
+
+var array = Array.prototype;
+
+var slice = array.slice;
+var map = array.map;
+
+function constant(x) {
+ return function() {
+ return x;
+ };
+}
+
+function identity(x) {
+ return x;
+}
+
+function range(start, stop, step) {
+ start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+
+ var i = -1,
+ n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+ range = new Array(n);
+
+ while (++i < n) {
+ range[i] = start + i * step;
+ }
+
+ return range;
+}
+
+var e10 = Math.sqrt(50),
+ e5 = Math.sqrt(10),
+ e2 = Math.sqrt(2);
+
+function ticks(start, stop, count) {
+ var reverse,
+ i = -1,
+ n,
+ ticks,
+ step;
+
+ stop = +stop, start = +start, count = +count;
+ if (start === stop && count > 0) return [start];
+ if (reverse = stop < start) n = start, start = stop, stop = n;
+ if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+ if (step > 0) {
+ start = Math.ceil(start / step);
+ stop = Math.floor(stop / step);
+ ticks = new Array(n = Math.ceil(stop - start + 1));
+ while (++i < n) ticks[i] = (start + i) * step;
+ } else {
+ start = Math.floor(start * step);
+ stop = Math.ceil(stop * step);
+ ticks = new Array(n = Math.ceil(start - stop + 1));
+ while (++i < n) ticks[i] = (start - i) / step;
+ }
+
+ if (reverse) ticks.reverse();
+
+ return ticks;
+}
+
+function tickIncrement(start, stop, count) {
+ var step = (stop - start) / Math.max(0, count),
+ power = Math.floor(Math.log(step) / Math.LN10),
+ error = step / Math.pow(10, power);
+ return power >= 0
+ ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
+ : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+}
+
+function tickStep(start, stop, count) {
+ var step0 = Math.abs(stop - start) / Math.max(0, count),
+ step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+ error = step0 / step1;
+ if (error >= e10) step1 *= 10;
+ else if (error >= e5) step1 *= 5;
+ else if (error >= e2) step1 *= 2;
+ return stop < start ? -step1 : step1;
+}
+
+function sturges(values) {
+ return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
+}
+
+function histogram() {
+ var value = identity,
+ domain = extent,
+ threshold = sturges;
+
+ function histogram(data) {
+ var i,
+ n = data.length,
+ x,
+ values = new Array(n);
+
+ for (i = 0; i < n; ++i) {
+ values[i] = value(data[i], i, data);
+ }
+
+ var xz = domain(values),
+ x0 = xz[0],
+ x1 = xz[1],
+ tz = threshold(values, x0, x1);
+
+ // Convert number of thresholds into uniform thresholds.
+ if (!Array.isArray(tz)) {
+ tz = tickStep(x0, x1, tz);
+ tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
+ }
+
+ // Remove any thresholds outside the domain.
+ var m = tz.length;
+ while (tz[0] <= x0) tz.shift(), --m;
+ while (tz[m - 1] > x1) tz.pop(), --m;
+
+ var bins = new Array(m + 1),
+ bin;
+
+ // Initialize bins.
+ for (i = 0; i <= m; ++i) {
+ bin = bins[i] = [];
+ bin.x0 = i > 0 ? tz[i - 1] : x0;
+ bin.x1 = i < m ? tz[i] : x1;
+ }
+
+ // Assign data to bins by value, ignoring any outside the domain.
+ for (i = 0; i < n; ++i) {
+ x = values[i];
+ if (x0 <= x && x <= x1) {
+ bins[bisectRight(tz, x, 0, m)].push(data[i]);
+ }
+ }
+
+ return bins;
+ }
+
+ histogram.value = function(_) {
+ return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+ };
+
+ histogram.domain = function(_) {
+ return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+ };
+
+ histogram.thresholds = function(_) {
+ return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
+ };
+
+ return histogram;
+}
+
+function quantile(values, p, valueof) {
+ if (valueof == null) valueof = number;
+ if (!(n = values.length)) return;
+ if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+ if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+ var n,
+ i = (n - 1) * p,
+ i0 = Math.floor(i),
+ value0 = +valueof(values[i0], i0, values),
+ value1 = +valueof(values[i0 + 1], i0 + 1, values);
+ return value0 + (value1 - value0) * (i - i0);
+}
+
+function freedmanDiaconis(values, min, max) {
+ values = map.call(values, number).sort(ascending);
+ return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+}
+
+function scott(values, min, max) {
+ return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
+}
+
+function max(values, valueof) {
+ var n = values.length,
+ i = -1,
+ value,
+ max;
+
+ if (valueof == null) {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = values[i]) != null && value >= value) {
+ max = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = values[i]) != null && value > max) {
+ max = value;
+ }
+ }
+ }
+ }
+ }
+
+ else {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = valueof(values[i], i, values)) != null && value >= value) {
+ max = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = valueof(values[i], i, values)) != null && value > max) {
+ max = value;
+ }
+ }
+ }
+ }
+ }
+
+ return max;
+}
+
+function mean(values, valueof) {
+ var n = values.length,
+ m = n,
+ i = -1,
+ value,
+ sum = 0;
+
+ if (valueof == null) {
+ while (++i < n) {
+ if (!isNaN(value = number(values[i]))) sum += value;
+ else --m;
+ }
+ }
+
+ else {
+ while (++i < n) {
+ if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
+ else --m;
+ }
+ }
+
+ if (m) return sum / m;
+}
+
+function median(values, valueof) {
+ var n = values.length,
+ i = -1,
+ value,
+ numbers = [];
+
+ if (valueof == null) {
+ while (++i < n) {
+ if (!isNaN(value = number(values[i]))) {
+ numbers.push(value);
+ }
+ }
+ }
+
+ else {
+ while (++i < n) {
+ if (!isNaN(value = number(valueof(values[i], i, values)))) {
+ numbers.push(value);
+ }
+ }
+ }
+
+ return quantile(numbers.sort(ascending), 0.5);
+}
+
+function merge(arrays) {
+ var n = arrays.length,
+ m,
+ i = -1,
+ j = 0,
+ merged,
+ array;
+
+ while (++i < n) j += arrays[i].length;
+ merged = new Array(j);
+
+ while (--n >= 0) {
+ array = arrays[n];
+ m = array.length;
+ while (--m >= 0) {
+ merged[--j] = array[m];
+ }
+ }
+
+ return merged;
+}
+
+function min(values, valueof) {
+ var n = values.length,
+ i = -1,
+ value,
+ min;
+
+ if (valueof == null) {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = values[i]) != null && value >= value) {
+ min = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = values[i]) != null && min > value) {
+ min = value;
+ }
+ }
+ }
+ }
+ }
+
+ else {
+ while (++i < n) { // Find the first comparable value.
+ if ((value = valueof(values[i], i, values)) != null && value >= value) {
+ min = value;
+ while (++i < n) { // Compare the remaining values.
+ if ((value = valueof(values[i], i, values)) != null && min > value) {
+ min = value;
+ }
+ }
+ }
+ }
+ }
+
+ return min;
+}
+
+function permute(array, indexes) {
+ var i = indexes.length, permutes = new Array(i);
+ while (i--) permutes[i] = array[indexes[i]];
+ return permutes;
+}
+
+function scan(values, compare) {
+ if (!(n = values.length)) return;
+ var n,
+ i = 0,
+ j = 0,
+ xi,
+ xj = values[j];
+
+ if (compare == null) compare = ascending;
+
+ while (++i < n) {
+ if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
+ xj = xi, j = i;
+ }
+ }
+
+ if (compare(xj, xj) === 0) return j;
+}
+
+function shuffle(array, i0, i1) {
+ var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
+ t,
+ i;
+
+ while (m) {
+ i = Math.random() * m-- | 0;
+ t = array[m + i0];
+ array[m + i0] = array[i + i0];
+ array[i + i0] = t;
+ }
+
+ return array;
+}
+
+function sum(values, valueof) {
+ var n = values.length,
+ i = -1,
+ value,
+ sum = 0;
+
+ if (valueof == null) {
+ while (++i < n) {
+ if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
+ }
+ }
+
+ else {
+ while (++i < n) {
+ if (value = +valueof(values[i], i, values)) sum += value;
+ }
+ }
+
+ return sum;
+}
+
+function transpose(matrix) {
+ if (!(n = matrix.length)) return [];
+ for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
+ for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
+ row[j] = matrix[j][i];
+ }
+ }
+ return transpose;
+}
+
+function length(d) {
+ return d.length;
+}
+
+function zip() {
+ return transpose(arguments);
+}
+
+exports.bisect = bisectRight;
+exports.bisectRight = bisectRight;
+exports.bisectLeft = bisectLeft;
+exports.ascending = ascending;
+exports.bisector = bisector;
+exports.cross = cross;
+exports.descending = descending;
+exports.deviation = deviation;
+exports.extent = extent;
+exports.histogram = histogram;
+exports.thresholdFreedmanDiaconis = freedmanDiaconis;
+exports.thresholdScott = scott;
+exports.thresholdSturges = sturges;
+exports.max = max;
+exports.mean = mean;
+exports.median = median;
+exports.merge = merge;
+exports.min = min;
+exports.pairs = pairs;
+exports.permute = permute;
+exports.quantile = quantile;
+exports.range = range;
+exports.scan = scan;
+exports.shuffle = shuffle;
+exports.sum = sum;
+exports.ticks = ticks;
+exports.tickIncrement = tickIncrement;
+exports.tickStep = tickStep;
+exports.transpose = transpose;
+exports.variance = variance;
+exports.zip = zip;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],141:[function(_dereq_,module,exports){
+// https://d3js.org/d3-collection/ Version 1.0.4. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+var prefix = "$";
+
+function Map() {}
+
+Map.prototype = map.prototype = {
+ constructor: Map,
+ has: function(key) {
+ return (prefix + key) in this;
+ },
+ get: function(key) {
+ return this[prefix + key];
+ },
+ set: function(key, value) {
+ this[prefix + key] = value;
+ return this;
+ },
+ remove: function(key) {
+ var property = prefix + key;
+ return property in this && delete this[property];
+ },
+ clear: function() {
+ for (var property in this) if (property[0] === prefix) delete this[property];
+ },
+ keys: function() {
+ var keys = [];
+ for (var property in this) if (property[0] === prefix) keys.push(property.slice(1));
+ return keys;
+ },
+ values: function() {
+ var values = [];
+ for (var property in this) if (property[0] === prefix) values.push(this[property]);
+ return values;
+ },
+ entries: function() {
+ var entries = [];
+ for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]});
+ return entries;
+ },
+ size: function() {
+ var size = 0;
+ for (var property in this) if (property[0] === prefix) ++size;
+ return size;
+ },
+ empty: function() {
+ for (var property in this) if (property[0] === prefix) return false;
+ return true;
+ },
+ each: function(f) {
+ for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this);
+ }
+};
+
+function map(object, f) {
+ var map = new Map;
+
+ // Copy constructor.
+ if (object instanceof Map) object.each(function(value, key) { map.set(key, value); });
+
+ // Index array by numeric index or specified key function.
+ else if (Array.isArray(object)) {
+ var i = -1,
+ n = object.length,
+ o;
+
+ if (f == null) while (++i < n) map.set(i, object[i]);
+ else while (++i < n) map.set(f(o = object[i], i, object), o);
+ }
+
+ // Convert object to map.
+ else if (object) for (var key in object) map.set(key, object[key]);
+
+ return map;
+}
+
+var nest = function() {
+ var keys = [],
+ sortKeys = [],
+ sortValues,
+ rollup,
+ nest;
+
+ function apply(array, depth, createResult, setResult) {
+ if (depth >= keys.length) {
+ if (sortValues != null) array.sort(sortValues);
+ return rollup != null ? rollup(array) : array;
+ }
+
+ var i = -1,
+ n = array.length,
+ key = keys[depth++],
+ keyValue,
+ value,
+ valuesByKey = map(),
+ values,
+ result = createResult();
+
+ while (++i < n) {
+ if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) {
+ values.push(value);
+ } else {
+ valuesByKey.set(keyValue, [value]);
+ }
+ }
+
+ valuesByKey.each(function(values, key) {
+ setResult(result, key, apply(values, depth, createResult, setResult));
+ });
+
+ return result;
+ }
+
+ function entries(map$$1, depth) {
+ if (++depth > keys.length) return map$$1;
+ var array, sortKey = sortKeys[depth - 1];
+ if (rollup != null && depth >= keys.length) array = map$$1.entries();
+ else array = [], map$$1.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); });
+ return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array;
+ }
+
+ return nest = {
+ object: function(array) { return apply(array, 0, createObject, setObject); },
+ map: function(array) { return apply(array, 0, createMap, setMap); },
+ entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); },
+ key: function(d) { keys.push(d); return nest; },
+ sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; },
+ sortValues: function(order) { sortValues = order; return nest; },
+ rollup: function(f) { rollup = f; return nest; }
+ };
+};
+
+function createObject() {
+ return {};
+}
+
+function setObject(object, key, value) {
+ object[key] = value;
+}
+
+function createMap() {
+ return map();
+}
+
+function setMap(map$$1, key, value) {
+ map$$1.set(key, value);
+}
+
+function Set() {}
+
+var proto = map.prototype;
+
+Set.prototype = set.prototype = {
+ constructor: Set,
+ has: proto.has,
+ add: function(value) {
+ value += "";
+ this[prefix + value] = value;
+ return this;
+ },
+ remove: proto.remove,
+ clear: proto.clear,
+ values: proto.keys,
+ size: proto.size,
+ empty: proto.empty,
+ each: proto.each
+};
+
+function set(object, f) {
+ var set = new Set;
+
+ // Copy constructor.
+ if (object instanceof Set) object.each(function(value) { set.add(value); });
+
+ // Otherwise, assume it’s an array.
+ else if (object) {
+ var i = -1, n = object.length;
+ if (f == null) while (++i < n) set.add(object[i]);
+ else while (++i < n) set.add(f(object[i], i, object));
+ }
+
+ return set;
+}
+
+var keys = function(map) {
+ var keys = [];
+ for (var key in map) keys.push(key);
+ return keys;
+};
+
+var values = function(map) {
+ var values = [];
+ for (var key in map) values.push(map[key]);
+ return values;
+};
+
+var entries = function(map) {
+ var entries = [];
+ for (var key in map) entries.push({key: key, value: map[key]});
+ return entries;
+};
+
+exports.nest = nest;
+exports.set = set;
+exports.map = map;
+exports.keys = keys;
+exports.values = values;
+exports.entries = entries;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],142:[function(_dereq_,module,exports){
+// https://d3js.org/d3-color/ v1.2.3 Copyright 2018 Mike Bostock
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+function define(constructor, factory, prototype) {
+ constructor.prototype = factory.prototype = prototype;
+ prototype.constructor = constructor;
+}
+
+function extend(parent, definition) {
+ var prototype = Object.create(parent.prototype);
+ for (var key in definition) prototype[key] = definition[key];
+ return prototype;
+}
+
+function Color() {}
+
+var darker = 0.7;
+var brighter = 1 / darker;
+
+var reI = "\\s*([+-]?\\d+)\\s*",
+ reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
+ reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
+ reHex3 = /^#([0-9a-f]{3})$/,
+ reHex6 = /^#([0-9a-f]{6})$/,
+ reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"),
+ reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"),
+ reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"),
+ reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"),
+ reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"),
+ reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$");
+
+var named = {
+ aliceblue: 0xf0f8ff,
+ antiquewhite: 0xfaebd7,
+ aqua: 0x00ffff,
+ aquamarine: 0x7fffd4,
+ azure: 0xf0ffff,
+ beige: 0xf5f5dc,
+ bisque: 0xffe4c4,
+ black: 0x000000,
+ blanchedalmond: 0xffebcd,
+ blue: 0x0000ff,
+ blueviolet: 0x8a2be2,
+ brown: 0xa52a2a,
+ burlywood: 0xdeb887,
+ cadetblue: 0x5f9ea0,
+ chartreuse: 0x7fff00,
+ chocolate: 0xd2691e,
+ coral: 0xff7f50,
+ cornflowerblue: 0x6495ed,
+ cornsilk: 0xfff8dc,
+ crimson: 0xdc143c,
+ cyan: 0x00ffff,
+ darkblue: 0x00008b,
+ darkcyan: 0x008b8b,
+ darkgoldenrod: 0xb8860b,
+ darkgray: 0xa9a9a9,
+ darkgreen: 0x006400,
+ darkgrey: 0xa9a9a9,
+ darkkhaki: 0xbdb76b,
+ darkmagenta: 0x8b008b,
+ darkolivegreen: 0x556b2f,
+ darkorange: 0xff8c00,
+ darkorchid: 0x9932cc,
+ darkred: 0x8b0000,
+ darksalmon: 0xe9967a,
+ darkseagreen: 0x8fbc8f,
+ darkslateblue: 0x483d8b,
+ darkslategray: 0x2f4f4f,
+ darkslategrey: 0x2f4f4f,
+ darkturquoise: 0x00ced1,
+ darkviolet: 0x9400d3,
+ deeppink: 0xff1493,
+ deepskyblue: 0x00bfff,
+ dimgray: 0x696969,
+ dimgrey: 0x696969,
+ dodgerblue: 0x1e90ff,
+ firebrick: 0xb22222,
+ floralwhite: 0xfffaf0,
+ forestgreen: 0x228b22,
+ fuchsia: 0xff00ff,
+ gainsboro: 0xdcdcdc,
+ ghostwhite: 0xf8f8ff,
+ gold: 0xffd700,
+ goldenrod: 0xdaa520,
+ gray: 0x808080,
+ green: 0x008000,
+ greenyellow: 0xadff2f,
+ grey: 0x808080,
+ honeydew: 0xf0fff0,
+ hotpink: 0xff69b4,
+ indianred: 0xcd5c5c,
+ indigo: 0x4b0082,
+ ivory: 0xfffff0,
+ khaki: 0xf0e68c,
+ lavender: 0xe6e6fa,
+ lavenderblush: 0xfff0f5,
+ lawngreen: 0x7cfc00,
+ lemonchiffon: 0xfffacd,
+ lightblue: 0xadd8e6,
+ lightcoral: 0xf08080,
+ lightcyan: 0xe0ffff,
+ lightgoldenrodyellow: 0xfafad2,
+ lightgray: 0xd3d3d3,
+ lightgreen: 0x90ee90,
+ lightgrey: 0xd3d3d3,
+ lightpink: 0xffb6c1,
+ lightsalmon: 0xffa07a,
+ lightseagreen: 0x20b2aa,
+ lightskyblue: 0x87cefa,
+ lightslategray: 0x778899,
+ lightslategrey: 0x778899,
+ lightsteelblue: 0xb0c4de,
+ lightyellow: 0xffffe0,
+ lime: 0x00ff00,
+ limegreen: 0x32cd32,
+ linen: 0xfaf0e6,
+ magenta: 0xff00ff,
+ maroon: 0x800000,
+ mediumaquamarine: 0x66cdaa,
+ mediumblue: 0x0000cd,
+ mediumorchid: 0xba55d3,
+ mediumpurple: 0x9370db,
+ mediumseagreen: 0x3cb371,
+ mediumslateblue: 0x7b68ee,
+ mediumspringgreen: 0x00fa9a,
+ mediumturquoise: 0x48d1cc,
+ mediumvioletred: 0xc71585,
+ midnightblue: 0x191970,
+ mintcream: 0xf5fffa,
+ mistyrose: 0xffe4e1,
+ moccasin: 0xffe4b5,
+ navajowhite: 0xffdead,
+ navy: 0x000080,
+ oldlace: 0xfdf5e6,
+ olive: 0x808000,
+ olivedrab: 0x6b8e23,
+ orange: 0xffa500,
+ orangered: 0xff4500,
+ orchid: 0xda70d6,
+ palegoldenrod: 0xeee8aa,
+ palegreen: 0x98fb98,
+ paleturquoise: 0xafeeee,
+ palevioletred: 0xdb7093,
+ papayawhip: 0xffefd5,
+ peachpuff: 0xffdab9,
+ peru: 0xcd853f,
+ pink: 0xffc0cb,
+ plum: 0xdda0dd,
+ powderblue: 0xb0e0e6,
+ purple: 0x800080,
+ rebeccapurple: 0x663399,
+ red: 0xff0000,
+ rosybrown: 0xbc8f8f,
+ royalblue: 0x4169e1,
+ saddlebrown: 0x8b4513,
+ salmon: 0xfa8072,
+ sandybrown: 0xf4a460,
+ seagreen: 0x2e8b57,
+ seashell: 0xfff5ee,
+ sienna: 0xa0522d,
+ silver: 0xc0c0c0,
+ skyblue: 0x87ceeb,
+ slateblue: 0x6a5acd,
+ slategray: 0x708090,
+ slategrey: 0x708090,
+ snow: 0xfffafa,
+ springgreen: 0x00ff7f,
+ steelblue: 0x4682b4,
+ tan: 0xd2b48c,
+ teal: 0x008080,
+ thistle: 0xd8bfd8,
+ tomato: 0xff6347,
+ turquoise: 0x40e0d0,
+ violet: 0xee82ee,
+ wheat: 0xf5deb3,
+ white: 0xffffff,
+ whitesmoke: 0xf5f5f5,
+ yellow: 0xffff00,
+ yellowgreen: 0x9acd32
+};
+
+define(Color, color, {
+ displayable: function() {
+ return this.rgb().displayable();
+ },
+ hex: function() {
+ return this.rgb().hex();
+ },
+ toString: function() {
+ return this.rgb() + "";
+ }
+});
+
+function color(format) {
+ var m;
+ format = (format + "").trim().toLowerCase();
+ return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00
+ : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000
+ : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
+ : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
+ : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
+ : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
+ : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
+ : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
+ : named.hasOwnProperty(format) ? rgbn(named[format])
+ : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0)
+ : null;
+}
+
+function rgbn(n) {
+ return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
+}
+
+function rgba(r, g, b, a) {
+ if (a <= 0) r = g = b = NaN;
+ return new Rgb(r, g, b, a);
+}
+
+function rgbConvert(o) {
+ if (!(o instanceof Color)) o = color(o);
+ if (!o) return new Rgb;
+ o = o.rgb();
+ return new Rgb(o.r, o.g, o.b, o.opacity);
+}
+
+function rgb(r, g, b, opacity) {
+ return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+}
+
+function Rgb(r, g, b, opacity) {
+ this.r = +r;
+ this.g = +g;
+ this.b = +b;
+ this.opacity = +opacity;
+}
+
+define(Rgb, rgb, extend(Color, {
+ brighter: function(k) {
+ k = k == null ? brighter : Math.pow(brighter, k);
+ return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+ },
+ darker: function(k) {
+ k = k == null ? darker : Math.pow(darker, k);
+ return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+ },
+ rgb: function() {
+ return this;
+ },
+ displayable: function() {
+ return (0 <= this.r && this.r <= 255)
+ && (0 <= this.g && this.g <= 255)
+ && (0 <= this.b && this.b <= 255)
+ && (0 <= this.opacity && this.opacity <= 1);
+ },
+ hex: function() {
+ return "#" + hex(this.r) + hex(this.g) + hex(this.b);
+ },
+ toString: function() {
+ var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
+ return (a === 1 ? "rgb(" : "rgba(")
+ + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", "
+ + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", "
+ + Math.max(0, Math.min(255, Math.round(this.b) || 0))
+ + (a === 1 ? ")" : ", " + a + ")");
+ }
+}));
+
+function hex(value) {
+ value = Math.max(0, Math.min(255, Math.round(value) || 0));
+ return (value < 16 ? "0" : "") + value.toString(16);
+}
+
+function hsla(h, s, l, a) {
+ if (a <= 0) h = s = l = NaN;
+ else if (l <= 0 || l >= 1) h = s = NaN;
+ else if (s <= 0) h = NaN;
+ return new Hsl(h, s, l, a);
+}
+
+function hslConvert(o) {
+ if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
+ if (!(o instanceof Color)) o = color(o);
+ if (!o) return new Hsl;
+ if (o instanceof Hsl) return o;
+ o = o.rgb();
+ var r = o.r / 255,
+ g = o.g / 255,
+ b = o.b / 255,
+ min = Math.min(r, g, b),
+ max = Math.max(r, g, b),
+ h = NaN,
+ s = max - min,
+ l = (max + min) / 2;
+ if (s) {
+ if (r === max) h = (g - b) / s + (g < b) * 6;
+ else if (g === max) h = (b - r) / s + 2;
+ else h = (r - g) / s + 4;
+ s /= l < 0.5 ? max + min : 2 - max - min;
+ h *= 60;
+ } else {
+ s = l > 0 && l < 1 ? 0 : h;
+ }
+ return new Hsl(h, s, l, o.opacity);
+}
+
+function hsl(h, s, l, opacity) {
+ return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+}
+
+function Hsl(h, s, l, opacity) {
+ this.h = +h;
+ this.s = +s;
+ this.l = +l;
+ this.opacity = +opacity;
+}
+
+define(Hsl, hsl, extend(Color, {
+ brighter: function(k) {
+ k = k == null ? brighter : Math.pow(brighter, k);
+ return new Hsl(this.h, this.s, this.l * k, this.opacity);
+ },
+ darker: function(k) {
+ k = k == null ? darker : Math.pow(darker, k);
+ return new Hsl(this.h, this.s, this.l * k, this.opacity);
+ },
+ rgb: function() {
+ var h = this.h % 360 + (this.h < 0) * 360,
+ s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
+ l = this.l,
+ m2 = l + (l < 0.5 ? l : 1 - l) * s,
+ m1 = 2 * l - m2;
+ return new Rgb(
+ hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2),
+ hsl2rgb(h, m1, m2),
+ hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2),
+ this.opacity
+ );
+ },
+ displayable: function() {
+ return (0 <= this.s && this.s <= 1 || isNaN(this.s))
+ && (0 <= this.l && this.l <= 1)
+ && (0 <= this.opacity && this.opacity <= 1);
+ }
+}));
+
+/* From FvD 13.37, CSS Color Module Level 3 */
+function hsl2rgb(h, m1, m2) {
+ return (h < 60 ? m1 + (m2 - m1) * h / 60
+ : h < 180 ? m2
+ : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60
+ : m1) * 255;
+}
+
+var deg2rad = Math.PI / 180;
+var rad2deg = 180 / Math.PI;
+
+// https://beta.observablehq.com/@mbostock/lab-and-rgb
+var K = 18,
+ Xn = 0.96422,
+ Yn = 1,
+ Zn = 0.82521,
+ t0 = 4 / 29,
+ t1 = 6 / 29,
+ t2 = 3 * t1 * t1,
+ t3 = t1 * t1 * t1;
+
+function labConvert(o) {
+ if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
+ if (o instanceof Hcl) {
+ if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
+ var h = o.h * deg2rad;
+ return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
+ }
+ if (!(o instanceof Rgb)) o = rgbConvert(o);
+ var r = rgb2lrgb(o.r),
+ g = rgb2lrgb(o.g),
+ b = rgb2lrgb(o.b),
+ y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z;
+ if (r === g && g === b) x = z = y; else {
+ x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn);
+ z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn);
+ }
+ return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
+}
+
+function gray(l, opacity) {
+ return new Lab(l, 0, 0, opacity == null ? 1 : opacity);
+}
+
+function lab(l, a, b, opacity) {
+ return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
+}
+
+function Lab(l, a, b, opacity) {
+ this.l = +l;
+ this.a = +a;
+ this.b = +b;
+ this.opacity = +opacity;
+}
+
+define(Lab, lab, extend(Color, {
+ brighter: function(k) {
+ return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity);
+ },
+ darker: function(k) {
+ return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity);
+ },
+ rgb: function() {
+ var y = (this.l + 16) / 116,
+ x = isNaN(this.a) ? y : y + this.a / 500,
+ z = isNaN(this.b) ? y : y - this.b / 200;
+ x = Xn * lab2xyz(x);
+ y = Yn * lab2xyz(y);
+ z = Zn * lab2xyz(z);
+ return new Rgb(
+ lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z),
+ lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z),
+ lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z),
+ this.opacity
+ );
+ }
+}));
+
+function xyz2lab(t) {
+ return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
+}
+
+function lab2xyz(t) {
+ return t > t1 ? t * t * t : t2 * (t - t0);
+}
+
+function lrgb2rgb(x) {
+ return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
+}
+
+function rgb2lrgb(x) {
+ return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
+}
+
+function hclConvert(o) {
+ if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
+ if (!(o instanceof Lab)) o = labConvert(o);
+ if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0, o.l, o.opacity);
+ var h = Math.atan2(o.b, o.a) * rad2deg;
+ return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
+}
+
+function lch(l, c, h, opacity) {
+ return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
+}
+
+function hcl(h, c, l, opacity) {
+ return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
+}
+
+function Hcl(h, c, l, opacity) {
+ this.h = +h;
+ this.c = +c;
+ this.l = +l;
+ this.opacity = +opacity;
+}
+
+define(Hcl, hcl, extend(Color, {
+ brighter: function(k) {
+ return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity);
+ },
+ darker: function(k) {
+ return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity);
+ },
+ rgb: function() {
+ return labConvert(this).rgb();
+ }
+}));
+
+var A = -0.14861,
+ B = +1.78277,
+ C = -0.29227,
+ D = -0.90649,
+ E = +1.97294,
+ ED = E * D,
+ EB = E * B,
+ BC_DA = B * C - D * A;
+
+function cubehelixConvert(o) {
+ if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
+ if (!(o instanceof Rgb)) o = rgbConvert(o);
+ var r = o.r / 255,
+ g = o.g / 255,
+ b = o.b / 255,
+ l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
+ bl = b - l,
+ k = (E * (g - l) - C * bl) / D,
+ s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1
+ h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN;
+ return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity);
+}
+
+function cubehelix(h, s, l, opacity) {
+ return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity);
+}
+
+function Cubehelix(h, s, l, opacity) {
+ this.h = +h;
+ this.s = +s;
+ this.l = +l;
+ this.opacity = +opacity;
+}
+
+define(Cubehelix, cubehelix, extend(Color, {
+ brighter: function(k) {
+ k = k == null ? brighter : Math.pow(brighter, k);
+ return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
+ },
+ darker: function(k) {
+ k = k == null ? darker : Math.pow(darker, k);
+ return new Cubehelix(this.h, this.s, this.l * k, this.opacity);
+ },
+ rgb: function() {
+ var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad,
+ l = +this.l,
+ a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
+ cosh = Math.cos(h),
+ sinh = Math.sin(h);
+ return new Rgb(
+ 255 * (l + a * (A * cosh + B * sinh)),
+ 255 * (l + a * (C * cosh + D * sinh)),
+ 255 * (l + a * (E * cosh)),
+ this.opacity
+ );
+ }
+}));
+
+exports.color = color;
+exports.rgb = rgb;
+exports.hsl = hsl;
+exports.lab = lab;
+exports.hcl = hcl;
+exports.lch = lch;
+exports.gray = gray;
+exports.cubehelix = cubehelix;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],143:[function(_dereq_,module,exports){
+// https://d3js.org/d3-dispatch/ Version 1.0.3. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+var noop = {value: function() {}};
+
+function dispatch() {
+ for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) {
+ if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t);
+ _[t] = [];
+ }
+ return new Dispatch(_);
+}
+
+function Dispatch(_) {
+ this._ = _;
+}
+
+function parseTypenames(typenames, types) {
+ return typenames.trim().split(/^|\s+/).map(function(t) {
+ var name = "", i = t.indexOf(".");
+ if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
+ if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t);
+ return {type: t, name: name};
+ });
+}
+
+Dispatch.prototype = dispatch.prototype = {
+ constructor: Dispatch,
+ on: function(typename, callback) {
+ var _ = this._,
+ T = parseTypenames(typename + "", _),
+ t,
+ i = -1,
+ n = T.length;
+
+ // If no callback was specified, return the callback of the given type and name.
+ if (arguments.length < 2) {
+ while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
+ return;
+ }
+
+ // If a type was specified, set the callback for the given type and name.
+ // Otherwise, if a null callback was specified, remove callbacks of the given name.
+ if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
+ while (++i < n) {
+ if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
+ else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
+ }
+
+ return this;
+ },
+ copy: function() {
+ var copy = {}, _ = this._;
+ for (var t in _) copy[t] = _[t].slice();
+ return new Dispatch(copy);
+ },
+ call: function(type, that) {
+ if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2];
+ if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+ for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
+ },
+ apply: function(type, that, args) {
+ if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type);
+ for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args);
+ }
+};
+
+function get(type, name) {
+ for (var i = 0, n = type.length, c; i < n; ++i) {
+ if ((c = type[i]).name === name) {
+ return c.value;
+ }
+ }
+}
+
+function set(type, name, callback) {
+ for (var i = 0, n = type.length; i < n; ++i) {
+ if (type[i].name === name) {
+ type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1));
+ break;
+ }
+ }
+ if (callback != null) type.push({name: name, value: callback});
+ return type;
+}
+
+exports.dispatch = dispatch;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],144:[function(_dereq_,module,exports){
+// https://d3js.org/d3-force/ Version 1.1.0. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, _dereq_('d3-quadtree'), _dereq_('d3-collection'), _dereq_('d3-dispatch'), _dereq_('d3-timer')) :
+ typeof define === 'function' && define.amd ? define(['exports', 'd3-quadtree', 'd3-collection', 'd3-dispatch', 'd3-timer'], factory) :
+ (factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3));
+}(this, (function (exports,d3Quadtree,d3Collection,d3Dispatch,d3Timer) { 'use strict';
+
+var center = function(x, y) {
+ var nodes;
+
+ if (x == null) x = 0;
+ if (y == null) y = 0;
+
+ function force() {
+ var i,
+ n = nodes.length,
+ node,
+ sx = 0,
+ sy = 0;
+
+ for (i = 0; i < n; ++i) {
+ node = nodes[i], sx += node.x, sy += node.y;
+ }
+
+ for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) {
+ node = nodes[i], node.x -= sx, node.y -= sy;
+ }
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ };
+
+ force.x = function(_) {
+ return arguments.length ? (x = +_, force) : x;
+ };
+
+ force.y = function(_) {
+ return arguments.length ? (y = +_, force) : y;
+ };
+
+ return force;
+};
+
+var constant = function(x) {
+ return function() {
+ return x;
+ };
+};
+
+var jiggle = function() {
+ return (Math.random() - 0.5) * 1e-6;
+};
+
+function x(d) {
+ return d.x + d.vx;
+}
+
+function y(d) {
+ return d.y + d.vy;
+}
+
+var collide = function(radius) {
+ var nodes,
+ radii,
+ strength = 1,
+ iterations = 1;
+
+ if (typeof radius !== "function") radius = constant(radius == null ? 1 : +radius);
+
+ function force() {
+ var i, n = nodes.length,
+ tree,
+ node,
+ xi,
+ yi,
+ ri,
+ ri2;
+
+ for (var k = 0; k < iterations; ++k) {
+ tree = d3Quadtree.quadtree(nodes, x, y).visitAfter(prepare);
+ for (i = 0; i < n; ++i) {
+ node = nodes[i];
+ ri = radii[node.index], ri2 = ri * ri;
+ xi = node.x + node.vx;
+ yi = node.y + node.vy;
+ tree.visit(apply);
+ }
+ }
+
+ function apply(quad, x0, y0, x1, y1) {
+ var data = quad.data, rj = quad.r, r = ri + rj;
+ if (data) {
+ if (data.index > node.index) {
+ var x = xi - data.x - data.vx,
+ y = yi - data.y - data.vy,
+ l = x * x + y * y;
+ if (l < r * r) {
+ if (x === 0) x = jiggle(), l += x * x;
+ if (y === 0) y = jiggle(), l += y * y;
+ l = (r - (l = Math.sqrt(l))) / l * strength;
+ node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj));
+ node.vy += (y *= l) * r;
+ data.vx -= x * (r = 1 - r);
+ data.vy -= y * r;
+ }
+ }
+ return;
+ }
+ return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;
+ }
+ }
+
+ function prepare(quad) {
+ if (quad.data) return quad.r = radii[quad.data.index];
+ for (var i = quad.r = 0; i < 4; ++i) {
+ if (quad[i] && quad[i].r > quad.r) {
+ quad.r = quad[i].r;
+ }
+ }
+ }
+
+ function initialize() {
+ if (!nodes) return;
+ var i, n = nodes.length, node;
+ radii = new Array(n);
+ for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ initialize();
+ };
+
+ force.iterations = function(_) {
+ return arguments.length ? (iterations = +_, force) : iterations;
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = +_, force) : strength;
+ };
+
+ force.radius = function(_) {
+ return arguments.length ? (radius = typeof _ === "function" ? _ : constant(+_), initialize(), force) : radius;
+ };
+
+ return force;
+};
+
+function index(d) {
+ return d.index;
+}
+
+function find(nodeById, nodeId) {
+ var node = nodeById.get(nodeId);
+ if (!node) throw new Error("missing: " + nodeId);
+ return node;
+}
+
+var link = function(links) {
+ var id = index,
+ strength = defaultStrength,
+ strengths,
+ distance = constant(30),
+ distances,
+ nodes,
+ count,
+ bias,
+ iterations = 1;
+
+ if (links == null) links = [];
+
+ function defaultStrength(link) {
+ return 1 / Math.min(count[link.source.index], count[link.target.index]);
+ }
+
+ function force(alpha) {
+ for (var k = 0, n = links.length; k < iterations; ++k) {
+ for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {
+ link = links[i], source = link.source, target = link.target;
+ x = target.x + target.vx - source.x - source.vx || jiggle();
+ y = target.y + target.vy - source.y - source.vy || jiggle();
+ l = Math.sqrt(x * x + y * y);
+ l = (l - distances[i]) / l * alpha * strengths[i];
+ x *= l, y *= l;
+ target.vx -= x * (b = bias[i]);
+ target.vy -= y * b;
+ source.vx += x * (b = 1 - b);
+ source.vy += y * b;
+ }
+ }
+ }
+
+ function initialize() {
+ if (!nodes) return;
+
+ var i,
+ n = nodes.length,
+ m = links.length,
+ nodeById = d3Collection.map(nodes, id),
+ link;
+
+ for (i = 0, count = new Array(n); i < m; ++i) {
+ link = links[i], link.index = i;
+ if (typeof link.source !== "object") link.source = find(nodeById, link.source);
+ if (typeof link.target !== "object") link.target = find(nodeById, link.target);
+ count[link.source.index] = (count[link.source.index] || 0) + 1;
+ count[link.target.index] = (count[link.target.index] || 0) + 1;
+ }
+
+ for (i = 0, bias = new Array(m); i < m; ++i) {
+ link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);
+ }
+
+ strengths = new Array(m), initializeStrength();
+ distances = new Array(m), initializeDistance();
+ }
+
+ function initializeStrength() {
+ if (!nodes) return;
+
+ for (var i = 0, n = links.length; i < n; ++i) {
+ strengths[i] = +strength(links[i], i, links);
+ }
+ }
+
+ function initializeDistance() {
+ if (!nodes) return;
+
+ for (var i = 0, n = links.length; i < n; ++i) {
+ distances[i] = +distance(links[i], i, links);
+ }
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ initialize();
+ };
+
+ force.links = function(_) {
+ return arguments.length ? (links = _, initialize(), force) : links;
+ };
+
+ force.id = function(_) {
+ return arguments.length ? (id = _, force) : id;
+ };
+
+ force.iterations = function(_) {
+ return arguments.length ? (iterations = +_, force) : iterations;
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initializeStrength(), force) : strength;
+ };
+
+ force.distance = function(_) {
+ return arguments.length ? (distance = typeof _ === "function" ? _ : constant(+_), initializeDistance(), force) : distance;
+ };
+
+ return force;
+};
+
+function x$1(d) {
+ return d.x;
+}
+
+function y$1(d) {
+ return d.y;
+}
+
+var initialRadius = 10;
+var initialAngle = Math.PI * (3 - Math.sqrt(5));
+
+var simulation = function(nodes) {
+ var simulation,
+ alpha = 1,
+ alphaMin = 0.001,
+ alphaDecay = 1 - Math.pow(alphaMin, 1 / 300),
+ alphaTarget = 0,
+ velocityDecay = 0.6,
+ forces = d3Collection.map(),
+ stepper = d3Timer.timer(step),
+ event = d3Dispatch.dispatch("tick", "end");
+
+ if (nodes == null) nodes = [];
+
+ function step() {
+ tick();
+ event.call("tick", simulation);
+ if (alpha < alphaMin) {
+ stepper.stop();
+ event.call("end", simulation);
+ }
+ }
+
+ function tick() {
+ var i, n = nodes.length, node;
+
+ alpha += (alphaTarget - alpha) * alphaDecay;
+
+ forces.each(function(force) {
+ force(alpha);
+ });
+
+ for (i = 0; i < n; ++i) {
+ node = nodes[i];
+ if (node.fx == null) node.x += node.vx *= velocityDecay;
+ else node.x = node.fx, node.vx = 0;
+ if (node.fy == null) node.y += node.vy *= velocityDecay;
+ else node.y = node.fy, node.vy = 0;
+ }
+ }
+
+ function initializeNodes() {
+ for (var i = 0, n = nodes.length, node; i < n; ++i) {
+ node = nodes[i], node.index = i;
+ if (isNaN(node.x) || isNaN(node.y)) {
+ var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle;
+ node.x = radius * Math.cos(angle);
+ node.y = radius * Math.sin(angle);
+ }
+ if (isNaN(node.vx) || isNaN(node.vy)) {
+ node.vx = node.vy = 0;
+ }
+ }
+ }
+
+ function initializeForce(force) {
+ if (force.initialize) force.initialize(nodes);
+ return force;
+ }
+
+ initializeNodes();
+
+ return simulation = {
+ tick: tick,
+
+ restart: function() {
+ return stepper.restart(step), simulation;
+ },
+
+ stop: function() {
+ return stepper.stop(), simulation;
+ },
+
+ nodes: function(_) {
+ return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes;
+ },
+
+ alpha: function(_) {
+ return arguments.length ? (alpha = +_, simulation) : alpha;
+ },
+
+ alphaMin: function(_) {
+ return arguments.length ? (alphaMin = +_, simulation) : alphaMin;
+ },
+
+ alphaDecay: function(_) {
+ return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay;
+ },
+
+ alphaTarget: function(_) {
+ return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget;
+ },
+
+ velocityDecay: function(_) {
+ return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay;
+ },
+
+ force: function(name, _) {
+ return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name);
+ },
+
+ find: function(x, y, radius) {
+ var i = 0,
+ n = nodes.length,
+ dx,
+ dy,
+ d2,
+ node,
+ closest;
+
+ if (radius == null) radius = Infinity;
+ else radius *= radius;
+
+ for (i = 0; i < n; ++i) {
+ node = nodes[i];
+ dx = x - node.x;
+ dy = y - node.y;
+ d2 = dx * dx + dy * dy;
+ if (d2 < radius) closest = node, radius = d2;
+ }
+
+ return closest;
+ },
+
+ on: function(name, _) {
+ return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name);
+ }
+ };
+};
+
+var manyBody = function() {
+ var nodes,
+ node,
+ alpha,
+ strength = constant(-30),
+ strengths,
+ distanceMin2 = 1,
+ distanceMax2 = Infinity,
+ theta2 = 0.81;
+
+ function force(_) {
+ var i, n = nodes.length, tree = d3Quadtree.quadtree(nodes, x$1, y$1).visitAfter(accumulate);
+ for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);
+ }
+
+ function initialize() {
+ if (!nodes) return;
+ var i, n = nodes.length, node;
+ strengths = new Array(n);
+ for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);
+ }
+
+ function accumulate(quad) {
+ var strength = 0, q, c, weight = 0, x, y, i;
+
+ // For internal nodes, accumulate forces from child quadrants.
+ if (quad.length) {
+ for (x = y = i = 0; i < 4; ++i) {
+ if ((q = quad[i]) && (c = Math.abs(q.value))) {
+ strength += q.value, weight += c, x += c * q.x, y += c * q.y;
+ }
+ }
+ quad.x = x / weight;
+ quad.y = y / weight;
+ }
+
+ // For leaf nodes, accumulate forces from coincident quadrants.
+ else {
+ q = quad;
+ q.x = q.data.x;
+ q.y = q.data.y;
+ do strength += strengths[q.data.index];
+ while (q = q.next);
+ }
+
+ quad.value = strength;
+ }
+
+ function apply(quad, x1, _, x2) {
+ if (!quad.value) return true;
+
+ var x = quad.x - node.x,
+ y = quad.y - node.y,
+ w = x2 - x1,
+ l = x * x + y * y;
+
+ // Apply the Barnes-Hut approximation if possible.
+ // Limit forces for very close nodes; randomize direction if coincident.
+ if (w * w / theta2 < l) {
+ if (l < distanceMax2) {
+ if (x === 0) x = jiggle(), l += x * x;
+ if (y === 0) y = jiggle(), l += y * y;
+ if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+ node.vx += x * quad.value * alpha / l;
+ node.vy += y * quad.value * alpha / l;
+ }
+ return true;
+ }
+
+ // Otherwise, process points directly.
+ else if (quad.length || l >= distanceMax2) return;
+
+ // Limit forces for very close nodes; randomize direction if coincident.
+ if (quad.data !== node || quad.next) {
+ if (x === 0) x = jiggle(), l += x * x;
+ if (y === 0) y = jiggle(), l += y * y;
+ if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+ }
+
+ do if (quad.data !== node) {
+ w = strengths[quad.data.index] * alpha / l;
+ node.vx += x * w;
+ node.vy += y * w;
+ } while (quad = quad.next);
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ initialize();
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : strength;
+ };
+
+ force.distanceMin = function(_) {
+ return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);
+ };
+
+ force.distanceMax = function(_) {
+ return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);
+ };
+
+ force.theta = function(_) {
+ return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);
+ };
+
+ return force;
+};
+
+var radial = function(radius, x, y) {
+ var nodes,
+ strength = constant(0.1),
+ strengths,
+ radiuses;
+
+ if (typeof radius !== "function") radius = constant(+radius);
+ if (x == null) x = 0;
+ if (y == null) y = 0;
+
+ function force(alpha) {
+ for (var i = 0, n = nodes.length; i < n; ++i) {
+ var node = nodes[i],
+ dx = node.x - x || 1e-6,
+ dy = node.y - y || 1e-6,
+ r = Math.sqrt(dx * dx + dy * dy),
+ k = (radiuses[i] - r) * strengths[i] * alpha / r;
+ node.vx += dx * k;
+ node.vy += dy * k;
+ }
+ }
+
+ function initialize() {
+ if (!nodes) return;
+ var i, n = nodes.length;
+ strengths = new Array(n);
+ radiuses = new Array(n);
+ for (i = 0; i < n; ++i) {
+ radiuses[i] = +radius(nodes[i], i, nodes);
+ strengths[i] = isNaN(radiuses[i]) ? 0 : +strength(nodes[i], i, nodes);
+ }
+ }
+
+ force.initialize = function(_) {
+ nodes = _, initialize();
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : strength;
+ };
+
+ force.radius = function(_) {
+ return arguments.length ? (radius = typeof _ === "function" ? _ : constant(+_), initialize(), force) : radius;
+ };
+
+ force.x = function(_) {
+ return arguments.length ? (x = +_, force) : x;
+ };
+
+ force.y = function(_) {
+ return arguments.length ? (y = +_, force) : y;
+ };
+
+ return force;
+};
+
+var x$2 = function(x) {
+ var strength = constant(0.1),
+ nodes,
+ strengths,
+ xz;
+
+ if (typeof x !== "function") x = constant(x == null ? 0 : +x);
+
+ function force(alpha) {
+ for (var i = 0, n = nodes.length, node; i < n; ++i) {
+ node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha;
+ }
+ }
+
+ function initialize() {
+ if (!nodes) return;
+ var i, n = nodes.length;
+ strengths = new Array(n);
+ xz = new Array(n);
+ for (i = 0; i < n; ++i) {
+ strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+ }
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ initialize();
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : strength;
+ };
+
+ force.x = function(_) {
+ return arguments.length ? (x = typeof _ === "function" ? _ : constant(+_), initialize(), force) : x;
+ };
+
+ return force;
+};
+
+var y$2 = function(y) {
+ var strength = constant(0.1),
+ nodes,
+ strengths,
+ yz;
+
+ if (typeof y !== "function") y = constant(y == null ? 0 : +y);
+
+ function force(alpha) {
+ for (var i = 0, n = nodes.length, node; i < n; ++i) {
+ node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha;
+ }
+ }
+
+ function initialize() {
+ if (!nodes) return;
+ var i, n = nodes.length;
+ strengths = new Array(n);
+ yz = new Array(n);
+ for (i = 0; i < n; ++i) {
+ strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes);
+ }
+ }
+
+ force.initialize = function(_) {
+ nodes = _;
+ initialize();
+ };
+
+ force.strength = function(_) {
+ return arguments.length ? (strength = typeof _ === "function" ? _ : constant(+_), initialize(), force) : strength;
+ };
+
+ force.y = function(_) {
+ return arguments.length ? (y = typeof _ === "function" ? _ : constant(+_), initialize(), force) : y;
+ };
+
+ return force;
+};
+
+exports.forceCenter = center;
+exports.forceCollide = collide;
+exports.forceLink = link;
+exports.forceManyBody = manyBody;
+exports.forceRadial = radial;
+exports.forceSimulation = simulation;
+exports.forceX = x$2;
+exports.forceY = y$2;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{"d3-collection":141,"d3-dispatch":143,"d3-quadtree":146,"d3-timer":147}],145:[function(_dereq_,module,exports){
+// https://d3js.org/d3-interpolate/ v1.3.2 Copyright 2018 Mike Bostock
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, _dereq_('d3-color')) :
+typeof define === 'function' && define.amd ? define(['exports', 'd3-color'], factory) :
+(factory((global.d3 = global.d3 || {}),global.d3));
+}(this, (function (exports,d3Color) { 'use strict';
+
+function basis(t1, v0, v1, v2, v3) {
+ var t2 = t1 * t1, t3 = t2 * t1;
+ return ((1 - 3 * t1 + 3 * t2 - t3) * v0
+ + (4 - 6 * t2 + 3 * t3) * v1
+ + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2
+ + t3 * v3) / 6;
+}
+
+function basis$1(values) {
+ var n = values.length - 1;
+ return function(t) {
+ var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
+ v1 = values[i],
+ v2 = values[i + 1],
+ v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
+ v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
+ return basis((t - i / n) * n, v0, v1, v2, v3);
+ };
+}
+
+function basisClosed(values) {
+ var n = values.length;
+ return function(t) {
+ var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
+ v0 = values[(i + n - 1) % n],
+ v1 = values[i % n],
+ v2 = values[(i + 1) % n],
+ v3 = values[(i + 2) % n];
+ return basis((t - i / n) * n, v0, v1, v2, v3);
+ };
+}
+
+function constant(x) {
+ return function() {
+ return x;
+ };
+}
+
+function linear(a, d) {
+ return function(t) {
+ return a + t * d;
+ };
+}
+
+function exponential(a, b, y) {
+ return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
+ return Math.pow(a + t * b, y);
+ };
+}
+
+function hue(a, b) {
+ var d = b - a;
+ return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant(isNaN(a) ? b : a);
+}
+
+function gamma(y) {
+ return (y = +y) === 1 ? nogamma : function(a, b) {
+ return b - a ? exponential(a, b, y) : constant(isNaN(a) ? b : a);
+ };
+}
+
+function nogamma(a, b) {
+ var d = b - a;
+ return d ? linear(a, d) : constant(isNaN(a) ? b : a);
+}
+
+var rgb = (function rgbGamma(y) {
+ var color = gamma(y);
+
+ function rgb(start, end) {
+ var r = color((start = d3Color.rgb(start)).r, (end = d3Color.rgb(end)).r),
+ g = color(start.g, end.g),
+ b = color(start.b, end.b),
+ opacity = nogamma(start.opacity, end.opacity);
+ return function(t) {
+ start.r = r(t);
+ start.g = g(t);
+ start.b = b(t);
+ start.opacity = opacity(t);
+ return start + "";
+ };
+ }
+
+ rgb.gamma = rgbGamma;
+
+ return rgb;
+})(1);
+
+function rgbSpline(spline) {
+ return function(colors) {
+ var n = colors.length,
+ r = new Array(n),
+ g = new Array(n),
+ b = new Array(n),
+ i, color;
+ for (i = 0; i < n; ++i) {
+ color = d3Color.rgb(colors[i]);
+ r[i] = color.r || 0;
+ g[i] = color.g || 0;
+ b[i] = color.b || 0;
+ }
+ r = spline(r);
+ g = spline(g);
+ b = spline(b);
+ color.opacity = 1;
+ return function(t) {
+ color.r = r(t);
+ color.g = g(t);
+ color.b = b(t);
+ return color + "";
+ };
+ };
+}
+
+var rgbBasis = rgbSpline(basis$1);
+var rgbBasisClosed = rgbSpline(basisClosed);
+
+function array(a, b) {
+ var nb = b ? b.length : 0,
+ na = a ? Math.min(nb, a.length) : 0,
+ x = new Array(na),
+ c = new Array(nb),
+ i;
+
+ for (i = 0; i < na; ++i) x[i] = value(a[i], b[i]);
+ for (; i < nb; ++i) c[i] = b[i];
+
+ return function(t) {
+ for (i = 0; i < na; ++i) c[i] = x[i](t);
+ return c;
+ };
+}
+
+function date(a, b) {
+ var d = new Date;
+ return a = +a, b -= a, function(t) {
+ return d.setTime(a + b * t), d;
+ };
+}
+
+function number(a, b) {
+ return a = +a, b -= a, function(t) {
+ return a + b * t;
+ };
+}
+
+function object(a, b) {
+ var i = {},
+ c = {},
+ k;
+
+ if (a === null || typeof a !== "object") a = {};
+ if (b === null || typeof b !== "object") b = {};
+
+ for (k in b) {
+ if (k in a) {
+ i[k] = value(a[k], b[k]);
+ } else {
+ c[k] = b[k];
+ }
+ }
+
+ return function(t) {
+ for (k in i) c[k] = i[k](t);
+ return c;
+ };
+}
+
+var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
+ reB = new RegExp(reA.source, "g");
+
+function zero(b) {
+ return function() {
+ return b;
+ };
+}
+
+function one(b) {
+ return function(t) {
+ return b(t) + "";
+ };
+}
+
+function string(a, b) {
+ var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b
+ am, // current match in a
+ bm, // current match in b
+ bs, // string preceding current number in b, if any
+ i = -1, // index in s
+ s = [], // string constants and placeholders
+ q = []; // number interpolators
+
+ // Coerce inputs to strings.
+ a = a + "", b = b + "";
+
+ // Interpolate pairs of numbers in a & b.
+ while ((am = reA.exec(a))
+ && (bm = reB.exec(b))) {
+ if ((bs = bm.index) > bi) { // a string precedes the next number in b
+ bs = b.slice(bi, bs);
+ if (s[i]) s[i] += bs; // coalesce with previous string
+ else s[++i] = bs;
+ }
+ if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match
+ if (s[i]) s[i] += bm; // coalesce with previous string
+ else s[++i] = bm;
+ } else { // interpolate non-matching numbers
+ s[++i] = null;
+ q.push({i: i, x: number(am, bm)});
+ }
+ bi = reB.lastIndex;
+ }
+
+ // Add remains of b.
+ if (bi < b.length) {
+ bs = b.slice(bi);
+ if (s[i]) s[i] += bs; // coalesce with previous string
+ else s[++i] = bs;
+ }
+
+ // Special optimization for only a single match.
+ // Otherwise, interpolate each of the numbers and rejoin the string.
+ return s.length < 2 ? (q[0]
+ ? one(q[0].x)
+ : zero(b))
+ : (b = q.length, function(t) {
+ for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ });
+}
+
+function value(a, b) {
+ var t = typeof b, c;
+ return b == null || t === "boolean" ? constant(b)
+ : (t === "number" ? number
+ : t === "string" ? ((c = d3Color.color(b)) ? (b = c, rgb) : string)
+ : b instanceof d3Color.color ? rgb
+ : b instanceof Date ? date
+ : Array.isArray(b) ? array
+ : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object
+ : number)(a, b);
+}
+
+function discrete(range) {
+ var n = range.length;
+ return function(t) {
+ return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
+ };
+}
+
+function hue$1(a, b) {
+ var i = hue(+a, +b);
+ return function(t) {
+ var x = i(t);
+ return x - 360 * Math.floor(x / 360);
+ };
+}
+
+function round(a, b) {
+ return a = +a, b -= a, function(t) {
+ return Math.round(a + b * t);
+ };
+}
+
+var degrees = 180 / Math.PI;
+
+var identity = {
+ translateX: 0,
+ translateY: 0,
+ rotate: 0,
+ skewX: 0,
+ scaleX: 1,
+ scaleY: 1
+};
+
+function decompose(a, b, c, d, e, f) {
+ var scaleX, scaleY, skewX;
+ if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX;
+ if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX;
+ if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY;
+ if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX;
+ return {
+ translateX: e,
+ translateY: f,
+ rotate: Math.atan2(b, a) * degrees,
+ skewX: Math.atan(skewX) * degrees,
+ scaleX: scaleX,
+ scaleY: scaleY
+ };
+}
+
+var cssNode,
+ cssRoot,
+ cssView,
+ svgNode;
+
+function parseCss(value) {
+ if (value === "none") return identity;
+ if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView;
+ cssNode.style.transform = value;
+ value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform");
+ cssRoot.removeChild(cssNode);
+ value = value.slice(7, -1).split(",");
+ return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]);
+}
+
+function parseSvg(value) {
+ if (value == null) return identity;
+ if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g");
+ svgNode.setAttribute("transform", value);
+ if (!(value = svgNode.transform.baseVal.consolidate())) return identity;
+ value = value.matrix;
+ return decompose(value.a, value.b, value.c, value.d, value.e, value.f);
+}
+
+function interpolateTransform(parse, pxComma, pxParen, degParen) {
+
+ function pop(s) {
+ return s.length ? s.pop() + " " : "";
+ }
+
+ function translate(xa, ya, xb, yb, s, q) {
+ if (xa !== xb || ya !== yb) {
+ var i = s.push("translate(", null, pxComma, null, pxParen);
+ q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)});
+ } else if (xb || yb) {
+ s.push("translate(" + xb + pxComma + yb + pxParen);
+ }
+ }
+
+ function rotate(a, b, s, q) {
+ if (a !== b) {
+ if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path
+ q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number(a, b)});
+ } else if (b) {
+ s.push(pop(s) + "rotate(" + b + degParen);
+ }
+ }
+
+ function skewX(a, b, s, q) {
+ if (a !== b) {
+ q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number(a, b)});
+ } else if (b) {
+ s.push(pop(s) + "skewX(" + b + degParen);
+ }
+ }
+
+ function scale(xa, ya, xb, yb, s, q) {
+ if (xa !== xb || ya !== yb) {
+ var i = s.push(pop(s) + "scale(", null, ",", null, ")");
+ q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)});
+ } else if (xb !== 1 || yb !== 1) {
+ s.push(pop(s) + "scale(" + xb + "," + yb + ")");
+ }
+ }
+
+ return function(a, b) {
+ var s = [], // string constants and placeholders
+ q = []; // number interpolators
+ a = parse(a), b = parse(b);
+ translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q);
+ rotate(a.rotate, b.rotate, s, q);
+ skewX(a.skewX, b.skewX, s, q);
+ scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q);
+ a = b = null; // gc
+ return function(t) {
+ var i = -1, n = q.length, o;
+ while (++i < n) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ };
+ };
+}
+
+var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)");
+var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
+
+var rho = Math.SQRT2,
+ rho2 = 2,
+ rho4 = 4,
+ epsilon2 = 1e-12;
+
+function cosh(x) {
+ return ((x = Math.exp(x)) + 1 / x) / 2;
+}
+
+function sinh(x) {
+ return ((x = Math.exp(x)) - 1 / x) / 2;
+}
+
+function tanh(x) {
+ return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+}
+
+// p0 = [ux0, uy0, w0]
+// p1 = [ux1, uy1, w1]
+function zoom(p0, p1) {
+ var ux0 = p0[0], uy0 = p0[1], w0 = p0[2],
+ ux1 = p1[0], uy1 = p1[1], w1 = p1[2],
+ dx = ux1 - ux0,
+ dy = uy1 - uy0,
+ d2 = dx * dx + dy * dy,
+ i,
+ S;
+
+ // Special case for u0 ≅ u1.
+ if (d2 < epsilon2) {
+ S = Math.log(w1 / w0) / rho;
+ i = function(t) {
+ return [
+ ux0 + t * dx,
+ uy0 + t * dy,
+ w0 * Math.exp(rho * t * S)
+ ];
+ };
+ }
+
+ // General case.
+ else {
+ var d1 = Math.sqrt(d2),
+ b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1),
+ b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1),
+ r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0),
+ r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+ S = (r1 - r0) / rho;
+ i = function(t) {
+ var s = t * S,
+ coshr0 = cosh(r0),
+ u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0));
+ return [
+ ux0 + u * dx,
+ uy0 + u * dy,
+ w0 * coshr0 / cosh(rho * s + r0)
+ ];
+ };
+ }
+
+ i.duration = S * 1000;
+
+ return i;
+}
+
+function hsl(hue$$1) {
+ return function(start, end) {
+ var h = hue$$1((start = d3Color.hsl(start)).h, (end = d3Color.hsl(end)).h),
+ s = nogamma(start.s, end.s),
+ l = nogamma(start.l, end.l),
+ opacity = nogamma(start.opacity, end.opacity);
+ return function(t) {
+ start.h = h(t);
+ start.s = s(t);
+ start.l = l(t);
+ start.opacity = opacity(t);
+ return start + "";
+ };
+ }
+}
+
+var hsl$1 = hsl(hue);
+var hslLong = hsl(nogamma);
+
+function lab(start, end) {
+ var l = nogamma((start = d3Color.lab(start)).l, (end = d3Color.lab(end)).l),
+ a = nogamma(start.a, end.a),
+ b = nogamma(start.b, end.b),
+ opacity = nogamma(start.opacity, end.opacity);
+ return function(t) {
+ start.l = l(t);
+ start.a = a(t);
+ start.b = b(t);
+ start.opacity = opacity(t);
+ return start + "";
+ };
+}
+
+function hcl(hue$$1) {
+ return function(start, end) {
+ var h = hue$$1((start = d3Color.hcl(start)).h, (end = d3Color.hcl(end)).h),
+ c = nogamma(start.c, end.c),
+ l = nogamma(start.l, end.l),
+ opacity = nogamma(start.opacity, end.opacity);
+ return function(t) {
+ start.h = h(t);
+ start.c = c(t);
+ start.l = l(t);
+ start.opacity = opacity(t);
+ return start + "";
+ };
+ }
+}
+
+var hcl$1 = hcl(hue);
+var hclLong = hcl(nogamma);
+
+function cubehelix(hue$$1) {
+ return (function cubehelixGamma(y) {
+ y = +y;
+
+ function cubehelix(start, end) {
+ var h = hue$$1((start = d3Color.cubehelix(start)).h, (end = d3Color.cubehelix(end)).h),
+ s = nogamma(start.s, end.s),
+ l = nogamma(start.l, end.l),
+ opacity = nogamma(start.opacity, end.opacity);
+ return function(t) {
+ start.h = h(t);
+ start.s = s(t);
+ start.l = l(Math.pow(t, y));
+ start.opacity = opacity(t);
+ return start + "";
+ };
+ }
+
+ cubehelix.gamma = cubehelixGamma;
+
+ return cubehelix;
+ })(1);
+}
+
+var cubehelix$1 = cubehelix(hue);
+var cubehelixLong = cubehelix(nogamma);
+
+function piecewise(interpolate, values) {
+ var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n);
+ while (i < n) I[i] = interpolate(v, v = values[++i]);
+ return function(t) {
+ var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n)));
+ return I[i](t - i);
+ };
+}
+
+function quantize(interpolator, n) {
+ var samples = new Array(n);
+ for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1));
+ return samples;
+}
+
+exports.interpolate = value;
+exports.interpolateArray = array;
+exports.interpolateBasis = basis$1;
+exports.interpolateBasisClosed = basisClosed;
+exports.interpolateDate = date;
+exports.interpolateDiscrete = discrete;
+exports.interpolateHue = hue$1;
+exports.interpolateNumber = number;
+exports.interpolateObject = object;
+exports.interpolateRound = round;
+exports.interpolateString = string;
+exports.interpolateTransformCss = interpolateTransformCss;
+exports.interpolateTransformSvg = interpolateTransformSvg;
+exports.interpolateZoom = zoom;
+exports.interpolateRgb = rgb;
+exports.interpolateRgbBasis = rgbBasis;
+exports.interpolateRgbBasisClosed = rgbBasisClosed;
+exports.interpolateHsl = hsl$1;
+exports.interpolateHslLong = hslLong;
+exports.interpolateLab = lab;
+exports.interpolateHcl = hcl$1;
+exports.interpolateHclLong = hclLong;
+exports.interpolateCubehelix = cubehelix$1;
+exports.interpolateCubehelixLong = cubehelixLong;
+exports.piecewise = piecewise;
+exports.quantize = quantize;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{"d3-color":142}],146:[function(_dereq_,module,exports){
+// https://d3js.org/d3-quadtree/ Version 1.0.3. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+var tree_add = function(d) {
+ var x = +this._x.call(null, d),
+ y = +this._y.call(null, d);
+ return add(this.cover(x, y), x, y, d);
+};
+
+function add(tree, x, y, d) {
+ if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points
+
+ var parent,
+ node = tree._root,
+ leaf = {data: d},
+ x0 = tree._x0,
+ y0 = tree._y0,
+ x1 = tree._x1,
+ y1 = tree._y1,
+ xm,
+ ym,
+ xp,
+ yp,
+ right,
+ bottom,
+ i,
+ j;
+
+ // If the tree is empty, initialize the root as a leaf.
+ if (!node) return tree._root = leaf, tree;
+
+ // Find the existing leaf for the new point, or add it.
+ while (node.length) {
+ if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;
+ if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;
+ if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;
+ }
+
+ // Is the new point is exactly coincident with the existing point?
+ xp = +tree._x.call(null, node.data);
+ yp = +tree._y.call(null, node.data);
+ if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
+
+ // Otherwise, split the leaf node until the old and new point are separated.
+ do {
+ parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);
+ if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;
+ if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;
+ } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));
+ return parent[j] = node, parent[i] = leaf, tree;
+}
+
+function addAll(data) {
+ var d, i, n = data.length,
+ x,
+ y,
+ xz = new Array(n),
+ yz = new Array(n),
+ x0 = Infinity,
+ y0 = Infinity,
+ x1 = -Infinity,
+ y1 = -Infinity;
+
+ // Compute the points and their extent.
+ for (i = 0; i < n; ++i) {
+ if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;
+ xz[i] = x;
+ yz[i] = y;
+ if (x < x0) x0 = x;
+ if (x > x1) x1 = x;
+ if (y < y0) y0 = y;
+ if (y > y1) y1 = y;
+ }
+
+ // If there were no (valid) points, inherit the existing extent.
+ if (x1 < x0) x0 = this._x0, x1 = this._x1;
+ if (y1 < y0) y0 = this._y0, y1 = this._y1;
+
+ // Expand the tree to cover the new points.
+ this.cover(x0, y0).cover(x1, y1);
+
+ // Add the new points.
+ for (i = 0; i < n; ++i) {
+ add(this, xz[i], yz[i], data[i]);
+ }
+
+ return this;
+}
+
+var tree_cover = function(x, y) {
+ if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points
+
+ var x0 = this._x0,
+ y0 = this._y0,
+ x1 = this._x1,
+ y1 = this._y1;
+
+ // If the quadtree has no extent, initialize them.
+ // Integer extent are necessary so that if we later double the extent,
+ // the existing quadrant boundaries don’t change due to floating point error!
+ if (isNaN(x0)) {
+ x1 = (x0 = Math.floor(x)) + 1;
+ y1 = (y0 = Math.floor(y)) + 1;
+ }
+
+ // Otherwise, double repeatedly to cover.
+ else if (x0 > x || x > x1 || y0 > y || y > y1) {
+ var z = x1 - x0,
+ node = this._root,
+ parent,
+ i;
+
+ switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) {
+ case 0: {
+ do parent = new Array(4), parent[i] = node, node = parent;
+ while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1);
+ break;
+ }
+ case 1: {
+ do parent = new Array(4), parent[i] = node, node = parent;
+ while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1);
+ break;
+ }
+ case 2: {
+ do parent = new Array(4), parent[i] = node, node = parent;
+ while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y);
+ break;
+ }
+ case 3: {
+ do parent = new Array(4), parent[i] = node, node = parent;
+ while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y);
+ break;
+ }
+ }
+
+ if (this._root && this._root.length) this._root = node;
+ }
+
+ // If the quadtree covers the point already, just return.
+ else return this;
+
+ this._x0 = x0;
+ this._y0 = y0;
+ this._x1 = x1;
+ this._y1 = y1;
+ return this;
+};
+
+var tree_data = function() {
+ var data = [];
+ this.visit(function(node) {
+ if (!node.length) do data.push(node.data); while (node = node.next)
+ });
+ return data;
+};
+
+var tree_extent = function(_) {
+ return arguments.length
+ ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1])
+ : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]];
+};
+
+var Quad = function(node, x0, y0, x1, y1) {
+ this.node = node;
+ this.x0 = x0;
+ this.y0 = y0;
+ this.x1 = x1;
+ this.y1 = y1;
+};
+
+var tree_find = function(x, y, radius) {
+ var data,
+ x0 = this._x0,
+ y0 = this._y0,
+ x1,
+ y1,
+ x2,
+ y2,
+ x3 = this._x1,
+ y3 = this._y1,
+ quads = [],
+ node = this._root,
+ q,
+ i;
+
+ if (node) quads.push(new Quad(node, x0, y0, x3, y3));
+ if (radius == null) radius = Infinity;
+ else {
+ x0 = x - radius, y0 = y - radius;
+ x3 = x + radius, y3 = y + radius;
+ radius *= radius;
+ }
+
+ while (q = quads.pop()) {
+
+ // Stop searching if this quadrant can’t contain a closer node.
+ if (!(node = q.node)
+ || (x1 = q.x0) > x3
+ || (y1 = q.y0) > y3
+ || (x2 = q.x1) < x0
+ || (y2 = q.y1) < y0) continue;
+
+ // Bisect the current quadrant.
+ if (node.length) {
+ var xm = (x1 + x2) / 2,
+ ym = (y1 + y2) / 2;
+
+ quads.push(
+ new Quad(node[3], xm, ym, x2, y2),
+ new Quad(node[2], x1, ym, xm, y2),
+ new Quad(node[1], xm, y1, x2, ym),
+ new Quad(node[0], x1, y1, xm, ym)
+ );
+
+ // Visit the closest quadrant first.
+ if (i = (y >= ym) << 1 | (x >= xm)) {
+ q = quads[quads.length - 1];
+ quads[quads.length - 1] = quads[quads.length - 1 - i];
+ quads[quads.length - 1 - i] = q;
+ }
+ }
+
+ // Visit this point. (Visiting coincident points isn’t necessary!)
+ else {
+ var dx = x - +this._x.call(null, node.data),
+ dy = y - +this._y.call(null, node.data),
+ d2 = dx * dx + dy * dy;
+ if (d2 < radius) {
+ var d = Math.sqrt(radius = d2);
+ x0 = x - d, y0 = y - d;
+ x3 = x + d, y3 = y + d;
+ data = node.data;
+ }
+ }
+ }
+
+ return data;
+};
+
+var tree_remove = function(d) {
+ if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points
+
+ var parent,
+ node = this._root,
+ retainer,
+ previous,
+ next,
+ x0 = this._x0,
+ y0 = this._y0,
+ x1 = this._x1,
+ y1 = this._y1,
+ x,
+ y,
+ xm,
+ ym,
+ right,
+ bottom,
+ i,
+ j;
+
+ // If the tree is empty, initialize the root as a leaf.
+ if (!node) return this;
+
+ // Find the leaf node for the point.
+ // While descending, also retain the deepest parent with a non-removed sibling.
+ if (node.length) while (true) {
+ if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;
+ if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;
+ if (!(parent = node, node = node[i = bottom << 1 | right])) return this;
+ if (!node.length) break;
+ if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i;
+ }
+
+ // Find the point to remove.
+ while (node.data !== d) if (!(previous = node, node = node.next)) return this;
+ if (next = node.next) delete node.next;
+
+ // If there are multiple coincident points, remove just the point.
+ if (previous) return (next ? previous.next = next : delete previous.next), this;
+
+ // If this is the root point, remove it.
+ if (!parent) return this._root = next, this;
+
+ // Remove this leaf.
+ next ? parent[i] = next : delete parent[i];
+
+ // If the parent now contains exactly one leaf, collapse superfluous parents.
+ if ((node = parent[0] || parent[1] || parent[2] || parent[3])
+ && node === (parent[3] || parent[2] || parent[1] || parent[0])
+ && !node.length) {
+ if (retainer) retainer[j] = node;
+ else this._root = node;
+ }
+
+ return this;
+};
+
+function removeAll(data) {
+ for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]);
+ return this;
+}
+
+var tree_root = function() {
+ return this._root;
+};
+
+var tree_size = function() {
+ var size = 0;
+ this.visit(function(node) {
+ if (!node.length) do ++size; while (node = node.next)
+ });
+ return size;
+};
+
+var tree_visit = function(callback) {
+ var quads = [], q, node = this._root, child, x0, y0, x1, y1;
+ if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1));
+ while (q = quads.pop()) {
+ if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) {
+ var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+ if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));
+ if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));
+ if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));
+ if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));
+ }
+ }
+ return this;
+};
+
+var tree_visitAfter = function(callback) {
+ var quads = [], next = [], q;
+ if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1));
+ while (q = quads.pop()) {
+ var node = q.node;
+ if (node.length) {
+ var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2;
+ if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym));
+ if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym));
+ if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1));
+ if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1));
+ }
+ next.push(q);
+ }
+ while (q = next.pop()) {
+ callback(q.node, q.x0, q.y0, q.x1, q.y1);
+ }
+ return this;
+};
+
+function defaultX(d) {
+ return d[0];
+}
+
+var tree_x = function(_) {
+ return arguments.length ? (this._x = _, this) : this._x;
+};
+
+function defaultY(d) {
+ return d[1];
+}
+
+var tree_y = function(_) {
+ return arguments.length ? (this._y = _, this) : this._y;
+};
+
+function quadtree(nodes, x, y) {
+ var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN);
+ return nodes == null ? tree : tree.addAll(nodes);
+}
+
+function Quadtree(x, y, x0, y0, x1, y1) {
+ this._x = x;
+ this._y = y;
+ this._x0 = x0;
+ this._y0 = y0;
+ this._x1 = x1;
+ this._y1 = y1;
+ this._root = undefined;
+}
+
+function leaf_copy(leaf) {
+ var copy = {data: leaf.data}, next = copy;
+ while (leaf = leaf.next) next = next.next = {data: leaf.data};
+ return copy;
+}
+
+var treeProto = quadtree.prototype = Quadtree.prototype;
+
+treeProto.copy = function() {
+ var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1),
+ node = this._root,
+ nodes,
+ child;
+
+ if (!node) return copy;
+
+ if (!node.length) return copy._root = leaf_copy(node), copy;
+
+ nodes = [{source: node, target: copy._root = new Array(4)}];
+ while (node = nodes.pop()) {
+ for (var i = 0; i < 4; ++i) {
+ if (child = node.source[i]) {
+ if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)});
+ else node.target[i] = leaf_copy(child);
+ }
+ }
+ }
+
+ return copy;
+};
+
+treeProto.add = tree_add;
+treeProto.addAll = addAll;
+treeProto.cover = tree_cover;
+treeProto.data = tree_data;
+treeProto.extent = tree_extent;
+treeProto.find = tree_find;
+treeProto.remove = tree_remove;
+treeProto.removeAll = removeAll;
+treeProto.root = tree_root;
+treeProto.size = tree_size;
+treeProto.visit = tree_visit;
+treeProto.visitAfter = tree_visitAfter;
+treeProto.x = tree_x;
+treeProto.y = tree_y;
+
+exports.quadtree = quadtree;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],147:[function(_dereq_,module,exports){
+// https://d3js.org/d3-timer/ Version 1.0.7. Copyright 2017 Mike Bostock.
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+var frame = 0;
+var timeout = 0;
+var interval = 0;
+var pokeDelay = 1000;
+var taskHead;
+var taskTail;
+var clockLast = 0;
+var clockNow = 0;
+var clockSkew = 0;
+var clock = typeof performance === "object" && performance.now ? performance : Date;
+var setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); };
+
+function now() {
+ return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew);
+}
+
+function clearNow() {
+ clockNow = 0;
+}
+
+function Timer() {
+ this._call =
+ this._time =
+ this._next = null;
+}
+
+Timer.prototype = timer.prototype = {
+ constructor: Timer,
+ restart: function(callback, delay, time) {
+ if (typeof callback !== "function") throw new TypeError("callback is not a function");
+ time = (time == null ? now() : +time) + (delay == null ? 0 : +delay);
+ if (!this._next && taskTail !== this) {
+ if (taskTail) taskTail._next = this;
+ else taskHead = this;
+ taskTail = this;
+ }
+ this._call = callback;
+ this._time = time;
+ sleep();
+ },
+ stop: function() {
+ if (this._call) {
+ this._call = null;
+ this._time = Infinity;
+ sleep();
+ }
+ }
+};
+
+function timer(callback, delay, time) {
+ var t = new Timer;
+ t.restart(callback, delay, time);
+ return t;
+}
+
+function timerFlush() {
+ now(); // Get the current time, if not already set.
+ ++frame; // Pretend we’ve set an alarm, if we haven’t already.
+ var t = taskHead, e;
+ while (t) {
+ if ((e = clockNow - t._time) >= 0) t._call.call(null, e);
+ t = t._next;
+ }
+ --frame;
+}
+
+function wake() {
+ clockNow = (clockLast = clock.now()) + clockSkew;
+ frame = timeout = 0;
+ try {
+ timerFlush();
+ } finally {
+ frame = 0;
+ nap();
+ clockNow = 0;
+ }
+}
+
+function poke() {
+ var now = clock.now(), delay = now - clockLast;
+ if (delay > pokeDelay) clockSkew -= delay, clockLast = now;
+}
+
+function nap() {
+ var t0, t1 = taskHead, t2, time = Infinity;
+ while (t1) {
+ if (t1._call) {
+ if (time > t1._time) time = t1._time;
+ t0 = t1, t1 = t1._next;
+ } else {
+ t2 = t1._next, t1._next = null;
+ t1 = t0 ? t0._next = t2 : taskHead = t2;
+ }
+ }
+ taskTail = t0;
+ sleep(time);
+}
+
+function sleep(time) {
+ if (frame) return; // Soonest alarm already set, or will be.
+ if (timeout) timeout = clearTimeout(timeout);
+ var delay = time - clockNow; // Strictly less than if we recomputed clockNow.
+ if (delay > 24) {
+ if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew);
+ if (interval) interval = clearInterval(interval);
+ } else {
+ if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay);
+ frame = 1, setFrame(wake);
+ }
+}
+
+var timeout$1 = function(callback, delay, time) {
+ var t = new Timer;
+ delay = delay == null ? 0 : +delay;
+ t.restart(function(elapsed) {
+ t.stop();
+ callback(elapsed + delay);
+ }, delay, time);
+ return t;
+};
+
+var interval$1 = function(callback, delay, time) {
+ var t = new Timer, total = delay;
+ if (delay == null) return t.restart(callback, delay, time), t;
+ delay = +delay, time = time == null ? now() : +time;
+ t.restart(function tick(elapsed) {
+ elapsed += total;
+ t.restart(tick, total += delay, time);
+ callback(elapsed);
+ }, delay, time);
+ return t;
+};
+
+exports.now = now;
+exports.timer = timer;
+exports.timerFlush = timerFlush;
+exports.timeout = timeout$1;
+exports.interval = interval$1;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],148:[function(_dereq_,module,exports){
+!function() {
+ var d3 = {
+ version: "3.5.17"
+ };
+ var d3_arraySlice = [].slice, d3_array = function(list) {
+ return d3_arraySlice.call(list);
+ };
+ var d3_document = this.document;
+ function d3_documentElement(node) {
+ return node && (node.ownerDocument || node.document || node).documentElement;
+ }
+ function d3_window(node) {
+ return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView);
+ }
+ if (d3_document) {
+ try {
+ d3_array(d3_document.documentElement.childNodes)[0].nodeType;
+ } catch (e) {
+ d3_array = function(list) {
+ var i = list.length, array = new Array(i);
+ while (i--) array[i] = list[i];
+ return array;
+ };
+ }
+ }
+ if (!Date.now) Date.now = function() {
+ return +new Date();
+ };
+ if (d3_document) {
+ try {
+ d3_document.createElement("DIV").style.setProperty("opacity", 0, "");
+ } catch (error) {
+ var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty;
+ d3_element_prototype.setAttribute = function(name, value) {
+ d3_element_setAttribute.call(this, name, value + "");
+ };
+ d3_element_prototype.setAttributeNS = function(space, local, value) {
+ d3_element_setAttributeNS.call(this, space, local, value + "");
+ };
+ d3_style_prototype.setProperty = function(name, value, priority) {
+ d3_style_setProperty.call(this, name, value + "", priority);
+ };
+ }
+ }
+ d3.ascending = d3_ascending;
+ function d3_ascending(a, b) {
+ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+ }
+ d3.descending = function(a, b) {
+ return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+ };
+ d3.min = function(array, f) {
+ var i = -1, n = array.length, a, b;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null && a > b) a = b;
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
+ }
+ return a;
+ };
+ d3.max = function(array, f) {
+ var i = -1, n = array.length, a, b;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null && b > a) a = b;
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
+ }
+ return a;
+ };
+ d3.extent = function(array, f) {
+ var i = -1, n = array.length, a, b, c;
+ if (arguments.length === 1) {
+ while (++i < n) if ((b = array[i]) != null && b >= b) {
+ a = c = b;
+ break;
+ }
+ while (++i < n) if ((b = array[i]) != null) {
+ if (a > b) a = b;
+ if (c < b) c = b;
+ }
+ } else {
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {
+ a = c = b;
+ break;
+ }
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
+ if (a > b) a = b;
+ if (c < b) c = b;
+ }
+ }
+ return [ a, c ];
+ };
+ function d3_number(x) {
+ return x === null ? NaN : +x;
+ }
+ function d3_numeric(x) {
+ return !isNaN(x);
+ }
+ d3.sum = function(array, f) {
+ var s = 0, n = array.length, a, i = -1;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = +array[i])) s += a;
+ } else {
+ while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;
+ }
+ return s;
+ };
+ d3.mean = function(array, f) {
+ var s = 0, n = array.length, a, i = -1, j = n;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;
+ } else {
+ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;
+ }
+ if (j) return s / j;
+ };
+ d3.quantile = function(values, p) {
+ var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h;
+ return e ? v + e * (values[h] - v) : v;
+ };
+ d3.median = function(array, f) {
+ var numbers = [], n = array.length, a, i = -1;
+ if (arguments.length === 1) {
+ while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);
+ } else {
+ while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);
+ }
+ if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5);
+ };
+ d3.variance = function(array, f) {
+ var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;
+ if (arguments.length === 1) {
+ while (++i < n) {
+ if (d3_numeric(a = d3_number(array[i]))) {
+ d = a - m;
+ m += d / ++j;
+ s += d * (a - m);
+ }
+ }
+ } else {
+ while (++i < n) {
+ if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {
+ d = a - m;
+ m += d / ++j;
+ s += d * (a - m);
+ }
+ }
+ }
+ if (j > 1) return s / (j - 1);
+ };
+ d3.deviation = function() {
+ var v = d3.variance.apply(this, arguments);
+ return v ? Math.sqrt(v) : v;
+ };
+ function d3_bisector(compare) {
+ return {
+ left: function(a, x, lo, hi) {
+ if (arguments.length < 3) lo = 0;
+ if (arguments.length < 4) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid;
+ }
+ return lo;
+ },
+ right: function(a, x, lo, hi) {
+ if (arguments.length < 3) lo = 0;
+ if (arguments.length < 4) hi = a.length;
+ while (lo < hi) {
+ var mid = lo + hi >>> 1;
+ if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1;
+ }
+ return lo;
+ }
+ };
+ }
+ var d3_bisect = d3_bisector(d3_ascending);
+ d3.bisectLeft = d3_bisect.left;
+ d3.bisect = d3.bisectRight = d3_bisect.right;
+ d3.bisector = function(f) {
+ return d3_bisector(f.length === 1 ? function(d, x) {
+ return d3_ascending(f(d), x);
+ } : f);
+ };
+ d3.shuffle = function(array, i0, i1) {
+ if ((m = arguments.length) < 3) {
+ i1 = array.length;
+ if (m < 2) i0 = 0;
+ }
+ var m = i1 - i0, t, i;
+ while (m) {
+ i = Math.random() * m-- | 0;
+ t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;
+ }
+ return array;
+ };
+ d3.permute = function(array, indexes) {
+ var i = indexes.length, permutes = new Array(i);
+ while (i--) permutes[i] = array[indexes[i]];
+ return permutes;
+ };
+ d3.pairs = function(array) {
+ var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);
+ while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];
+ return pairs;
+ };
+ d3.transpose = function(matrix) {
+ if (!(n = matrix.length)) return [];
+ for (var i = -1, m = d3.min(matrix, d3_transposeLength), transpose = new Array(m); ++i < m; ) {
+ for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n; ) {
+ row[j] = matrix[j][i];
+ }
+ }
+ return transpose;
+ };
+ function d3_transposeLength(d) {
+ return d.length;
+ }
+ d3.zip = function() {
+ return d3.transpose(arguments);
+ };
+ d3.keys = function(map) {
+ var keys = [];
+ for (var key in map) keys.push(key);
+ return keys;
+ };
+ d3.values = function(map) {
+ var values = [];
+ for (var key in map) values.push(map[key]);
+ return values;
+ };
+ d3.entries = function(map) {
+ var entries = [];
+ for (var key in map) entries.push({
+ key: key,
+ value: map[key]
+ });
+ return entries;
+ };
+ d3.merge = function(arrays) {
+ var n = arrays.length, m, i = -1, j = 0, merged, array;
+ while (++i < n) j += arrays[i].length;
+ merged = new Array(j);
+ while (--n >= 0) {
+ array = arrays[n];
+ m = array.length;
+ while (--m >= 0) {
+ merged[--j] = array[m];
+ }
+ }
+ return merged;
+ };
+ var abs = Math.abs;
+ d3.range = function(start, stop, step) {
+ if (arguments.length < 3) {
+ step = 1;
+ if (arguments.length < 2) {
+ stop = start;
+ start = 0;
+ }
+ }
+ if ((stop - start) / step === Infinity) throw new Error("infinite range");
+ var range = [], k = d3_range_integerScale(abs(step)), i = -1, j;
+ start *= k, stop *= k, step *= k;
+ if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k);
+ return range;
+ };
+ function d3_range_integerScale(x) {
+ var k = 1;
+ while (x * k % 1) k *= 10;
+ return k;
+ }
+ function d3_class(ctor, properties) {
+ for (var key in properties) {
+ Object.defineProperty(ctor.prototype, key, {
+ value: properties[key],
+ enumerable: false
+ });
+ }
+ }
+ d3.map = function(object, f) {
+ var map = new d3_Map();
+ if (object instanceof d3_Map) {
+ object.forEach(function(key, value) {
+ map.set(key, value);
+ });
+ } else if (Array.isArray(object)) {
+ var i = -1, n = object.length, o;
+ if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o);
+ } else {
+ for (var key in object) map.set(key, object[key]);
+ }
+ return map;
+ };
+ function d3_Map() {
+ this._ = Object.create(null);
+ }
+ var d3_map_proto = "__proto__", d3_map_zero = "\x00";
+ d3_class(d3_Map, {
+ has: d3_map_has,
+ get: function(key) {
+ return this._[d3_map_escape(key)];
+ },
+ set: function(key, value) {
+ return this._[d3_map_escape(key)] = value;
+ },
+ remove: d3_map_remove,
+ keys: d3_map_keys,
+ values: function() {
+ var values = [];
+ for (var key in this._) values.push(this._[key]);
+ return values;
+ },
+ entries: function() {
+ var entries = [];
+ for (var key in this._) entries.push({
+ key: d3_map_unescape(key),
+ value: this._[key]
+ });
+ return entries;
+ },
+ size: d3_map_size,
+ empty: d3_map_empty,
+ forEach: function(f) {
+ for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]);
+ }
+ });
+ function d3_map_escape(key) {
+ return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key;
+ }
+ function d3_map_unescape(key) {
+ return (key += "")[0] === d3_map_zero ? key.slice(1) : key;
+ }
+ function d3_map_has(key) {
+ return d3_map_escape(key) in this._;
+ }
+ function d3_map_remove(key) {
+ return (key = d3_map_escape(key)) in this._ && delete this._[key];
+ }
+ function d3_map_keys() {
+ var keys = [];
+ for (var key in this._) keys.push(d3_map_unescape(key));
+ return keys;
+ }
+ function d3_map_size() {
+ var size = 0;
+ for (var key in this._) ++size;
+ return size;
+ }
+ function d3_map_empty() {
+ for (var key in this._) return false;
+ return true;
+ }
+ d3.nest = function() {
+ var nest = {}, keys = [], sortKeys = [], sortValues, rollup;
+ function map(mapType, array, depth) {
+ if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;
+ var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;
+ while (++i < n) {
+ if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
+ values.push(object);
+ } else {
+ valuesByKey.set(keyValue, [ object ]);
+ }
+ }
+ if (mapType) {
+ object = mapType();
+ setter = function(keyValue, values) {
+ object.set(keyValue, map(mapType, values, depth));
+ };
+ } else {
+ object = {};
+ setter = function(keyValue, values) {
+ object[keyValue] = map(mapType, values, depth);
+ };
+ }
+ valuesByKey.forEach(setter);
+ return object;
+ }
+ function entries(map, depth) {
+ if (depth >= keys.length) return map;
+ var array = [], sortKey = sortKeys[depth++];
+ map.forEach(function(key, keyMap) {
+ array.push({
+ key: key,
+ values: entries(keyMap, depth)
+ });
+ });
+ return sortKey ? array.sort(function(a, b) {
+ return sortKey(a.key, b.key);
+ }) : array;
+ }
+ nest.map = function(array, mapType) {
+ return map(mapType, array, 0);
+ };
+ nest.entries = function(array) {
+ return entries(map(d3.map, array, 0), 0);
+ };
+ nest.key = function(d) {
+ keys.push(d);
+ return nest;
+ };
+ nest.sortKeys = function(order) {
+ sortKeys[keys.length - 1] = order;
+ return nest;
+ };
+ nest.sortValues = function(order) {
+ sortValues = order;
+ return nest;
+ };
+ nest.rollup = function(f) {
+ rollup = f;
+ return nest;
+ };
+ return nest;
+ };
+ d3.set = function(array) {
+ var set = new d3_Set();
+ if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);
+ return set;
+ };
+ function d3_Set() {
+ this._ = Object.create(null);
+ }
+ d3_class(d3_Set, {
+ has: d3_map_has,
+ add: function(key) {
+ this._[d3_map_escape(key += "")] = true;
+ return key;
+ },
+ remove: d3_map_remove,
+ values: d3_map_keys,
+ size: d3_map_size,
+ empty: d3_map_empty,
+ forEach: function(f) {
+ for (var key in this._) f.call(this, d3_map_unescape(key));
+ }
+ });
+ d3.behavior = {};
+ function d3_identity(d) {
+ return d;
+ }
+ d3.rebind = function(target, source) {
+ var i = 1, n = arguments.length, method;
+ while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]);
+ return target;
+ };
+ function d3_rebind(target, source, method) {
+ return function() {
+ var value = method.apply(source, arguments);
+ return value === source ? target : value;
+ };
+ }
+ function d3_vendorSymbol(object, name) {
+ if (name in object) return name;
+ name = name.charAt(0).toUpperCase() + name.slice(1);
+ for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) {
+ var prefixName = d3_vendorPrefixes[i] + name;
+ if (prefixName in object) return prefixName;
+ }
+ }
+ var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ];
+ function d3_noop() {}
+ d3.dispatch = function() {
+ var dispatch = new d3_dispatch(), i = -1, n = arguments.length;
+ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+ return dispatch;
+ };
+ function d3_dispatch() {}
+ d3_dispatch.prototype.on = function(type, listener) {
+ var i = type.indexOf("."), name = "";
+ if (i >= 0) {
+ name = type.slice(i + 1);
+ type = type.slice(0, i);
+ }
+ if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener);
+ if (arguments.length === 2) {
+ if (listener == null) for (type in this) {
+ if (this.hasOwnProperty(type)) this[type].on(name, null);
+ }
+ return this;
+ }
+ };
+ function d3_dispatch_event(dispatch) {
+ var listeners = [], listenerByName = new d3_Map();
+ function event() {
+ var z = listeners, i = -1, n = z.length, l;
+ while (++i < n) if (l = z[i].on) l.apply(this, arguments);
+ return dispatch;
+ }
+ event.on = function(name, listener) {
+ var l = listenerByName.get(name), i;
+ if (arguments.length < 2) return l && l.on;
+ if (l) {
+ l.on = null;
+ listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1));
+ listenerByName.remove(name);
+ }
+ if (listener) listeners.push(listenerByName.set(name, {
+ on: listener
+ }));
+ return dispatch;
+ };
+ return event;
+ }
+ d3.event = null;
+ function d3_eventPreventDefault() {
+ d3.event.preventDefault();
+ }
+ function d3_eventSource() {
+ var e = d3.event, s;
+ while (s = e.sourceEvent) e = s;
+ return e;
+ }
+ function d3_eventDispatch(target) {
+ var dispatch = new d3_dispatch(), i = 0, n = arguments.length;
+ while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch);
+ dispatch.of = function(thiz, argumentz) {
+ return function(e1) {
+ try {
+ var e0 = e1.sourceEvent = d3.event;
+ e1.target = target;
+ d3.event = e1;
+ dispatch[e1.type].apply(thiz, argumentz);
+ } finally {
+ d3.event = e0;
+ }
+ };
+ };
+ return dispatch;
+ }
+ d3.requote = function(s) {
+ return s.replace(d3_requote_re, "\\$&");
+ };
+ var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
+ var d3_subclass = {}.__proto__ ? function(object, prototype) {
+ object.__proto__ = prototype;
+ } : function(object, prototype) {
+ for (var property in prototype) object[property] = prototype[property];
+ };
+ function d3_selection(groups) {
+ d3_subclass(groups, d3_selectionPrototype);
+ return groups;
+ }
+ var d3_select = function(s, n) {
+ return n.querySelector(s);
+ }, d3_selectAll = function(s, n) {
+ return n.querySelectorAll(s);
+ }, d3_selectMatches = function(n, s) {
+ var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")];
+ d3_selectMatches = function(n, s) {
+ return d3_selectMatcher.call(n, s);
+ };
+ return d3_selectMatches(n, s);
+ };
+ if (typeof Sizzle === "function") {
+ d3_select = function(s, n) {
+ return Sizzle(s, n)[0] || null;
+ };
+ d3_selectAll = Sizzle;
+ d3_selectMatches = Sizzle.matchesSelector;
+ }
+ d3.selection = function() {
+ return d3.select(d3_document.documentElement);
+ };
+ var d3_selectionPrototype = d3.selection.prototype = [];
+ d3_selectionPrototype.select = function(selector) {
+ var subgroups = [], subgroup, subnode, group, node;
+ selector = d3_selection_selector(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = (group = this[j]).parentNode;
+ for (var i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroup.push(subnode = selector.call(node, node.__data__, i, j));
+ if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_selector(selector) {
+ return typeof selector === "function" ? selector : function() {
+ return d3_select(selector, this);
+ };
+ }
+ d3_selectionPrototype.selectAll = function(selector) {
+ var subgroups = [], subgroup, node;
+ selector = d3_selection_selectorAll(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));
+ subgroup.parentNode = node;
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_selectorAll(selector) {
+ return typeof selector === "function" ? selector : function() {
+ return d3_selectAll(selector, this);
+ };
+ }
+ var d3_nsXhtml = "http://www.w3.org/1999/xhtml";
+ var d3_nsPrefix = {
+ svg: "http://www.w3.org/2000/svg",
+ xhtml: d3_nsXhtml,
+ xlink: "http://www.w3.org/1999/xlink",
+ xml: "http://www.w3.org/XML/1998/namespace",
+ xmlns: "http://www.w3.org/2000/xmlns/"
+ };
+ d3.ns = {
+ prefix: d3_nsPrefix,
+ qualify: function(name) {
+ var i = name.indexOf(":"), prefix = name;
+ if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
+ return d3_nsPrefix.hasOwnProperty(prefix) ? {
+ space: d3_nsPrefix[prefix],
+ local: name
+ } : name;
+ }
+ };
+ d3_selectionPrototype.attr = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") {
+ var node = this.node();
+ name = d3.ns.qualify(name);
+ return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name);
+ }
+ for (value in name) this.each(d3_selection_attr(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_attr(name, value));
+ };
+ function d3_selection_attr(name, value) {
+ name = d3.ns.qualify(name);
+ function attrNull() {
+ this.removeAttribute(name);
+ }
+ function attrNullNS() {
+ this.removeAttributeNS(name.space, name.local);
+ }
+ function attrConstant() {
+ this.setAttribute(name, value);
+ }
+ function attrConstantNS() {
+ this.setAttributeNS(name.space, name.local, value);
+ }
+ function attrFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.removeAttribute(name); else this.setAttribute(name, x);
+ }
+ function attrFunctionNS() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x);
+ }
+ return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant;
+ }
+ function d3_collapse(s) {
+ return s.trim().replace(/\s+/g, " ");
+ }
+ d3_selectionPrototype.classed = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") {
+ var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1;
+ if (value = node.classList) {
+ while (++i < n) if (!value.contains(name[i])) return false;
+ } else {
+ value = node.getAttribute("class");
+ while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false;
+ }
+ return true;
+ }
+ for (value in name) this.each(d3_selection_classed(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_classed(name, value));
+ };
+ function d3_selection_classedRe(name) {
+ return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g");
+ }
+ function d3_selection_classes(name) {
+ return (name + "").trim().split(/^|\s+/);
+ }
+ function d3_selection_classed(name, value) {
+ name = d3_selection_classes(name).map(d3_selection_classedName);
+ var n = name.length;
+ function classedConstant() {
+ var i = -1;
+ while (++i < n) name[i](this, value);
+ }
+ function classedFunction() {
+ var i = -1, x = value.apply(this, arguments);
+ while (++i < n) name[i](this, x);
+ }
+ return typeof value === "function" ? classedFunction : classedConstant;
+ }
+ function d3_selection_classedName(name) {
+ var re = d3_selection_classedRe(name);
+ return function(node, value) {
+ if (c = node.classList) return value ? c.add(name) : c.remove(name);
+ var c = node.getAttribute("class") || "";
+ if (value) {
+ re.lastIndex = 0;
+ if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name));
+ } else {
+ node.setAttribute("class", d3_collapse(c.replace(re, " ")));
+ }
+ };
+ }
+ d3_selectionPrototype.style = function(name, value, priority) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof name !== "string") {
+ if (n < 2) value = "";
+ for (priority in name) this.each(d3_selection_style(priority, name[priority], value));
+ return this;
+ }
+ if (n < 2) {
+ var node = this.node();
+ return d3_window(node).getComputedStyle(node, null).getPropertyValue(name);
+ }
+ priority = "";
+ }
+ return this.each(d3_selection_style(name, value, priority));
+ };
+ function d3_selection_style(name, value, priority) {
+ function styleNull() {
+ this.style.removeProperty(name);
+ }
+ function styleConstant() {
+ this.style.setProperty(name, value, priority);
+ }
+ function styleFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority);
+ }
+ return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant;
+ }
+ d3_selectionPrototype.property = function(name, value) {
+ if (arguments.length < 2) {
+ if (typeof name === "string") return this.node()[name];
+ for (value in name) this.each(d3_selection_property(value, name[value]));
+ return this;
+ }
+ return this.each(d3_selection_property(name, value));
+ };
+ function d3_selection_property(name, value) {
+ function propertyNull() {
+ delete this[name];
+ }
+ function propertyConstant() {
+ this[name] = value;
+ }
+ function propertyFunction() {
+ var x = value.apply(this, arguments);
+ if (x == null) delete this[name]; else this[name] = x;
+ }
+ return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant;
+ }
+ d3_selectionPrototype.text = function(value) {
+ return arguments.length ? this.each(typeof value === "function" ? function() {
+ var v = value.apply(this, arguments);
+ this.textContent = v == null ? "" : v;
+ } : value == null ? function() {
+ this.textContent = "";
+ } : function() {
+ this.textContent = value;
+ }) : this.node().textContent;
+ };
+ d3_selectionPrototype.html = function(value) {
+ return arguments.length ? this.each(typeof value === "function" ? function() {
+ var v = value.apply(this, arguments);
+ this.innerHTML = v == null ? "" : v;
+ } : value == null ? function() {
+ this.innerHTML = "";
+ } : function() {
+ this.innerHTML = value;
+ }) : this.node().innerHTML;
+ };
+ d3_selectionPrototype.append = function(name) {
+ name = d3_selection_creator(name);
+ return this.select(function() {
+ return this.appendChild(name.apply(this, arguments));
+ });
+ };
+ function d3_selection_creator(name) {
+ function create() {
+ var document = this.ownerDocument, namespace = this.namespaceURI;
+ return namespace === d3_nsXhtml && document.documentElement.namespaceURI === d3_nsXhtml ? document.createElement(name) : document.createElementNS(namespace, name);
+ }
+ function createNS() {
+ return this.ownerDocument.createElementNS(name.space, name.local);
+ }
+ return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create;
+ }
+ d3_selectionPrototype.insert = function(name, before) {
+ name = d3_selection_creator(name);
+ before = d3_selection_selector(before);
+ return this.select(function() {
+ return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null);
+ });
+ };
+ d3_selectionPrototype.remove = function() {
+ return this.each(d3_selectionRemove);
+ };
+ function d3_selectionRemove() {
+ var parent = this.parentNode;
+ if (parent) parent.removeChild(this);
+ }
+ d3_selectionPrototype.data = function(value, key) {
+ var i = -1, n = this.length, group, node;
+ if (!arguments.length) {
+ value = new Array(n = (group = this[0]).length);
+ while (++i < n) {
+ if (node = group[i]) {
+ value[i] = node.__data__;
+ }
+ }
+ return value;
+ }
+ function bind(group, groupData) {
+ var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;
+ if (key) {
+ var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;
+ for (i = -1; ++i < n; ) {
+ if (node = group[i]) {
+ if (nodeByKeyValue.has(keyValue = key.call(node, node.__data__, i))) {
+ exitNodes[i] = node;
+ } else {
+ nodeByKeyValue.set(keyValue, node);
+ }
+ keyValues[i] = keyValue;
+ }
+ }
+ for (i = -1; ++i < m; ) {
+ if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) {
+ enterNodes[i] = d3_selection_dataNode(nodeData);
+ } else if (node !== true) {
+ updateNodes[i] = node;
+ node.__data__ = nodeData;
+ }
+ nodeByKeyValue.set(keyValue, true);
+ }
+ for (i = -1; ++i < n; ) {
+ if (i in keyValues && nodeByKeyValue.get(keyValues[i]) !== true) {
+ exitNodes[i] = group[i];
+ }
+ }
+ } else {
+ for (i = -1; ++i < n0; ) {
+ node = group[i];
+ nodeData = groupData[i];
+ if (node) {
+ node.__data__ = nodeData;
+ updateNodes[i] = node;
+ } else {
+ enterNodes[i] = d3_selection_dataNode(nodeData);
+ }
+ }
+ for (;i < m; ++i) {
+ enterNodes[i] = d3_selection_dataNode(groupData[i]);
+ }
+ for (;i < n; ++i) {
+ exitNodes[i] = group[i];
+ }
+ }
+ enterNodes.update = updateNodes;
+ enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode;
+ enter.push(enterNodes);
+ update.push(updateNodes);
+ exit.push(exitNodes);
+ }
+ var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]);
+ if (typeof value === "function") {
+ while (++i < n) {
+ bind(group = this[i], value.call(group, group.parentNode.__data__, i));
+ }
+ } else {
+ while (++i < n) {
+ bind(group = this[i], value);
+ }
+ }
+ update.enter = function() {
+ return enter;
+ };
+ update.exit = function() {
+ return exit;
+ };
+ return update;
+ };
+ function d3_selection_dataNode(data) {
+ return {
+ __data__: data
+ };
+ }
+ d3_selectionPrototype.datum = function(value) {
+ return arguments.length ? this.property("__data__", value) : this.property("__data__");
+ };
+ d3_selectionPrototype.filter = function(filter) {
+ var subgroups = [], subgroup, group, node;
+ if (typeof filter !== "function") filter = d3_selection_filter(filter);
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = (group = this[j]).parentNode;
+ for (var i = 0, n = group.length; i < n; i++) {
+ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+ subgroup.push(node);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ function d3_selection_filter(selector) {
+ return function() {
+ return d3_selectMatches(this, selector);
+ };
+ }
+ d3_selectionPrototype.order = function() {
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) {
+ if (node = group[i]) {
+ if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next);
+ next = node;
+ }
+ }
+ }
+ return this;
+ };
+ d3_selectionPrototype.sort = function(comparator) {
+ comparator = d3_selection_sortComparator.apply(this, arguments);
+ for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator);
+ return this.order();
+ };
+ function d3_selection_sortComparator(comparator) {
+ if (!arguments.length) comparator = d3_ascending;
+ return function(a, b) {
+ return a && b ? comparator(a.__data__, b.__data__) : !a - !b;
+ };
+ }
+ d3_selectionPrototype.each = function(callback) {
+ return d3_selection_each(this, function(node, i, j) {
+ callback.call(node, node.__data__, i, j);
+ });
+ };
+ function d3_selection_each(groups, callback) {
+ for (var j = 0, m = groups.length; j < m; j++) {
+ for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) {
+ if (node = group[i]) callback(node, i, j);
+ }
+ }
+ return groups;
+ }
+ d3_selectionPrototype.call = function(callback) {
+ var args = d3_array(arguments);
+ callback.apply(args[0] = this, args);
+ return this;
+ };
+ d3_selectionPrototype.empty = function() {
+ return !this.node();
+ };
+ d3_selectionPrototype.node = function() {
+ for (var j = 0, m = this.length; j < m; j++) {
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ var node = group[i];
+ if (node) return node;
+ }
+ }
+ return null;
+ };
+ d3_selectionPrototype.size = function() {
+ var n = 0;
+ d3_selection_each(this, function() {
+ ++n;
+ });
+ return n;
+ };
+ function d3_selection_enter(selection) {
+ d3_subclass(selection, d3_selection_enterPrototype);
+ return selection;
+ }
+ var d3_selection_enterPrototype = [];
+ d3.selection.enter = d3_selection_enter;
+ d3.selection.enter.prototype = d3_selection_enterPrototype;
+ d3_selection_enterPrototype.append = d3_selectionPrototype.append;
+ d3_selection_enterPrototype.empty = d3_selectionPrototype.empty;
+ d3_selection_enterPrototype.node = d3_selectionPrototype.node;
+ d3_selection_enterPrototype.call = d3_selectionPrototype.call;
+ d3_selection_enterPrototype.size = d3_selectionPrototype.size;
+ d3_selection_enterPrototype.select = function(selector) {
+ var subgroups = [], subgroup, subnode, upgroup, group, node;
+ for (var j = -1, m = this.length; ++j < m; ) {
+ upgroup = (group = this[j]).update;
+ subgroups.push(subgroup = []);
+ subgroup.parentNode = group.parentNode;
+ for (var i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j));
+ subnode.__data__ = node.__data__;
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_selection(subgroups);
+ };
+ d3_selection_enterPrototype.insert = function(name, before) {
+ if (arguments.length < 2) before = d3_selection_enterInsertBefore(this);
+ return d3_selectionPrototype.insert.call(this, name, before);
+ };
+ function d3_selection_enterInsertBefore(enter) {
+ var i0, j0;
+ return function(d, i, j) {
+ var group = enter[j].update, n = group.length, node;
+ if (j != j0) j0 = j, i0 = 0;
+ if (i >= i0) i0 = i + 1;
+ while (!(node = group[i0]) && ++i0 < n) ;
+ return node;
+ };
+ }
+ d3.select = function(node) {
+ var group;
+ if (typeof node === "string") {
+ group = [ d3_select(node, d3_document) ];
+ group.parentNode = d3_document.documentElement;
+ } else {
+ group = [ node ];
+ group.parentNode = d3_documentElement(node);
+ }
+ return d3_selection([ group ]);
+ };
+ d3.selectAll = function(nodes) {
+ var group;
+ if (typeof nodes === "string") {
+ group = d3_array(d3_selectAll(nodes, d3_document));
+ group.parentNode = d3_document.documentElement;
+ } else {
+ group = d3_array(nodes);
+ group.parentNode = null;
+ }
+ return d3_selection([ group ]);
+ };
+ d3_selectionPrototype.on = function(type, listener, capture) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof type !== "string") {
+ if (n < 2) listener = false;
+ for (capture in type) this.each(d3_selection_on(capture, type[capture], listener));
+ return this;
+ }
+ if (n < 2) return (n = this.node()["__on" + type]) && n._;
+ capture = false;
+ }
+ return this.each(d3_selection_on(type, listener, capture));
+ };
+ function d3_selection_on(type, listener, capture) {
+ var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener;
+ if (i > 0) type = type.slice(0, i);
+ var filter = d3_selection_onFilters.get(type);
+ if (filter) type = filter, wrap = d3_selection_onFilter;
+ function onRemove() {
+ var l = this[name];
+ if (l) {
+ this.removeEventListener(type, l, l.$);
+ delete this[name];
+ }
+ }
+ function onAdd() {
+ var l = wrap(listener, d3_array(arguments));
+ onRemove.call(this);
+ this.addEventListener(type, this[name] = l, l.$ = capture);
+ l._ = listener;
+ }
+ function removeAll() {
+ var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match;
+ for (var name in this) {
+ if (match = name.match(re)) {
+ var l = this[name];
+ this.removeEventListener(match[1], l, l.$);
+ delete this[name];
+ }
+ }
+ }
+ return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll;
+ }
+ var d3_selection_onFilters = d3.map({
+ mouseenter: "mouseover",
+ mouseleave: "mouseout"
+ });
+ if (d3_document) {
+ d3_selection_onFilters.forEach(function(k) {
+ if ("on" + k in d3_document) d3_selection_onFilters.remove(k);
+ });
+ }
+ function d3_selection_onListener(listener, argumentz) {
+ return function(e) {
+ var o = d3.event;
+ d3.event = e;
+ argumentz[0] = this.__data__;
+ try {
+ listener.apply(this, argumentz);
+ } finally {
+ d3.event = o;
+ }
+ };
+ }
+ function d3_selection_onFilter(listener, argumentz) {
+ var l = d3_selection_onListener(listener, argumentz);
+ return function(e) {
+ var target = this, related = e.relatedTarget;
+ if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) {
+ l.call(target, e);
+ }
+ };
+ }
+ var d3_event_dragSelect, d3_event_dragId = 0;
+ function d3_event_dragSuppress(node) {
+ var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault);
+ if (d3_event_dragSelect == null) {
+ d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect");
+ }
+ if (d3_event_dragSelect) {
+ var style = d3_documentElement(node).style, select = style[d3_event_dragSelect];
+ style[d3_event_dragSelect] = "none";
+ }
+ return function(suppressClick) {
+ w.on(name, null);
+ if (d3_event_dragSelect) style[d3_event_dragSelect] = select;
+ if (suppressClick) {
+ var off = function() {
+ w.on(click, null);
+ };
+ w.on(click, function() {
+ d3_eventPreventDefault();
+ off();
+ }, true);
+ setTimeout(off, 0);
+ }
+ };
+ }
+ d3.mouse = function(container) {
+ return d3_mousePoint(container, d3_eventSource());
+ };
+ var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;
+ function d3_mousePoint(container, e) {
+ if (e.changedTouches) e = e.changedTouches[0];
+ var svg = container.ownerSVGElement || container;
+ if (svg.createSVGPoint) {
+ var point = svg.createSVGPoint();
+ if (d3_mouse_bug44083 < 0) {
+ var window = d3_window(container);
+ if (window.scrollX || window.scrollY) {
+ svg = d3.select("body").append("svg").style({
+ position: "absolute",
+ top: 0,
+ left: 0,
+ margin: 0,
+ padding: 0,
+ border: "none"
+ }, "important");
+ var ctm = svg[0][0].getScreenCTM();
+ d3_mouse_bug44083 = !(ctm.f || ctm.e);
+ svg.remove();
+ }
+ }
+ if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX,
+ point.y = e.clientY;
+ point = point.matrixTransform(container.getScreenCTM().inverse());
+ return [ point.x, point.y ];
+ }
+ var rect = container.getBoundingClientRect();
+ return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ];
+ }
+ d3.touch = function(container, touches, identifier) {
+ if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches;
+ if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) {
+ if ((touch = touches[i]).identifier === identifier) {
+ return d3_mousePoint(container, touch);
+ }
+ }
+ };
+ d3.behavior.drag = function() {
+ var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend");
+ function drag() {
+ this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart);
+ }
+ function dragstart(id, position, subject, move, end) {
+ return function() {
+ var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId);
+ if (origin) {
+ dragOffset = origin.apply(that, arguments);
+ dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ];
+ } else {
+ dragOffset = [ 0, 0 ];
+ }
+ dispatch({
+ type: "dragstart"
+ });
+ function moved() {
+ var position1 = position(parent, dragId), dx, dy;
+ if (!position1) return;
+ dx = position1[0] - position0[0];
+ dy = position1[1] - position0[1];
+ dragged |= dx | dy;
+ position0 = position1;
+ dispatch({
+ type: "drag",
+ x: position1[0] + dragOffset[0],
+ y: position1[1] + dragOffset[1],
+ dx: dx,
+ dy: dy
+ });
+ }
+ function ended() {
+ if (!position(parent, dragId)) return;
+ dragSubject.on(move + dragName, null).on(end + dragName, null);
+ dragRestore(dragged);
+ dispatch({
+ type: "dragend"
+ });
+ }
+ };
+ }
+ drag.origin = function(x) {
+ if (!arguments.length) return origin;
+ origin = x;
+ return drag;
+ };
+ return d3.rebind(drag, event, "on");
+ };
+ function d3_behavior_dragTouchId() {
+ return d3.event.changedTouches[0].identifier;
+ }
+ d3.touches = function(container, touches) {
+ if (arguments.length < 2) touches = d3_eventSource().touches;
+ return touches ? d3_array(touches).map(function(touch) {
+ var point = d3_mousePoint(container, touch);
+ point.identifier = touch.identifier;
+ return point;
+ }) : [];
+ };
+ var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π;
+ function d3_sgn(x) {
+ return x > 0 ? 1 : x < 0 ? -1 : 0;
+ }
+ function d3_cross2d(a, b, c) {
+ return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+ }
+ function d3_acos(x) {
+ return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
+ }
+ function d3_asin(x) {
+ return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
+ }
+ function d3_sinh(x) {
+ return ((x = Math.exp(x)) - 1 / x) / 2;
+ }
+ function d3_cosh(x) {
+ return ((x = Math.exp(x)) + 1 / x) / 2;
+ }
+ function d3_tanh(x) {
+ return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+ }
+ function d3_haversin(x) {
+ return (x = Math.sin(x / 2)) * x;
+ }
+ var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4;
+ d3.interpolateZoom = function(p0, p1) {
+ var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S;
+ if (d2 < ε2) {
+ S = Math.log(w1 / w0) / ρ;
+ i = function(t) {
+ return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * t * S) ];
+ };
+ } else {
+ var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+ S = (r1 - r0) / ρ;
+ i = function(t) {
+ var s = t * S, coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0));
+ return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ];
+ };
+ }
+ i.duration = S * 1e3;
+ return i;
+ };
+ d3.behavior.zoom = function() {
+ var view = {
+ x: 0,
+ y: 0,
+ k: 1
+ }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1;
+ if (!d3_behavior_zoomWheel) {
+ d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+ return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1);
+ }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() {
+ return d3.event.wheelDelta;
+ }, "mousewheel") : (d3_behavior_zoomDelta = function() {
+ return -d3.event.detail;
+ }, "MozMousePixelScroll");
+ }
+ function zoom(g) {
+ g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted);
+ }
+ zoom.event = function(g) {
+ g.each(function() {
+ var dispatch = event.of(this, arguments), view1 = view;
+ if (d3_transitionInheritId) {
+ d3.select(this).transition().each("start.zoom", function() {
+ view = this.__chart__ || {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ zoomstarted(dispatch);
+ }).tween("zoom:zoom", function() {
+ var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]);
+ return function(t) {
+ var l = i(t), k = dx / l[2];
+ this.__chart__ = view = {
+ x: cx - l[0] * k,
+ y: cy - l[1] * k,
+ k: k
+ };
+ zoomed(dispatch);
+ };
+ }).each("interrupt.zoom", function() {
+ zoomended(dispatch);
+ }).each("end.zoom", function() {
+ zoomended(dispatch);
+ });
+ } else {
+ this.__chart__ = view;
+ zoomstarted(dispatch);
+ zoomed(dispatch);
+ zoomended(dispatch);
+ }
+ });
+ };
+ zoom.translate = function(_) {
+ if (!arguments.length) return [ view.x, view.y ];
+ view = {
+ x: +_[0],
+ y: +_[1],
+ k: view.k
+ };
+ rescale();
+ return zoom;
+ };
+ zoom.scale = function(_) {
+ if (!arguments.length) return view.k;
+ view = {
+ x: view.x,
+ y: view.y,
+ k: null
+ };
+ scaleTo(+_);
+ rescale();
+ return zoom;
+ };
+ zoom.scaleExtent = function(_) {
+ if (!arguments.length) return scaleExtent;
+ scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.center = function(_) {
+ if (!arguments.length) return center;
+ center = _ && [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.size = function(_) {
+ if (!arguments.length) return size;
+ size = _ && [ +_[0], +_[1] ];
+ return zoom;
+ };
+ zoom.duration = function(_) {
+ if (!arguments.length) return duration;
+ duration = +_;
+ return zoom;
+ };
+ zoom.x = function(z) {
+ if (!arguments.length) return x1;
+ x1 = z;
+ x0 = z.copy();
+ view = {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ return zoom;
+ };
+ zoom.y = function(z) {
+ if (!arguments.length) return y1;
+ y1 = z;
+ y0 = z.copy();
+ view = {
+ x: 0,
+ y: 0,
+ k: 1
+ };
+ return zoom;
+ };
+ function location(p) {
+ return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ];
+ }
+ function point(l) {
+ return [ l[0] * view.k + view.x, l[1] * view.k + view.y ];
+ }
+ function scaleTo(s) {
+ view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s));
+ }
+ function translateTo(p, l) {
+ l = point(l);
+ view.x += p[0] - l[0];
+ view.y += p[1] - l[1];
+ }
+ function zoomTo(that, p, l, k) {
+ that.__chart__ = {
+ x: view.x,
+ y: view.y,
+ k: view.k
+ };
+ scaleTo(Math.pow(2, k));
+ translateTo(center0 = p, l);
+ that = d3.select(that);
+ if (duration > 0) that = that.transition().duration(duration);
+ that.call(zoom.event);
+ }
+ function rescale() {
+ if (x1) x1.domain(x0.range().map(function(x) {
+ return (x - view.x) / view.k;
+ }).map(x0.invert));
+ if (y1) y1.domain(y0.range().map(function(y) {
+ return (y - view.y) / view.k;
+ }).map(y0.invert));
+ }
+ function zoomstarted(dispatch) {
+ if (!zooming++) dispatch({
+ type: "zoomstart"
+ });
+ }
+ function zoomed(dispatch) {
+ rescale();
+ dispatch({
+ type: "zoom",
+ scale: view.k,
+ translate: [ view.x, view.y ]
+ });
+ }
+ function zoomended(dispatch) {
+ if (!--zooming) dispatch({
+ type: "zoomend"
+ }), center0 = null;
+ }
+ function mousedowned() {
+ var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that);
+ d3_selection_interrupt.call(that);
+ zoomstarted(dispatch);
+ function moved() {
+ dragged = 1;
+ translateTo(d3.mouse(that), location0);
+ zoomed(dispatch);
+ }
+ function ended() {
+ subject.on(mousemove, null).on(mouseup, null);
+ dragRestore(dragged);
+ zoomended(dispatch);
+ }
+ }
+ function touchstarted() {
+ var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that);
+ started();
+ zoomstarted(dispatch);
+ subject.on(mousedown, null).on(touchstart, started);
+ function relocate() {
+ var touches = d3.touches(that);
+ scale0 = view.k;
+ touches.forEach(function(t) {
+ if (t.identifier in locations0) locations0[t.identifier] = location(t);
+ });
+ return touches;
+ }
+ function started() {
+ var target = d3.event.target;
+ d3.select(target).on(touchmove, moved).on(touchend, ended);
+ targets.push(target);
+ var changed = d3.event.changedTouches;
+ for (var i = 0, n = changed.length; i < n; ++i) {
+ locations0[changed[i].identifier] = null;
+ }
+ var touches = relocate(), now = Date.now();
+ if (touches.length === 1) {
+ if (now - touchtime < 500) {
+ var p = touches[0];
+ zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1);
+ d3_eventPreventDefault();
+ }
+ touchtime = now;
+ } else if (touches.length > 1) {
+ var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1];
+ distance0 = dx * dx + dy * dy;
+ }
+ }
+ function moved() {
+ var touches = d3.touches(that), p0, l0, p1, l1;
+ d3_selection_interrupt.call(that);
+ for (var i = 0, n = touches.length; i < n; ++i, l1 = null) {
+ p1 = touches[i];
+ if (l1 = locations0[p1.identifier]) {
+ if (l0) break;
+ p0 = p1, l0 = l1;
+ }
+ }
+ if (l1) {
+ var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0);
+ p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ];
+ l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ];
+ scaleTo(scale1 * scale0);
+ }
+ touchtime = null;
+ translateTo(p0, l0);
+ zoomed(dispatch);
+ }
+ function ended() {
+ if (d3.event.touches.length) {
+ var changed = d3.event.changedTouches;
+ for (var i = 0, n = changed.length; i < n; ++i) {
+ delete locations0[changed[i].identifier];
+ }
+ for (var identifier in locations0) {
+ return void relocate();
+ }
+ }
+ d3.selectAll(targets).on(zoomName, null);
+ subject.on(mousedown, mousedowned).on(touchstart, touchstarted);
+ dragRestore();
+ zoomended(dispatch);
+ }
+ }
+ function mousewheeled() {
+ var dispatch = event.of(this, arguments);
+ if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this),
+ translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch);
+ mousewheelTimer = setTimeout(function() {
+ mousewheelTimer = null;
+ zoomended(dispatch);
+ }, 50);
+ d3_eventPreventDefault();
+ scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k);
+ translateTo(center0, translate0);
+ zoomed(dispatch);
+ }
+ function dblclicked() {
+ var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2;
+ zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1);
+ }
+ return d3.rebind(zoom, event, "on");
+ };
+ var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel;
+ d3.color = d3_color;
+ function d3_color() {}
+ d3_color.prototype.toString = function() {
+ return this.rgb() + "";
+ };
+ d3.hsl = d3_hsl;
+ function d3_hsl(h, s, l) {
+ return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l);
+ }
+ var d3_hslPrototype = d3_hsl.prototype = new d3_color();
+ d3_hslPrototype.brighter = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_hsl(this.h, this.s, this.l / k);
+ };
+ d3_hslPrototype.darker = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_hsl(this.h, this.s, k * this.l);
+ };
+ d3_hslPrototype.rgb = function() {
+ return d3_hsl_rgb(this.h, this.s, this.l);
+ };
+ function d3_hsl_rgb(h, s, l) {
+ var m1, m2;
+ h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h;
+ s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s;
+ l = l < 0 ? 0 : l > 1 ? 1 : l;
+ m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
+ m1 = 2 * l - m2;
+ function v(h) {
+ if (h > 360) h -= 360; else if (h < 0) h += 360;
+ if (h < 60) return m1 + (m2 - m1) * h / 60;
+ if (h < 180) return m2;
+ if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
+ return m1;
+ }
+ function vv(h) {
+ return Math.round(v(h) * 255);
+ }
+ return new d3_rgb(vv(h + 120), vv(h), vv(h - 120));
+ }
+ d3.hcl = d3_hcl;
+ function d3_hcl(h, c, l) {
+ return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l);
+ }
+ var d3_hclPrototype = d3_hcl.prototype = new d3_color();
+ d3_hclPrototype.brighter = function(k) {
+ return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)));
+ };
+ d3_hclPrototype.darker = function(k) {
+ return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)));
+ };
+ d3_hclPrototype.rgb = function() {
+ return d3_hcl_lab(this.h, this.c, this.l).rgb();
+ };
+ function d3_hcl_lab(h, c, l) {
+ if (isNaN(h)) h = 0;
+ if (isNaN(c)) c = 0;
+ return new d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c);
+ }
+ d3.lab = d3_lab;
+ function d3_lab(l, a, b) {
+ return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b);
+ }
+ var d3_lab_K = 18;
+ var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883;
+ var d3_labPrototype = d3_lab.prototype = new d3_color();
+ d3_labPrototype.brighter = function(k) {
+ return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+ };
+ d3_labPrototype.darker = function(k) {
+ return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b);
+ };
+ d3_labPrototype.rgb = function() {
+ return d3_lab_rgb(this.l, this.a, this.b);
+ };
+ function d3_lab_rgb(l, a, b) {
+ var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
+ x = d3_lab_xyz(x) * d3_lab_X;
+ y = d3_lab_xyz(y) * d3_lab_Y;
+ z = d3_lab_xyz(z) * d3_lab_Z;
+ return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z));
+ }
+ function d3_lab_hcl(l, a, b) {
+ return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l);
+ }
+ function d3_lab_xyz(x) {
+ return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
+ }
+ function d3_xyz_lab(x) {
+ return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+ }
+ function d3_xyz_rgb(r) {
+ return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055));
+ }
+ d3.rgb = d3_rgb;
+ function d3_rgb(r, g, b) {
+ return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b);
+ }
+ function d3_rgbNumber(value) {
+ return new d3_rgb(value >> 16, value >> 8 & 255, value & 255);
+ }
+ function d3_rgbString(value) {
+ return d3_rgbNumber(value) + "";
+ }
+ var d3_rgbPrototype = d3_rgb.prototype = new d3_color();
+ d3_rgbPrototype.brighter = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ var r = this.r, g = this.g, b = this.b, i = 30;
+ if (!r && !g && !b) return new d3_rgb(i, i, i);
+ if (r && r < i) r = i;
+ if (g && g < i) g = i;
+ if (b && b < i) b = i;
+ return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k));
+ };
+ d3_rgbPrototype.darker = function(k) {
+ k = Math.pow(.7, arguments.length ? k : 1);
+ return new d3_rgb(k * this.r, k * this.g, k * this.b);
+ };
+ d3_rgbPrototype.hsl = function() {
+ return d3_rgb_hsl(this.r, this.g, this.b);
+ };
+ d3_rgbPrototype.toString = function() {
+ return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
+ };
+ function d3_rgb_hex(v) {
+ return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16);
+ }
+ function d3_rgb_parse(format, rgb, hsl) {
+ var r = 0, g = 0, b = 0, m1, m2, color;
+ m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase());
+ if (m1) {
+ m2 = m1[2].split(",");
+ switch (m1[1]) {
+ case "hsl":
+ {
+ return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100);
+ }
+
+ case "rgb":
+ {
+ return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]));
+ }
+ }
+ }
+ if (color = d3_rgb_names.get(format)) {
+ return rgb(color.r, color.g, color.b);
+ }
+ if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) {
+ if (format.length === 4) {
+ r = (color & 3840) >> 4;
+ r = r >> 4 | r;
+ g = color & 240;
+ g = g >> 4 | g;
+ b = color & 15;
+ b = b << 4 | b;
+ } else if (format.length === 7) {
+ r = (color & 16711680) >> 16;
+ g = (color & 65280) >> 8;
+ b = color & 255;
+ }
+ }
+ return rgb(r, g, b);
+ }
+ function d3_rgb_hsl(r, g, b) {
+ var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2;
+ if (d) {
+ s = l < .5 ? d / (max + min) : d / (2 - max - min);
+ if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4;
+ h *= 60;
+ } else {
+ h = NaN;
+ s = l > 0 && l < 1 ? 0 : h;
+ }
+ return new d3_hsl(h, s, l);
+ }
+ function d3_rgb_lab(r, g, b) {
+ r = d3_rgb_xyz(r);
+ g = d3_rgb_xyz(g);
+ b = d3_rgb_xyz(b);
+ var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z);
+ return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
+ }
+ function d3_rgb_xyz(r) {
+ return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4);
+ }
+ function d3_rgb_parseNumber(c) {
+ var f = parseFloat(c);
+ return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
+ }
+ var d3_rgb_names = d3.map({
+ aliceblue: 15792383,
+ antiquewhite: 16444375,
+ aqua: 65535,
+ aquamarine: 8388564,
+ azure: 15794175,
+ beige: 16119260,
+ bisque: 16770244,
+ black: 0,
+ blanchedalmond: 16772045,
+ blue: 255,
+ blueviolet: 9055202,
+ brown: 10824234,
+ burlywood: 14596231,
+ cadetblue: 6266528,
+ chartreuse: 8388352,
+ chocolate: 13789470,
+ coral: 16744272,
+ cornflowerblue: 6591981,
+ cornsilk: 16775388,
+ crimson: 14423100,
+ cyan: 65535,
+ darkblue: 139,
+ darkcyan: 35723,
+ darkgoldenrod: 12092939,
+ darkgray: 11119017,
+ darkgreen: 25600,
+ darkgrey: 11119017,
+ darkkhaki: 12433259,
+ darkmagenta: 9109643,
+ darkolivegreen: 5597999,
+ darkorange: 16747520,
+ darkorchid: 10040012,
+ darkred: 9109504,
+ darksalmon: 15308410,
+ darkseagreen: 9419919,
+ darkslateblue: 4734347,
+ darkslategray: 3100495,
+ darkslategrey: 3100495,
+ darkturquoise: 52945,
+ darkviolet: 9699539,
+ deeppink: 16716947,
+ deepskyblue: 49151,
+ dimgray: 6908265,
+ dimgrey: 6908265,
+ dodgerblue: 2003199,
+ firebrick: 11674146,
+ floralwhite: 16775920,
+ forestgreen: 2263842,
+ fuchsia: 16711935,
+ gainsboro: 14474460,
+ ghostwhite: 16316671,
+ gold: 16766720,
+ goldenrod: 14329120,
+ gray: 8421504,
+ green: 32768,
+ greenyellow: 11403055,
+ grey: 8421504,
+ honeydew: 15794160,
+ hotpink: 16738740,
+ indianred: 13458524,
+ indigo: 4915330,
+ ivory: 16777200,
+ khaki: 15787660,
+ lavender: 15132410,
+ lavenderblush: 16773365,
+ lawngreen: 8190976,
+ lemonchiffon: 16775885,
+ lightblue: 11393254,
+ lightcoral: 15761536,
+ lightcyan: 14745599,
+ lightgoldenrodyellow: 16448210,
+ lightgray: 13882323,
+ lightgreen: 9498256,
+ lightgrey: 13882323,
+ lightpink: 16758465,
+ lightsalmon: 16752762,
+ lightseagreen: 2142890,
+ lightskyblue: 8900346,
+ lightslategray: 7833753,
+ lightslategrey: 7833753,
+ lightsteelblue: 11584734,
+ lightyellow: 16777184,
+ lime: 65280,
+ limegreen: 3329330,
+ linen: 16445670,
+ magenta: 16711935,
+ maroon: 8388608,
+ mediumaquamarine: 6737322,
+ mediumblue: 205,
+ mediumorchid: 12211667,
+ mediumpurple: 9662683,
+ mediumseagreen: 3978097,
+ mediumslateblue: 8087790,
+ mediumspringgreen: 64154,
+ mediumturquoise: 4772300,
+ mediumvioletred: 13047173,
+ midnightblue: 1644912,
+ mintcream: 16121850,
+ mistyrose: 16770273,
+ moccasin: 16770229,
+ navajowhite: 16768685,
+ navy: 128,
+ oldlace: 16643558,
+ olive: 8421376,
+ olivedrab: 7048739,
+ orange: 16753920,
+ orangered: 16729344,
+ orchid: 14315734,
+ palegoldenrod: 15657130,
+ palegreen: 10025880,
+ paleturquoise: 11529966,
+ palevioletred: 14381203,
+ papayawhip: 16773077,
+ peachpuff: 16767673,
+ peru: 13468991,
+ pink: 16761035,
+ plum: 14524637,
+ powderblue: 11591910,
+ purple: 8388736,
+ rebeccapurple: 6697881,
+ red: 16711680,
+ rosybrown: 12357519,
+ royalblue: 4286945,
+ saddlebrown: 9127187,
+ salmon: 16416882,
+ sandybrown: 16032864,
+ seagreen: 3050327,
+ seashell: 16774638,
+ sienna: 10506797,
+ silver: 12632256,
+ skyblue: 8900331,
+ slateblue: 6970061,
+ slategray: 7372944,
+ slategrey: 7372944,
+ snow: 16775930,
+ springgreen: 65407,
+ steelblue: 4620980,
+ tan: 13808780,
+ teal: 32896,
+ thistle: 14204888,
+ tomato: 16737095,
+ turquoise: 4251856,
+ violet: 15631086,
+ wheat: 16113331,
+ white: 16777215,
+ whitesmoke: 16119285,
+ yellow: 16776960,
+ yellowgreen: 10145074
+ });
+ d3_rgb_names.forEach(function(key, value) {
+ d3_rgb_names.set(key, d3_rgbNumber(value));
+ });
+ function d3_functor(v) {
+ return typeof v === "function" ? v : function() {
+ return v;
+ };
+ }
+ d3.functor = d3_functor;
+ d3.xhr = d3_xhrType(d3_identity);
+ function d3_xhrType(response) {
+ return function(url, mimeType, callback) {
+ if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType,
+ mimeType = null;
+ return d3_xhr(url, mimeType, response, callback);
+ };
+ }
+ function d3_xhr(url, mimeType, response, callback) {
+ var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null;
+ if (this.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
+ "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() {
+ request.readyState > 3 && respond();
+ };
+ function respond() {
+ var status = request.status, result;
+ if (!status && d3_xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
+ try {
+ result = response.call(xhr, request);
+ } catch (e) {
+ dispatch.error.call(xhr, e);
+ return;
+ }
+ dispatch.load.call(xhr, result);
+ } else {
+ dispatch.error.call(xhr, request);
+ }
+ }
+ request.onprogress = function(event) {
+ var o = d3.event;
+ d3.event = event;
+ try {
+ dispatch.progress.call(xhr, request);
+ } finally {
+ d3.event = o;
+ }
+ };
+ xhr.header = function(name, value) {
+ name = (name + "").toLowerCase();
+ if (arguments.length < 2) return headers[name];
+ if (value == null) delete headers[name]; else headers[name] = value + "";
+ return xhr;
+ };
+ xhr.mimeType = function(value) {
+ if (!arguments.length) return mimeType;
+ mimeType = value == null ? null : value + "";
+ return xhr;
+ };
+ xhr.responseType = function(value) {
+ if (!arguments.length) return responseType;
+ responseType = value;
+ return xhr;
+ };
+ xhr.response = function(value) {
+ response = value;
+ return xhr;
+ };
+ [ "get", "post" ].forEach(function(method) {
+ xhr[method] = function() {
+ return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));
+ };
+ });
+ xhr.send = function(method, data, callback) {
+ if (arguments.length === 2 && typeof data === "function") callback = data, data = null;
+ request.open(method, url, true);
+ if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*";
+ if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]);
+ if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType);
+ if (responseType != null) request.responseType = responseType;
+ if (callback != null) xhr.on("error", callback).on("load", function(request) {
+ callback(null, request);
+ });
+ dispatch.beforesend.call(xhr, request);
+ request.send(data == null ? null : data);
+ return xhr;
+ };
+ xhr.abort = function() {
+ request.abort();
+ return xhr;
+ };
+ d3.rebind(xhr, dispatch, "on");
+ return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback));
+ }
+ function d3_xhr_fixCallback(callback) {
+ return callback.length === 1 ? function(error, request) {
+ callback(error == null ? request : null);
+ } : callback;
+ }
+ function d3_xhrHasResponse(request) {
+ var type = request.responseType;
+ return type && type !== "text" ? request.response : request.responseText;
+ }
+ d3.dsv = function(delimiter, mimeType) {
+ var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0);
+ function dsv(url, row, callback) {
+ if (arguments.length < 3) callback = row, row = null;
+ var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback);
+ xhr.row = function(_) {
+ return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row;
+ };
+ return xhr;
+ }
+ function response(request) {
+ return dsv.parse(request.responseText);
+ }
+ function typedResponse(f) {
+ return function(request) {
+ return dsv.parse(request.responseText, f);
+ };
+ }
+ dsv.parse = function(text, f) {
+ var o;
+ return dsv.parseRows(text, function(row, i) {
+ if (o) return o(row, i - 1);
+ var a = new Function("d", "return {" + row.map(function(name, i) {
+ return JSON.stringify(name) + ": d[" + i + "]";
+ }).join(",") + "}");
+ o = f ? function(row, i) {
+ return f(a(row), i);
+ } : a;
+ });
+ };
+ dsv.parseRows = function(text, f) {
+ var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol;
+ function token() {
+ if (I >= N) return EOF;
+ if (eol) return eol = false, EOL;
+ var j = I;
+ if (text.charCodeAt(j) === 34) {
+ var i = j;
+ while (i++ < N) {
+ if (text.charCodeAt(i) === 34) {
+ if (text.charCodeAt(i + 1) !== 34) break;
+ ++i;
+ }
+ }
+ I = i + 2;
+ var c = text.charCodeAt(i + 1);
+ if (c === 13) {
+ eol = true;
+ if (text.charCodeAt(i + 2) === 10) ++I;
+ } else if (c === 10) {
+ eol = true;
+ }
+ return text.slice(j + 1, i).replace(/""/g, '"');
+ }
+ while (I < N) {
+ var c = text.charCodeAt(I++), k = 1;
+ if (c === 10) eol = true; else if (c === 13) {
+ eol = true;
+ if (text.charCodeAt(I) === 10) ++I, ++k;
+ } else if (c !== delimiterCode) continue;
+ return text.slice(j, I - k);
+ }
+ return text.slice(j);
+ }
+ while ((t = token()) !== EOF) {
+ var a = [];
+ while (t !== EOL && t !== EOF) {
+ a.push(t);
+ t = token();
+ }
+ if (f && (a = f(a, n++)) == null) continue;
+ rows.push(a);
+ }
+ return rows;
+ };
+ dsv.format = function(rows) {
+ if (Array.isArray(rows[0])) return dsv.formatRows(rows);
+ var fieldSet = new d3_Set(), fields = [];
+ rows.forEach(function(row) {
+ for (var field in row) {
+ if (!fieldSet.has(field)) {
+ fields.push(fieldSet.add(field));
+ }
+ }
+ });
+ return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) {
+ return fields.map(function(field) {
+ return formatValue(row[field]);
+ }).join(delimiter);
+ })).join("\n");
+ };
+ dsv.formatRows = function(rows) {
+ return rows.map(formatRow).join("\n");
+ };
+ function formatRow(row) {
+ return row.map(formatValue).join(delimiter);
+ }
+ function formatValue(text) {
+ return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text;
+ }
+ return dsv;
+ };
+ d3.csv = d3.dsv(",", "text/csv");
+ d3.tsv = d3.dsv(" ", "text/tab-separated-values");
+ var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_frame = this[d3_vendorSymbol(this, "requestAnimationFrame")] || function(callback) {
+ setTimeout(callback, 17);
+ };
+ d3.timer = function() {
+ d3_timer.apply(this, arguments);
+ };
+ function d3_timer(callback, delay, then) {
+ var n = arguments.length;
+ if (n < 2) delay = 0;
+ if (n < 3) then = Date.now();
+ var time = then + delay, timer = {
+ c: callback,
+ t: time,
+ n: null
+ };
+ if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer;
+ d3_timer_queueTail = timer;
+ if (!d3_timer_interval) {
+ d3_timer_timeout = clearTimeout(d3_timer_timeout);
+ d3_timer_interval = 1;
+ d3_timer_frame(d3_timer_step);
+ }
+ return timer;
+ }
+ function d3_timer_step() {
+ var now = d3_timer_mark(), delay = d3_timer_sweep() - now;
+ if (delay > 24) {
+ if (isFinite(delay)) {
+ clearTimeout(d3_timer_timeout);
+ d3_timer_timeout = setTimeout(d3_timer_step, delay);
+ }
+ d3_timer_interval = 0;
+ } else {
+ d3_timer_interval = 1;
+ d3_timer_frame(d3_timer_step);
+ }
+ }
+ d3.timer.flush = function() {
+ d3_timer_mark();
+ d3_timer_sweep();
+ };
+ function d3_timer_mark() {
+ var now = Date.now(), timer = d3_timer_queueHead;
+ while (timer) {
+ if (now >= timer.t && timer.c(now - timer.t)) timer.c = null;
+ timer = timer.n;
+ }
+ return now;
+ }
+ function d3_timer_sweep() {
+ var t0, t1 = d3_timer_queueHead, time = Infinity;
+ while (t1) {
+ if (t1.c) {
+ if (t1.t < time) time = t1.t;
+ t1 = (t0 = t1).n;
+ } else {
+ t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n;
+ }
+ }
+ d3_timer_queueTail = t0;
+ return time;
+ }
+ function d3_format_precision(x, p) {
+ return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1);
+ }
+ d3.round = function(x, n) {
+ return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x);
+ };
+ var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix);
+ d3.formatPrefix = function(value, precision) {
+ var i = 0;
+ if (value = +value) {
+ if (value < 0) value *= -1;
+ if (precision) value = d3.round(value, d3_format_precision(value, precision));
+ i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10);
+ i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3));
+ }
+ return d3_formatPrefixes[8 + i / 3];
+ };
+ function d3_formatPrefix(d, i) {
+ var k = Math.pow(10, abs(8 - i) * 3);
+ return {
+ scale: i > 8 ? function(d) {
+ return d / k;
+ } : function(d) {
+ return d * k;
+ },
+ symbol: d
+ };
+ }
+ function d3_locale_numberFormat(locale) {
+ var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping && locale_thousands ? function(value, width) {
+ var i = value.length, t = [], j = 0, g = locale_grouping[0], length = 0;
+ while (i > 0 && g > 0) {
+ if (length + g + 1 > width) g = Math.max(1, width - length);
+ t.push(value.substring(i -= g, i + g));
+ if ((length += g + 1) > width) break;
+ g = locale_grouping[j = (j + 1) % locale_grouping.length];
+ }
+ return t.reverse().join(locale_thousands);
+ } : d3_identity;
+ return function(specifier) {
+ var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "-", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false, exponent = true;
+ if (precision) precision = +precision.substring(1);
+ if (zfill || fill === "0" && align === "=") {
+ zfill = fill = "0";
+ align = "=";
+ }
+ switch (type) {
+ case "n":
+ comma = true;
+ type = "g";
+ break;
+
+ case "%":
+ scale = 100;
+ suffix = "%";
+ type = "f";
+ break;
+
+ case "p":
+ scale = 100;
+ suffix = "%";
+ type = "r";
+ break;
+
+ case "b":
+ case "o":
+ case "x":
+ case "X":
+ if (symbol === "#") prefix = "0" + type.toLowerCase();
+
+ case "c":
+ exponent = false;
+
+ case "d":
+ integer = true;
+ precision = 0;
+ break;
+
+ case "s":
+ scale = -1;
+ type = "r";
+ break;
+ }
+ if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1];
+ if (type == "r" && !precision) type = "g";
+ if (precision != null) {
+ if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision));
+ }
+ type = d3_format_types.get(type) || d3_format_typeDefault;
+ var zcomma = zfill && comma;
+ return function(value) {
+ var fullSuffix = suffix;
+ if (integer && value % 1) return "";
+ var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign === "-" ? "" : sign;
+ if (scale < 0) {
+ var unit = d3.formatPrefix(value, precision);
+ value = unit.scale(value);
+ fullSuffix = unit.symbol + suffix;
+ } else {
+ value *= scale;
+ }
+ value = type(value, precision);
+ var i = value.lastIndexOf("."), before, after;
+ if (i < 0) {
+ var j = exponent ? value.lastIndexOf("e") : -1;
+ if (j < 0) before = value, after = ""; else before = value.substring(0, j), after = value.substring(j);
+ } else {
+ before = value.substring(0, i);
+ after = locale_decimal + value.substring(i + 1);
+ }
+ if (!zfill && comma) before = formatGroup(before, Infinity);
+ var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";
+ if (zcomma) before = formatGroup(padding + before, padding.length ? width - after.length : Infinity);
+ negative += prefix;
+ value = before + after;
+ return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix;
+ };
+ };
+ }
+ var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i;
+ var d3_format_types = d3.map({
+ b: function(x) {
+ return x.toString(2);
+ },
+ c: function(x) {
+ return String.fromCharCode(x);
+ },
+ o: function(x) {
+ return x.toString(8);
+ },
+ x: function(x) {
+ return x.toString(16);
+ },
+ X: function(x) {
+ return x.toString(16).toUpperCase();
+ },
+ g: function(x, p) {
+ return x.toPrecision(p);
+ },
+ e: function(x, p) {
+ return x.toExponential(p);
+ },
+ f: function(x, p) {
+ return x.toFixed(p);
+ },
+ r: function(x, p) {
+ return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p))));
+ }
+ });
+ function d3_format_typeDefault(x) {
+ return x + "";
+ }
+ var d3_time = d3.time = {}, d3_date = Date;
+ function d3_date_utc() {
+ this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]);
+ }
+ d3_date_utc.prototype = {
+ getDate: function() {
+ return this._.getUTCDate();
+ },
+ getDay: function() {
+ return this._.getUTCDay();
+ },
+ getFullYear: function() {
+ return this._.getUTCFullYear();
+ },
+ getHours: function() {
+ return this._.getUTCHours();
+ },
+ getMilliseconds: function() {
+ return this._.getUTCMilliseconds();
+ },
+ getMinutes: function() {
+ return this._.getUTCMinutes();
+ },
+ getMonth: function() {
+ return this._.getUTCMonth();
+ },
+ getSeconds: function() {
+ return this._.getUTCSeconds();
+ },
+ getTime: function() {
+ return this._.getTime();
+ },
+ getTimezoneOffset: function() {
+ return 0;
+ },
+ valueOf: function() {
+ return this._.valueOf();
+ },
+ setDate: function() {
+ d3_time_prototype.setUTCDate.apply(this._, arguments);
+ },
+ setDay: function() {
+ d3_time_prototype.setUTCDay.apply(this._, arguments);
+ },
+ setFullYear: function() {
+ d3_time_prototype.setUTCFullYear.apply(this._, arguments);
+ },
+ setHours: function() {
+ d3_time_prototype.setUTCHours.apply(this._, arguments);
+ },
+ setMilliseconds: function() {
+ d3_time_prototype.setUTCMilliseconds.apply(this._, arguments);
+ },
+ setMinutes: function() {
+ d3_time_prototype.setUTCMinutes.apply(this._, arguments);
+ },
+ setMonth: function() {
+ d3_time_prototype.setUTCMonth.apply(this._, arguments);
+ },
+ setSeconds: function() {
+ d3_time_prototype.setUTCSeconds.apply(this._, arguments);
+ },
+ setTime: function() {
+ d3_time_prototype.setTime.apply(this._, arguments);
+ }
+ };
+ var d3_time_prototype = Date.prototype;
+ function d3_time_interval(local, step, number) {
+ function round(date) {
+ var d0 = local(date), d1 = offset(d0, 1);
+ return date - d0 < d1 - date ? d0 : d1;
+ }
+ function ceil(date) {
+ step(date = local(new d3_date(date - 1)), 1);
+ return date;
+ }
+ function offset(date, k) {
+ step(date = new d3_date(+date), k);
+ return date;
+ }
+ function range(t0, t1, dt) {
+ var time = ceil(t0), times = [];
+ if (dt > 1) {
+ while (time < t1) {
+ if (!(number(time) % dt)) times.push(new Date(+time));
+ step(time, 1);
+ }
+ } else {
+ while (time < t1) times.push(new Date(+time)), step(time, 1);
+ }
+ return times;
+ }
+ function range_utc(t0, t1, dt) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date_utc();
+ utc._ = t0;
+ return range(utc, t1, dt);
+ } finally {
+ d3_date = Date;
+ }
+ }
+ local.floor = local;
+ local.round = round;
+ local.ceil = ceil;
+ local.offset = offset;
+ local.range = range;
+ var utc = local.utc = d3_time_interval_utc(local);
+ utc.floor = utc;
+ utc.round = d3_time_interval_utc(round);
+ utc.ceil = d3_time_interval_utc(ceil);
+ utc.offset = d3_time_interval_utc(offset);
+ utc.range = range_utc;
+ return local;
+ }
+ function d3_time_interval_utc(method) {
+ return function(date, k) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date_utc();
+ utc._ = date;
+ return method(utc, k)._;
+ } finally {
+ d3_date = Date;
+ }
+ };
+ }
+ d3_time.year = d3_time_interval(function(date) {
+ date = d3_time.day(date);
+ date.setMonth(0, 1);
+ return date;
+ }, function(date, offset) {
+ date.setFullYear(date.getFullYear() + offset);
+ }, function(date) {
+ return date.getFullYear();
+ });
+ d3_time.years = d3_time.year.range;
+ d3_time.years.utc = d3_time.year.utc.range;
+ d3_time.day = d3_time_interval(function(date) {
+ var day = new d3_date(2e3, 0);
+ day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+ return day;
+ }, function(date, offset) {
+ date.setDate(date.getDate() + offset);
+ }, function(date) {
+ return date.getDate() - 1;
+ });
+ d3_time.days = d3_time.day.range;
+ d3_time.days.utc = d3_time.day.utc.range;
+ d3_time.dayOfYear = function(date) {
+ var year = d3_time.year(date);
+ return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5);
+ };
+ [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) {
+ i = 7 - i;
+ var interval = d3_time[day] = d3_time_interval(function(date) {
+ (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7);
+ return date;
+ }, function(date, offset) {
+ date.setDate(date.getDate() + Math.floor(offset) * 7);
+ }, function(date) {
+ var day = d3_time.year(date).getDay();
+ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i);
+ });
+ d3_time[day + "s"] = interval.range;
+ d3_time[day + "s"].utc = interval.utc.range;
+ d3_time[day + "OfYear"] = function(date) {
+ var day = d3_time.year(date).getDay();
+ return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7);
+ };
+ });
+ d3_time.week = d3_time.sunday;
+ d3_time.weeks = d3_time.sunday.range;
+ d3_time.weeks.utc = d3_time.sunday.utc.range;
+ d3_time.weekOfYear = d3_time.sundayOfYear;
+ function d3_locale_timeFormat(locale) {
+ var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths;
+ function d3_time_format(template) {
+ var n = template.length;
+ function format(date) {
+ var string = [], i = -1, j = 0, c, p, f;
+ while (++i < n) {
+ if (template.charCodeAt(i) === 37) {
+ string.push(template.slice(j, i));
+ if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i);
+ if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p);
+ string.push(c);
+ j = i + 1;
+ }
+ }
+ string.push(template.slice(j, i));
+ return string.join("");
+ }
+ format.parse = function(string) {
+ var d = {
+ y: 1900,
+ m: 0,
+ d: 1,
+ H: 0,
+ M: 0,
+ S: 0,
+ L: 0,
+ Z: null
+ }, i = d3_time_parse(d, template, string, 0);
+ if (i != string.length) return null;
+ if ("p" in d) d.H = d.H % 12 + d.p * 12;
+ var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)();
+ if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("W" in d || "U" in d) {
+ if (!("w" in d)) d.w = "W" in d ? 1 : 0;
+ date.setFullYear(d.y, 0, 1);
+ date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7);
+ } else date.setFullYear(d.y, d.m, d.d);
+ date.setHours(d.H + (d.Z / 100 | 0), d.M + d.Z % 100, d.S, d.L);
+ return localZ ? date._ : date;
+ };
+ format.toString = function() {
+ return template;
+ };
+ return format;
+ }
+ function d3_time_parse(date, template, string, j) {
+ var c, p, t, i = 0, n = template.length, m = string.length;
+ while (i < n) {
+ if (j >= m) return -1;
+ c = template.charCodeAt(i++);
+ if (c === 37) {
+ t = template.charAt(i++);
+ p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t];
+ if (!p || (j = p(date, string, j)) < 0) return -1;
+ } else if (c != string.charCodeAt(j++)) {
+ return -1;
+ }
+ }
+ return j;
+ }
+ d3_time_format.utc = function(template) {
+ var local = d3_time_format(template);
+ function format(date) {
+ try {
+ d3_date = d3_date_utc;
+ var utc = new d3_date();
+ utc._ = date;
+ return local(utc);
+ } finally {
+ d3_date = Date;
+ }
+ }
+ format.parse = function(string) {
+ try {
+ d3_date = d3_date_utc;
+ var date = local.parse(string);
+ return date && date._;
+ } finally {
+ d3_date = Date;
+ }
+ };
+ format.toString = local.toString;
+ return format;
+ };
+ d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti;
+ var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths);
+ locale_periods.forEach(function(p, i) {
+ d3_time_periodLookup.set(p.toLowerCase(), i);
+ });
+ var d3_time_formats = {
+ a: function(d) {
+ return locale_shortDays[d.getDay()];
+ },
+ A: function(d) {
+ return locale_days[d.getDay()];
+ },
+ b: function(d) {
+ return locale_shortMonths[d.getMonth()];
+ },
+ B: function(d) {
+ return locale_months[d.getMonth()];
+ },
+ c: d3_time_format(locale_dateTime),
+ d: function(d, p) {
+ return d3_time_formatPad(d.getDate(), p, 2);
+ },
+ e: function(d, p) {
+ return d3_time_formatPad(d.getDate(), p, 2);
+ },
+ H: function(d, p) {
+ return d3_time_formatPad(d.getHours(), p, 2);
+ },
+ I: function(d, p) {
+ return d3_time_formatPad(d.getHours() % 12 || 12, p, 2);
+ },
+ j: function(d, p) {
+ return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3);
+ },
+ L: function(d, p) {
+ return d3_time_formatPad(d.getMilliseconds(), p, 3);
+ },
+ m: function(d, p) {
+ return d3_time_formatPad(d.getMonth() + 1, p, 2);
+ },
+ M: function(d, p) {
+ return d3_time_formatPad(d.getMinutes(), p, 2);
+ },
+ p: function(d) {
+ return locale_periods[+(d.getHours() >= 12)];
+ },
+ S: function(d, p) {
+ return d3_time_formatPad(d.getSeconds(), p, 2);
+ },
+ U: function(d, p) {
+ return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2);
+ },
+ w: function(d) {
+ return d.getDay();
+ },
+ W: function(d, p) {
+ return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2);
+ },
+ x: d3_time_format(locale_date),
+ X: d3_time_format(locale_time),
+ y: function(d, p) {
+ return d3_time_formatPad(d.getFullYear() % 100, p, 2);
+ },
+ Y: function(d, p) {
+ return d3_time_formatPad(d.getFullYear() % 1e4, p, 4);
+ },
+ Z: d3_time_zone,
+ "%": function() {
+ return "%";
+ }
+ };
+ var d3_time_parsers = {
+ a: d3_time_parseWeekdayAbbrev,
+ A: d3_time_parseWeekday,
+ b: d3_time_parseMonthAbbrev,
+ B: d3_time_parseMonth,
+ c: d3_time_parseLocaleFull,
+ d: d3_time_parseDay,
+ e: d3_time_parseDay,
+ H: d3_time_parseHour24,
+ I: d3_time_parseHour24,
+ j: d3_time_parseDayOfYear,
+ L: d3_time_parseMilliseconds,
+ m: d3_time_parseMonthNumber,
+ M: d3_time_parseMinutes,
+ p: d3_time_parseAmPm,
+ S: d3_time_parseSeconds,
+ U: d3_time_parseWeekNumberSunday,
+ w: d3_time_parseWeekdayNumber,
+ W: d3_time_parseWeekNumberMonday,
+ x: d3_time_parseLocaleDate,
+ X: d3_time_parseLocaleTime,
+ y: d3_time_parseYear,
+ Y: d3_time_parseFullYear,
+ Z: d3_time_parseZone,
+ "%": d3_time_parseLiteralPercent
+ };
+ function d3_time_parseWeekdayAbbrev(date, string, i) {
+ d3_time_dayAbbrevRe.lastIndex = 0;
+ var n = d3_time_dayAbbrevRe.exec(string.slice(i));
+ return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekday(date, string, i) {
+ d3_time_dayRe.lastIndex = 0;
+ var n = d3_time_dayRe.exec(string.slice(i));
+ return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseMonthAbbrev(date, string, i) {
+ d3_time_monthAbbrevRe.lastIndex = 0;
+ var n = d3_time_monthAbbrevRe.exec(string.slice(i));
+ return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseMonth(date, string, i) {
+ d3_time_monthRe.lastIndex = 0;
+ var n = d3_time_monthRe.exec(string.slice(i));
+ return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+ }
+ function d3_time_parseLocaleFull(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.c.toString(), string, i);
+ }
+ function d3_time_parseLocaleDate(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.x.toString(), string, i);
+ }
+ function d3_time_parseLocaleTime(date, string, i) {
+ return d3_time_parse(date, d3_time_formats.X.toString(), string, i);
+ }
+ function d3_time_parseAmPm(date, string, i) {
+ var n = d3_time_periodLookup.get(string.slice(i, i += 2).toLowerCase());
+ return n == null ? -1 : (date.p = n, i);
+ }
+ return d3_time_format;
+ }
+ var d3_time_formatPads = {
+ "-": "",
+ _: " ",
+ "0": "0"
+ }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/;
+ function d3_time_formatPad(value, fill, width) {
+ var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length;
+ return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+ }
+ function d3_time_formatRe(names) {
+ return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i");
+ }
+ function d3_time_formatLookup(names) {
+ var map = new d3_Map(), i = -1, n = names.length;
+ while (++i < n) map.set(names[i].toLowerCase(), i);
+ return map;
+ }
+ function d3_time_parseWeekdayNumber(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 1));
+ return n ? (date.w = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekNumberSunday(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i));
+ return n ? (date.U = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseWeekNumberMonday(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i));
+ return n ? (date.W = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseFullYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 4));
+ return n ? (date.y = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1;
+ }
+ function d3_time_parseZone(date, string, i) {
+ return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5)) ? (date.Z = -string,
+ i + 5) : -1;
+ }
+ function d3_time_expandYear(d) {
+ return d + (d > 68 ? 1900 : 2e3);
+ }
+ function d3_time_parseMonthNumber(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.m = n[0] - 1, i + n[0].length) : -1;
+ }
+ function d3_time_parseDay(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.d = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseDayOfYear(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+ return n ? (date.j = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseHour24(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.H = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseMinutes(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.M = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseSeconds(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 2));
+ return n ? (date.S = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_parseMilliseconds(date, string, i) {
+ d3_time_numberRe.lastIndex = 0;
+ var n = d3_time_numberRe.exec(string.slice(i, i + 3));
+ return n ? (date.L = +n[0], i + n[0].length) : -1;
+ }
+ function d3_time_zone(d) {
+ var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = abs(z) / 60 | 0, zm = abs(z) % 60;
+ return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2);
+ }
+ function d3_time_parseLiteralPercent(date, string, i) {
+ d3_time_percentRe.lastIndex = 0;
+ var n = d3_time_percentRe.exec(string.slice(i, i + 1));
+ return n ? i + n[0].length : -1;
+ }
+ function d3_time_formatMulti(formats) {
+ var n = formats.length, i = -1;
+ while (++i < n) formats[i][0] = this(formats[i][0]);
+ return function(date) {
+ var i = 0, f = formats[i];
+ while (!f[1](date)) f = formats[++i];
+ return f[0](date);
+ };
+ }
+ d3.locale = function(locale) {
+ return {
+ numberFormat: d3_locale_numberFormat(locale),
+ timeFormat: d3_locale_timeFormat(locale)
+ };
+ };
+ var d3_locale_enUS = d3.locale({
+ decimal: ".",
+ thousands: ",",
+ grouping: [ 3 ],
+ currency: [ "$", "" ],
+ dateTime: "%a %b %e %X %Y",
+ date: "%m/%d/%Y",
+ time: "%H:%M:%S",
+ periods: [ "AM", "PM" ],
+ days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ],
+ shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ],
+ months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ],
+ shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
+ });
+ d3.format = d3_locale_enUS.numberFormat;
+ d3.geo = {};
+ function d3_adder() {}
+ d3_adder.prototype = {
+ s: 0,
+ t: 0,
+ add: function(y) {
+ d3_adderSum(y, this.t, d3_adderTemp);
+ d3_adderSum(d3_adderTemp.s, this.s, this);
+ if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t;
+ },
+ reset: function() {
+ this.s = this.t = 0;
+ },
+ valueOf: function() {
+ return this.s;
+ }
+ };
+ var d3_adderTemp = new d3_adder();
+ function d3_adderSum(a, b, o) {
+ var x = o.s = a + b, bv = x - a, av = x - bv;
+ o.t = a - av + (b - bv);
+ }
+ d3.geo.stream = function(object, listener) {
+ if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
+ d3_geo_streamObjectType[object.type](object, listener);
+ } else {
+ d3_geo_streamGeometry(object, listener);
+ }
+ };
+ function d3_geo_streamGeometry(geometry, listener) {
+ if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
+ d3_geo_streamGeometryType[geometry.type](geometry, listener);
+ }
+ }
+ var d3_geo_streamObjectType = {
+ Feature: function(feature, listener) {
+ d3_geo_streamGeometry(feature.geometry, listener);
+ },
+ FeatureCollection: function(object, listener) {
+ var features = object.features, i = -1, n = features.length;
+ while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
+ }
+ };
+ var d3_geo_streamGeometryType = {
+ Sphere: function(object, listener) {
+ listener.sphere();
+ },
+ Point: function(object, listener) {
+ object = object.coordinates;
+ listener.point(object[0], object[1], object[2]);
+ },
+ MultiPoint: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]);
+ },
+ LineString: function(object, listener) {
+ d3_geo_streamLine(object.coordinates, listener, 0);
+ },
+ MultiLineString: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
+ },
+ Polygon: function(object, listener) {
+ d3_geo_streamPolygon(object.coordinates, listener);
+ },
+ MultiPolygon: function(object, listener) {
+ var coordinates = object.coordinates, i = -1, n = coordinates.length;
+ while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
+ },
+ GeometryCollection: function(object, listener) {
+ var geometries = object.geometries, i = -1, n = geometries.length;
+ while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
+ }
+ };
+ function d3_geo_streamLine(coordinates, listener, closed) {
+ var i = -1, n = coordinates.length - closed, coordinate;
+ listener.lineStart();
+ while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]);
+ listener.lineEnd();
+ }
+ function d3_geo_streamPolygon(coordinates, listener) {
+ var i = -1, n = coordinates.length;
+ listener.polygonStart();
+ while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
+ listener.polygonEnd();
+ }
+ d3.geo.area = function(object) {
+ d3_geo_areaSum = 0;
+ d3.geo.stream(object, d3_geo_area);
+ return d3_geo_areaSum;
+ };
+ var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder();
+ var d3_geo_area = {
+ sphere: function() {
+ d3_geo_areaSum += 4 * π;
+ },
+ point: d3_noop,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: function() {
+ d3_geo_areaRingSum.reset();
+ d3_geo_area.lineStart = d3_geo_areaRingStart;
+ },
+ polygonEnd: function() {
+ var area = 2 * d3_geo_areaRingSum;
+ d3_geo_areaSum += area < 0 ? 4 * π + area : area;
+ d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop;
+ }
+ };
+ function d3_geo_areaRingStart() {
+ var λ00, φ00, λ0, cosφ0, sinφ0;
+ d3_geo_area.point = function(λ, φ) {
+ d3_geo_area.point = nextPoint;
+ λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4),
+ sinφ0 = Math.sin(φ);
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ φ = φ * d3_radians / 2 + π / 4;
+ var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ);
+ d3_geo_areaRingSum.add(Math.atan2(v, u));
+ λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ;
+ }
+ d3_geo_area.lineEnd = function() {
+ nextPoint(λ00, φ00);
+ };
+ }
+ function d3_geo_cartesian(spherical) {
+ var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ);
+ return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ];
+ }
+ function d3_geo_cartesianDot(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+ }
+ function d3_geo_cartesianCross(a, b) {
+ return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ];
+ }
+ function d3_geo_cartesianAdd(a, b) {
+ a[0] += b[0];
+ a[1] += b[1];
+ a[2] += b[2];
+ }
+ function d3_geo_cartesianScale(vector, k) {
+ return [ vector[0] * k, vector[1] * k, vector[2] * k ];
+ }
+ function d3_geo_cartesianNormalize(d) {
+ var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+ d[0] /= l;
+ d[1] /= l;
+ d[2] /= l;
+ }
+ function d3_geo_spherical(cartesian) {
+ return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ];
+ }
+ function d3_geo_sphericalEqual(a, b) {
+ return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε;
+ }
+ d3.geo.bounds = function() {
+ var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range;
+ var bound = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ bound.point = ringPoint;
+ bound.lineStart = ringStart;
+ bound.lineEnd = ringEnd;
+ dλSum = 0;
+ d3_geo_area.polygonStart();
+ },
+ polygonEnd: function() {
+ d3_geo_area.polygonEnd();
+ bound.point = point;
+ bound.lineStart = lineStart;
+ bound.lineEnd = lineEnd;
+ if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90;
+ range[0] = λ0, range[1] = λ1;
+ }
+ };
+ function point(λ, φ) {
+ ranges.push(range = [ λ0 = λ, λ1 = λ ]);
+ if (φ < φ0) φ0 = φ;
+ if (φ > φ1) φ1 = φ;
+ }
+ function linePoint(λ, φ) {
+ var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]);
+ if (p0) {
+ var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal);
+ d3_geo_cartesianNormalize(inflection);
+ inflection = d3_geo_spherical(inflection);
+ var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180;
+ if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+ var φi = inflection[1] * d3_degrees;
+ if (φi > φ1) φ1 = φi;
+ } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+ var φi = -inflection[1] * d3_degrees;
+ if (φi < φ0) φ0 = φi;
+ } else {
+ if (φ < φ0) φ0 = φ;
+ if (φ > φ1) φ1 = φ;
+ }
+ if (antimeridian) {
+ if (λ < λ_) {
+ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+ } else {
+ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+ }
+ } else {
+ if (λ1 >= λ0) {
+ if (λ < λ0) λ0 = λ;
+ if (λ > λ1) λ1 = λ;
+ } else {
+ if (λ > λ_) {
+ if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+ } else {
+ if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+ }
+ }
+ }
+ } else {
+ point(λ, φ);
+ }
+ p0 = p, λ_ = λ;
+ }
+ function lineStart() {
+ bound.point = linePoint;
+ }
+ function lineEnd() {
+ range[0] = λ0, range[1] = λ1;
+ bound.point = point;
+ p0 = null;
+ }
+ function ringPoint(λ, φ) {
+ if (p0) {
+ var dλ = λ - λ_;
+ dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
+ } else λ__ = λ, φ__ = φ;
+ d3_geo_area.point(λ, φ);
+ linePoint(λ, φ);
+ }
+ function ringStart() {
+ d3_geo_area.lineStart();
+ }
+ function ringEnd() {
+ ringPoint(λ__, φ__);
+ d3_geo_area.lineEnd();
+ if (abs(dλSum) > ε) λ0 = -(λ1 = 180);
+ range[0] = λ0, range[1] = λ1;
+ p0 = null;
+ }
+ function angle(λ0, λ1) {
+ return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1;
+ }
+ function compareRanges(a, b) {
+ return a[0] - b[0];
+ }
+ function withinRange(x, range) {
+ return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+ }
+ return function(feature) {
+ φ1 = λ1 = -(λ0 = φ0 = Infinity);
+ ranges = [];
+ d3.geo.stream(feature, bound);
+ var n = ranges.length;
+ if (n) {
+ ranges.sort(compareRanges);
+ for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) {
+ b = ranges[i];
+ if (withinRange(b[0], a) || withinRange(b[1], a)) {
+ if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+ if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+ } else {
+ merged.push(a = b);
+ }
+ }
+ var best = -Infinity, dλ;
+ for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
+ b = merged[i];
+ if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
+ }
+ }
+ ranges = range = null;
+ return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ];
+ };
+ }();
+ d3.geo.centroid = function(object) {
+ d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+ d3.geo.stream(object, d3_geo_centroid);
+ var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z;
+ if (m < ε2) {
+ x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
+ if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
+ m = x * x + y * y + z * z;
+ if (m < ε2) return [ NaN, NaN ];
+ }
+ return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ];
+ };
+ var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2;
+ var d3_geo_centroid = {
+ sphere: d3_noop,
+ point: d3_geo_centroidPoint,
+ lineStart: d3_geo_centroidLineStart,
+ lineEnd: d3_geo_centroidLineEnd,
+ polygonStart: function() {
+ d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
+ }
+ };
+ function d3_geo_centroidPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
+ }
+ function d3_geo_centroidPointXYZ(x, y, z) {
+ ++d3_geo_centroidW0;
+ d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
+ d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
+ d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
+ }
+ function d3_geo_centroidLineStart() {
+ var x0, y0, z0;
+ d3_geo_centroid.point = function(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ x0 = cosφ * Math.cos(λ);
+ y0 = cosφ * Math.sin(λ);
+ z0 = Math.sin(φ);
+ d3_geo_centroid.point = nextPoint;
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+ d3_geo_centroidW1 += w;
+ d3_geo_centroidX1 += w * (x0 + (x0 = x));
+ d3_geo_centroidY1 += w * (y0 + (y0 = y));
+ d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ }
+ }
+ function d3_geo_centroidLineEnd() {
+ d3_geo_centroid.point = d3_geo_centroidPoint;
+ }
+ function d3_geo_centroidRingStart() {
+ var λ00, φ00, x0, y0, z0;
+ d3_geo_centroid.point = function(λ, φ) {
+ λ00 = λ, φ00 = φ;
+ d3_geo_centroid.point = nextPoint;
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians);
+ x0 = cosφ * Math.cos(λ);
+ y0 = cosφ * Math.sin(λ);
+ z0 = Math.sin(φ);
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ };
+ d3_geo_centroid.lineEnd = function() {
+ nextPoint(λ00, φ00);
+ d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
+ d3_geo_centroid.point = d3_geo_centroidPoint;
+ };
+ function nextPoint(λ, φ) {
+ λ *= d3_radians;
+ var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u);
+ d3_geo_centroidX2 += v * cx;
+ d3_geo_centroidY2 += v * cy;
+ d3_geo_centroidZ2 += v * cz;
+ d3_geo_centroidW1 += w;
+ d3_geo_centroidX1 += w * (x0 + (x0 = x));
+ d3_geo_centroidY1 += w * (y0 + (y0 = y));
+ d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+ d3_geo_centroidPointXYZ(x0, y0, z0);
+ }
+ }
+ function d3_geo_compose(a, b) {
+ function compose(x, y) {
+ return x = a(x, y), b(x[0], x[1]);
+ }
+ if (a.invert && b.invert) compose.invert = function(x, y) {
+ return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+ };
+ return compose;
+ }
+ function d3_true() {
+ return true;
+ }
+ function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
+ var subject = [], clip = [];
+ segments.forEach(function(segment) {
+ if ((n = segment.length - 1) <= 0) return;
+ var n, p0 = segment[0], p1 = segment[n];
+ if (d3_geo_sphericalEqual(p0, p1)) {
+ listener.lineStart();
+ for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
+ listener.lineEnd();
+ return;
+ }
+ var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
+ a.o = b;
+ subject.push(a);
+ clip.push(b);
+ a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
+ b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
+ a.o = b;
+ subject.push(a);
+ clip.push(b);
+ });
+ clip.sort(compare);
+ d3_geo_clipPolygonLinkCircular(subject);
+ d3_geo_clipPolygonLinkCircular(clip);
+ if (!subject.length) return;
+ for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
+ clip[i].e = entry = !entry;
+ }
+ var start = subject[0], points, point;
+ while (1) {
+ var current = start, isSubject = true;
+ while (current.v) if ((current = current.n) === start) return;
+ points = current.z;
+ listener.lineStart();
+ do {
+ current.v = current.o.v = true;
+ if (current.e) {
+ if (isSubject) {
+ for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
+ } else {
+ interpolate(current.x, current.n.x, 1, listener);
+ }
+ current = current.n;
+ } else {
+ if (isSubject) {
+ points = current.p.z;
+ for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
+ } else {
+ interpolate(current.x, current.p.x, -1, listener);
+ }
+ current = current.p;
+ }
+ current = current.o;
+ points = current.z;
+ isSubject = !isSubject;
+ } while (!current.v);
+ listener.lineEnd();
+ }
+ }
+ function d3_geo_clipPolygonLinkCircular(array) {
+ if (!(n = array.length)) return;
+ var n, i = 0, a = array[0], b;
+ while (++i < n) {
+ a.n = b = array[i];
+ b.p = a;
+ a = b;
+ }
+ a.n = b = array[0];
+ b.p = a;
+ }
+ function d3_geo_clipPolygonIntersection(point, points, other, entry) {
+ this.x = point;
+ this.z = points;
+ this.o = other;
+ this.e = entry;
+ this.v = false;
+ this.n = this.p = null;
+ }
+ function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
+ return function(rotate, listener) {
+ var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
+ var clip = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ clip.point = pointRing;
+ clip.lineStart = ringStart;
+ clip.lineEnd = ringEnd;
+ segments = [];
+ polygon = [];
+ },
+ polygonEnd: function() {
+ clip.point = point;
+ clip.lineStart = lineStart;
+ clip.lineEnd = lineEnd;
+ segments = d3.merge(segments);
+ var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
+ if (segments.length) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
+ } else if (clipStartInside) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ }
+ if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
+ segments = polygon = null;
+ },
+ sphere: function() {
+ listener.polygonStart();
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ listener.polygonEnd();
+ }
+ };
+ function point(λ, φ) {
+ var point = rotate(λ, φ);
+ if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
+ }
+ function pointLine(λ, φ) {
+ var point = rotate(λ, φ);
+ line.point(point[0], point[1]);
+ }
+ function lineStart() {
+ clip.point = pointLine;
+ line.lineStart();
+ }
+ function lineEnd() {
+ clip.point = point;
+ line.lineEnd();
+ }
+ var segments;
+ var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring;
+ function pointRing(λ, φ) {
+ ring.push([ λ, φ ]);
+ var point = rotate(λ, φ);
+ ringListener.point(point[0], point[1]);
+ }
+ function ringStart() {
+ ringListener.lineStart();
+ ring = [];
+ }
+ function ringEnd() {
+ pointRing(ring[0][0], ring[0][1]);
+ ringListener.lineEnd();
+ var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length;
+ ring.pop();
+ polygon.push(ring);
+ ring = null;
+ if (!n) return;
+ if (clean & 1) {
+ segment = ringSegments[0];
+ var n = segment.length - 1, i = -1, point;
+ if (n > 0) {
+ if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+ listener.lineStart();
+ while (++i < n) listener.point((point = segment[i])[0], point[1]);
+ listener.lineEnd();
+ }
+ return;
+ }
+ if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+ segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
+ }
+ return clip;
+ };
+ }
+ function d3_geo_clipSegmentLength1(segment) {
+ return segment.length > 1;
+ }
+ function d3_geo_clipBufferListener() {
+ var lines = [], line;
+ return {
+ lineStart: function() {
+ lines.push(line = []);
+ },
+ point: function(λ, φ) {
+ line.push([ λ, φ ]);
+ },
+ lineEnd: d3_noop,
+ buffer: function() {
+ var buffer = lines;
+ lines = [];
+ line = null;
+ return buffer;
+ },
+ rejoin: function() {
+ if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+ }
+ };
+ }
+ function d3_geo_clipSort(a, b) {
+ return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
+ }
+ var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]);
+ function d3_geo_clipAntimeridianLine(listener) {
+ var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean;
+ return {
+ lineStart: function() {
+ listener.lineStart();
+ clean = 1;
+ },
+ point: function(λ1, φ1) {
+ var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0);
+ if (abs(dλ - π) < ε) {
+ listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
+ listener.point(sλ0, φ0);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(sλ1, φ0);
+ listener.point(λ1, φ0);
+ clean = 0;
+ } else if (sλ0 !== sλ1 && dλ >= π) {
+ if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
+ if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
+ φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
+ listener.point(sλ0, φ0);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(sλ1, φ0);
+ clean = 0;
+ }
+ listener.point(λ0 = λ1, φ0 = φ1);
+ sλ0 = sλ1;
+ },
+ lineEnd: function() {
+ listener.lineEnd();
+ λ0 = φ0 = NaN;
+ },
+ clean: function() {
+ return 2 - clean;
+ }
+ };
+ }
+ function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
+ var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1);
+ return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2;
+ }
+ function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
+ var φ;
+ if (from == null) {
+ φ = direction * halfπ;
+ listener.point(-π, φ);
+ listener.point(0, φ);
+ listener.point(π, φ);
+ listener.point(π, 0);
+ listener.point(π, -φ);
+ listener.point(0, -φ);
+ listener.point(-π, -φ);
+ listener.point(-π, 0);
+ listener.point(-π, φ);
+ } else if (abs(from[0] - to[0]) > ε) {
+ var s = from[0] < to[0] ? π : -π;
+ φ = direction * s / 2;
+ listener.point(-s, φ);
+ listener.point(0, φ);
+ listener.point(s, φ);
+ } else {
+ listener.point(to[0], to[1]);
+ }
+ }
+ function d3_geo_pointInPolygon(point, polygon) {
+ var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0;
+ d3_geo_areaRingSum.reset();
+ for (var i = 0, n = polygon.length; i < n; ++i) {
+ var ring = polygon[i], m = ring.length;
+ if (!m) continue;
+ var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1;
+ while (true) {
+ if (j === m) j = 0;
+ point = ring[j];
+ var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ;
+ d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ)));
+ polarAngle += antimeridian ? dλ + sdλ * τ : dλ;
+ if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
+ var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
+ d3_geo_cartesianNormalize(arc);
+ var intersection = d3_geo_cartesianCross(meridianNormal, arc);
+ d3_geo_cartesianNormalize(intersection);
+ var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
+ if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) {
+ winding += antimeridian ^ dλ >= 0 ? 1 : -1;
+ }
+ }
+ if (!j++) break;
+ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
+ }
+ }
+ return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < -ε) ^ winding & 1;
+ }
+ function d3_geo_clipCircle(radius) {
+ var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
+ return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]);
+ function visible(λ, φ) {
+ return Math.cos(λ) * Math.cos(φ) > cr;
+ }
+ function clipLine(listener) {
+ var point0, c0, v0, v00, clean;
+ return {
+ lineStart: function() {
+ v00 = v0 = false;
+ clean = 1;
+ },
+ point: function(λ, φ) {
+ var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
+ if (!point0 && (v00 = v0 = v)) listener.lineStart();
+ if (v !== v0) {
+ point2 = intersect(point0, point1);
+ if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
+ point1[0] += ε;
+ point1[1] += ε;
+ v = visible(point1[0], point1[1]);
+ }
+ }
+ if (v !== v0) {
+ clean = 0;
+ if (v) {
+ listener.lineStart();
+ point2 = intersect(point1, point0);
+ listener.point(point2[0], point2[1]);
+ } else {
+ point2 = intersect(point0, point1);
+ listener.point(point2[0], point2[1]);
+ listener.lineEnd();
+ }
+ point0 = point2;
+ } else if (notHemisphere && point0 && smallRadius ^ v) {
+ var t;
+ if (!(c & c0) && (t = intersect(point1, point0, true))) {
+ clean = 0;
+ if (smallRadius) {
+ listener.lineStart();
+ listener.point(t[0][0], t[0][1]);
+ listener.point(t[1][0], t[1][1]);
+ listener.lineEnd();
+ } else {
+ listener.point(t[1][0], t[1][1]);
+ listener.lineEnd();
+ listener.lineStart();
+ listener.point(t[0][0], t[0][1]);
+ }
+ }
+ }
+ if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
+ listener.point(point1[0], point1[1]);
+ }
+ point0 = point1, v0 = v, c0 = c;
+ },
+ lineEnd: function() {
+ if (v0) listener.lineEnd();
+ point0 = null;
+ },
+ clean: function() {
+ return clean | (v00 && v0) << 1;
+ }
+ };
+ }
+ function intersect(a, b, two) {
+ var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b);
+ var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
+ if (!determinant) return !two && a;
+ var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2);
+ d3_geo_cartesianAdd(A, B);
+ var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
+ if (t2 < 0) return;
+ var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu);
+ d3_geo_cartesianAdd(q, A);
+ q = d3_geo_spherical(q);
+ if (!two) return q;
+ var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z;
+ if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
+ var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε;
+ if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
+ if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
+ var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
+ d3_geo_cartesianAdd(q1, A);
+ return [ q, d3_geo_spherical(q1) ];
+ }
+ }
+ function code(λ, φ) {
+ var r = smallRadius ? radius : π - radius, code = 0;
+ if (λ < -r) code |= 1; else if (λ > r) code |= 2;
+ if (φ < -r) code |= 4; else if (φ > r) code |= 8;
+ return code;
+ }
+ }
+ function d3_geom_clipLine(x0, y0, x1, y1) {
+ return function(line) {
+ var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
+ r = x0 - ax;
+ if (!dx && r > 0) return;
+ r /= dx;
+ if (dx < 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ } else if (dx > 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ }
+ r = x1 - ax;
+ if (!dx && r < 0) return;
+ r /= dx;
+ if (dx < 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ } else if (dx > 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ }
+ r = y0 - ay;
+ if (!dy && r > 0) return;
+ r /= dy;
+ if (dy < 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ } else if (dy > 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ }
+ r = y1 - ay;
+ if (!dy && r < 0) return;
+ r /= dy;
+ if (dy < 0) {
+ if (r > t1) return;
+ if (r > t0) t0 = r;
+ } else if (dy > 0) {
+ if (r < t0) return;
+ if (r < t1) t1 = r;
+ }
+ if (t0 > 0) line.a = {
+ x: ax + t0 * dx,
+ y: ay + t0 * dy
+ };
+ if (t1 < 1) line.b = {
+ x: ax + t1 * dx,
+ y: ay + t1 * dy
+ };
+ return line;
+ };
+ }
+ var d3_geo_clipExtentMAX = 1e9;
+ d3.geo.clipExtent = function() {
+ var x0, y0, x1, y1, stream, clip, clipExtent = {
+ stream: function(output) {
+ if (stream) stream.valid = false;
+ stream = clip(output);
+ stream.valid = true;
+ return stream;
+ },
+ extent: function(_) {
+ if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+ clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
+ if (stream) stream.valid = false, stream = null;
+ return clipExtent;
+ }
+ };
+ return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]);
+ };
+ function d3_geo_clipExtent(x0, y0, x1, y1) {
+ return function(listener) {
+ var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring;
+ var clip = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ listener = bufferListener;
+ segments = [];
+ polygon = [];
+ clean = true;
+ },
+ polygonEnd: function() {
+ listener = listener_;
+ segments = d3.merge(segments);
+ var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length;
+ if (inside || visible) {
+ listener.polygonStart();
+ if (inside) {
+ listener.lineStart();
+ interpolate(null, null, 1, listener);
+ listener.lineEnd();
+ }
+ if (visible) {
+ d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
+ }
+ listener.polygonEnd();
+ }
+ segments = polygon = ring = null;
+ }
+ };
+ function insidePolygon(p) {
+ var wn = 0, n = polygon.length, y = p[1];
+ for (var i = 0; i < n; ++i) {
+ for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
+ b = v[j];
+ if (a[1] <= y) {
+ if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn;
+ } else {
+ if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
+ }
+ a = b;
+ }
+ }
+ return wn !== 0;
+ }
+ function interpolate(from, to, direction, listener) {
+ var a = 0, a1 = 0;
+ if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) {
+ do {
+ listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
+ } while ((a = (a + direction + 4) % 4) !== a1);
+ } else {
+ listener.point(to[0], to[1]);
+ }
+ }
+ function pointVisible(x, y) {
+ return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+ }
+ function point(x, y) {
+ if (pointVisible(x, y)) listener.point(x, y);
+ }
+ var x__, y__, v__, x_, y_, v_, first, clean;
+ function lineStart() {
+ clip.point = linePoint;
+ if (polygon) polygon.push(ring = []);
+ first = true;
+ v_ = false;
+ x_ = y_ = NaN;
+ }
+ function lineEnd() {
+ if (segments) {
+ linePoint(x__, y__);
+ if (v__ && v_) bufferListener.rejoin();
+ segments.push(bufferListener.buffer());
+ }
+ clip.point = point;
+ if (v_) listener.lineEnd();
+ }
+ function linePoint(x, y) {
+ x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
+ y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
+ var v = pointVisible(x, y);
+ if (polygon) ring.push([ x, y ]);
+ if (first) {
+ x__ = x, y__ = y, v__ = v;
+ first = false;
+ if (v) {
+ listener.lineStart();
+ listener.point(x, y);
+ }
+ } else {
+ if (v && v_) listener.point(x, y); else {
+ var l = {
+ a: {
+ x: x_,
+ y: y_
+ },
+ b: {
+ x: x,
+ y: y
+ }
+ };
+ if (clipLine(l)) {
+ if (!v_) {
+ listener.lineStart();
+ listener.point(l.a.x, l.a.y);
+ }
+ listener.point(l.b.x, l.b.y);
+ if (!v) listener.lineEnd();
+ clean = false;
+ } else if (v) {
+ listener.lineStart();
+ listener.point(x, y);
+ clean = false;
+ }
+ }
+ }
+ x_ = x, y_ = y, v_ = v;
+ }
+ return clip;
+ };
+ function corner(p, direction) {
+ return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
+ }
+ function compare(a, b) {
+ return comparePoints(a.x, b.x);
+ }
+ function comparePoints(a, b) {
+ var ca = corner(a, 1), cb = corner(b, 1);
+ return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
+ }
+ }
+ function d3_geo_conic(projectAt) {
+ var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1);
+ p.parallels = function(_) {
+ if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ];
+ return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+ };
+ return p;
+ }
+ function d3_geo_conicEqualArea(φ0, φ1) {
+ var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n;
+ function forward(λ, φ) {
+ var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
+ return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = ρ0 - y;
+ return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ];
+ };
+ return forward;
+ }
+ (d3.geo.conicEqualArea = function() {
+ return d3_geo_conic(d3_geo_conicEqualArea);
+ }).raw = d3_geo_conicEqualArea;
+ d3.geo.albers = function() {
+ return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070);
+ };
+ d3.geo.albersUsa = function() {
+ var lower48 = d3.geo.albers();
+ var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]);
+ var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]);
+ var point, pointStream = {
+ point: function(x, y) {
+ point = [ x, y ];
+ }
+ }, lower48Point, alaskaPoint, hawaiiPoint;
+ function albersUsa(coordinates) {
+ var x = coordinates[0], y = coordinates[1];
+ point = null;
+ (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y);
+ return point;
+ }
+ albersUsa.invert = function(coordinates) {
+ var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k;
+ return (y >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates);
+ };
+ albersUsa.stream = function(stream) {
+ var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
+ return {
+ point: function(x, y) {
+ lower48Stream.point(x, y);
+ alaskaStream.point(x, y);
+ hawaiiStream.point(x, y);
+ },
+ sphere: function() {
+ lower48Stream.sphere();
+ alaskaStream.sphere();
+ hawaiiStream.sphere();
+ },
+ lineStart: function() {
+ lower48Stream.lineStart();
+ alaskaStream.lineStart();
+ hawaiiStream.lineStart();
+ },
+ lineEnd: function() {
+ lower48Stream.lineEnd();
+ alaskaStream.lineEnd();
+ hawaiiStream.lineEnd();
+ },
+ polygonStart: function() {
+ lower48Stream.polygonStart();
+ alaskaStream.polygonStart();
+ hawaiiStream.polygonStart();
+ },
+ polygonEnd: function() {
+ lower48Stream.polygonEnd();
+ alaskaStream.polygonEnd();
+ hawaiiStream.polygonEnd();
+ }
+ };
+ };
+ albersUsa.precision = function(_) {
+ if (!arguments.length) return lower48.precision();
+ lower48.precision(_);
+ alaska.precision(_);
+ hawaii.precision(_);
+ return albersUsa;
+ };
+ albersUsa.scale = function(_) {
+ if (!arguments.length) return lower48.scale();
+ lower48.scale(_);
+ alaska.scale(_ * .35);
+ hawaii.scale(_);
+ return albersUsa.translate(lower48.translate());
+ };
+ albersUsa.translate = function(_) {
+ if (!arguments.length) return lower48.translate();
+ var k = lower48.scale(), x = +_[0], y = +_[1];
+ lower48Point = lower48.translate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
+ alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+ hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
+ return albersUsa;
+ };
+ return albersUsa.scale(1070);
+ };
+ var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
+ point: d3_noop,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: function() {
+ d3_geo_pathAreaPolygon = 0;
+ d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
+ d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
+ }
+ };
+ function d3_geo_pathAreaRingStart() {
+ var x00, y00, x0, y0;
+ d3_geo_pathArea.point = function(x, y) {
+ d3_geo_pathArea.point = nextPoint;
+ x00 = x0 = x, y00 = y0 = y;
+ };
+ function nextPoint(x, y) {
+ d3_geo_pathAreaPolygon += y0 * x - x0 * y;
+ x0 = x, y0 = y;
+ }
+ d3_geo_pathArea.lineEnd = function() {
+ nextPoint(x00, y00);
+ };
+ }
+ var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
+ var d3_geo_pathBounds = {
+ point: d3_geo_pathBoundsPoint,
+ lineStart: d3_noop,
+ lineEnd: d3_noop,
+ polygonStart: d3_noop,
+ polygonEnd: d3_noop
+ };
+ function d3_geo_pathBoundsPoint(x, y) {
+ if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
+ if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
+ if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
+ if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
+ }
+ function d3_geo_pathBuffer() {
+ var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
+ var stream = {
+ point: point,
+ lineStart: function() {
+ stream.point = pointLineStart;
+ },
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.lineEnd = lineEndPolygon;
+ },
+ polygonEnd: function() {
+ stream.lineEnd = lineEnd;
+ stream.point = point;
+ },
+ pointRadius: function(_) {
+ pointCircle = d3_geo_pathBufferCircle(_);
+ return stream;
+ },
+ result: function() {
+ if (buffer.length) {
+ var result = buffer.join("");
+ buffer = [];
+ return result;
+ }
+ }
+ };
+ function point(x, y) {
+ buffer.push("M", x, ",", y, pointCircle);
+ }
+ function pointLineStart(x, y) {
+ buffer.push("M", x, ",", y);
+ stream.point = pointLine;
+ }
+ function pointLine(x, y) {
+ buffer.push("L", x, ",", y);
+ }
+ function lineEnd() {
+ stream.point = point;
+ }
+ function lineEndPolygon() {
+ buffer.push("Z");
+ }
+ return stream;
+ }
+ function d3_geo_pathBufferCircle(radius) {
+ return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z";
+ }
+ var d3_geo_pathCentroid = {
+ point: d3_geo_pathCentroidPoint,
+ lineStart: d3_geo_pathCentroidLineStart,
+ lineEnd: d3_geo_pathCentroidLineEnd,
+ polygonStart: function() {
+ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
+ },
+ polygonEnd: function() {
+ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+ d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
+ d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
+ }
+ };
+ function d3_geo_pathCentroidPoint(x, y) {
+ d3_geo_centroidX0 += x;
+ d3_geo_centroidY0 += y;
+ ++d3_geo_centroidZ0;
+ }
+ function d3_geo_pathCentroidLineStart() {
+ var x0, y0;
+ d3_geo_pathCentroid.point = function(x, y) {
+ d3_geo_pathCentroid.point = nextPoint;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ };
+ function nextPoint(x, y) {
+ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+ d3_geo_centroidX1 += z * (x0 + x) / 2;
+ d3_geo_centroidY1 += z * (y0 + y) / 2;
+ d3_geo_centroidZ1 += z;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ }
+ }
+ function d3_geo_pathCentroidLineEnd() {
+ d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+ }
+ function d3_geo_pathCentroidRingStart() {
+ var x00, y00, x0, y0;
+ d3_geo_pathCentroid.point = function(x, y) {
+ d3_geo_pathCentroid.point = nextPoint;
+ d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
+ };
+ function nextPoint(x, y) {
+ var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+ d3_geo_centroidX1 += z * (x0 + x) / 2;
+ d3_geo_centroidY1 += z * (y0 + y) / 2;
+ d3_geo_centroidZ1 += z;
+ z = y0 * x - x0 * y;
+ d3_geo_centroidX2 += z * (x0 + x);
+ d3_geo_centroidY2 += z * (y0 + y);
+ d3_geo_centroidZ2 += z * 3;
+ d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+ }
+ d3_geo_pathCentroid.lineEnd = function() {
+ nextPoint(x00, y00);
+ };
+ }
+ function d3_geo_pathContext(context) {
+ var pointRadius = 4.5;
+ var stream = {
+ point: point,
+ lineStart: function() {
+ stream.point = pointLineStart;
+ },
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.lineEnd = lineEndPolygon;
+ },
+ polygonEnd: function() {
+ stream.lineEnd = lineEnd;
+ stream.point = point;
+ },
+ pointRadius: function(_) {
+ pointRadius = _;
+ return stream;
+ },
+ result: d3_noop
+ };
+ function point(x, y) {
+ context.moveTo(x + pointRadius, y);
+ context.arc(x, y, pointRadius, 0, τ);
+ }
+ function pointLineStart(x, y) {
+ context.moveTo(x, y);
+ stream.point = pointLine;
+ }
+ function pointLine(x, y) {
+ context.lineTo(x, y);
+ }
+ function lineEnd() {
+ stream.point = point;
+ }
+ function lineEndPolygon() {
+ context.closePath();
+ }
+ return stream;
+ }
+ function d3_geo_resample(project) {
+ var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16;
+ function resample(stream) {
+ return (maxDepth ? resampleRecursive : resampleNone)(stream);
+ }
+ function resampleNone(stream) {
+ return d3_geo_transformPoint(stream, function(x, y) {
+ x = project(x, y);
+ stream.point(x[0], x[1]);
+ });
+ }
+ function resampleRecursive(stream) {
+ var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0;
+ var resample = {
+ point: point,
+ lineStart: lineStart,
+ lineEnd: lineEnd,
+ polygonStart: function() {
+ stream.polygonStart();
+ resample.lineStart = ringStart;
+ },
+ polygonEnd: function() {
+ stream.polygonEnd();
+ resample.lineStart = lineStart;
+ }
+ };
+ function point(x, y) {
+ x = project(x, y);
+ stream.point(x[0], x[1]);
+ }
+ function lineStart() {
+ x0 = NaN;
+ resample.point = linePoint;
+ stream.lineStart();
+ }
+ function linePoint(λ, φ) {
+ var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ);
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+ stream.point(x0, y0);
+ }
+ function lineEnd() {
+ resample.point = point;
+ stream.lineEnd();
+ }
+ function ringStart() {
+ lineStart();
+ resample.point = ringPoint;
+ resample.lineEnd = ringEnd;
+ }
+ function ringPoint(λ, φ) {
+ linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+ resample.point = linePoint;
+ }
+ function ringEnd() {
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
+ resample.lineEnd = lineEnd;
+ lineEnd();
+ }
+ return resample;
+ }
+ function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
+ var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy;
+ if (d2 > 4 * δ2 && depth--) {
+ var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2;
+ if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
+ resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
+ stream.point(x2, y2);
+ resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
+ }
+ }
+ }
+ resample.precision = function(_) {
+ if (!arguments.length) return Math.sqrt(δ2);
+ maxDepth = (δ2 = _ * _) > 0 && 16;
+ return resample;
+ };
+ return resample;
+ }
+ d3.geo.path = function() {
+ var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
+ function path(object) {
+ if (object) {
+ if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+ if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
+ d3.geo.stream(object, cacheStream);
+ }
+ return contextStream.result();
+ }
+ path.area = function(object) {
+ d3_geo_pathAreaSum = 0;
+ d3.geo.stream(object, projectStream(d3_geo_pathArea));
+ return d3_geo_pathAreaSum;
+ };
+ path.centroid = function(object) {
+ d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+ d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
+ return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ];
+ };
+ path.bounds = function(object) {
+ d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
+ d3.geo.stream(object, projectStream(d3_geo_pathBounds));
+ return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
+ };
+ path.projection = function(_) {
+ if (!arguments.length) return projection;
+ projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
+ return reset();
+ };
+ path.context = function(_) {
+ if (!arguments.length) return context;
+ contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
+ if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+ return reset();
+ };
+ path.pointRadius = function(_) {
+ if (!arguments.length) return pointRadius;
+ pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+ return path;
+ };
+ function reset() {
+ cacheStream = null;
+ return path;
+ }
+ return path.projection(d3.geo.albersUsa()).context(null);
+ };
+ function d3_geo_pathProjectStream(project) {
+ var resample = d3_geo_resample(function(x, y) {
+ return project([ x * d3_degrees, y * d3_degrees ]);
+ });
+ return function(stream) {
+ return d3_geo_projectionRadians(resample(stream));
+ };
+ }
+ d3.geo.transform = function(methods) {
+ return {
+ stream: function(stream) {
+ var transform = new d3_geo_transform(stream);
+ for (var k in methods) transform[k] = methods[k];
+ return transform;
+ }
+ };
+ };
+ function d3_geo_transform(stream) {
+ this.stream = stream;
+ }
+ d3_geo_transform.prototype = {
+ point: function(x, y) {
+ this.stream.point(x, y);
+ },
+ sphere: function() {
+ this.stream.sphere();
+ },
+ lineStart: function() {
+ this.stream.lineStart();
+ },
+ lineEnd: function() {
+ this.stream.lineEnd();
+ },
+ polygonStart: function() {
+ this.stream.polygonStart();
+ },
+ polygonEnd: function() {
+ this.stream.polygonEnd();
+ }
+ };
+ function d3_geo_transformPoint(stream, point) {
+ return {
+ point: point,
+ sphere: function() {
+ stream.sphere();
+ },
+ lineStart: function() {
+ stream.lineStart();
+ },
+ lineEnd: function() {
+ stream.lineEnd();
+ },
+ polygonStart: function() {
+ stream.polygonStart();
+ },
+ polygonEnd: function() {
+ stream.polygonEnd();
+ }
+ };
+ }
+ d3.geo.projection = d3_geo_projection;
+ d3.geo.projectionMutator = d3_geo_projectionMutator;
+ function d3_geo_projection(project) {
+ return d3_geo_projectionMutator(function() {
+ return project;
+ })();
+ }
+ function d3_geo_projectionMutator(projectAt) {
+ var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) {
+ x = project(x, y);
+ return [ x[0] * k + δx, δy - x[1] * k ];
+ }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream;
+ function projection(point) {
+ point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
+ return [ point[0] * k + δx, δy - point[1] * k ];
+ }
+ function invert(point) {
+ point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
+ return point && [ point[0] * d3_degrees, point[1] * d3_degrees ];
+ }
+ projection.stream = function(output) {
+ if (stream) stream.valid = false;
+ stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output))));
+ stream.valid = true;
+ return stream;
+ };
+ projection.clipAngle = function(_) {
+ if (!arguments.length) return clipAngle;
+ preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
+ return invalidate();
+ };
+ projection.clipExtent = function(_) {
+ if (!arguments.length) return clipExtent;
+ clipExtent = _;
+ postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity;
+ return invalidate();
+ };
+ projection.scale = function(_) {
+ if (!arguments.length) return k;
+ k = +_;
+ return reset();
+ };
+ projection.translate = function(_) {
+ if (!arguments.length) return [ x, y ];
+ x = +_[0];
+ y = +_[1];
+ return reset();
+ };
+ projection.center = function(_) {
+ if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ];
+ λ = _[0] % 360 * d3_radians;
+ φ = _[1] % 360 * d3_radians;
+ return reset();
+ };
+ projection.rotate = function(_) {
+ if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ];
+ δλ = _[0] % 360 * d3_radians;
+ δφ = _[1] % 360 * d3_radians;
+ δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
+ return reset();
+ };
+ d3.rebind(projection, projectResample, "precision");
+ function reset() {
+ projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
+ var center = project(λ, φ);
+ δx = x - center[0] * k;
+ δy = y + center[1] * k;
+ return invalidate();
+ }
+ function invalidate() {
+ if (stream) stream.valid = false, stream = null;
+ return projection;
+ }
+ return function() {
+ project = projectAt.apply(this, arguments);
+ projection.invert = project.invert && invert;
+ return reset();
+ };
+ }
+ function d3_geo_projectionRadians(stream) {
+ return d3_geo_transformPoint(stream, function(x, y) {
+ stream.point(x * d3_radians, y * d3_radians);
+ });
+ }
+ function d3_geo_equirectangular(λ, φ) {
+ return [ λ, φ ];
+ }
+ (d3.geo.equirectangular = function() {
+ return d3_geo_projection(d3_geo_equirectangular);
+ }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;
+ d3.geo.rotation = function(rotate) {
+ rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
+ function forward(coordinates) {
+ coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+ }
+ forward.invert = function(coordinates) {
+ coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+ return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+ };
+ return forward;
+ };
+ function d3_geo_identityRotation(λ, φ) {
+ return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+ }
+ d3_geo_identityRotation.invert = d3_geo_equirectangular;
+ function d3_geo_rotation(δλ, δφ, δγ) {
+ return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation;
+ }
+ function d3_geo_forwardRotationλ(δλ) {
+ return function(λ, φ) {
+ return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ];
+ };
+ }
+ function d3_geo_rotationλ(δλ) {
+ var rotation = d3_geo_forwardRotationλ(δλ);
+ rotation.invert = d3_geo_forwardRotationλ(-δλ);
+ return rotation;
+ }
+ function d3_geo_rotationφγ(δφ, δγ) {
+ var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ);
+ function rotation(λ, φ) {
+ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ;
+ return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ];
+ }
+ rotation.invert = function(λ, φ) {
+ var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ;
+ return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ];
+ };
+ return rotation;
+ }
+ d3.geo.circle = function() {
+ var origin = [ 0, 0 ], angle, precision = 6, interpolate;
+ function circle() {
+ var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = [];
+ interpolate(null, null, 1, {
+ point: function(x, y) {
+ ring.push(x = rotate(x, y));
+ x[0] *= d3_degrees, x[1] *= d3_degrees;
+ }
+ });
+ return {
+ type: "Polygon",
+ coordinates: [ ring ]
+ };
+ }
+ circle.origin = function(x) {
+ if (!arguments.length) return origin;
+ origin = x;
+ return circle;
+ };
+ circle.angle = function(x) {
+ if (!arguments.length) return angle;
+ interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
+ return circle;
+ };
+ circle.precision = function(_) {
+ if (!arguments.length) return precision;
+ interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
+ return circle;
+ };
+ return circle.angle(90);
+ };
+ function d3_geo_circleInterpolate(radius, precision) {
+ var cr = Math.cos(radius), sr = Math.sin(radius);
+ return function(from, to, direction, listener) {
+ var step = direction * precision;
+ if (from != null) {
+ from = d3_geo_circleAngle(cr, from);
+ to = d3_geo_circleAngle(cr, to);
+ if (direction > 0 ? from < to : from > to) from += direction * τ;
+ } else {
+ from = radius + direction * τ;
+ to = radius - .5 * step;
+ }
+ for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) {
+ listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]);
+ }
+ };
+ }
+ function d3_geo_circleAngle(cr, point) {
+ var a = d3_geo_cartesian(point);
+ a[0] -= cr;
+ d3_geo_cartesianNormalize(a);
+ var angle = d3_acos(-a[1]);
+ return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
+ }
+ d3.geo.distance = function(a, b) {
+ var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t;
+ return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
+ };
+ d3.geo.graticule = function() {
+ var x1, x0, X1, X0, y1, y0, Y1, Y0, dx = 10, dy = dx, DX = 90, DY = 360, x, y, X, Y, precision = 2.5;
+ function graticule() {
+ return {
+ type: "MultiLineString",
+ coordinates: lines()
+ };
+ }
+ function lines() {
+ return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) {
+ return abs(x % DX) > ε;
+ }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) {
+ return abs(y % DY) > ε;
+ }).map(y));
+ }
+ graticule.lines = function() {
+ return lines().map(function(coordinates) {
+ return {
+ type: "LineString",
+ coordinates: coordinates
+ };
+ });
+ };
+ graticule.outline = function() {
+ return {
+ type: "Polygon",
+ coordinates: [ X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1)) ]
+ };
+ };
+ graticule.extent = function(_) {
+ if (!arguments.length) return graticule.minorExtent();
+ return graticule.majorExtent(_).minorExtent(_);
+ };
+ graticule.majorExtent = function(_) {
+ if (!arguments.length) return [ [ X0, Y0 ], [ X1, Y1 ] ];
+ X0 = +_[0][0], X1 = +_[1][0];
+ Y0 = +_[0][1], Y1 = +_[1][1];
+ if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+ if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+ return graticule.precision(precision);
+ };
+ graticule.minorExtent = function(_) {
+ if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ];
+ x0 = +_[0][0], x1 = +_[1][0];
+ y0 = +_[0][1], y1 = +_[1][1];
+ if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+ if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+ return graticule.precision(precision);
+ };
+ graticule.step = function(_) {
+ if (!arguments.length) return graticule.minorStep();
+ return graticule.majorStep(_).minorStep(_);
+ };
+ graticule.majorStep = function(_) {
+ if (!arguments.length) return [ DX, DY ];
+ DX = +_[0], DY = +_[1];
+ return graticule;
+ };
+ graticule.minorStep = function(_) {
+ if (!arguments.length) return [ dx, dy ];
+ dx = +_[0], dy = +_[1];
+ return graticule;
+ };
+ graticule.precision = function(_) {
+ if (!arguments.length) return precision;
+ precision = +_;
+ x = d3_geo_graticuleX(y0, y1, 90);
+ y = d3_geo_graticuleY(x0, x1, precision);
+ X = d3_geo_graticuleX(Y0, Y1, 90);
+ Y = d3_geo_graticuleY(X0, X1, precision);
+ return graticule;
+ };
+ return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]);
+ };
+ function d3_geo_graticuleX(y0, y1, dy) {
+ var y = d3.range(y0, y1 - ε, dy).concat(y1);
+ return function(x) {
+ return y.map(function(y) {
+ return [ x, y ];
+ });
+ };
+ }
+ function d3_geo_graticuleY(x0, x1, dx) {
+ var x = d3.range(x0, x1 - ε, dx).concat(x1);
+ return function(y) {
+ return x.map(function(x) {
+ return [ x, y ];
+ });
+ };
+ }
+ function d3_source(d) {
+ return d.source;
+ }
+ function d3_target(d) {
+ return d.target;
+ }
+ d3.geo.greatArc = function() {
+ var source = d3_source, source_, target = d3_target, target_;
+ function greatArc() {
+ return {
+ type: "LineString",
+ coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ]
+ };
+ }
+ greatArc.distance = function() {
+ return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments));
+ };
+ greatArc.source = function(_) {
+ if (!arguments.length) return source;
+ source = _, source_ = typeof _ === "function" ? null : _;
+ return greatArc;
+ };
+ greatArc.target = function(_) {
+ if (!arguments.length) return target;
+ target = _, target_ = typeof _ === "function" ? null : _;
+ return greatArc;
+ };
+ greatArc.precision = function() {
+ return arguments.length ? greatArc : 0;
+ };
+ return greatArc;
+ };
+ d3.geo.interpolate = function(source, target) {
+ return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians);
+ };
+ function d3_geo_interpolate(x0, y0, x1, y1) {
+ var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d);
+ var interpolate = d ? function(t) {
+ var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1;
+ return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ];
+ } : function() {
+ return [ x0 * d3_degrees, y0 * d3_degrees ];
+ };
+ interpolate.distance = d;
+ return interpolate;
+ }
+ d3.geo.length = function(object) {
+ d3_geo_lengthSum = 0;
+ d3.geo.stream(object, d3_geo_length);
+ return d3_geo_lengthSum;
+ };
+ var d3_geo_lengthSum;
+ var d3_geo_length = {
+ sphere: d3_noop,
+ point: d3_noop,
+ lineStart: d3_geo_lengthLineStart,
+ lineEnd: d3_noop,
+ polygonStart: d3_noop,
+ polygonEnd: d3_noop
+ };
+ function d3_geo_lengthLineStart() {
+ var λ0, sinφ0, cosφ0;
+ d3_geo_length.point = function(λ, φ) {
+ λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
+ d3_geo_length.point = nextPoint;
+ };
+ d3_geo_length.lineEnd = function() {
+ d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
+ };
+ function nextPoint(λ, φ) {
+ var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t);
+ d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
+ λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
+ }
+ }
+ function d3_geo_azimuthal(scale, angle) {
+ function azimuthal(λ, φ) {
+ var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ);
+ return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ];
+ }
+ azimuthal.invert = function(x, y) {
+ var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c);
+ return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ];
+ };
+ return azimuthal;
+ }
+ var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) {
+ return Math.sqrt(2 / (1 + cosλcosφ));
+ }, function(ρ) {
+ return 2 * Math.asin(ρ / 2);
+ });
+ (d3.geo.azimuthalEqualArea = function() {
+ return d3_geo_projection(d3_geo_azimuthalEqualArea);
+ }).raw = d3_geo_azimuthalEqualArea;
+ var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) {
+ var c = Math.acos(cosλcosφ);
+ return c && c / Math.sin(c);
+ }, d3_identity);
+ (d3.geo.azimuthalEquidistant = function() {
+ return d3_geo_projection(d3_geo_azimuthalEquidistant);
+ }).raw = d3_geo_azimuthalEquidistant;
+ function d3_geo_conicConformal(φ0, φ1) {
+ var cosφ0 = Math.cos(φ0), t = function(φ) {
+ return Math.tan(π / 4 + φ / 2);
+ }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n;
+ if (!n) return d3_geo_mercator;
+ function forward(λ, φ) {
+ if (F > 0) {
+ if (φ < -halfπ + ε) φ = -halfπ + ε;
+ } else {
+ if (φ > halfπ - ε) φ = halfπ - ε;
+ }
+ var ρ = F / Math.pow(t(φ), n);
+ return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+ return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ];
+ };
+ return forward;
+ }
+ (d3.geo.conicConformal = function() {
+ return d3_geo_conic(d3_geo_conicConformal);
+ }).raw = d3_geo_conicConformal;
+ function d3_geo_conicEquidistant(φ0, φ1) {
+ var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0;
+ if (abs(n) < ε) return d3_geo_equirectangular;
+ function forward(λ, φ) {
+ var ρ = G - φ;
+ return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ];
+ }
+ forward.invert = function(x, y) {
+ var ρ0_y = G - y;
+ return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ];
+ };
+ return forward;
+ }
+ (d3.geo.conicEquidistant = function() {
+ return d3_geo_conic(d3_geo_conicEquidistant);
+ }).raw = d3_geo_conicEquidistant;
+ var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) {
+ return 1 / cosλcosφ;
+ }, Math.atan);
+ (d3.geo.gnomonic = function() {
+ return d3_geo_projection(d3_geo_gnomonic);
+ }).raw = d3_geo_gnomonic;
+ function d3_geo_mercator(λ, φ) {
+ return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ];
+ }
+ d3_geo_mercator.invert = function(x, y) {
+ return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ];
+ };
+ function d3_geo_mercatorProjection(project) {
+ var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto;
+ m.scale = function() {
+ var v = scale.apply(m, arguments);
+ return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+ };
+ m.translate = function() {
+ var v = translate.apply(m, arguments);
+ return v === m ? clipAuto ? m.clipExtent(null) : m : v;
+ };
+ m.clipExtent = function(_) {
+ var v = clipExtent.apply(m, arguments);
+ if (v === m) {
+ if (clipAuto = _ == null) {
+ var k = π * scale(), t = translate();
+ clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]);
+ }
+ } else if (clipAuto) {
+ v = null;
+ }
+ return v;
+ };
+ return m.clipExtent(null);
+ }
+ (d3.geo.mercator = function() {
+ return d3_geo_mercatorProjection(d3_geo_mercator);
+ }).raw = d3_geo_mercator;
+ var d3_geo_orthographic = d3_geo_azimuthal(function() {
+ return 1;
+ }, Math.asin);
+ (d3.geo.orthographic = function() {
+ return d3_geo_projection(d3_geo_orthographic);
+ }).raw = d3_geo_orthographic;
+ var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) {
+ return 1 / (1 + cosλcosφ);
+ }, function(ρ) {
+ return 2 * Math.atan(ρ);
+ });
+ (d3.geo.stereographic = function() {
+ return d3_geo_projection(d3_geo_stereographic);
+ }).raw = d3_geo_stereographic;
+ function d3_geo_transverseMercator(λ, φ) {
+ return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ];
+ }
+ d3_geo_transverseMercator.invert = function(x, y) {
+ return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ];
+ };
+ (d3.geo.transverseMercator = function() {
+ var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate;
+ projection.center = function(_) {
+ return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ _[1], -_[0] ]);
+ };
+ projection.rotate = function(_) {
+ return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(),
+ [ _[0], _[1], _[2] - 90 ]);
+ };
+ return rotate([ 0, 0, 90 ]);
+ }).raw = d3_geo_transverseMercator;
+ d3.geom = {};
+ function d3_geom_pointX(d) {
+ return d[0];
+ }
+ function d3_geom_pointY(d) {
+ return d[1];
+ }
+ d3.geom.hull = function(vertices) {
+ var x = d3_geom_pointX, y = d3_geom_pointY;
+ if (arguments.length) return hull(vertices);
+ function hull(data) {
+ if (data.length < 3) return [];
+ var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = [];
+ for (i = 0; i < n; i++) {
+ points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]);
+ }
+ points.sort(d3_geom_hullOrder);
+ for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]);
+ var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints);
+ var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = [];
+ for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]);
+ for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]);
+ return polygon;
+ }
+ hull.x = function(_) {
+ return arguments.length ? (x = _, hull) : x;
+ };
+ hull.y = function(_) {
+ return arguments.length ? (y = _, hull) : y;
+ };
+ return hull;
+ };
+ function d3_geom_hullUpper(points) {
+ var n = points.length, hull = [ 0, 1 ], hs = 2;
+ for (var i = 2; i < n; i++) {
+ while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs;
+ hull[hs++] = i;
+ }
+ return hull.slice(0, hs);
+ }
+ function d3_geom_hullOrder(a, b) {
+ return a[0] - b[0] || a[1] - b[1];
+ }
+ d3.geom.polygon = function(coordinates) {
+ d3_subclass(coordinates, d3_geom_polygonPrototype);
+ return coordinates;
+ };
+ var d3_geom_polygonPrototype = d3.geom.polygon.prototype = [];
+ d3_geom_polygonPrototype.area = function() {
+ var i = -1, n = this.length, a, b = this[n - 1], area = 0;
+ while (++i < n) {
+ a = b;
+ b = this[i];
+ area += a[1] * b[0] - a[0] * b[1];
+ }
+ return area * .5;
+ };
+ d3_geom_polygonPrototype.centroid = function(k) {
+ var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c;
+ if (!arguments.length) k = -1 / (6 * this.area());
+ while (++i < n) {
+ a = b;
+ b = this[i];
+ c = a[0] * b[1] - b[0] * a[1];
+ x += (a[0] + b[0]) * c;
+ y += (a[1] + b[1]) * c;
+ }
+ return [ x * k, y * k ];
+ };
+ d3_geom_polygonPrototype.clip = function(subject) {
+ var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d;
+ while (++i < n) {
+ input = subject.slice();
+ subject.length = 0;
+ b = this[i];
+ c = input[(m = input.length - closed) - 1];
+ j = -1;
+ while (++j < m) {
+ d = input[j];
+ if (d3_geom_polygonInside(d, a, b)) {
+ if (!d3_geom_polygonInside(c, a, b)) {
+ subject.push(d3_geom_polygonIntersect(c, d, a, b));
+ }
+ subject.push(d);
+ } else if (d3_geom_polygonInside(c, a, b)) {
+ subject.push(d3_geom_polygonIntersect(c, d, a, b));
+ }
+ c = d;
+ }
+ if (closed) subject.push(subject[0]);
+ a = b;
+ }
+ return subject;
+ };
+ function d3_geom_polygonInside(p, a, b) {
+ return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]);
+ }
+ function d3_geom_polygonIntersect(c, d, a, b) {
+ var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21);
+ return [ x1 + ua * x21, y1 + ua * y21 ];
+ }
+ function d3_geom_polygonClosed(coordinates) {
+ var a = coordinates[0], b = coordinates[coordinates.length - 1];
+ return !(a[0] - b[0] || a[1] - b[1]);
+ }
+ var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = [];
+ function d3_geom_voronoiBeach() {
+ d3_geom_voronoiRedBlackNode(this);
+ this.edge = this.site = this.circle = null;
+ }
+ function d3_geom_voronoiCreateBeach(site) {
+ var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach();
+ beach.site = site;
+ return beach;
+ }
+ function d3_geom_voronoiDetachBeach(beach) {
+ d3_geom_voronoiDetachCircle(beach);
+ d3_geom_voronoiBeaches.remove(beach);
+ d3_geom_voronoiBeachPool.push(beach);
+ d3_geom_voronoiRedBlackNode(beach);
+ }
+ function d3_geom_voronoiRemoveBeach(beach) {
+ var circle = beach.circle, x = circle.x, y = circle.cy, vertex = {
+ x: x,
+ y: y
+ }, previous = beach.P, next = beach.N, disappearing = [ beach ];
+ d3_geom_voronoiDetachBeach(beach);
+ var lArc = previous;
+ while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) {
+ previous = lArc.P;
+ disappearing.unshift(lArc);
+ d3_geom_voronoiDetachBeach(lArc);
+ lArc = previous;
+ }
+ disappearing.unshift(lArc);
+ d3_geom_voronoiDetachCircle(lArc);
+ var rArc = next;
+ while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) {
+ next = rArc.N;
+ disappearing.push(rArc);
+ d3_geom_voronoiDetachBeach(rArc);
+ rArc = next;
+ }
+ disappearing.push(rArc);
+ d3_geom_voronoiDetachCircle(rArc);
+ var nArcs = disappearing.length, iArc;
+ for (iArc = 1; iArc < nArcs; ++iArc) {
+ rArc = disappearing[iArc];
+ lArc = disappearing[iArc - 1];
+ d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);
+ }
+ lArc = disappearing[0];
+ rArc = disappearing[nArcs - 1];
+ rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ }
+ function d3_geom_voronoiAddBeach(site) {
+ var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._;
+ while (node) {
+ dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x;
+ if (dxl > ε) node = node.L; else {
+ dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix);
+ if (dxr > ε) {
+ if (!node.R) {
+ lArc = node;
+ break;
+ }
+ node = node.R;
+ } else {
+ if (dxl > -ε) {
+ lArc = node.P;
+ rArc = node;
+ } else if (dxr > -ε) {
+ lArc = node;
+ rArc = node.N;
+ } else {
+ lArc = rArc = node;
+ }
+ break;
+ }
+ }
+ }
+ var newArc = d3_geom_voronoiCreateBeach(site);
+ d3_geom_voronoiBeaches.insert(lArc, newArc);
+ if (!lArc && !rArc) return;
+ if (lArc === rArc) {
+ d3_geom_voronoiDetachCircle(lArc);
+ rArc = d3_geom_voronoiCreateBeach(lArc.site);
+ d3_geom_voronoiBeaches.insert(newArc, rArc);
+ newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ return;
+ }
+ if (!rArc) {
+ newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+ return;
+ }
+ d3_geom_voronoiDetachCircle(lArc);
+ d3_geom_voronoiDetachCircle(rArc);
+ var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = {
+ x: (cy * hb - by * hc) / d + ax,
+ y: (bx * hc - cx * hb) / d + ay
+ };
+ d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex);
+ newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex);
+ rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex);
+ d3_geom_voronoiAttachCircle(lArc);
+ d3_geom_voronoiAttachCircle(rArc);
+ }
+ function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
+ var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix;
+ if (!pby2) return rfocx;
+ var lArc = arc.P;
+ if (!lArc) return -Infinity;
+ site = lArc.site;
+ var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix;
+ if (!plby2) return lfocx;
+ var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2;
+ if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
+ return (rfocx + lfocx) / 2;
+ }
+ function d3_geom_voronoiRightBreakPoint(arc, directrix) {
+ var rArc = arc.N;
+ if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
+ var site = arc.site;
+ return site.y === directrix ? site.x : Infinity;
+ }
+ function d3_geom_voronoiCell(site) {
+ this.site = site;
+ this.edges = [];
+ }
+ d3_geom_voronoiCell.prototype.prepare = function() {
+ var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge;
+ while (iHalfEdge--) {
+ edge = halfEdges[iHalfEdge].edge;
+ if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
+ }
+ halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
+ return halfEdges.length;
+ };
+ function d3_geom_voronoiCloseCells(extent) {
+ var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end;
+ while (iCell--) {
+ cell = cells[iCell];
+ if (!cell || !cell.prepare()) continue;
+ halfEdges = cell.edges;
+ nHalfEdges = halfEdges.length;
+ iHalfEdge = 0;
+ while (iHalfEdge < nHalfEdges) {
+ end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
+ start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
+ if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
+ halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? {
+ x: x0,
+ y: abs(x2 - x0) < ε ? y2 : y1
+ } : abs(y3 - y1) < ε && x1 - x3 > ε ? {
+ x: abs(y2 - y1) < ε ? x2 : x1,
+ y: y1
+ } : abs(x3 - x1) < ε && y3 - y0 > ε ? {
+ x: x1,
+ y: abs(x2 - x1) < ε ? y2 : y0
+ } : abs(y3 - y0) < ε && x3 - x0 > ε ? {
+ x: abs(y2 - y0) < ε ? x2 : x0,
+ y: y0
+ } : null), cell.site, null));
+ ++nHalfEdges;
+ }
+ }
+ }
+ }
+ function d3_geom_voronoiHalfEdgeOrder(a, b) {
+ return b.angle - a.angle;
+ }
+ function d3_geom_voronoiCircle() {
+ d3_geom_voronoiRedBlackNode(this);
+ this.x = this.y = this.arc = this.site = this.cy = null;
+ }
+ function d3_geom_voronoiAttachCircle(arc) {
+ var lArc = arc.P, rArc = arc.N;
+ if (!lArc || !rArc) return;
+ var lSite = lArc.site, cSite = arc.site, rSite = rArc.site;
+ if (lSite === rSite) return;
+ var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by;
+ var d = 2 * (ax * cy - ay * cx);
+ if (d >= -ε2) return;
+ var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by;
+ var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle();
+ circle.arc = arc;
+ circle.site = cSite;
+ circle.x = x + bx;
+ circle.y = cy + Math.sqrt(x * x + y * y);
+ circle.cy = cy;
+ arc.circle = circle;
+ var before = null, node = d3_geom_voronoiCircles._;
+ while (node) {
+ if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) {
+ if (node.L) node = node.L; else {
+ before = node.P;
+ break;
+ }
+ } else {
+ if (node.R) node = node.R; else {
+ before = node;
+ break;
+ }
+ }
+ }
+ d3_geom_voronoiCircles.insert(before, circle);
+ if (!before) d3_geom_voronoiFirstCircle = circle;
+ }
+ function d3_geom_voronoiDetachCircle(arc) {
+ var circle = arc.circle;
+ if (circle) {
+ if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
+ d3_geom_voronoiCircles.remove(circle);
+ d3_geom_voronoiCirclePool.push(circle);
+ d3_geom_voronoiRedBlackNode(circle);
+ arc.circle = null;
+ }
+ }
+ function d3_geom_voronoiClipEdges(extent) {
+ var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e;
+ while (i--) {
+ e = edges[i];
+ if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) {
+ e.a = e.b = null;
+ edges.splice(i, 1);
+ }
+ }
+ }
+ function d3_geom_voronoiConnectEdge(edge, extent) {
+ var vb = edge.b;
+ if (vb) return true;
+ var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb;
+ if (ry === ly) {
+ if (fx < x0 || fx >= x1) return;
+ if (lx > rx) {
+ if (!va) va = {
+ x: fx,
+ y: y0
+ }; else if (va.y >= y1) return;
+ vb = {
+ x: fx,
+ y: y1
+ };
+ } else {
+ if (!va) va = {
+ x: fx,
+ y: y1
+ }; else if (va.y < y0) return;
+ vb = {
+ x: fx,
+ y: y0
+ };
+ }
+ } else {
+ fm = (lx - rx) / (ry - ly);
+ fb = fy - fm * fx;
+ if (fm < -1 || fm > 1) {
+ if (lx > rx) {
+ if (!va) va = {
+ x: (y0 - fb) / fm,
+ y: y0
+ }; else if (va.y >= y1) return;
+ vb = {
+ x: (y1 - fb) / fm,
+ y: y1
+ };
+ } else {
+ if (!va) va = {
+ x: (y1 - fb) / fm,
+ y: y1
+ }; else if (va.y < y0) return;
+ vb = {
+ x: (y0 - fb) / fm,
+ y: y0
+ };
+ }
+ } else {
+ if (ly < ry) {
+ if (!va) va = {
+ x: x0,
+ y: fm * x0 + fb
+ }; else if (va.x >= x1) return;
+ vb = {
+ x: x1,
+ y: fm * x1 + fb
+ };
+ } else {
+ if (!va) va = {
+ x: x1,
+ y: fm * x1 + fb
+ }; else if (va.x < x0) return;
+ vb = {
+ x: x0,
+ y: fm * x0 + fb
+ };
+ }
+ }
+ }
+ edge.a = va;
+ edge.b = vb;
+ return true;
+ }
+ function d3_geom_voronoiEdge(lSite, rSite) {
+ this.l = lSite;
+ this.r = rSite;
+ this.a = this.b = null;
+ }
+ function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
+ var edge = new d3_geom_voronoiEdge(lSite, rSite);
+ d3_geom_voronoiEdges.push(edge);
+ if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va);
+ if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb);
+ d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
+ d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
+ return edge;
+ }
+ function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
+ var edge = new d3_geom_voronoiEdge(lSite, null);
+ edge.a = va;
+ edge.b = vb;
+ d3_geom_voronoiEdges.push(edge);
+ return edge;
+ }
+ function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
+ if (!edge.a && !edge.b) {
+ edge.a = vertex;
+ edge.l = lSite;
+ edge.r = rSite;
+ } else if (edge.l === rSite) {
+ edge.b = vertex;
+ } else {
+ edge.a = vertex;
+ }
+ }
+ function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
+ var va = edge.a, vb = edge.b;
+ this.edge = edge;
+ this.site = lSite;
+ this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y);
+ }
+ d3_geom_voronoiHalfEdge.prototype = {
+ start: function() {
+ return this.edge.l === this.site ? this.edge.a : this.edge.b;
+ },
+ end: function() {
+ return this.edge.l === this.site ? this.edge.b : this.edge.a;
+ }
+ };
+ function d3_geom_voronoiRedBlackTree() {
+ this._ = null;
+ }
+ function d3_geom_voronoiRedBlackNode(node) {
+ node.U = node.C = node.L = node.R = node.P = node.N = null;
+ }
+ d3_geom_voronoiRedBlackTree.prototype = {
+ insert: function(after, node) {
+ var parent, grandpa, uncle;
+ if (after) {
+ node.P = after;
+ node.N = after.N;
+ if (after.N) after.N.P = node;
+ after.N = node;
+ if (after.R) {
+ after = after.R;
+ while (after.L) after = after.L;
+ after.L = node;
+ } else {
+ after.R = node;
+ }
+ parent = after;
+ } else if (this._) {
+ after = d3_geom_voronoiRedBlackFirst(this._);
+ node.P = null;
+ node.N = after;
+ after.P = after.L = node;
+ parent = after;
+ } else {
+ node.P = node.N = null;
+ this._ = node;
+ parent = null;
+ }
+ node.L = node.R = null;
+ node.U = parent;
+ node.C = true;
+ after = node;
+ while (parent && parent.C) {
+ grandpa = parent.U;
+ if (parent === grandpa.L) {
+ uncle = grandpa.R;
+ if (uncle && uncle.C) {
+ parent.C = uncle.C = false;
+ grandpa.C = true;
+ after = grandpa;
+ } else {
+ if (after === parent.R) {
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ after = parent;
+ parent = after.U;
+ }
+ parent.C = false;
+ grandpa.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, grandpa);
+ }
+ } else {
+ uncle = grandpa.L;
+ if (uncle && uncle.C) {
+ parent.C = uncle.C = false;
+ grandpa.C = true;
+ after = grandpa;
+ } else {
+ if (after === parent.L) {
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ after = parent;
+ parent = after.U;
+ }
+ parent.C = false;
+ grandpa.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
+ }
+ }
+ parent = after.U;
+ }
+ this._.C = false;
+ },
+ remove: function(node) {
+ if (node.N) node.N.P = node.P;
+ if (node.P) node.P.N = node.N;
+ node.N = node.P = null;
+ var parent = node.U, sibling, left = node.L, right = node.R, next, red;
+ if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right);
+ if (parent) {
+ if (parent.L === node) parent.L = next; else parent.R = next;
+ } else {
+ this._ = next;
+ }
+ if (left && right) {
+ red = next.C;
+ next.C = node.C;
+ next.L = left;
+ left.U = next;
+ if (next !== right) {
+ parent = next.U;
+ next.U = node.U;
+ node = next.R;
+ parent.L = node;
+ next.R = right;
+ right.U = next;
+ } else {
+ next.U = parent;
+ parent = next;
+ node = next.R;
+ }
+ } else {
+ red = node.C;
+ node = next;
+ }
+ if (node) node.U = parent;
+ if (red) return;
+ if (node && node.C) {
+ node.C = false;
+ return;
+ }
+ do {
+ if (node === this._) break;
+ if (node === parent.L) {
+ sibling = parent.R;
+ if (sibling.C) {
+ sibling.C = false;
+ parent.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ sibling = parent.R;
+ }
+ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+ if (!sibling.R || !sibling.R.C) {
+ sibling.L.C = false;
+ sibling.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, sibling);
+ sibling = parent.R;
+ }
+ sibling.C = parent.C;
+ parent.C = sibling.R.C = false;
+ d3_geom_voronoiRedBlackRotateLeft(this, parent);
+ node = this._;
+ break;
+ }
+ } else {
+ sibling = parent.L;
+ if (sibling.C) {
+ sibling.C = false;
+ parent.C = true;
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ sibling = parent.L;
+ }
+ if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) {
+ if (!sibling.L || !sibling.L.C) {
+ sibling.R.C = false;
+ sibling.C = true;
+ d3_geom_voronoiRedBlackRotateLeft(this, sibling);
+ sibling = parent.L;
+ }
+ sibling.C = parent.C;
+ parent.C = sibling.L.C = false;
+ d3_geom_voronoiRedBlackRotateRight(this, parent);
+ node = this._;
+ break;
+ }
+ }
+ sibling.C = true;
+ node = parent;
+ parent = parent.U;
+ } while (!node.C);
+ if (node) node.C = false;
+ }
+ };
+ function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
+ var p = node, q = node.R, parent = p.U;
+ if (parent) {
+ if (parent.L === p) parent.L = q; else parent.R = q;
+ } else {
+ tree._ = q;
+ }
+ q.U = parent;
+ p.U = q;
+ p.R = q.L;
+ if (p.R) p.R.U = p;
+ q.L = p;
+ }
+ function d3_geom_voronoiRedBlackRotateRight(tree, node) {
+ var p = node, q = node.L, parent = p.U;
+ if (parent) {
+ if (parent.L === p) parent.L = q; else parent.R = q;
+ } else {
+ tree._ = q;
+ }
+ q.U = parent;
+ p.U = q;
+ p.L = q.R;
+ if (p.L) p.L.U = p;
+ q.R = p;
+ }
+ function d3_geom_voronoiRedBlackFirst(node) {
+ while (node.L) node = node.L;
+ return node;
+ }
+ function d3_geom_voronoi(sites, bbox) {
+ var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle;
+ d3_geom_voronoiEdges = [];
+ d3_geom_voronoiCells = new Array(sites.length);
+ d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree();
+ d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree();
+ while (true) {
+ circle = d3_geom_voronoiFirstCircle;
+ if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) {
+ if (site.x !== x0 || site.y !== y0) {
+ d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
+ d3_geom_voronoiAddBeach(site);
+ x0 = site.x, y0 = site.y;
+ }
+ site = sites.pop();
+ } else if (circle) {
+ d3_geom_voronoiRemoveBeach(circle.arc);
+ } else {
+ break;
+ }
+ }
+ if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
+ var diagram = {
+ cells: d3_geom_voronoiCells,
+ edges: d3_geom_voronoiEdges
+ };
+ d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null;
+ return diagram;
+ }
+ function d3_geom_voronoiVertexOrder(a, b) {
+ return b.y - a.y || b.x - a.x;
+ }
+ d3.geom.voronoi = function(points) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent;
+ if (points) return voronoi(points);
+ function voronoi(data) {
+ var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1];
+ d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) {
+ var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) {
+ var s = e.start();
+ return [ s.x, s.y ];
+ }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : [];
+ polygon.point = data[i];
+ });
+ return polygons;
+ }
+ function sites(data) {
+ return data.map(function(d, i) {
+ return {
+ x: Math.round(fx(d, i) / ε) * ε,
+ y: Math.round(fy(d, i) / ε) * ε,
+ i: i
+ };
+ });
+ }
+ voronoi.links = function(data) {
+ return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
+ return edge.l && edge.r;
+ }).map(function(edge) {
+ return {
+ source: data[edge.l.i],
+ target: data[edge.r.i]
+ };
+ });
+ };
+ voronoi.triangles = function(data) {
+ var triangles = [];
+ d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) {
+ var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l;
+ while (++j < m) {
+ e0 = e1;
+ s0 = s1;
+ e1 = edges[j].edge;
+ s1 = e1.l === site ? e1.r : e1.l;
+ if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
+ triangles.push([ data[i], data[s0.i], data[s1.i] ]);
+ }
+ }
+ });
+ return triangles;
+ };
+ voronoi.x = function(_) {
+ return arguments.length ? (fx = d3_functor(x = _), voronoi) : x;
+ };
+ voronoi.y = function(_) {
+ return arguments.length ? (fy = d3_functor(y = _), voronoi) : y;
+ };
+ voronoi.clipExtent = function(_) {
+ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
+ clipExtent = _ == null ? d3_geom_voronoiClipExtent : _;
+ return voronoi;
+ };
+ voronoi.size = function(_) {
+ if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
+ return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]);
+ };
+ return voronoi;
+ };
+ var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ];
+ function d3_geom_voronoiTriangleArea(a, b, c) {
+ return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y);
+ }
+ d3.geom.delaunay = function(vertices) {
+ return d3.geom.voronoi().triangles(vertices);
+ };
+ d3.geom.quadtree = function(points, x1, y1, x2, y2) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, compat;
+ if (compat = arguments.length) {
+ x = d3_geom_quadtreeCompatX;
+ y = d3_geom_quadtreeCompatY;
+ if (compat === 3) {
+ y2 = y1;
+ x2 = x1;
+ y1 = x1 = 0;
+ }
+ return quadtree(points);
+ }
+ function quadtree(data) {
+ var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_;
+ if (x1 != null) {
+ x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
+ } else {
+ x2_ = y2_ = -(x1_ = y1_ = Infinity);
+ xs = [], ys = [];
+ n = data.length;
+ if (compat) for (i = 0; i < n; ++i) {
+ d = data[i];
+ if (d.x < x1_) x1_ = d.x;
+ if (d.y < y1_) y1_ = d.y;
+ if (d.x > x2_) x2_ = d.x;
+ if (d.y > y2_) y2_ = d.y;
+ xs.push(d.x);
+ ys.push(d.y);
+ } else for (i = 0; i < n; ++i) {
+ var x_ = +fx(d = data[i], i), y_ = +fy(d, i);
+ if (x_ < x1_) x1_ = x_;
+ if (y_ < y1_) y1_ = y_;
+ if (x_ > x2_) x2_ = x_;
+ if (y_ > y2_) y2_ = y_;
+ xs.push(x_);
+ ys.push(y_);
+ }
+ }
+ var dx = x2_ - x1_, dy = y2_ - y1_;
+ if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy;
+ function insert(n, d, x, y, x1, y1, x2, y2) {
+ if (isNaN(x) || isNaN(y)) return;
+ if (n.leaf) {
+ var nx = n.x, ny = n.y;
+ if (nx != null) {
+ if (abs(nx - x) + abs(ny - y) < .01) {
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ } else {
+ var nPoint = n.point;
+ n.x = n.y = n.point = null;
+ insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ }
+ } else {
+ n.x = x, n.y = y, n.point = d;
+ }
+ } else {
+ insertChild(n, d, x, y, x1, y1, x2, y2);
+ }
+ }
+ function insertChild(n, d, x, y, x1, y1, x2, y2) {
+ var xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym, i = below << 1 | right;
+ n.leaf = false;
+ n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());
+ if (right) x1 = xm; else x2 = xm;
+ if (below) y1 = ym; else y2 = ym;
+ insert(n, d, x, y, x1, y1, x2, y2);
+ }
+ var root = d3_geom_quadtreeNode();
+ root.add = function(d) {
+ insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
+ };
+ root.visit = function(f) {
+ d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
+ };
+ root.find = function(point) {
+ return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
+ };
+ i = -1;
+ if (x1 == null) {
+ while (++i < n) {
+ insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
+ }
+ --i;
+ } else data.forEach(root.add);
+ xs = ys = data = d = null;
+ return root;
+ }
+ quadtree.x = function(_) {
+ return arguments.length ? (x = _, quadtree) : x;
+ };
+ quadtree.y = function(_) {
+ return arguments.length ? (y = _, quadtree) : y;
+ };
+ quadtree.extent = function(_) {
+ if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ];
+ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0],
+ y2 = +_[1][1];
+ return quadtree;
+ };
+ quadtree.size = function(_) {
+ if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ];
+ if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
+ return quadtree;
+ };
+ return quadtree;
+ };
+ function d3_geom_quadtreeCompatX(d) {
+ return d.x;
+ }
+ function d3_geom_quadtreeCompatY(d) {
+ return d.y;
+ }
+ function d3_geom_quadtreeNode() {
+ return {
+ leaf: true,
+ nodes: [],
+ point: null,
+ x: null,
+ y: null
+ };
+ }
+ function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
+ if (!f(node, x1, y1, x2, y2)) {
+ var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes;
+ if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
+ if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
+ if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
+ if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
+ }
+ }
+ function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
+ var minDistance2 = Infinity, closestPoint;
+ (function find(node, x1, y1, x2, y2) {
+ if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return;
+ if (point = node.point) {
+ var point, dx = x - node.x, dy = y - node.y, distance2 = dx * dx + dy * dy;
+ if (distance2 < minDistance2) {
+ var distance = Math.sqrt(minDistance2 = distance2);
+ x0 = x - distance, y0 = y - distance;
+ x3 = x + distance, y3 = y + distance;
+ closestPoint = point;
+ }
+ }
+ var children = node.nodes, xm = (x1 + x2) * .5, ym = (y1 + y2) * .5, right = x >= xm, below = y >= ym;
+ for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
+ if (node = children[i & 3]) switch (i & 3) {
+ case 0:
+ find(node, x1, y1, xm, ym);
+ break;
+
+ case 1:
+ find(node, xm, y1, x2, ym);
+ break;
+
+ case 2:
+ find(node, x1, ym, xm, y2);
+ break;
+
+ case 3:
+ find(node, xm, ym, x2, y2);
+ break;
+ }
+ }
+ })(root, x0, y0, x3, y3);
+ return closestPoint;
+ }
+ d3.interpolateRgb = d3_interpolateRgb;
+ function d3_interpolateRgb(a, b) {
+ a = d3.rgb(a);
+ b = d3.rgb(b);
+ var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;
+ return function(t) {
+ return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t));
+ };
+ }
+ d3.interpolateObject = d3_interpolateObject;
+ function d3_interpolateObject(a, b) {
+ var i = {}, c = {}, k;
+ for (k in a) {
+ if (k in b) {
+ i[k] = d3_interpolate(a[k], b[k]);
+ } else {
+ c[k] = a[k];
+ }
+ }
+ for (k in b) {
+ if (!(k in a)) {
+ c[k] = b[k];
+ }
+ }
+ return function(t) {
+ for (k in i) c[k] = i[k](t);
+ return c;
+ };
+ }
+ d3.interpolateNumber = d3_interpolateNumber;
+ function d3_interpolateNumber(a, b) {
+ a = +a, b = +b;
+ return function(t) {
+ return a * (1 - t) + b * t;
+ };
+ }
+ d3.interpolateString = d3_interpolateString;
+ function d3_interpolateString(a, b) {
+ var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = [];
+ a = a + "", b = b + "";
+ while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) {
+ if ((bs = bm.index) > bi) {
+ bs = b.slice(bi, bs);
+ if (s[i]) s[i] += bs; else s[++i] = bs;
+ }
+ if ((am = am[0]) === (bm = bm[0])) {
+ if (s[i]) s[i] += bm; else s[++i] = bm;
+ } else {
+ s[++i] = null;
+ q.push({
+ i: i,
+ x: d3_interpolateNumber(am, bm)
+ });
+ }
+ bi = d3_interpolate_numberB.lastIndex;
+ }
+ if (bi < b.length) {
+ bs = b.slice(bi);
+ if (s[i]) s[i] += bs; else s[++i] = bs;
+ }
+ return s.length < 2 ? q[0] ? (b = q[0].x, function(t) {
+ return b(t) + "";
+ }) : function() {
+ return b;
+ } : (b = q.length, function(t) {
+ for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ });
+ }
+ var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g");
+ d3.interpolate = d3_interpolate;
+ function d3_interpolate(a, b) {
+ var i = d3.interpolators.length, f;
+ while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ;
+ return f;
+ }
+ d3.interpolators = [ function(a, b) {
+ var t = typeof b;
+ return (t === "string" ? d3_rgb_names.has(b.toLowerCase()) || /^(#|rgb\(|hsl\()/i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);
+ } ];
+ d3.interpolateArray = d3_interpolateArray;
+ function d3_interpolateArray(a, b) {
+ var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i;
+ for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i]));
+ for (;i < na; ++i) c[i] = a[i];
+ for (;i < nb; ++i) c[i] = b[i];
+ return function(t) {
+ for (i = 0; i < n0; ++i) c[i] = x[i](t);
+ return c;
+ };
+ }
+ var d3_ease_default = function() {
+ return d3_identity;
+ };
+ var d3_ease = d3.map({
+ linear: d3_ease_default,
+ poly: d3_ease_poly,
+ quad: function() {
+ return d3_ease_quad;
+ },
+ cubic: function() {
+ return d3_ease_cubic;
+ },
+ sin: function() {
+ return d3_ease_sin;
+ },
+ exp: function() {
+ return d3_ease_exp;
+ },
+ circle: function() {
+ return d3_ease_circle;
+ },
+ elastic: d3_ease_elastic,
+ back: d3_ease_back,
+ bounce: function() {
+ return d3_ease_bounce;
+ }
+ });
+ var d3_ease_mode = d3.map({
+ "in": d3_identity,
+ out: d3_ease_reverse,
+ "in-out": d3_ease_reflect,
+ "out-in": function(f) {
+ return d3_ease_reflect(d3_ease_reverse(f));
+ }
+ });
+ d3.ease = function(name) {
+ var i = name.indexOf("-"), t = i >= 0 ? name.slice(0, i) : name, m = i >= 0 ? name.slice(i + 1) : "in";
+ t = d3_ease.get(t) || d3_ease_default;
+ m = d3_ease_mode.get(m) || d3_identity;
+ return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));
+ };
+ function d3_ease_clamp(f) {
+ return function(t) {
+ return t <= 0 ? 0 : t >= 1 ? 1 : f(t);
+ };
+ }
+ function d3_ease_reverse(f) {
+ return function(t) {
+ return 1 - f(1 - t);
+ };
+ }
+ function d3_ease_reflect(f) {
+ return function(t) {
+ return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t));
+ };
+ }
+ function d3_ease_quad(t) {
+ return t * t;
+ }
+ function d3_ease_cubic(t) {
+ return t * t * t;
+ }
+ function d3_ease_cubicInOut(t) {
+ if (t <= 0) return 0;
+ if (t >= 1) return 1;
+ var t2 = t * t, t3 = t2 * t;
+ return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75);
+ }
+ function d3_ease_poly(e) {
+ return function(t) {
+ return Math.pow(t, e);
+ };
+ }
+ function d3_ease_sin(t) {
+ return 1 - Math.cos(t * halfπ);
+ }
+ function d3_ease_exp(t) {
+ return Math.pow(2, 10 * (t - 1));
+ }
+ function d3_ease_circle(t) {
+ return 1 - Math.sqrt(1 - t * t);
+ }
+ function d3_ease_elastic(a, p) {
+ var s;
+ if (arguments.length < 2) p = .45;
+ if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4;
+ return function(t) {
+ return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p);
+ };
+ }
+ function d3_ease_back(s) {
+ if (!s) s = 1.70158;
+ return function(t) {
+ return t * t * ((s + 1) * t - s);
+ };
+ }
+ function d3_ease_bounce(t) {
+ return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
+ }
+ d3.interpolateHcl = d3_interpolateHcl;
+ function d3_interpolateHcl(a, b) {
+ a = d3.hcl(a);
+ b = d3.hcl(b);
+ var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al;
+ if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac;
+ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+ return function(t) {
+ return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + "";
+ };
+ }
+ d3.interpolateHsl = d3_interpolateHsl;
+ function d3_interpolateHsl(a, b) {
+ a = d3.hsl(a);
+ b = d3.hsl(b);
+ var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;
+ if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as;
+ if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360;
+ return function(t) {
+ return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + "";
+ };
+ }
+ d3.interpolateLab = d3_interpolateLab;
+ function d3_interpolateLab(a, b) {
+ a = d3.lab(a);
+ b = d3.lab(b);
+ var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab;
+ return function(t) {
+ return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + "";
+ };
+ }
+ d3.interpolateRound = d3_interpolateRound;
+ function d3_interpolateRound(a, b) {
+ b -= a;
+ return function(t) {
+ return Math.round(a + b * t);
+ };
+ }
+ d3.transform = function(string) {
+ var g = d3_document.createElementNS(d3.ns.prefix.svg, "g");
+ return (d3.transform = function(string) {
+ if (string != null) {
+ g.setAttribute("transform", string);
+ var t = g.transform.baseVal.consolidate();
+ }
+ return new d3_transform(t ? t.matrix : d3_transformIdentity);
+ })(string);
+ };
+ function d3_transform(m) {
+ var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
+ if (r0[0] * r1[1] < r1[0] * r0[1]) {
+ r0[0] *= -1;
+ r0[1] *= -1;
+ kx *= -1;
+ kz *= -1;
+ }
+ this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
+ this.translate = [ m.e, m.f ];
+ this.scale = [ kx, ky ];
+ this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
+ }
+ d3_transform.prototype.toString = function() {
+ return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";
+ };
+ function d3_transformDot(a, b) {
+ return a[0] * b[0] + a[1] * b[1];
+ }
+ function d3_transformNormalize(a) {
+ var k = Math.sqrt(d3_transformDot(a, a));
+ if (k) {
+ a[0] /= k;
+ a[1] /= k;
+ }
+ return k;
+ }
+ function d3_transformCombine(a, b, k) {
+ a[0] += k * b[0];
+ a[1] += k * b[1];
+ return a;
+ }
+ var d3_transformIdentity = {
+ a: 1,
+ b: 0,
+ c: 0,
+ d: 1,
+ e: 0,
+ f: 0
+ };
+ d3.interpolateTransform = d3_interpolateTransform;
+ function d3_interpolateTransformPop(s) {
+ return s.length ? s.pop() + "," : "";
+ }
+ function d3_interpolateTranslate(ta, tb, s, q) {
+ if (ta[0] !== tb[0] || ta[1] !== tb[1]) {
+ var i = s.push("translate(", null, ",", null, ")");
+ q.push({
+ i: i - 4,
+ x: d3_interpolateNumber(ta[0], tb[0])
+ }, {
+ i: i - 2,
+ x: d3_interpolateNumber(ta[1], tb[1])
+ });
+ } else if (tb[0] || tb[1]) {
+ s.push("translate(" + tb + ")");
+ }
+ }
+ function d3_interpolateRotate(ra, rb, s, q) {
+ if (ra !== rb) {
+ if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360;
+ q.push({
+ i: s.push(d3_interpolateTransformPop(s) + "rotate(", null, ")") - 2,
+ x: d3_interpolateNumber(ra, rb)
+ });
+ } else if (rb) {
+ s.push(d3_interpolateTransformPop(s) + "rotate(" + rb + ")");
+ }
+ }
+ function d3_interpolateSkew(wa, wb, s, q) {
+ if (wa !== wb) {
+ q.push({
+ i: s.push(d3_interpolateTransformPop(s) + "skewX(", null, ")") - 2,
+ x: d3_interpolateNumber(wa, wb)
+ });
+ } else if (wb) {
+ s.push(d3_interpolateTransformPop(s) + "skewX(" + wb + ")");
+ }
+ }
+ function d3_interpolateScale(ka, kb, s, q) {
+ if (ka[0] !== kb[0] || ka[1] !== kb[1]) {
+ var i = s.push(d3_interpolateTransformPop(s) + "scale(", null, ",", null, ")");
+ q.push({
+ i: i - 4,
+ x: d3_interpolateNumber(ka[0], kb[0])
+ }, {
+ i: i - 2,
+ x: d3_interpolateNumber(ka[1], kb[1])
+ });
+ } else if (kb[0] !== 1 || kb[1] !== 1) {
+ s.push(d3_interpolateTransformPop(s) + "scale(" + kb + ")");
+ }
+ }
+ function d3_interpolateTransform(a, b) {
+ var s = [], q = [];
+ a = d3.transform(a), b = d3.transform(b);
+ d3_interpolateTranslate(a.translate, b.translate, s, q);
+ d3_interpolateRotate(a.rotate, b.rotate, s, q);
+ d3_interpolateSkew(a.skew, b.skew, s, q);
+ d3_interpolateScale(a.scale, b.scale, s, q);
+ a = b = null;
+ return function(t) {
+ var i = -1, n = q.length, o;
+ while (++i < n) s[(o = q[i]).i] = o.x(t);
+ return s.join("");
+ };
+ }
+ function d3_uninterpolateNumber(a, b) {
+ b = (b -= a = +a) || 1 / b;
+ return function(x) {
+ return (x - a) / b;
+ };
+ }
+ function d3_uninterpolateClamp(a, b) {
+ b = (b -= a = +a) || 1 / b;
+ return function(x) {
+ return Math.max(0, Math.min(1, (x - a) / b));
+ };
+ }
+ d3.layout = {};
+ d3.layout.bundle = function() {
+ return function(links) {
+ var paths = [], i = -1, n = links.length;
+ while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
+ return paths;
+ };
+ };
+ function d3_layout_bundlePath(link) {
+ var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ];
+ while (start !== lca) {
+ start = start.parent;
+ points.push(start);
+ }
+ var k = points.length;
+ while (end !== lca) {
+ points.splice(k, 0, end);
+ end = end.parent;
+ }
+ return points;
+ }
+ function d3_layout_bundleAncestors(node) {
+ var ancestors = [], parent = node.parent;
+ while (parent != null) {
+ ancestors.push(node);
+ node = parent;
+ parent = parent.parent;
+ }
+ ancestors.push(node);
+ return ancestors;
+ }
+ function d3_layout_bundleLeastCommonAncestor(a, b) {
+ if (a === b) return a;
+ var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null;
+ while (aNode === bNode) {
+ sharedNode = aNode;
+ aNode = aNodes.pop();
+ bNode = bNodes.pop();
+ }
+ return sharedNode;
+ }
+ d3.layout.chord = function() {
+ var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;
+ function relayout() {
+ var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j;
+ chords = [];
+ groups = [];
+ k = 0, i = -1;
+ while (++i < n) {
+ x = 0, j = -1;
+ while (++j < n) {
+ x += matrix[i][j];
+ }
+ groupSums.push(x);
+ subgroupIndex.push(d3.range(n));
+ k += x;
+ }
+ if (sortGroups) {
+ groupIndex.sort(function(a, b) {
+ return sortGroups(groupSums[a], groupSums[b]);
+ });
+ }
+ if (sortSubgroups) {
+ subgroupIndex.forEach(function(d, i) {
+ d.sort(function(a, b) {
+ return sortSubgroups(matrix[i][a], matrix[i][b]);
+ });
+ });
+ }
+ k = (τ - padding * n) / k;
+ x = 0, i = -1;
+ while (++i < n) {
+ x0 = x, j = -1;
+ while (++j < n) {
+ var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;
+ subgroups[di + "-" + dj] = {
+ index: di,
+ subindex: dj,
+ startAngle: a0,
+ endAngle: a1,
+ value: v
+ };
+ }
+ groups[di] = {
+ index: di,
+ startAngle: x0,
+ endAngle: x,
+ value: groupSums[di]
+ };
+ x += padding;
+ }
+ i = -1;
+ while (++i < n) {
+ j = i - 1;
+ while (++j < n) {
+ var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i];
+ if (source.value || target.value) {
+ chords.push(source.value < target.value ? {
+ source: target,
+ target: source
+ } : {
+ source: source,
+ target: target
+ });
+ }
+ }
+ }
+ if (sortChords) resort();
+ }
+ function resort() {
+ chords.sort(function(a, b) {
+ return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2);
+ });
+ }
+ chord.matrix = function(x) {
+ if (!arguments.length) return matrix;
+ n = (matrix = x) && matrix.length;
+ chords = groups = null;
+ return chord;
+ };
+ chord.padding = function(x) {
+ if (!arguments.length) return padding;
+ padding = x;
+ chords = groups = null;
+ return chord;
+ };
+ chord.sortGroups = function(x) {
+ if (!arguments.length) return sortGroups;
+ sortGroups = x;
+ chords = groups = null;
+ return chord;
+ };
+ chord.sortSubgroups = function(x) {
+ if (!arguments.length) return sortSubgroups;
+ sortSubgroups = x;
+ chords = null;
+ return chord;
+ };
+ chord.sortChords = function(x) {
+ if (!arguments.length) return sortChords;
+ sortChords = x;
+ if (chords) resort();
+ return chord;
+ };
+ chord.chords = function() {
+ if (!chords) relayout();
+ return chords;
+ };
+ chord.groups = function() {
+ if (!groups) relayout();
+ return groups;
+ };
+ return chord;
+ };
+ d3.layout.force = function() {
+ var force = {}, event = d3.dispatch("start", "tick", "end"), timer, size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges;
+ function repulse(node) {
+ return function(quad, x1, _, x2) {
+ if (quad.point !== node) {
+ var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy;
+ if (dw * dw / theta2 < dn) {
+ if (dn < chargeDistance2) {
+ var k = quad.charge / dn;
+ node.px -= dx * k;
+ node.py -= dy * k;
+ }
+ return true;
+ }
+ if (quad.point && dn && dn < chargeDistance2) {
+ var k = quad.pointCharge / dn;
+ node.px -= dx * k;
+ node.py -= dy * k;
+ }
+ }
+ return !quad.charge;
+ };
+ }
+ force.tick = function() {
+ if ((alpha *= .99) < .005) {
+ timer = null;
+ event.end({
+ type: "end",
+ alpha: alpha = 0
+ });
+ return true;
+ }
+ var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y;
+ for (i = 0; i < m; ++i) {
+ o = links[i];
+ s = o.source;
+ t = o.target;
+ x = t.x - s.x;
+ y = t.y - s.y;
+ if (l = x * x + y * y) {
+ l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l;
+ x *= l;
+ y *= l;
+ t.x -= x * (k = s.weight + t.weight ? s.weight / (s.weight + t.weight) : .5);
+ t.y -= y * k;
+ s.x += x * (k = 1 - k);
+ s.y += y * k;
+ }
+ }
+ if (k = alpha * gravity) {
+ x = size[0] / 2;
+ y = size[1] / 2;
+ i = -1;
+ if (k) while (++i < n) {
+ o = nodes[i];
+ o.x += (x - o.x) * k;
+ o.y += (y - o.y) * k;
+ }
+ }
+ if (charge) {
+ d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges);
+ i = -1;
+ while (++i < n) {
+ if (!(o = nodes[i]).fixed) {
+ q.visit(repulse(o));
+ }
+ }
+ }
+ i = -1;
+ while (++i < n) {
+ o = nodes[i];
+ if (o.fixed) {
+ o.x = o.px;
+ o.y = o.py;
+ } else {
+ o.x -= (o.px - (o.px = o.x)) * friction;
+ o.y -= (o.py - (o.py = o.y)) * friction;
+ }
+ }
+ event.tick({
+ type: "tick",
+ alpha: alpha
+ });
+ };
+ force.nodes = function(x) {
+ if (!arguments.length) return nodes;
+ nodes = x;
+ return force;
+ };
+ force.links = function(x) {
+ if (!arguments.length) return links;
+ links = x;
+ return force;
+ };
+ force.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return force;
+ };
+ force.linkDistance = function(x) {
+ if (!arguments.length) return linkDistance;
+ linkDistance = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.distance = force.linkDistance;
+ force.linkStrength = function(x) {
+ if (!arguments.length) return linkStrength;
+ linkStrength = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.friction = function(x) {
+ if (!arguments.length) return friction;
+ friction = +x;
+ return force;
+ };
+ force.charge = function(x) {
+ if (!arguments.length) return charge;
+ charge = typeof x === "function" ? x : +x;
+ return force;
+ };
+ force.chargeDistance = function(x) {
+ if (!arguments.length) return Math.sqrt(chargeDistance2);
+ chargeDistance2 = x * x;
+ return force;
+ };
+ force.gravity = function(x) {
+ if (!arguments.length) return gravity;
+ gravity = +x;
+ return force;
+ };
+ force.theta = function(x) {
+ if (!arguments.length) return Math.sqrt(theta2);
+ theta2 = x * x;
+ return force;
+ };
+ force.alpha = function(x) {
+ if (!arguments.length) return alpha;
+ x = +x;
+ if (alpha) {
+ if (x > 0) {
+ alpha = x;
+ } else {
+ timer.c = null, timer.t = NaN, timer = null;
+ event.end({
+ type: "end",
+ alpha: alpha = 0
+ });
+ }
+ } else if (x > 0) {
+ event.start({
+ type: "start",
+ alpha: alpha = x
+ });
+ timer = d3_timer(force.tick);
+ }
+ return force;
+ };
+ force.start = function() {
+ var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o;
+ for (i = 0; i < n; ++i) {
+ (o = nodes[i]).index = i;
+ o.weight = 0;
+ }
+ for (i = 0; i < m; ++i) {
+ o = links[i];
+ if (typeof o.source == "number") o.source = nodes[o.source];
+ if (typeof o.target == "number") o.target = nodes[o.target];
+ ++o.source.weight;
+ ++o.target.weight;
+ }
+ for (i = 0; i < n; ++i) {
+ o = nodes[i];
+ if (isNaN(o.x)) o.x = position("x", w);
+ if (isNaN(o.y)) o.y = position("y", h);
+ if (isNaN(o.px)) o.px = o.x;
+ if (isNaN(o.py)) o.py = o.y;
+ }
+ distances = [];
+ if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance;
+ strengths = [];
+ if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength;
+ charges = [];
+ if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge;
+ function position(dimension, size) {
+ if (!neighbors) {
+ neighbors = new Array(n);
+ for (j = 0; j < n; ++j) {
+ neighbors[j] = [];
+ }
+ for (j = 0; j < m; ++j) {
+ var o = links[j];
+ neighbors[o.source.index].push(o.target);
+ neighbors[o.target.index].push(o.source);
+ }
+ }
+ var candidates = neighbors[i], j = -1, l = candidates.length, x;
+ while (++j < l) if (!isNaN(x = candidates[j][dimension])) return x;
+ return Math.random() * size;
+ }
+ return force.resume();
+ };
+ force.resume = function() {
+ return force.alpha(.1);
+ };
+ force.stop = function() {
+ return force.alpha(0);
+ };
+ force.drag = function() {
+ if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend);
+ if (!arguments.length) return drag;
+ this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag);
+ };
+ function dragmove(d) {
+ d.px = d3.event.x, d.py = d3.event.y;
+ force.resume();
+ }
+ return d3.rebind(force, event, "on");
+ };
+ function d3_layout_forceDragstart(d) {
+ d.fixed |= 2;
+ }
+ function d3_layout_forceDragend(d) {
+ d.fixed &= ~6;
+ }
+ function d3_layout_forceMouseover(d) {
+ d.fixed |= 4;
+ d.px = d.x, d.py = d.y;
+ }
+ function d3_layout_forceMouseout(d) {
+ d.fixed &= ~4;
+ }
+ function d3_layout_forceAccumulate(quad, alpha, charges) {
+ var cx = 0, cy = 0;
+ quad.charge = 0;
+ if (!quad.leaf) {
+ var nodes = quad.nodes, n = nodes.length, i = -1, c;
+ while (++i < n) {
+ c = nodes[i];
+ if (c == null) continue;
+ d3_layout_forceAccumulate(c, alpha, charges);
+ quad.charge += c.charge;
+ cx += c.charge * c.cx;
+ cy += c.charge * c.cy;
+ }
+ }
+ if (quad.point) {
+ if (!quad.leaf) {
+ quad.point.x += Math.random() - .5;
+ quad.point.y += Math.random() - .5;
+ }
+ var k = alpha * charges[quad.point.index];
+ quad.charge += quad.pointCharge = k;
+ cx += k * quad.point.x;
+ cy += k * quad.point.y;
+ }
+ quad.cx = cx / quad.charge;
+ quad.cy = cy / quad.charge;
+ }
+ var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity;
+ d3.layout.hierarchy = function() {
+ var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue;
+ function hierarchy(root) {
+ var stack = [ root ], nodes = [], node;
+ root.depth = 0;
+ while ((node = stack.pop()) != null) {
+ nodes.push(node);
+ if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) {
+ var n, childs, child;
+ while (--n >= 0) {
+ stack.push(child = childs[n]);
+ child.parent = node;
+ child.depth = node.depth + 1;
+ }
+ if (value) node.value = 0;
+ node.children = childs;
+ } else {
+ if (value) node.value = +value.call(hierarchy, node, node.depth) || 0;
+ delete node.children;
+ }
+ }
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var childs, parent;
+ if (sort && (childs = node.children)) childs.sort(sort);
+ if (value && (parent = node.parent)) parent.value += node.value;
+ });
+ return nodes;
+ }
+ hierarchy.sort = function(x) {
+ if (!arguments.length) return sort;
+ sort = x;
+ return hierarchy;
+ };
+ hierarchy.children = function(x) {
+ if (!arguments.length) return children;
+ children = x;
+ return hierarchy;
+ };
+ hierarchy.value = function(x) {
+ if (!arguments.length) return value;
+ value = x;
+ return hierarchy;
+ };
+ hierarchy.revalue = function(root) {
+ if (value) {
+ d3_layout_hierarchyVisitBefore(root, function(node) {
+ if (node.children) node.value = 0;
+ });
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var parent;
+ if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0;
+ if (parent = node.parent) parent.value += node.value;
+ });
+ }
+ return root;
+ };
+ return hierarchy;
+ };
+ function d3_layout_hierarchyRebind(object, hierarchy) {
+ d3.rebind(object, hierarchy, "sort", "children", "value");
+ object.nodes = object;
+ object.links = d3_layout_hierarchyLinks;
+ return object;
+ }
+ function d3_layout_hierarchyVisitBefore(node, callback) {
+ var nodes = [ node ];
+ while ((node = nodes.pop()) != null) {
+ callback(node);
+ if ((children = node.children) && (n = children.length)) {
+ var n, children;
+ while (--n >= 0) nodes.push(children[n]);
+ }
+ }
+ }
+ function d3_layout_hierarchyVisitAfter(node, callback) {
+ var nodes = [ node ], nodes2 = [];
+ while ((node = nodes.pop()) != null) {
+ nodes2.push(node);
+ if ((children = node.children) && (n = children.length)) {
+ var i = -1, n, children;
+ while (++i < n) nodes.push(children[i]);
+ }
+ }
+ while ((node = nodes2.pop()) != null) {
+ callback(node);
+ }
+ }
+ function d3_layout_hierarchyChildren(d) {
+ return d.children;
+ }
+ function d3_layout_hierarchyValue(d) {
+ return d.value;
+ }
+ function d3_layout_hierarchySort(a, b) {
+ return b.value - a.value;
+ }
+ function d3_layout_hierarchyLinks(nodes) {
+ return d3.merge(nodes.map(function(parent) {
+ return (parent.children || []).map(function(child) {
+ return {
+ source: parent,
+ target: child
+ };
+ });
+ }));
+ }
+ d3.layout.partition = function() {
+ var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ];
+ function position(node, x, dx, dy) {
+ var children = node.children;
+ node.x = x;
+ node.y = node.depth * dy;
+ node.dx = dx;
+ node.dy = dy;
+ if (children && (n = children.length)) {
+ var i = -1, n, c, d;
+ dx = node.value ? dx / node.value : 0;
+ while (++i < n) {
+ position(c = children[i], x, d = c.value * dx, dy);
+ x += d;
+ }
+ }
+ }
+ function depth(node) {
+ var children = node.children, d = 0;
+ if (children && (n = children.length)) {
+ var i = -1, n;
+ while (++i < n) d = Math.max(d, depth(children[i]));
+ }
+ return 1 + d;
+ }
+ function partition(d, i) {
+ var nodes = hierarchy.call(this, d, i);
+ position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
+ return nodes;
+ }
+ partition.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return partition;
+ };
+ return d3_layout_hierarchyRebind(partition, hierarchy);
+ };
+ d3.layout.pie = function() {
+ var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ, padAngle = 0;
+ function pie(data) {
+ var n = data.length, values = data.map(function(d, i) {
+ return +value.call(pie, d, i);
+ }), a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle), da = (typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a, p = Math.min(Math.abs(da) / n, +(typeof padAngle === "function" ? padAngle.apply(this, arguments) : padAngle)), pa = p * (da < 0 ? -1 : 1), sum = d3.sum(values), k = sum ? (da - n * pa) / sum : 0, index = d3.range(n), arcs = [], v;
+ if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) {
+ return values[j] - values[i];
+ } : function(i, j) {
+ return sort(data[i], data[j]);
+ });
+ index.forEach(function(i) {
+ arcs[i] = {
+ data: data[i],
+ value: v = values[i],
+ startAngle: a,
+ endAngle: a += v * k + pa,
+ padAngle: p
+ };
+ });
+ return arcs;
+ }
+ pie.value = function(_) {
+ if (!arguments.length) return value;
+ value = _;
+ return pie;
+ };
+ pie.sort = function(_) {
+ if (!arguments.length) return sort;
+ sort = _;
+ return pie;
+ };
+ pie.startAngle = function(_) {
+ if (!arguments.length) return startAngle;
+ startAngle = _;
+ return pie;
+ };
+ pie.endAngle = function(_) {
+ if (!arguments.length) return endAngle;
+ endAngle = _;
+ return pie;
+ };
+ pie.padAngle = function(_) {
+ if (!arguments.length) return padAngle;
+ padAngle = _;
+ return pie;
+ };
+ return pie;
+ };
+ var d3_layout_pieSortByValue = {};
+ d3.layout.stack = function() {
+ var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY;
+ function stack(data, index) {
+ if (!(n = data.length)) return data;
+ var series = data.map(function(d, i) {
+ return values.call(stack, d, i);
+ });
+ var points = series.map(function(d) {
+ return d.map(function(v, i) {
+ return [ x.call(stack, v, i), y.call(stack, v, i) ];
+ });
+ });
+ var orders = order.call(stack, points, index);
+ series = d3.permute(series, orders);
+ points = d3.permute(points, orders);
+ var offsets = offset.call(stack, points, index);
+ var m = series[0].length, n, i, j, o;
+ for (j = 0; j < m; ++j) {
+ out.call(stack, series[0][j], o = offsets[j], points[0][j][1]);
+ for (i = 1; i < n; ++i) {
+ out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]);
+ }
+ }
+ return data;
+ }
+ stack.values = function(x) {
+ if (!arguments.length) return values;
+ values = x;
+ return stack;
+ };
+ stack.order = function(x) {
+ if (!arguments.length) return order;
+ order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault;
+ return stack;
+ };
+ stack.offset = function(x) {
+ if (!arguments.length) return offset;
+ offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero;
+ return stack;
+ };
+ stack.x = function(z) {
+ if (!arguments.length) return x;
+ x = z;
+ return stack;
+ };
+ stack.y = function(z) {
+ if (!arguments.length) return y;
+ y = z;
+ return stack;
+ };
+ stack.out = function(z) {
+ if (!arguments.length) return out;
+ out = z;
+ return stack;
+ };
+ return stack;
+ };
+ function d3_layout_stackX(d) {
+ return d.x;
+ }
+ function d3_layout_stackY(d) {
+ return d.y;
+ }
+ function d3_layout_stackOut(d, y0, y) {
+ d.y0 = y0;
+ d.y = y;
+ }
+ var d3_layout_stackOrders = d3.map({
+ "inside-out": function(data) {
+ var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) {
+ return max[a] - max[b];
+ }), top = 0, bottom = 0, tops = [], bottoms = [];
+ for (i = 0; i < n; ++i) {
+ j = index[i];
+ if (top < bottom) {
+ top += sums[j];
+ tops.push(j);
+ } else {
+ bottom += sums[j];
+ bottoms.push(j);
+ }
+ }
+ return bottoms.reverse().concat(tops);
+ },
+ reverse: function(data) {
+ return d3.range(data.length).reverse();
+ },
+ "default": d3_layout_stackOrderDefault
+ });
+ var d3_layout_stackOffsets = d3.map({
+ silhouette: function(data) {
+ var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = [];
+ for (j = 0; j < m; ++j) {
+ for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+ if (o > max) max = o;
+ sums.push(o);
+ }
+ for (j = 0; j < m; ++j) {
+ y0[j] = (max - sums[j]) / 2;
+ }
+ return y0;
+ },
+ wiggle: function(data) {
+ var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = [];
+ y0[0] = o = o0 = 0;
+ for (j = 1; j < m; ++j) {
+ for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1];
+ for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) {
+ for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) {
+ s3 += (data[k][j][1] - data[k][j - 1][1]) / dx;
+ }
+ s2 += s3 * data[i][j][1];
+ }
+ y0[j] = o -= s1 ? s2 / s1 * dx : 0;
+ if (o < o0) o0 = o;
+ }
+ for (j = 0; j < m; ++j) y0[j] -= o0;
+ return y0;
+ },
+ expand: function(data) {
+ var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = [];
+ for (j = 0; j < m; ++j) {
+ for (i = 0, o = 0; i < n; i++) o += data[i][j][1];
+ if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k;
+ }
+ for (j = 0; j < m; ++j) y0[j] = 0;
+ return y0;
+ },
+ zero: d3_layout_stackOffsetZero
+ });
+ function d3_layout_stackOrderDefault(data) {
+ return d3.range(data.length);
+ }
+ function d3_layout_stackOffsetZero(data) {
+ var j = -1, m = data[0].length, y0 = [];
+ while (++j < m) y0[j] = 0;
+ return y0;
+ }
+ function d3_layout_stackMaxIndex(array) {
+ var i = 1, j = 0, v = array[0][1], k, n = array.length;
+ for (;i < n; ++i) {
+ if ((k = array[i][1]) > v) {
+ j = i;
+ v = k;
+ }
+ }
+ return j;
+ }
+ function d3_layout_stackReduceSum(d) {
+ return d.reduce(d3_layout_stackSum, 0);
+ }
+ function d3_layout_stackSum(p, d) {
+ return p + d[1];
+ }
+ d3.layout.histogram = function() {
+ var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges;
+ function histogram(data, i) {
+ var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x;
+ while (++i < m) {
+ bin = bins[i] = [];
+ bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]);
+ bin.y = 0;
+ }
+ if (m > 0) {
+ i = -1;
+ while (++i < n) {
+ x = values[i];
+ if (x >= range[0] && x <= range[1]) {
+ bin = bins[d3.bisect(thresholds, x, 1, m) - 1];
+ bin.y += k;
+ bin.push(data[i]);
+ }
+ }
+ }
+ return bins;
+ }
+ histogram.value = function(x) {
+ if (!arguments.length) return valuer;
+ valuer = x;
+ return histogram;
+ };
+ histogram.range = function(x) {
+ if (!arguments.length) return ranger;
+ ranger = d3_functor(x);
+ return histogram;
+ };
+ histogram.bins = function(x) {
+ if (!arguments.length) return binner;
+ binner = typeof x === "number" ? function(range) {
+ return d3_layout_histogramBinFixed(range, x);
+ } : d3_functor(x);
+ return histogram;
+ };
+ histogram.frequency = function(x) {
+ if (!arguments.length) return frequency;
+ frequency = !!x;
+ return histogram;
+ };
+ return histogram;
+ };
+ function d3_layout_histogramBinSturges(range, values) {
+ return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1));
+ }
+ function d3_layout_histogramBinFixed(range, n) {
+ var x = -1, b = +range[0], m = (range[1] - b) / n, f = [];
+ while (++x <= n) f[x] = m * x + b;
+ return f;
+ }
+ function d3_layout_histogramRange(values) {
+ return [ d3.min(values), d3.max(values) ];
+ }
+ d3.layout.pack = function() {
+ var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius;
+ function pack(d, i) {
+ var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() {
+ return radius;
+ };
+ root.x = root.y = 0;
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r = +r(d.value);
+ });
+ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+ if (padding) {
+ var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2;
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r += dr;
+ });
+ d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings);
+ d3_layout_hierarchyVisitAfter(root, function(d) {
+ d.r -= dr;
+ });
+ }
+ d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h));
+ return nodes;
+ }
+ pack.size = function(_) {
+ if (!arguments.length) return size;
+ size = _;
+ return pack;
+ };
+ pack.radius = function(_) {
+ if (!arguments.length) return radius;
+ radius = _ == null || typeof _ === "function" ? _ : +_;
+ return pack;
+ };
+ pack.padding = function(_) {
+ if (!arguments.length) return padding;
+ padding = +_;
+ return pack;
+ };
+ return d3_layout_hierarchyRebind(pack, hierarchy);
+ };
+ function d3_layout_packSort(a, b) {
+ return a.value - b.value;
+ }
+ function d3_layout_packInsert(a, b) {
+ var c = a._pack_next;
+ a._pack_next = b;
+ b._pack_prev = a;
+ b._pack_next = c;
+ c._pack_prev = b;
+ }
+ function d3_layout_packSplice(a, b) {
+ a._pack_next = b;
+ b._pack_prev = a;
+ }
+ function d3_layout_packIntersects(a, b) {
+ var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r;
+ return .999 * dr * dr > dx * dx + dy * dy;
+ }
+ function d3_layout_packSiblings(node) {
+ if (!(nodes = node.children) || !(n = nodes.length)) return;
+ var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n;
+ function bound(node) {
+ xMin = Math.min(node.x - node.r, xMin);
+ xMax = Math.max(node.x + node.r, xMax);
+ yMin = Math.min(node.y - node.r, yMin);
+ yMax = Math.max(node.y + node.r, yMax);
+ }
+ nodes.forEach(d3_layout_packLink);
+ a = nodes[0];
+ a.x = -a.r;
+ a.y = 0;
+ bound(a);
+ if (n > 1) {
+ b = nodes[1];
+ b.x = b.r;
+ b.y = 0;
+ bound(b);
+ if (n > 2) {
+ c = nodes[2];
+ d3_layout_packPlace(a, b, c);
+ bound(c);
+ d3_layout_packInsert(a, c);
+ a._pack_prev = c;
+ d3_layout_packInsert(c, b);
+ b = a._pack_next;
+ for (i = 3; i < n; i++) {
+ d3_layout_packPlace(a, b, c = nodes[i]);
+ var isect = 0, s1 = 1, s2 = 1;
+ for (j = b._pack_next; j !== b; j = j._pack_next, s1++) {
+ if (d3_layout_packIntersects(j, c)) {
+ isect = 1;
+ break;
+ }
+ }
+ if (isect == 1) {
+ for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) {
+ if (d3_layout_packIntersects(k, c)) {
+ break;
+ }
+ }
+ }
+ if (isect) {
+ if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b);
+ i--;
+ } else {
+ d3_layout_packInsert(a, c);
+ b = c;
+ bound(c);
+ }
+ }
+ }
+ }
+ var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0;
+ for (i = 0; i < n; i++) {
+ c = nodes[i];
+ c.x -= cx;
+ c.y -= cy;
+ cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y));
+ }
+ node.r = cr;
+ nodes.forEach(d3_layout_packUnlink);
+ }
+ function d3_layout_packLink(node) {
+ node._pack_next = node._pack_prev = node;
+ }
+ function d3_layout_packUnlink(node) {
+ delete node._pack_next;
+ delete node._pack_prev;
+ }
+ function d3_layout_packTransform(node, x, y, k) {
+ var children = node.children;
+ node.x = x += k * node.x;
+ node.y = y += k * node.y;
+ node.r *= k;
+ if (children) {
+ var i = -1, n = children.length;
+ while (++i < n) d3_layout_packTransform(children[i], x, y, k);
+ }
+ }
+ function d3_layout_packPlace(a, b, c) {
+ var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y;
+ if (db && (dx || dy)) {
+ var da = b.r + c.r, dc = dx * dx + dy * dy;
+ da *= da;
+ db *= db;
+ var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc);
+ c.x = a.x + x * dx + y * dy;
+ c.y = a.y + x * dy - y * dx;
+ } else {
+ c.x = a.x + db;
+ c.y = a.y;
+ }
+ }
+ d3.layout.tree = function() {
+ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null;
+ function tree(d, i) {
+ var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0);
+ d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z;
+ d3_layout_hierarchyVisitBefore(root1, secondWalk);
+ if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else {
+ var left = root0, right = root0, bottom = root0;
+ d3_layout_hierarchyVisitBefore(root0, function(node) {
+ if (node.x < left.x) left = node;
+ if (node.x > right.x) right = node;
+ if (node.depth > bottom.depth) bottom = node;
+ });
+ var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1);
+ d3_layout_hierarchyVisitBefore(root0, function(node) {
+ node.x = (node.x + tx) * kx;
+ node.y = node.depth * ky;
+ });
+ }
+ return nodes;
+ }
+ function wrapTree(root0) {
+ var root1 = {
+ A: null,
+ children: [ root0 ]
+ }, queue = [ root1 ], node1;
+ while ((node1 = queue.pop()) != null) {
+ for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) {
+ queue.push((children[i] = child = {
+ _: children[i],
+ parent: node1,
+ children: (child = children[i].children) && child.slice() || [],
+ A: null,
+ a: null,
+ z: 0,
+ m: 0,
+ c: 0,
+ s: 0,
+ t: null,
+ i: i
+ }).a = child);
+ }
+ }
+ return root1.children[0];
+ }
+ function firstWalk(v) {
+ var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null;
+ if (children.length) {
+ d3_layout_treeShift(v);
+ var midpoint = (children[0].z + children[children.length - 1].z) / 2;
+ if (w) {
+ v.z = w.z + separation(v._, w._);
+ v.m = v.z - midpoint;
+ } else {
+ v.z = midpoint;
+ }
+ } else if (w) {
+ v.z = w.z + separation(v._, w._);
+ }
+ v.parent.A = apportion(v, w, v.parent.A || siblings[0]);
+ }
+ function secondWalk(v) {
+ v._.x = v.z + v.parent.m;
+ v.m += v.parent.m;
+ }
+ function apportion(v, w, ancestor) {
+ if (w) {
+ var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift;
+ while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) {
+ vom = d3_layout_treeLeft(vom);
+ vop = d3_layout_treeRight(vop);
+ vop.a = v;
+ shift = vim.z + sim - vip.z - sip + separation(vim._, vip._);
+ if (shift > 0) {
+ d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift);
+ sip += shift;
+ sop += shift;
+ }
+ sim += vim.m;
+ sip += vip.m;
+ som += vom.m;
+ sop += vop.m;
+ }
+ if (vim && !d3_layout_treeRight(vop)) {
+ vop.t = vim;
+ vop.m += sim - sop;
+ }
+ if (vip && !d3_layout_treeLeft(vom)) {
+ vom.t = vip;
+ vom.m += sip - som;
+ ancestor = v;
+ }
+ }
+ return ancestor;
+ }
+ function sizeNode(node) {
+ node.x *= size[0];
+ node.y = node.depth * size[1];
+ }
+ tree.separation = function(x) {
+ if (!arguments.length) return separation;
+ separation = x;
+ return tree;
+ };
+ tree.size = function(x) {
+ if (!arguments.length) return nodeSize ? null : size;
+ nodeSize = (size = x) == null ? sizeNode : null;
+ return tree;
+ };
+ tree.nodeSize = function(x) {
+ if (!arguments.length) return nodeSize ? size : null;
+ nodeSize = (size = x) == null ? null : sizeNode;
+ return tree;
+ };
+ return d3_layout_hierarchyRebind(tree, hierarchy);
+ };
+ function d3_layout_treeSeparation(a, b) {
+ return a.parent == b.parent ? 1 : 2;
+ }
+ function d3_layout_treeLeft(v) {
+ var children = v.children;
+ return children.length ? children[0] : v.t;
+ }
+ function d3_layout_treeRight(v) {
+ var children = v.children, n;
+ return (n = children.length) ? children[n - 1] : v.t;
+ }
+ function d3_layout_treeMove(wm, wp, shift) {
+ var change = shift / (wp.i - wm.i);
+ wp.c -= change;
+ wp.s += shift;
+ wm.c += change;
+ wp.z += shift;
+ wp.m += shift;
+ }
+ function d3_layout_treeShift(v) {
+ var shift = 0, change = 0, children = v.children, i = children.length, w;
+ while (--i >= 0) {
+ w = children[i];
+ w.z += shift;
+ w.m += shift;
+ shift += w.s + (change += w.c);
+ }
+ }
+ function d3_layout_treeAncestor(vim, v, ancestor) {
+ return vim.a.parent === v.parent ? vim.a : ancestor;
+ }
+ d3.layout.cluster = function() {
+ var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false;
+ function cluster(d, i) {
+ var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0;
+ d3_layout_hierarchyVisitAfter(root, function(node) {
+ var children = node.children;
+ if (children && children.length) {
+ node.x = d3_layout_clusterX(children);
+ node.y = d3_layout_clusterY(children);
+ } else {
+ node.x = previousNode ? x += separation(node, previousNode) : 0;
+ node.y = 0;
+ previousNode = node;
+ }
+ });
+ var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2;
+ d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) {
+ node.x = (node.x - root.x) * size[0];
+ node.y = (root.y - node.y) * size[1];
+ } : function(node) {
+ node.x = (node.x - x0) / (x1 - x0) * size[0];
+ node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1];
+ });
+ return nodes;
+ }
+ cluster.separation = function(x) {
+ if (!arguments.length) return separation;
+ separation = x;
+ return cluster;
+ };
+ cluster.size = function(x) {
+ if (!arguments.length) return nodeSize ? null : size;
+ nodeSize = (size = x) == null;
+ return cluster;
+ };
+ cluster.nodeSize = function(x) {
+ if (!arguments.length) return nodeSize ? size : null;
+ nodeSize = (size = x) != null;
+ return cluster;
+ };
+ return d3_layout_hierarchyRebind(cluster, hierarchy);
+ };
+ function d3_layout_clusterY(children) {
+ return 1 + d3.max(children, function(child) {
+ return child.y;
+ });
+ }
+ function d3_layout_clusterX(children) {
+ return children.reduce(function(x, child) {
+ return x + child.x;
+ }, 0) / children.length;
+ }
+ function d3_layout_clusterLeft(node) {
+ var children = node.children;
+ return children && children.length ? d3_layout_clusterLeft(children[0]) : node;
+ }
+ function d3_layout_clusterRight(node) {
+ var children = node.children, n;
+ return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node;
+ }
+ d3.layout.treemap = function() {
+ var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5));
+ function scale(children, k) {
+ var i = -1, n = children.length, child, area;
+ while (++i < n) {
+ area = (child = children[i]).value * (k < 0 ? 0 : k);
+ child.area = isNaN(area) || area <= 0 ? 0 : area;
+ }
+ }
+ function squarify(node) {
+ var children = node.children;
+ if (children && children.length) {
+ var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n;
+ scale(remaining, rect.dx * rect.dy / node.value);
+ row.area = 0;
+ while ((n = remaining.length) > 0) {
+ row.push(child = remaining[n - 1]);
+ row.area += child.area;
+ if (mode !== "squarify" || (score = worst(row, u)) <= best) {
+ remaining.pop();
+ best = score;
+ } else {
+ row.area -= row.pop().area;
+ position(row, u, rect, false);
+ u = Math.min(rect.dx, rect.dy);
+ row.length = row.area = 0;
+ best = Infinity;
+ }
+ }
+ if (row.length) {
+ position(row, u, rect, true);
+ row.length = row.area = 0;
+ }
+ children.forEach(squarify);
+ }
+ }
+ function stickify(node) {
+ var children = node.children;
+ if (children && children.length) {
+ var rect = pad(node), remaining = children.slice(), child, row = [];
+ scale(remaining, rect.dx * rect.dy / node.value);
+ row.area = 0;
+ while (child = remaining.pop()) {
+ row.push(child);
+ row.area += child.area;
+ if (child.z != null) {
+ position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length);
+ row.length = row.area = 0;
+ }
+ }
+ children.forEach(stickify);
+ }
+ }
+ function worst(row, u) {
+ var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length;
+ while (++i < n) {
+ if (!(r = row[i].area)) continue;
+ if (r < rmin) rmin = r;
+ if (r > rmax) rmax = r;
+ }
+ s *= s;
+ u *= u;
+ return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity;
+ }
+ function position(row, u, rect, flush) {
+ var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o;
+ if (u == rect.dx) {
+ if (flush || v > rect.dy) v = rect.dy;
+ while (++i < n) {
+ o = row[i];
+ o.x = x;
+ o.y = y;
+ o.dy = v;
+ x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0);
+ }
+ o.z = true;
+ o.dx += rect.x + rect.dx - x;
+ rect.y += v;
+ rect.dy -= v;
+ } else {
+ if (flush || v > rect.dx) v = rect.dx;
+ while (++i < n) {
+ o = row[i];
+ o.x = x;
+ o.y = y;
+ o.dx = v;
+ y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0);
+ }
+ o.z = false;
+ o.dy += rect.y + rect.dy - y;
+ rect.x += v;
+ rect.dx -= v;
+ }
+ }
+ function treemap(d) {
+ var nodes = stickies || hierarchy(d), root = nodes[0];
+ root.x = root.y = 0;
+ if (root.value) root.dx = size[0], root.dy = size[1]; else root.dx = root.dy = 0;
+ if (stickies) hierarchy.revalue(root);
+ scale([ root ], root.dx * root.dy / root.value);
+ (stickies ? stickify : squarify)(root);
+ if (sticky) stickies = nodes;
+ return nodes;
+ }
+ treemap.size = function(x) {
+ if (!arguments.length) return size;
+ size = x;
+ return treemap;
+ };
+ treemap.padding = function(x) {
+ if (!arguments.length) return padding;
+ function padFunction(node) {
+ var p = x.call(treemap, node, node.depth);
+ return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p);
+ }
+ function padConstant(node) {
+ return d3_layout_treemapPad(node, x);
+ }
+ var type;
+ pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ],
+ padConstant) : padConstant;
+ return treemap;
+ };
+ treemap.round = function(x) {
+ if (!arguments.length) return round != Number;
+ round = x ? Math.round : Number;
+ return treemap;
+ };
+ treemap.sticky = function(x) {
+ if (!arguments.length) return sticky;
+ sticky = x;
+ stickies = null;
+ return treemap;
+ };
+ treemap.ratio = function(x) {
+ if (!arguments.length) return ratio;
+ ratio = x;
+ return treemap;
+ };
+ treemap.mode = function(x) {
+ if (!arguments.length) return mode;
+ mode = x + "";
+ return treemap;
+ };
+ return d3_layout_hierarchyRebind(treemap, hierarchy);
+ };
+ function d3_layout_treemapPadNull(node) {
+ return {
+ x: node.x,
+ y: node.y,
+ dx: node.dx,
+ dy: node.dy
+ };
+ }
+ function d3_layout_treemapPad(node, padding) {
+ var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2];
+ if (dx < 0) {
+ x += dx / 2;
+ dx = 0;
+ }
+ if (dy < 0) {
+ y += dy / 2;
+ dy = 0;
+ }
+ return {
+ x: x,
+ y: y,
+ dx: dx,
+ dy: dy
+ };
+ }
+ d3.random = {
+ normal: function(µ, σ) {
+ var n = arguments.length;
+ if (n < 2) σ = 1;
+ if (n < 1) µ = 0;
+ return function() {
+ var x, y, r;
+ do {
+ x = Math.random() * 2 - 1;
+ y = Math.random() * 2 - 1;
+ r = x * x + y * y;
+ } while (!r || r > 1);
+ return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r);
+ };
+ },
+ logNormal: function() {
+ var random = d3.random.normal.apply(d3, arguments);
+ return function() {
+ return Math.exp(random());
+ };
+ },
+ bates: function(m) {
+ var random = d3.random.irwinHall(m);
+ return function() {
+ return random() / m;
+ };
+ },
+ irwinHall: function(m) {
+ return function() {
+ for (var s = 0, j = 0; j < m; j++) s += Math.random();
+ return s;
+ };
+ }
+ };
+ d3.scale = {};
+ function d3_scaleExtent(domain) {
+ var start = domain[0], stop = domain[domain.length - 1];
+ return start < stop ? [ start, stop ] : [ stop, start ];
+ }
+ function d3_scaleRange(scale) {
+ return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
+ }
+ function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
+ var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]);
+ return function(x) {
+ return i(u(x));
+ };
+ }
+ function d3_scale_nice(domain, nice) {
+ var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx;
+ if (x1 < x0) {
+ dx = i0, i0 = i1, i1 = dx;
+ dx = x0, x0 = x1, x1 = dx;
+ }
+ domain[i0] = nice.floor(x0);
+ domain[i1] = nice.ceil(x1);
+ return domain;
+ }
+ function d3_scale_niceStep(step) {
+ return step ? {
+ floor: function(x) {
+ return Math.floor(x / step) * step;
+ },
+ ceil: function(x) {
+ return Math.ceil(x / step) * step;
+ }
+ } : d3_scale_niceIdentity;
+ }
+ var d3_scale_niceIdentity = {
+ floor: d3_identity,
+ ceil: d3_identity
+ };
+ function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
+ var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1;
+ if (domain[k] < domain[0]) {
+ domain = domain.slice().reverse();
+ range = range.slice().reverse();
+ }
+ while (++j <= k) {
+ u.push(uninterpolate(domain[j - 1], domain[j]));
+ i.push(interpolate(range[j - 1], range[j]));
+ }
+ return function(x) {
+ var j = d3.bisect(domain, x, 1, k) - 1;
+ return i[j](u[j](x));
+ };
+ }
+ d3.scale.linear = function() {
+ return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false);
+ };
+ function d3_scale_linear(domain, range, interpolate, clamp) {
+ var output, input;
+ function rescale() {
+ var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
+ output = linear(domain, range, uninterpolate, interpolate);
+ input = linear(range, domain, uninterpolate, d3_interpolate);
+ return scale;
+ }
+ function scale(x) {
+ return output(x);
+ }
+ scale.invert = function(y) {
+ return input(y);
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(Number);
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.rangeRound = function(x) {
+ return scale.range(x).interpolate(d3_interpolateRound);
+ };
+ scale.clamp = function(x) {
+ if (!arguments.length) return clamp;
+ clamp = x;
+ return rescale();
+ };
+ scale.interpolate = function(x) {
+ if (!arguments.length) return interpolate;
+ interpolate = x;
+ return rescale();
+ };
+ scale.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ scale.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ scale.nice = function(m) {
+ d3_scale_linearNice(domain, m);
+ return rescale();
+ };
+ scale.copy = function() {
+ return d3_scale_linear(domain, range, interpolate, clamp);
+ };
+ return rescale();
+ }
+ function d3_scale_linearRebind(scale, linear) {
+ return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");
+ }
+ function d3_scale_linearNice(domain, m) {
+ d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+ d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+ return domain;
+ }
+ function d3_scale_linearTickRange(domain, m) {
+ if (m == null) m = 10;
+ var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step;
+ if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2;
+ extent[0] = Math.ceil(extent[0] / step) * step;
+ extent[1] = Math.floor(extent[1] / step) * step + step * .5;
+ extent[2] = step;
+ return extent;
+ }
+ function d3_scale_linearTicks(domain, m) {
+ return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
+ }
+ function d3_scale_linearTickFormat(domain, m, format) {
+ var range = d3_scale_linearTickRange(domain, m);
+ if (format) {
+ var match = d3_format_re.exec(format);
+ match.shift();
+ if (match[8] === "s") {
+ var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1])));
+ if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2]));
+ match[8] = "f";
+ format = d3.format(match.join(""));
+ return function(d) {
+ return format(prefix.scale(d)) + prefix.symbol;
+ };
+ }
+ if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range);
+ format = match.join("");
+ } else {
+ format = ",." + d3_scale_linearPrecision(range[2]) + "f";
+ }
+ return d3.format(format);
+ }
+ var d3_scale_linearFormatSignificant = {
+ s: 1,
+ g: 1,
+ p: 1,
+ r: 1,
+ e: 1
+ };
+ function d3_scale_linearPrecision(value) {
+ return -Math.floor(Math.log(value) / Math.LN10 + .01);
+ }
+ function d3_scale_linearFormatPrecision(type, range) {
+ var p = d3_scale_linearPrecision(range[2]);
+ return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2;
+ }
+ d3.scale.log = function() {
+ return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]);
+ };
+ function d3_scale_log(linear, base, positive, domain) {
+ function log(x) {
+ return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
+ }
+ function pow(x) {
+ return positive ? Math.pow(base, x) : -Math.pow(base, -x);
+ }
+ function scale(x) {
+ return linear(log(x));
+ }
+ scale.invert = function(x) {
+ return pow(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ positive = x[0] >= 0;
+ linear.domain((domain = x.map(Number)).map(log));
+ return scale;
+ };
+ scale.base = function(_) {
+ if (!arguments.length) return base;
+ base = +_;
+ linear.domain(domain.map(log));
+ return scale;
+ };
+ scale.nice = function() {
+ var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative);
+ linear.domain(niced);
+ domain = niced.map(pow);
+ return scale;
+ };
+ scale.ticks = function() {
+ var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base;
+ if (isFinite(j - i)) {
+ if (positive) {
+ for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k);
+ ticks.push(pow(i));
+ } else {
+ ticks.push(pow(i));
+ for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k);
+ }
+ for (i = 0; ticks[i] < u; i++) {}
+ for (j = ticks.length; ticks[j - 1] > v; j--) {}
+ ticks = ticks.slice(i, j);
+ }
+ return ticks;
+ };
+ scale.tickFormat = function(n, format) {
+ if (!arguments.length) return d3_scale_logFormat;
+ if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format);
+ var k = Math.max(1, base * n / scale.ticks().length);
+ return function(d) {
+ var i = d / pow(Math.round(log(d)));
+ if (i * base < base - .5) i *= base;
+ return i <= k ? format(d) : "";
+ };
+ };
+ scale.copy = function() {
+ return d3_scale_log(linear.copy(), base, positive, domain);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = {
+ floor: function(x) {
+ return -Math.ceil(-x);
+ },
+ ceil: function(x) {
+ return -Math.floor(-x);
+ }
+ };
+ d3.scale.pow = function() {
+ return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]);
+ };
+ function d3_scale_pow(linear, exponent, domain) {
+ var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent);
+ function scale(x) {
+ return linear(powp(x));
+ }
+ scale.invert = function(x) {
+ return powb(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ linear.domain((domain = x.map(Number)).map(powp));
+ return scale;
+ };
+ scale.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ scale.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ scale.nice = function(m) {
+ return scale.domain(d3_scale_linearNice(domain, m));
+ };
+ scale.exponent = function(x) {
+ if (!arguments.length) return exponent;
+ powp = d3_scale_powPow(exponent = x);
+ powb = d3_scale_powPow(1 / exponent);
+ linear.domain(domain.map(powp));
+ return scale;
+ };
+ scale.copy = function() {
+ return d3_scale_pow(linear.copy(), exponent, domain);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ function d3_scale_powPow(e) {
+ return function(x) {
+ return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
+ };
+ }
+ d3.scale.sqrt = function() {
+ return d3.scale.pow().exponent(.5);
+ };
+ d3.scale.ordinal = function() {
+ return d3_scale_ordinal([], {
+ t: "range",
+ a: [ [] ]
+ });
+ };
+ function d3_scale_ordinal(domain, ranger) {
+ var index, range, rangeBand;
+ function scale(x) {
+ return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length];
+ }
+ function steps(start, step) {
+ return d3.range(domain.length).map(function(i) {
+ return start + step * i;
+ });
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = [];
+ index = new d3_Map();
+ var i = -1, n = x.length, xi;
+ while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi));
+ return scale[ranger.t].apply(scale, ranger.a);
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ rangeBand = 0;
+ ranger = {
+ t: "range",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangePoints = function(x, padding) {
+ if (arguments.length < 2) padding = 0;
+ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = (start + stop) / 2,
+ 0) : (stop - start) / (domain.length - 1 + padding);
+ range = steps(start + step * padding / 2, step);
+ rangeBand = 0;
+ ranger = {
+ t: "rangePoints",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeRoundPoints = function(x, padding) {
+ if (arguments.length < 2) padding = 0;
+ var start = x[0], stop = x[1], step = domain.length < 2 ? (start = stop = Math.round((start + stop) / 2),
+ 0) : (stop - start) / (domain.length - 1 + padding) | 0;
+ range = steps(start + Math.round(step * padding / 2 + (stop - start - (domain.length - 1 + padding) * step) / 2), step);
+ rangeBand = 0;
+ ranger = {
+ t: "rangeRoundPoints",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeBands = function(x, padding, outerPadding) {
+ if (arguments.length < 2) padding = 0;
+ if (arguments.length < 3) outerPadding = padding;
+ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding);
+ range = steps(start + step * outerPadding, step);
+ if (reverse) range.reverse();
+ rangeBand = step * (1 - padding);
+ ranger = {
+ t: "rangeBands",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeRoundBands = function(x, padding, outerPadding) {
+ if (arguments.length < 2) padding = 0;
+ if (arguments.length < 3) outerPadding = padding;
+ var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding));
+ range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step);
+ if (reverse) range.reverse();
+ rangeBand = Math.round(step * (1 - padding));
+ ranger = {
+ t: "rangeRoundBands",
+ a: arguments
+ };
+ return scale;
+ };
+ scale.rangeBand = function() {
+ return rangeBand;
+ };
+ scale.rangeExtent = function() {
+ return d3_scaleExtent(ranger.a[0]);
+ };
+ scale.copy = function() {
+ return d3_scale_ordinal(domain, ranger);
+ };
+ return scale.domain(domain);
+ }
+ d3.scale.category10 = function() {
+ return d3.scale.ordinal().range(d3_category10);
+ };
+ d3.scale.category20 = function() {
+ return d3.scale.ordinal().range(d3_category20);
+ };
+ d3.scale.category20b = function() {
+ return d3.scale.ordinal().range(d3_category20b);
+ };
+ d3.scale.category20c = function() {
+ return d3.scale.ordinal().range(d3_category20c);
+ };
+ var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString);
+ var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString);
+ var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString);
+ var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString);
+ d3.scale.quantile = function() {
+ return d3_scale_quantile([], []);
+ };
+ function d3_scale_quantile(domain, range) {
+ var thresholds;
+ function rescale() {
+ var k = 0, q = range.length;
+ thresholds = [];
+ while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+ return scale;
+ }
+ function scale(x) {
+ if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(d3_number).filter(d3_numeric).sort(d3_ascending);
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.quantiles = function() {
+ return thresholds;
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ];
+ };
+ scale.copy = function() {
+ return d3_scale_quantile(domain, range);
+ };
+ return rescale();
+ }
+ d3.scale.quantize = function() {
+ return d3_scale_quantize(0, 1, [ 0, 1 ]);
+ };
+ function d3_scale_quantize(x0, x1, range) {
+ var kx, i;
+ function scale(x) {
+ return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
+ }
+ function rescale() {
+ kx = range.length / (x1 - x0);
+ i = range.length - 1;
+ return scale;
+ }
+ scale.domain = function(x) {
+ if (!arguments.length) return [ x0, x1 ];
+ x0 = +x[0];
+ x1 = +x[x.length - 1];
+ return rescale();
+ };
+ scale.range = function(x) {
+ if (!arguments.length) return range;
+ range = x;
+ return rescale();
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ y = y < 0 ? NaN : y / kx + x0;
+ return [ y, y + 1 / kx ];
+ };
+ scale.copy = function() {
+ return d3_scale_quantize(x0, x1, range);
+ };
+ return rescale();
+ }
+ d3.scale.threshold = function() {
+ return d3_scale_threshold([ .5 ], [ 0, 1 ]);
+ };
+ function d3_scale_threshold(domain, range) {
+ function scale(x) {
+ if (x <= x) return range[d3.bisect(domain, x)];
+ }
+ scale.domain = function(_) {
+ if (!arguments.length) return domain;
+ domain = _;
+ return scale;
+ };
+ scale.range = function(_) {
+ if (!arguments.length) return range;
+ range = _;
+ return scale;
+ };
+ scale.invertExtent = function(y) {
+ y = range.indexOf(y);
+ return [ domain[y - 1], domain[y] ];
+ };
+ scale.copy = function() {
+ return d3_scale_threshold(domain, range);
+ };
+ return scale;
+ }
+ d3.scale.identity = function() {
+ return d3_scale_identity([ 0, 1 ]);
+ };
+ function d3_scale_identity(domain) {
+ function identity(x) {
+ return +x;
+ }
+ identity.invert = identity;
+ identity.domain = identity.range = function(x) {
+ if (!arguments.length) return domain;
+ domain = x.map(identity);
+ return identity;
+ };
+ identity.ticks = function(m) {
+ return d3_scale_linearTicks(domain, m);
+ };
+ identity.tickFormat = function(m, format) {
+ return d3_scale_linearTickFormat(domain, m, format);
+ };
+ identity.copy = function() {
+ return d3_scale_identity(domain);
+ };
+ return identity;
+ }
+ d3.svg = {};
+ function d3_zero() {
+ return 0;
+ }
+ d3.svg.arc = function() {
+ var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, cornerRadius = d3_zero, padRadius = d3_svg_arcAuto, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle, padAngle = d3_svg_arcPadAngle;
+ function arc() {
+ var r0 = Math.max(0, +innerRadius.apply(this, arguments)), r1 = Math.max(0, +outerRadius.apply(this, arguments)), a0 = startAngle.apply(this, arguments) - halfπ, a1 = endAngle.apply(this, arguments) - halfπ, da = Math.abs(a1 - a0), cw = a0 > a1 ? 0 : 1;
+ if (r1 < r0) rc = r1, r1 = r0, r0 = rc;
+ if (da >= τε) return circleSegment(r1, cw) + (r0 ? circleSegment(r0, 1 - cw) : "") + "Z";
+ var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
+ if (ap = (+padAngle.apply(this, arguments) || 0) / 2) {
+ rp = padRadius === d3_svg_arcAuto ? Math.sqrt(r0 * r0 + r1 * r1) : +padRadius.apply(this, arguments);
+ if (!cw) p1 *= -1;
+ if (r1) p1 = d3_asin(rp / r1 * Math.sin(ap));
+ if (r0) p0 = d3_asin(rp / r0 * Math.sin(ap));
+ }
+ if (r1) {
+ x0 = r1 * Math.cos(a0 + p1);
+ y0 = r1 * Math.sin(a0 + p1);
+ x1 = r1 * Math.cos(a1 - p1);
+ y1 = r1 * Math.sin(a1 - p1);
+ var l1 = Math.abs(a1 - a0 - 2 * p1) <= π ? 0 : 1;
+ if (p1 && d3_svg_arcSweep(x0, y0, x1, y1) === cw ^ l1) {
+ var h1 = (a0 + a1) / 2;
+ x0 = r1 * Math.cos(h1);
+ y0 = r1 * Math.sin(h1);
+ x1 = y1 = null;
+ }
+ } else {
+ x0 = y0 = 0;
+ }
+ if (r0) {
+ x2 = r0 * Math.cos(a1 - p0);
+ y2 = r0 * Math.sin(a1 - p0);
+ x3 = r0 * Math.cos(a0 + p0);
+ y3 = r0 * Math.sin(a0 + p0);
+ var l0 = Math.abs(a0 - a1 + 2 * p0) <= π ? 0 : 1;
+ if (p0 && d3_svg_arcSweep(x2, y2, x3, y3) === 1 - cw ^ l0) {
+ var h0 = (a0 + a1) / 2;
+ x2 = r0 * Math.cos(h0);
+ y2 = r0 * Math.sin(h0);
+ x3 = y3 = null;
+ }
+ } else {
+ x2 = y2 = 0;
+ }
+ if (da > ε && (rc = Math.min(Math.abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments))) > .001) {
+ cr = r0 < r1 ^ cw ? 0 : 1;
+ var rc1 = rc, rc0 = rc;
+ if (da < π) {
+ var oc = x3 == null ? [ x2, y2 ] : x1 == null ? [ x0, y0 ] : d3_geom_polygonIntersect([ x0, y0 ], [ x3, y3 ], [ x1, y1 ], [ x2, y2 ]), ax = x0 - oc[0], ay = y0 - oc[1], bx = x1 - oc[0], by = y1 - oc[1], kc = 1 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
+ rc0 = Math.min(rc, (r0 - lc) / (kc - 1));
+ rc1 = Math.min(rc, (r1 - lc) / (kc + 1));
+ }
+ if (x1 != null) {
+ var t30 = d3_svg_arcCornerTangents(x3 == null ? [ x2, y2 ] : [ x3, y3 ], [ x0, y0 ], r1, rc1, cw), t12 = d3_svg_arcCornerTangents([ x1, y1 ], [ x2, y2 ], r1, rc1, cw);
+ if (rc === rc1) {
+ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d3_svg_arcSweep(t30[1][0], t30[1][1], t12[1][0], t12[1][1]), ",", cw, " ", t12[1], "A", rc1, ",", rc1, " 0 0,", cr, " ", t12[0]);
+ } else {
+ path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
+ }
+ } else {
+ path.push("M", x0, ",", y0);
+ }
+ if (x3 != null) {
+ var t03 = d3_svg_arcCornerTangents([ x0, y0 ], [ x3, y3 ], r0, -rc0, cw), t21 = d3_svg_arcCornerTangents([ x2, y2 ], x1 == null ? [ x0, y0 ] : [ x1, y1 ], r0, -rc0, cw);
+ if (rc === rc0) {
+ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_svg_arcSweep(t21[1][0], t21[1][1], t03[1][0], t03[1][1]), ",", 1 - cw, " ", t03[1], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+ } else {
+ path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
+ }
+ } else {
+ path.push("L", x2, ",", y2);
+ }
+ } else {
+ path.push("M", x0, ",", y0);
+ if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
+ path.push("L", x2, ",", y2);
+ if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
+ }
+ path.push("Z");
+ return path.join("");
+ }
+ function circleSegment(r1, cw) {
+ return "M0," + r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + -r1 + "A" + r1 + "," + r1 + " 0 1," + cw + " 0," + r1;
+ }
+ arc.innerRadius = function(v) {
+ if (!arguments.length) return innerRadius;
+ innerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.outerRadius = function(v) {
+ if (!arguments.length) return outerRadius;
+ outerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.cornerRadius = function(v) {
+ if (!arguments.length) return cornerRadius;
+ cornerRadius = d3_functor(v);
+ return arc;
+ };
+ arc.padRadius = function(v) {
+ if (!arguments.length) return padRadius;
+ padRadius = v == d3_svg_arcAuto ? d3_svg_arcAuto : d3_functor(v);
+ return arc;
+ };
+ arc.startAngle = function(v) {
+ if (!arguments.length) return startAngle;
+ startAngle = d3_functor(v);
+ return arc;
+ };
+ arc.endAngle = function(v) {
+ if (!arguments.length) return endAngle;
+ endAngle = d3_functor(v);
+ return arc;
+ };
+ arc.padAngle = function(v) {
+ if (!arguments.length) return padAngle;
+ padAngle = d3_functor(v);
+ return arc;
+ };
+ arc.centroid = function() {
+ var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - halfπ;
+ return [ Math.cos(a) * r, Math.sin(a) * r ];
+ };
+ return arc;
+ };
+ var d3_svg_arcAuto = "auto";
+ function d3_svg_arcInnerRadius(d) {
+ return d.innerRadius;
+ }
+ function d3_svg_arcOuterRadius(d) {
+ return d.outerRadius;
+ }
+ function d3_svg_arcStartAngle(d) {
+ return d.startAngle;
+ }
+ function d3_svg_arcEndAngle(d) {
+ return d.endAngle;
+ }
+ function d3_svg_arcPadAngle(d) {
+ return d && d.padAngle;
+ }
+ function d3_svg_arcSweep(x0, y0, x1, y1) {
+ return (x0 - x1) * y0 - (y0 - y1) * x0 > 0 ? 0 : 1;
+ }
+ function d3_svg_arcCornerTangents(p0, p1, r1, rc, cw) {
+ var x01 = p0[0] - p1[0], y01 = p0[1] - p1[1], lo = (cw ? rc : -rc) / Math.sqrt(x01 * x01 + y01 * y01), ox = lo * y01, oy = -lo * x01, x1 = p0[0] + ox, y1 = p0[1] + oy, x2 = p1[0] + ox, y2 = p1[1] + oy, x3 = (x1 + x2) / 2, y3 = (y1 + y2) / 2, dx = x2 - x1, dy = y2 - y1, d2 = dx * dx + dy * dy, r = r1 - rc, D = x1 * y2 - x2 * y1, d = (dy < 0 ? -1 : 1) * Math.sqrt(Math.max(0, r * r * d2 - D * D)), cx0 = (D * dy - dx * d) / d2, cy0 = (-D * dx - dy * d) / d2, cx1 = (D * dy + dx * d) / d2, cy1 = (-D * dx + dy * d) / d2, dx0 = cx0 - x3, dy0 = cy0 - y3, dx1 = cx1 - x3, dy1 = cy1 - y3;
+ if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+ return [ [ cx0 - ox, cy0 - oy ], [ cx0 * r1 / r, cy0 * r1 / r ] ];
+ }
+ function d3_svg_line(projection) {
+ var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7;
+ function line(data) {
+ var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y);
+ function segment() {
+ segments.push("M", interpolate(projection(points), tension));
+ }
+ while (++i < n) {
+ if (defined.call(this, d = data[i], i)) {
+ points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]);
+ } else if (points.length) {
+ segment();
+ points = [];
+ }
+ }
+ if (points.length) segment();
+ return segments.length ? segments.join("") : null;
+ }
+ line.x = function(_) {
+ if (!arguments.length) return x;
+ x = _;
+ return line;
+ };
+ line.y = function(_) {
+ if (!arguments.length) return y;
+ y = _;
+ return line;
+ };
+ line.defined = function(_) {
+ if (!arguments.length) return defined;
+ defined = _;
+ return line;
+ };
+ line.interpolate = function(_) {
+ if (!arguments.length) return interpolateKey;
+ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+ return line;
+ };
+ line.tension = function(_) {
+ if (!arguments.length) return tension;
+ tension = _;
+ return line;
+ };
+ return line;
+ }
+ d3.svg.line = function() {
+ return d3_svg_line(d3_identity);
+ };
+ var d3_svg_lineInterpolators = d3.map({
+ linear: d3_svg_lineLinear,
+ "linear-closed": d3_svg_lineLinearClosed,
+ step: d3_svg_lineStep,
+ "step-before": d3_svg_lineStepBefore,
+ "step-after": d3_svg_lineStepAfter,
+ basis: d3_svg_lineBasis,
+ "basis-open": d3_svg_lineBasisOpen,
+ "basis-closed": d3_svg_lineBasisClosed,
+ bundle: d3_svg_lineBundle,
+ cardinal: d3_svg_lineCardinal,
+ "cardinal-open": d3_svg_lineCardinalOpen,
+ "cardinal-closed": d3_svg_lineCardinalClosed,
+ monotone: d3_svg_lineMonotone
+ });
+ d3_svg_lineInterpolators.forEach(function(key, value) {
+ value.key = key;
+ value.closed = /-closed$/.test(key);
+ });
+ function d3_svg_lineLinear(points) {
+ return points.length > 1 ? points.join("L") : points + "Z";
+ }
+ function d3_svg_lineLinearClosed(points) {
+ return points.join("L") + "Z";
+ }
+ function d3_svg_lineStep(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
+ if (n > 1) path.push("H", p[0]);
+ return path.join("");
+ }
+ function d3_svg_lineStepBefore(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
+ return path.join("");
+ }
+ function d3_svg_lineStepAfter(points) {
+ var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
+ while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
+ return path.join("");
+ }
+ function d3_svg_lineCardinalOpen(points, tension) {
+ return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, -1), d3_svg_lineCardinalTangents(points, tension));
+ }
+ function d3_svg_lineCardinalClosed(points, tension) {
+ return points.length < 3 ? d3_svg_lineLinearClosed(points) : points[0] + d3_svg_lineHermite((points.push(points[0]),
+ points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension));
+ }
+ function d3_svg_lineCardinal(points, tension) {
+ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension));
+ }
+ function d3_svg_lineHermite(points, tangents) {
+ if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) {
+ return d3_svg_lineLinear(points);
+ }
+ var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
+ if (quad) {
+ path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
+ p0 = points[1];
+ pi = 2;
+ }
+ if (tangents.length > 1) {
+ t = tangents[1];
+ p = points[pi];
+ pi++;
+ path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+ for (var i = 2; i < tangents.length; i++, pi++) {
+ p = points[pi];
+ t = tangents[i];
+ path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
+ }
+ }
+ if (quad) {
+ var lp = points[pi];
+ path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
+ }
+ return path;
+ }
+ function d3_svg_lineCardinalTangents(points, tension) {
+ var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length;
+ while (++i < n) {
+ p0 = p1;
+ p1 = p2;
+ p2 = points[i];
+ tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]);
+ }
+ return tangents;
+ }
+ function d3_svg_lineBasis(points) {
+ if (points.length < 3) return d3_svg_lineLinear(points);
+ var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+ points.push(points[n - 1]);
+ while (++i <= n) {
+ pi = points[i];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ points.pop();
+ path.push("L", pi);
+ return path.join("");
+ }
+ function d3_svg_lineBasisOpen(points) {
+ if (points.length < 4) return d3_svg_lineLinear(points);
+ var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
+ while (++i < 3) {
+ pi = points[i];
+ px.push(pi[0]);
+ py.push(pi[1]);
+ }
+ path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
+ --i;
+ while (++i < n) {
+ pi = points[i];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ return path.join("");
+ }
+ function d3_svg_lineBasisClosed(points) {
+ var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
+ while (++i < 4) {
+ pi = points[i % n];
+ px.push(pi[0]);
+ py.push(pi[1]);
+ }
+ path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ];
+ --i;
+ while (++i < m) {
+ pi = points[i % n];
+ px.shift();
+ px.push(pi[0]);
+ py.shift();
+ py.push(pi[1]);
+ d3_svg_lineBasisBezier(path, px, py);
+ }
+ return path.join("");
+ }
+ function d3_svg_lineBundle(points, tension) {
+ var n = points.length - 1;
+ if (n) {
+ var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t;
+ while (++i <= n) {
+ p = points[i];
+ t = i / n;
+ p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
+ p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
+ }
+ }
+ return d3_svg_lineBasis(points);
+ }
+ function d3_svg_lineDot4(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+ }
+ var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ];
+ function d3_svg_lineBasisBezier(path, x, y) {
+ path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
+ }
+ function d3_svg_lineSlope(p0, p1) {
+ return (p1[1] - p0[1]) / (p1[0] - p0[0]);
+ }
+ function d3_svg_lineFiniteDifferences(points) {
+ var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1);
+ while (++i < j) {
+ m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2;
+ }
+ m[i] = d;
+ return m;
+ }
+ function d3_svg_lineMonotoneTangents(points) {
+ var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1;
+ while (++i < j) {
+ d = d3_svg_lineSlope(points[i], points[i + 1]);
+ if (abs(d) < ε) {
+ m[i] = m[i + 1] = 0;
+ } else {
+ a = m[i] / d;
+ b = m[i + 1] / d;
+ s = a * a + b * b;
+ if (s > 9) {
+ s = d * 3 / Math.sqrt(s);
+ m[i] = s * a;
+ m[i + 1] = s * b;
+ }
+ }
+ }
+ i = -1;
+ while (++i <= j) {
+ s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i]));
+ tangents.push([ s || 0, m[i] * s || 0 ]);
+ }
+ return tangents;
+ }
+ function d3_svg_lineMonotone(points) {
+ return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
+ }
+ d3.svg.line.radial = function() {
+ var line = d3_svg_line(d3_svg_lineRadial);
+ line.radius = line.x, delete line.x;
+ line.angle = line.y, delete line.y;
+ return line;
+ };
+ function d3_svg_lineRadial(points) {
+ var point, i = -1, n = points.length, r, a;
+ while (++i < n) {
+ point = points[i];
+ r = point[0];
+ a = point[1] - halfπ;
+ point[0] = r * Math.cos(a);
+ point[1] = r * Math.sin(a);
+ }
+ return points;
+ }
+ function d3_svg_area(projection) {
+ var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7;
+ function area(data) {
+ var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() {
+ return x;
+ } : d3_functor(x1), fy1 = y0 === y1 ? function() {
+ return y;
+ } : d3_functor(y1), x, y;
+ function segment() {
+ segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z");
+ }
+ while (++i < n) {
+ if (defined.call(this, d = data[i], i)) {
+ points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]);
+ points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]);
+ } else if (points0.length) {
+ segment();
+ points0 = [];
+ points1 = [];
+ }
+ }
+ if (points0.length) segment();
+ return segments.length ? segments.join("") : null;
+ }
+ area.x = function(_) {
+ if (!arguments.length) return x1;
+ x0 = x1 = _;
+ return area;
+ };
+ area.x0 = function(_) {
+ if (!arguments.length) return x0;
+ x0 = _;
+ return area;
+ };
+ area.x1 = function(_) {
+ if (!arguments.length) return x1;
+ x1 = _;
+ return area;
+ };
+ area.y = function(_) {
+ if (!arguments.length) return y1;
+ y0 = y1 = _;
+ return area;
+ };
+ area.y0 = function(_) {
+ if (!arguments.length) return y0;
+ y0 = _;
+ return area;
+ };
+ area.y1 = function(_) {
+ if (!arguments.length) return y1;
+ y1 = _;
+ return area;
+ };
+ area.defined = function(_) {
+ if (!arguments.length) return defined;
+ defined = _;
+ return area;
+ };
+ area.interpolate = function(_) {
+ if (!arguments.length) return interpolateKey;
+ if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key;
+ interpolateReverse = interpolate.reverse || interpolate;
+ L = interpolate.closed ? "M" : "L";
+ return area;
+ };
+ area.tension = function(_) {
+ if (!arguments.length) return tension;
+ tension = _;
+ return area;
+ };
+ return area;
+ }
+ d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter;
+ d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore;
+ d3.svg.area = function() {
+ return d3_svg_area(d3_identity);
+ };
+ d3.svg.area.radial = function() {
+ var area = d3_svg_area(d3_svg_lineRadial);
+ area.radius = area.x, delete area.x;
+ area.innerRadius = area.x0, delete area.x0;
+ area.outerRadius = area.x1, delete area.x1;
+ area.angle = area.y, delete area.y;
+ area.startAngle = area.y0, delete area.y0;
+ area.endAngle = area.y1, delete area.y1;
+ return area;
+ };
+ d3.svg.chord = function() {
+ var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle;
+ function chord(d, i) {
+ var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i);
+ return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z";
+ }
+ function subgroup(self, f, d, i) {
+ var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) - halfπ, a1 = endAngle.call(self, subgroup, i) - halfπ;
+ return {
+ r: r,
+ a0: a0,
+ a1: a1,
+ p0: [ r * Math.cos(a0), r * Math.sin(a0) ],
+ p1: [ r * Math.cos(a1), r * Math.sin(a1) ]
+ };
+ }
+ function equals(a, b) {
+ return a.a0 == b.a0 && a.a1 == b.a1;
+ }
+ function arc(r, p, a) {
+ return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p;
+ }
+ function curve(r0, p0, r1, p1) {
+ return "Q 0,0 " + p1;
+ }
+ chord.radius = function(v) {
+ if (!arguments.length) return radius;
+ radius = d3_functor(v);
+ return chord;
+ };
+ chord.source = function(v) {
+ if (!arguments.length) return source;
+ source = d3_functor(v);
+ return chord;
+ };
+ chord.target = function(v) {
+ if (!arguments.length) return target;
+ target = d3_functor(v);
+ return chord;
+ };
+ chord.startAngle = function(v) {
+ if (!arguments.length) return startAngle;
+ startAngle = d3_functor(v);
+ return chord;
+ };
+ chord.endAngle = function(v) {
+ if (!arguments.length) return endAngle;
+ endAngle = d3_functor(v);
+ return chord;
+ };
+ return chord;
+ };
+ function d3_svg_chordRadius(d) {
+ return d.radius;
+ }
+ d3.svg.diagonal = function() {
+ var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection;
+ function diagonal(d, i) {
+ var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, {
+ x: p0.x,
+ y: m
+ }, {
+ x: p3.x,
+ y: m
+ }, p3 ];
+ p = p.map(projection);
+ return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
+ }
+ diagonal.source = function(x) {
+ if (!arguments.length) return source;
+ source = d3_functor(x);
+ return diagonal;
+ };
+ diagonal.target = function(x) {
+ if (!arguments.length) return target;
+ target = d3_functor(x);
+ return diagonal;
+ };
+ diagonal.projection = function(x) {
+ if (!arguments.length) return projection;
+ projection = x;
+ return diagonal;
+ };
+ return diagonal;
+ };
+ function d3_svg_diagonalProjection(d) {
+ return [ d.x, d.y ];
+ }
+ d3.svg.diagonal.radial = function() {
+ var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection;
+ diagonal.projection = function(x) {
+ return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection;
+ };
+ return diagonal;
+ };
+ function d3_svg_diagonalRadialProjection(projection) {
+ return function() {
+ var d = projection.apply(this, arguments), r = d[0], a = d[1] - halfπ;
+ return [ r * Math.cos(a), r * Math.sin(a) ];
+ };
+ }
+ d3.svg.symbol = function() {
+ var type = d3_svg_symbolType, size = d3_svg_symbolSize;
+ function symbol(d, i) {
+ return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i));
+ }
+ symbol.type = function(x) {
+ if (!arguments.length) return type;
+ type = d3_functor(x);
+ return symbol;
+ };
+ symbol.size = function(x) {
+ if (!arguments.length) return size;
+ size = d3_functor(x);
+ return symbol;
+ };
+ return symbol;
+ };
+ function d3_svg_symbolSize() {
+ return 64;
+ }
+ function d3_svg_symbolType() {
+ return "circle";
+ }
+ function d3_svg_symbolCircle(size) {
+ var r = Math.sqrt(size / π);
+ return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z";
+ }
+ var d3_svg_symbols = d3.map({
+ circle: d3_svg_symbolCircle,
+ cross: function(size) {
+ var r = Math.sqrt(size / 5) / 2;
+ return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z";
+ },
+ diamond: function(size) {
+ var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30;
+ return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z";
+ },
+ square: function(size) {
+ var r = Math.sqrt(size) / 2;
+ return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z";
+ },
+ "triangle-down": function(size) {
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+ return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z";
+ },
+ "triangle-up": function(size) {
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2;
+ return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z";
+ }
+ });
+ d3.svg.symbolTypes = d3_svg_symbols.keys();
+ var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians);
+ d3_selectionPrototype.transition = function(name) {
+ var id = d3_transitionInheritId || ++d3_transitionId, ns = d3_transitionNamespace(name), subgroups = [], subgroup, node, transition = d3_transitionInherit || {
+ time: Date.now(),
+ ease: d3_ease_cubicInOut,
+ delay: 0,
+ duration: 250
+ };
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) d3_transitionNode(node, i, ns, id, transition);
+ subgroup.push(node);
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_selectionPrototype.interrupt = function(name) {
+ return this.each(name == null ? d3_selection_interrupt : d3_selection_interruptNS(d3_transitionNamespace(name)));
+ };
+ var d3_selection_interrupt = d3_selection_interruptNS(d3_transitionNamespace());
+ function d3_selection_interruptNS(ns) {
+ return function() {
+ var lock, activeId, active;
+ if ((lock = this[ns]) && (active = lock[activeId = lock.active])) {
+ active.timer.c = null;
+ active.timer.t = NaN;
+ if (--lock.count) delete lock[activeId]; else delete this[ns];
+ lock.active += .5;
+ active.event && active.event.interrupt.call(this, this.__data__, active.index);
+ }
+ };
+ }
+ function d3_transition(groups, ns, id) {
+ d3_subclass(groups, d3_transitionPrototype);
+ groups.namespace = ns;
+ groups.id = id;
+ return groups;
+ }
+ var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit;
+ d3_transitionPrototype.call = d3_selectionPrototype.call;
+ d3_transitionPrototype.empty = d3_selectionPrototype.empty;
+ d3_transitionPrototype.node = d3_selectionPrototype.node;
+ d3_transitionPrototype.size = d3_selectionPrototype.size;
+ d3.transition = function(selection, name) {
+ return selection && selection.transition ? d3_transitionInheritId ? selection.transition(name) : selection : d3.selection().transition(selection);
+ };
+ d3.transition.prototype = d3_transitionPrototype;
+ d3_transitionPrototype.select = function(selector) {
+ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnode, node;
+ selector = d3_selection_selector(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) {
+ if ("__data__" in node) subnode.__data__ = node.__data__;
+ d3_transitionNode(subnode, i, ns, id, node[ns][id]);
+ subgroup.push(subnode);
+ } else {
+ subgroup.push(null);
+ }
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_transitionPrototype.selectAll = function(selector) {
+ var id = this.id, ns = this.namespace, subgroups = [], subgroup, subnodes, node, subnode, transition;
+ selector = d3_selection_selectorAll(selector);
+ for (var j = -1, m = this.length; ++j < m; ) {
+ for (var group = this[j], i = -1, n = group.length; ++i < n; ) {
+ if (node = group[i]) {
+ transition = node[ns][id];
+ subnodes = selector.call(node, node.__data__, i, j);
+ subgroups.push(subgroup = []);
+ for (var k = -1, o = subnodes.length; ++k < o; ) {
+ if (subnode = subnodes[k]) d3_transitionNode(subnode, k, ns, id, transition);
+ subgroup.push(subnode);
+ }
+ }
+ }
+ }
+ return d3_transition(subgroups, ns, id);
+ };
+ d3_transitionPrototype.filter = function(filter) {
+ var subgroups = [], subgroup, group, node;
+ if (typeof filter !== "function") filter = d3_selection_filter(filter);
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ if ((node = group[i]) && filter.call(node, node.__data__, i, j)) {
+ subgroup.push(node);
+ }
+ }
+ }
+ return d3_transition(subgroups, this.namespace, this.id);
+ };
+ d3_transitionPrototype.tween = function(name, tween) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 2) return this.node()[ns][id].tween.get(name);
+ return d3_selection_each(this, tween == null ? function(node) {
+ node[ns][id].tween.remove(name);
+ } : function(node) {
+ node[ns][id].tween.set(name, tween);
+ });
+ };
+ function d3_transition_tween(groups, name, value, tween) {
+ var id = groups.id, ns = groups.namespace;
+ return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].tween.set(name, tween(value.call(node, node.__data__, i, j)));
+ } : (value = tween(value), function(node) {
+ node[ns][id].tween.set(name, value);
+ }));
+ }
+ d3_transitionPrototype.attr = function(nameNS, value) {
+ if (arguments.length < 2) {
+ for (value in nameNS) this.attr(value, nameNS[value]);
+ return this;
+ }
+ var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS);
+ function attrNull() {
+ this.removeAttribute(name);
+ }
+ function attrNullNS() {
+ this.removeAttributeNS(name.space, name.local);
+ }
+ function attrTween(b) {
+ return b == null ? attrNull : (b += "", function() {
+ var a = this.getAttribute(name), i;
+ return a !== b && (i = interpolate(a, b), function(t) {
+ this.setAttribute(name, i(t));
+ });
+ });
+ }
+ function attrTweenNS(b) {
+ return b == null ? attrNullNS : (b += "", function() {
+ var a = this.getAttributeNS(name.space, name.local), i;
+ return a !== b && (i = interpolate(a, b), function(t) {
+ this.setAttributeNS(name.space, name.local, i(t));
+ });
+ });
+ }
+ return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween);
+ };
+ d3_transitionPrototype.attrTween = function(nameNS, tween) {
+ var name = d3.ns.qualify(nameNS);
+ function attrTween(d, i) {
+ var f = tween.call(this, d, i, this.getAttribute(name));
+ return f && function(t) {
+ this.setAttribute(name, f(t));
+ };
+ }
+ function attrTweenNS(d, i) {
+ var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
+ return f && function(t) {
+ this.setAttributeNS(name.space, name.local, f(t));
+ };
+ }
+ return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween);
+ };
+ d3_transitionPrototype.style = function(name, value, priority) {
+ var n = arguments.length;
+ if (n < 3) {
+ if (typeof name !== "string") {
+ if (n < 2) value = "";
+ for (priority in name) this.style(priority, name[priority], value);
+ return this;
+ }
+ priority = "";
+ }
+ function styleNull() {
+ this.style.removeProperty(name);
+ }
+ function styleString(b) {
+ return b == null ? styleNull : (b += "", function() {
+ var a = d3_window(this).getComputedStyle(this, null).getPropertyValue(name), i;
+ return a !== b && (i = d3_interpolate(a, b), function(t) {
+ this.style.setProperty(name, i(t), priority);
+ });
+ });
+ }
+ return d3_transition_tween(this, "style." + name, value, styleString);
+ };
+ d3_transitionPrototype.styleTween = function(name, tween, priority) {
+ if (arguments.length < 3) priority = "";
+ function styleTween(d, i) {
+ var f = tween.call(this, d, i, d3_window(this).getComputedStyle(this, null).getPropertyValue(name));
+ return f && function(t) {
+ this.style.setProperty(name, f(t), priority);
+ };
+ }
+ return this.tween("style." + name, styleTween);
+ };
+ d3_transitionPrototype.text = function(value) {
+ return d3_transition_tween(this, "text", value, d3_transition_text);
+ };
+ function d3_transition_text(b) {
+ if (b == null) b = "";
+ return function() {
+ this.textContent = b;
+ };
+ }
+ d3_transitionPrototype.remove = function() {
+ var ns = this.namespace;
+ return this.each("end.transition", function() {
+ var p;
+ if (this[ns].count < 2 && (p = this.parentNode)) p.removeChild(this);
+ });
+ };
+ d3_transitionPrototype.ease = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].ease;
+ if (typeof value !== "function") value = d3.ease.apply(d3, arguments);
+ return d3_selection_each(this, function(node) {
+ node[ns][id].ease = value;
+ });
+ };
+ d3_transitionPrototype.delay = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].delay;
+ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].delay = +value.call(node, node.__data__, i, j);
+ } : (value = +value, function(node) {
+ node[ns][id].delay = value;
+ }));
+ };
+ d3_transitionPrototype.duration = function(value) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 1) return this.node()[ns][id].duration;
+ return d3_selection_each(this, typeof value === "function" ? function(node, i, j) {
+ node[ns][id].duration = Math.max(1, value.call(node, node.__data__, i, j));
+ } : (value = Math.max(1, value), function(node) {
+ node[ns][id].duration = value;
+ }));
+ };
+ d3_transitionPrototype.each = function(type, listener) {
+ var id = this.id, ns = this.namespace;
+ if (arguments.length < 2) {
+ var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId;
+ try {
+ d3_transitionInheritId = id;
+ d3_selection_each(this, function(node, i, j) {
+ d3_transitionInherit = node[ns][id];
+ type.call(node, node.__data__, i, j);
+ });
+ } finally {
+ d3_transitionInherit = inherit;
+ d3_transitionInheritId = inheritId;
+ }
+ } else {
+ d3_selection_each(this, function(node) {
+ var transition = node[ns][id];
+ (transition.event || (transition.event = d3.dispatch("start", "end", "interrupt"))).on(type, listener);
+ });
+ }
+ return this;
+ };
+ d3_transitionPrototype.transition = function() {
+ var id0 = this.id, id1 = ++d3_transitionId, ns = this.namespace, subgroups = [], subgroup, group, node, transition;
+ for (var j = 0, m = this.length; j < m; j++) {
+ subgroups.push(subgroup = []);
+ for (var group = this[j], i = 0, n = group.length; i < n; i++) {
+ if (node = group[i]) {
+ transition = node[ns][id0];
+ d3_transitionNode(node, i, ns, id1, {
+ time: transition.time,
+ ease: transition.ease,
+ delay: transition.delay + transition.duration,
+ duration: transition.duration
+ });
+ }
+ subgroup.push(node);
+ }
+ }
+ return d3_transition(subgroups, ns, id1);
+ };
+ function d3_transitionNamespace(name) {
+ return name == null ? "__transition__" : "__transition_" + name + "__";
+ }
+ function d3_transitionNode(node, i, ns, id, inherit) {
+ var lock = node[ns] || (node[ns] = {
+ active: 0,
+ count: 0
+ }), transition = lock[id], time, timer, duration, ease, tweens;
+ function schedule(elapsed) {
+ var delay = transition.delay;
+ timer.t = delay + time;
+ if (delay <= elapsed) return start(elapsed - delay);
+ timer.c = start;
+ }
+ function start(elapsed) {
+ var activeId = lock.active, active = lock[activeId];
+ if (active) {
+ active.timer.c = null;
+ active.timer.t = NaN;
+ --lock.count;
+ delete lock[activeId];
+ active.event && active.event.interrupt.call(node, node.__data__, active.index);
+ }
+ for (var cancelId in lock) {
+ if (+cancelId < id) {
+ var cancel = lock[cancelId];
+ cancel.timer.c = null;
+ cancel.timer.t = NaN;
+ --lock.count;
+ delete lock[cancelId];
+ }
+ }
+ timer.c = tick;
+ d3_timer(function() {
+ if (timer.c && tick(elapsed || 1)) {
+ timer.c = null;
+ timer.t = NaN;
+ }
+ return 1;
+ }, 0, time);
+ lock.active = id;
+ transition.event && transition.event.start.call(node, node.__data__, i);
+ tweens = [];
+ transition.tween.forEach(function(key, value) {
+ if (value = value.call(node, node.__data__, i)) {
+ tweens.push(value);
+ }
+ });
+ ease = transition.ease;
+ duration = transition.duration;
+ }
+ function tick(elapsed) {
+ var t = elapsed / duration, e = ease(t), n = tweens.length;
+ while (n > 0) {
+ tweens[--n].call(node, e);
+ }
+ if (t >= 1) {
+ transition.event && transition.event.end.call(node, node.__data__, i);
+ if (--lock.count) delete lock[id]; else delete node[ns];
+ return 1;
+ }
+ }
+ if (!transition) {
+ time = inherit.time;
+ timer = d3_timer(schedule, 0, time);
+ transition = lock[id] = {
+ tween: new d3_Map(),
+ time: time,
+ timer: timer,
+ delay: inherit.delay,
+ duration: inherit.duration,
+ ease: inherit.ease,
+ index: i
+ };
+ inherit = null;
+ ++lock.count;
+ }
+ }
+ d3.svg.axis = function() {
+ var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_;
+ function axis(g) {
+ g.each(function() {
+ var g = d3.select(this);
+ var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy();
+ var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickSpacing = Math.max(innerTickSize, 0) + tickPadding, tickTransform;
+ var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"),
+ d3.transition(path));
+ tickEnter.append("line");
+ tickEnter.append("text");
+ var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"), sign = orient === "top" || orient === "left" ? -1 : 1, x1, x2, y1, y2;
+ if (orient === "bottom" || orient === "top") {
+ tickTransform = d3_svg_axisX, x1 = "x", y1 = "y", x2 = "x2", y2 = "y2";
+ text.attr("dy", sign < 0 ? "0em" : ".71em").style("text-anchor", "middle");
+ pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outerTickSize);
+ } else {
+ tickTransform = d3_svg_axisY, x1 = "y", y1 = "x", x2 = "y2", y2 = "x2";
+ text.attr("dy", ".32em").style("text-anchor", sign < 0 ? "end" : "start");
+ pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outerTickSize);
+ }
+ lineEnter.attr(y2, sign * innerTickSize);
+ textEnter.attr(y1, sign * tickSpacing);
+ lineUpdate.attr(x2, 0).attr(y2, sign * innerTickSize);
+ textUpdate.attr(x1, 0).attr(y1, sign * tickSpacing);
+ if (scale1.rangeBand) {
+ var x = scale1, dx = x.rangeBand() / 2;
+ scale0 = scale1 = function(d) {
+ return x(d) + dx;
+ };
+ } else if (scale0.rangeBand) {
+ scale0 = scale1;
+ } else {
+ tickExit.call(tickTransform, scale1, scale0);
+ }
+ tickEnter.call(tickTransform, scale0, scale1);
+ tickUpdate.call(tickTransform, scale1, scale1);
+ });
+ }
+ axis.scale = function(x) {
+ if (!arguments.length) return scale;
+ scale = x;
+ return axis;
+ };
+ axis.orient = function(x) {
+ if (!arguments.length) return orient;
+ orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient;
+ return axis;
+ };
+ axis.ticks = function() {
+ if (!arguments.length) return tickArguments_;
+ tickArguments_ = d3_array(arguments);
+ return axis;
+ };
+ axis.tickValues = function(x) {
+ if (!arguments.length) return tickValues;
+ tickValues = x;
+ return axis;
+ };
+ axis.tickFormat = function(x) {
+ if (!arguments.length) return tickFormat_;
+ tickFormat_ = x;
+ return axis;
+ };
+ axis.tickSize = function(x) {
+ var n = arguments.length;
+ if (!n) return innerTickSize;
+ innerTickSize = +x;
+ outerTickSize = +arguments[n - 1];
+ return axis;
+ };
+ axis.innerTickSize = function(x) {
+ if (!arguments.length) return innerTickSize;
+ innerTickSize = +x;
+ return axis;
+ };
+ axis.outerTickSize = function(x) {
+ if (!arguments.length) return outerTickSize;
+ outerTickSize = +x;
+ return axis;
+ };
+ axis.tickPadding = function(x) {
+ if (!arguments.length) return tickPadding;
+ tickPadding = +x;
+ return axis;
+ };
+ axis.tickSubdivide = function() {
+ return arguments.length && axis;
+ };
+ return axis;
+ };
+ var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = {
+ top: 1,
+ right: 1,
+ bottom: 1,
+ left: 1
+ };
+ function d3_svg_axisX(selection, x0, x1) {
+ selection.attr("transform", function(d) {
+ var v0 = x0(d);
+ return "translate(" + (isFinite(v0) ? v0 : x1(d)) + ",0)";
+ });
+ }
+ function d3_svg_axisY(selection, y0, y1) {
+ selection.attr("transform", function(d) {
+ var v0 = y0(d);
+ return "translate(0," + (isFinite(v0) ? v0 : y1(d)) + ")";
+ });
+ }
+ d3.svg.brush = function() {
+ var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0];
+ function brush(g) {
+ g.each(function() {
+ var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart);
+ var background = g.selectAll(".background").data([ 0 ]);
+ background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair");
+ g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move");
+ var resize = g.selectAll(".resize").data(resizes, d3_identity);
+ resize.exit().remove();
+ resize.enter().append("g").attr("class", function(d) {
+ return "resize " + d;
+ }).style("cursor", function(d) {
+ return d3_svg_brushCursor[d];
+ }).append("rect").attr("x", function(d) {
+ return /[ew]$/.test(d) ? -3 : null;
+ }).attr("y", function(d) {
+ return /^[ns]/.test(d) ? -3 : null;
+ }).attr("width", 6).attr("height", 6).style("visibility", "hidden");
+ resize.style("display", brush.empty() ? "none" : null);
+ var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range;
+ if (x) {
+ range = d3_scaleRange(x);
+ backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]);
+ redrawX(gUpdate);
+ }
+ if (y) {
+ range = d3_scaleRange(y);
+ backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]);
+ redrawY(gUpdate);
+ }
+ redraw(gUpdate);
+ });
+ }
+ brush.event = function(g) {
+ g.each(function() {
+ var event_ = event.of(this, arguments), extent1 = {
+ x: xExtent,
+ y: yExtent,
+ i: xExtentDomain,
+ j: yExtentDomain
+ }, extent0 = this.__chart__ || extent1;
+ this.__chart__ = extent1;
+ if (d3_transitionInheritId) {
+ d3.select(this).transition().each("start.brush", function() {
+ xExtentDomain = extent0.i;
+ yExtentDomain = extent0.j;
+ xExtent = extent0.x;
+ yExtent = extent0.y;
+ event_({
+ type: "brushstart"
+ });
+ }).tween("brush:brush", function() {
+ var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);
+ xExtentDomain = yExtentDomain = null;
+ return function(t) {
+ xExtent = extent1.x = xi(t);
+ yExtent = extent1.y = yi(t);
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ };
+ }).each("end.brush", function() {
+ xExtentDomain = extent1.i;
+ yExtentDomain = extent1.j;
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ event_({
+ type: "brushend"
+ });
+ });
+ } else {
+ event_({
+ type: "brushstart"
+ });
+ event_({
+ type: "brush",
+ mode: "resize"
+ });
+ event_({
+ type: "brushend"
+ });
+ }
+ });
+ };
+ function redraw(g) {
+ g.selectAll(".resize").attr("transform", function(d) {
+ return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")";
+ });
+ }
+ function redrawX(g) {
+ g.select(".extent").attr("x", xExtent[0]);
+ g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]);
+ }
+ function redrawY(g) {
+ g.select(".extent").attr("y", yExtent[0]);
+ g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]);
+ }
+ function brushstart() {
+ var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(target), center, origin = d3.mouse(target), offset;
+ var w = d3.select(d3_window(target)).on("keydown.brush", keydown).on("keyup.brush", keyup);
+ if (d3.event.changedTouches) {
+ w.on("touchmove.brush", brushmove).on("touchend.brush", brushend);
+ } else {
+ w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend);
+ }
+ g.interrupt().selectAll("*").interrupt();
+ if (dragging) {
+ origin[0] = xExtent[0] - origin[0];
+ origin[1] = yExtent[0] - origin[1];
+ } else if (resizing) {
+ var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing);
+ offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ];
+ origin[0] = xExtent[ex];
+ origin[1] = yExtent[ey];
+ } else if (d3.event.altKey) center = origin.slice();
+ g.style("pointer-events", "none").selectAll(".resize").style("display", null);
+ d3.select("body").style("cursor", eventTarget.style("cursor"));
+ event_({
+ type: "brushstart"
+ });
+ brushmove();
+ function keydown() {
+ if (d3.event.keyCode == 32) {
+ if (!dragging) {
+ center = null;
+ origin[0] -= xExtent[1];
+ origin[1] -= yExtent[1];
+ dragging = 2;
+ }
+ d3_eventPreventDefault();
+ }
+ }
+ function keyup() {
+ if (d3.event.keyCode == 32 && dragging == 2) {
+ origin[0] += xExtent[1];
+ origin[1] += yExtent[1];
+ dragging = 0;
+ d3_eventPreventDefault();
+ }
+ }
+ function brushmove() {
+ var point = d3.mouse(target), moved = false;
+ if (offset) {
+ point[0] += offset[0];
+ point[1] += offset[1];
+ }
+ if (!dragging) {
+ if (d3.event.altKey) {
+ if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ];
+ origin[0] = xExtent[+(point[0] < center[0])];
+ origin[1] = yExtent[+(point[1] < center[1])];
+ } else center = null;
+ }
+ if (resizingX && move1(point, x, 0)) {
+ redrawX(g);
+ moved = true;
+ }
+ if (resizingY && move1(point, y, 1)) {
+ redrawY(g);
+ moved = true;
+ }
+ if (moved) {
+ redraw(g);
+ event_({
+ type: "brush",
+ mode: dragging ? "move" : "resize"
+ });
+ }
+ }
+ function move1(point, scale, i) {
+ var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max;
+ if (dragging) {
+ r0 -= position;
+ r1 -= size + position;
+ }
+ min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i];
+ if (dragging) {
+ max = (min += position) + size;
+ } else {
+ if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min));
+ if (position < min) {
+ max = min;
+ min = position;
+ } else {
+ max = position;
+ }
+ }
+ if (extent[0] != min || extent[1] != max) {
+ if (i) yExtentDomain = null; else xExtentDomain = null;
+ extent[0] = min;
+ extent[1] = max;
+ return true;
+ }
+ }
+ function brushend() {
+ brushmove();
+ g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null);
+ d3.select("body").style("cursor", null);
+ w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null);
+ dragRestore();
+ event_({
+ type: "brushend"
+ });
+ }
+ }
+ brush.x = function(z) {
+ if (!arguments.length) return x;
+ x = z;
+ resizes = d3_svg_brushResizes[!x << 1 | !y];
+ return brush;
+ };
+ brush.y = function(z) {
+ if (!arguments.length) return y;
+ y = z;
+ resizes = d3_svg_brushResizes[!x << 1 | !y];
+ return brush;
+ };
+ brush.clamp = function(z) {
+ if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null;
+ if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z;
+ return brush;
+ };
+ brush.extent = function(z) {
+ var x0, x1, y0, y1, t;
+ if (!arguments.length) {
+ if (x) {
+ if (xExtentDomain) {
+ x0 = xExtentDomain[0], x1 = xExtentDomain[1];
+ } else {
+ x0 = xExtent[0], x1 = xExtent[1];
+ if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1);
+ if (x1 < x0) t = x0, x0 = x1, x1 = t;
+ }
+ }
+ if (y) {
+ if (yExtentDomain) {
+ y0 = yExtentDomain[0], y1 = yExtentDomain[1];
+ } else {
+ y0 = yExtent[0], y1 = yExtent[1];
+ if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1);
+ if (y1 < y0) t = y0, y0 = y1, y1 = t;
+ }
+ }
+ return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ];
+ }
+ if (x) {
+ x0 = z[0], x1 = z[1];
+ if (y) x0 = x0[0], x1 = x1[0];
+ xExtentDomain = [ x0, x1 ];
+ if (x.invert) x0 = x(x0), x1 = x(x1);
+ if (x1 < x0) t = x0, x0 = x1, x1 = t;
+ if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ];
+ }
+ if (y) {
+ y0 = z[0], y1 = z[1];
+ if (x) y0 = y0[1], y1 = y1[1];
+ yExtentDomain = [ y0, y1 ];
+ if (y.invert) y0 = y(y0), y1 = y(y1);
+ if (y1 < y0) t = y0, y0 = y1, y1 = t;
+ if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ];
+ }
+ return brush;
+ };
+ brush.clear = function() {
+ if (!brush.empty()) {
+ xExtent = [ 0, 0 ], yExtent = [ 0, 0 ];
+ xExtentDomain = yExtentDomain = null;
+ }
+ return brush;
+ };
+ brush.empty = function() {
+ return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1];
+ };
+ return d3.rebind(brush, event, "on");
+ };
+ var d3_svg_brushCursor = {
+ n: "ns-resize",
+ e: "ew-resize",
+ s: "ns-resize",
+ w: "ew-resize",
+ nw: "nwse-resize",
+ ne: "nesw-resize",
+ se: "nwse-resize",
+ sw: "nesw-resize"
+ };
+ var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ];
+ var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat;
+ var d3_time_formatUtc = d3_time_format.utc;
+ var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ");
+ d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso;
+ function d3_time_formatIsoNative(date) {
+ return date.toISOString();
+ }
+ d3_time_formatIsoNative.parse = function(string) {
+ var date = new Date(string);
+ return isNaN(date) ? null : date;
+ };
+ d3_time_formatIsoNative.toString = d3_time_formatIso.toString;
+ d3_time.second = d3_time_interval(function(date) {
+ return new d3_date(Math.floor(date / 1e3) * 1e3);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 1e3);
+ }, function(date) {
+ return date.getSeconds();
+ });
+ d3_time.seconds = d3_time.second.range;
+ d3_time.seconds.utc = d3_time.second.utc.range;
+ d3_time.minute = d3_time_interval(function(date) {
+ return new d3_date(Math.floor(date / 6e4) * 6e4);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 6e4);
+ }, function(date) {
+ return date.getMinutes();
+ });
+ d3_time.minutes = d3_time.minute.range;
+ d3_time.minutes.utc = d3_time.minute.utc.range;
+ d3_time.hour = d3_time_interval(function(date) {
+ var timezone = date.getTimezoneOffset() / 60;
+ return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5);
+ }, function(date, offset) {
+ date.setTime(date.getTime() + Math.floor(offset) * 36e5);
+ }, function(date) {
+ return date.getHours();
+ });
+ d3_time.hours = d3_time.hour.range;
+ d3_time.hours.utc = d3_time.hour.utc.range;
+ d3_time.month = d3_time_interval(function(date) {
+ date = d3_time.day(date);
+ date.setDate(1);
+ return date;
+ }, function(date, offset) {
+ date.setMonth(date.getMonth() + offset);
+ }, function(date) {
+ return date.getMonth();
+ });
+ d3_time.months = d3_time.month.range;
+ d3_time.months.utc = d3_time.month.utc.range;
+ function d3_time_scale(linear, methods, format) {
+ function scale(x) {
+ return linear(x);
+ }
+ scale.invert = function(x) {
+ return d3_time_scaleDate(linear.invert(x));
+ };
+ scale.domain = function(x) {
+ if (!arguments.length) return linear.domain().map(d3_time_scaleDate);
+ linear.domain(x);
+ return scale;
+ };
+ function tickMethod(extent, count) {
+ var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target);
+ return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) {
+ return d / 31536e6;
+ }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i];
+ }
+ scale.nice = function(interval, skip) {
+ var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval);
+ if (method) interval = method[0], skip = method[1];
+ function skipped(date) {
+ return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length;
+ }
+ return scale.domain(d3_scale_nice(domain, skip > 1 ? {
+ floor: function(date) {
+ while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1);
+ return date;
+ },
+ ceil: function(date) {
+ while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1);
+ return date;
+ }
+ } : interval));
+ };
+ scale.ticks = function(interval, skip) {
+ var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ {
+ range: interval
+ }, skip ];
+ if (method) interval = method[0], skip = method[1];
+ return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip);
+ };
+ scale.tickFormat = function() {
+ return format;
+ };
+ scale.copy = function() {
+ return d3_time_scale(linear.copy(), methods, format);
+ };
+ return d3_scale_linearRebind(scale, linear);
+ }
+ function d3_time_scaleDate(t) {
+ return new Date(t);
+ }
+ var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ];
+ var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ];
+ var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) {
+ return d.getMilliseconds();
+ } ], [ ":%S", function(d) {
+ return d.getSeconds();
+ } ], [ "%I:%M", function(d) {
+ return d.getMinutes();
+ } ], [ "%I %p", function(d) {
+ return d.getHours();
+ } ], [ "%a %d", function(d) {
+ return d.getDay() && d.getDate() != 1;
+ } ], [ "%b %d", function(d) {
+ return d.getDate() != 1;
+ } ], [ "%B", function(d) {
+ return d.getMonth();
+ } ], [ "%Y", d3_true ] ]);
+ var d3_time_scaleMilliseconds = {
+ range: function(start, stop, step) {
+ return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate);
+ },
+ floor: d3_identity,
+ ceil: d3_identity
+ };
+ d3_time_scaleLocalMethods.year = d3_time.year;
+ d3_time.scale = function() {
+ return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat);
+ };
+ var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) {
+ return [ m[0].utc, m[1] ];
+ });
+ var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) {
+ return d.getUTCMilliseconds();
+ } ], [ ":%S", function(d) {
+ return d.getUTCSeconds();
+ } ], [ "%I:%M", function(d) {
+ return d.getUTCMinutes();
+ } ], [ "%I %p", function(d) {
+ return d.getUTCHours();
+ } ], [ "%a %d", function(d) {
+ return d.getUTCDay() && d.getUTCDate() != 1;
+ } ], [ "%b %d", function(d) {
+ return d.getUTCDate() != 1;
+ } ], [ "%B", function(d) {
+ return d.getUTCMonth();
+ } ], [ "%Y", d3_true ] ]);
+ d3_time_scaleUtcMethods.year = d3_time.year.utc;
+ d3_time.scale.utc = function() {
+ return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat);
+ };
+ d3.text = d3_xhrType(function(request) {
+ return request.responseText;
+ });
+ d3.json = function(url, callback) {
+ return d3_xhr(url, "application/json", d3_json, callback);
+ };
+ function d3_json(request) {
+ return JSON.parse(request.responseText);
+ }
+ d3.html = function(url, callback) {
+ return d3_xhr(url, "text/html", d3_html, callback);
+ };
+ function d3_html(request) {
+ var range = d3_document.createRange();
+ range.selectNode(d3_document.body);
+ return range.createContextualFragment(request.responseText);
+ }
+ d3.xml = d3_xhrType(function(request) {
+ return request.responseXML;
+ });
+ if (typeof define === "function" && define.amd) this.d3 = d3, define(d3); else if (typeof module === "object" && module.exports) module.exports = d3; else this.d3 = d3;
+}();
+},{}],149:[function(_dereq_,module,exports){
+module.exports = function () {
+ for (var i = 0; i < arguments.length; i++) {
+ if (arguments[i] !== undefined) return arguments[i];
+ }
+};
+
+},{}],150:[function(_dereq_,module,exports){
+"use strict"
+
+var ch = _dereq_("incremental-convex-hull")
+var uniq = _dereq_("uniq")
+
+module.exports = triangulate
+
+function LiftedPoint(p, i) {
+ this.point = p
+ this.index = i
+}
+
+function compareLifted(a, b) {
+ var ap = a.point
+ var bp = b.point
+ var d = ap.length
+ for(var i=0; i= 2) {
+ return false
+ }
+ }
+ cell[j] = v
+ }
+ return true
+ })
+ } else {
+ hull = hull.filter(function(cell) {
+ for(var i=0; i<=d; ++i) {
+ var v = dindex[cell[i]]
+ if(v < 0) {
+ return false
+ }
+ cell[i] = v
+ }
+ return true
+ })
+ }
+
+ if(d & 1) {
+ for(var i=0; i fs * threshold) {
+ var emWidth = (kerningWidth - width) / fs
+ table[pair] = emWidth * 1000
+ }
+ }
+
+ return table
+}
+
+
+function createPairs (range) {
+ var pairs = []
+
+ for (var i = range[0]; i <= range[1]; i++) {
+ var leftChar = String.fromCharCode(i)
+ for (var j = range[0]; j < range[1]; j++) {
+ var rightChar = String.fromCharCode(j)
+ var pair = leftChar + rightChar
+
+ pairs.push(pair)
+ }
+ }
+
+ return pairs
+}
+
+},{}],152:[function(_dereq_,module,exports){
+(function (Buffer){
+var hasTypedArrays = false
+if(typeof Float64Array !== "undefined") {
+ var DOUBLE_VIEW = new Float64Array(1)
+ , UINT_VIEW = new Uint32Array(DOUBLE_VIEW.buffer)
+ DOUBLE_VIEW[0] = 1.0
+ hasTypedArrays = true
+ if(UINT_VIEW[1] === 0x3ff00000) {
+ //Use little endian
+ module.exports = function doubleBitsLE(n) {
+ DOUBLE_VIEW[0] = n
+ return [ UINT_VIEW[0], UINT_VIEW[1] ]
+ }
+ function toDoubleLE(lo, hi) {
+ UINT_VIEW[0] = lo
+ UINT_VIEW[1] = hi
+ return DOUBLE_VIEW[0]
+ }
+ module.exports.pack = toDoubleLE
+ function lowUintLE(n) {
+ DOUBLE_VIEW[0] = n
+ return UINT_VIEW[0]
+ }
+ module.exports.lo = lowUintLE
+ function highUintLE(n) {
+ DOUBLE_VIEW[0] = n
+ return UINT_VIEW[1]
+ }
+ module.exports.hi = highUintLE
+ } else if(UINT_VIEW[0] === 0x3ff00000) {
+ //Use big endian
+ module.exports = function doubleBitsBE(n) {
+ DOUBLE_VIEW[0] = n
+ return [ UINT_VIEW[1], UINT_VIEW[0] ]
+ }
+ function toDoubleBE(lo, hi) {
+ UINT_VIEW[1] = lo
+ UINT_VIEW[0] = hi
+ return DOUBLE_VIEW[0]
+ }
+ module.exports.pack = toDoubleBE
+ function lowUintBE(n) {
+ DOUBLE_VIEW[0] = n
+ return UINT_VIEW[1]
+ }
+ module.exports.lo = lowUintBE
+ function highUintBE(n) {
+ DOUBLE_VIEW[0] = n
+ return UINT_VIEW[0]
+ }
+ module.exports.hi = highUintBE
+ } else {
+ hasTypedArrays = false
+ }
+}
+if(!hasTypedArrays) {
+ var buffer = new Buffer(8)
+ module.exports = function doubleBits(n) {
+ buffer.writeDoubleLE(n, 0, true)
+ return [ buffer.readUInt32LE(0, true), buffer.readUInt32LE(4, true) ]
+ }
+ function toDouble(lo, hi) {
+ buffer.writeUInt32LE(lo, 0, true)
+ buffer.writeUInt32LE(hi, 4, true)
+ return buffer.readDoubleLE(0, true)
+ }
+ module.exports.pack = toDouble
+ function lowUint(n) {
+ buffer.writeDoubleLE(n, 0, true)
+ return buffer.readUInt32LE(0, true)
+ }
+ module.exports.lo = lowUint
+ function highUint(n) {
+ buffer.writeDoubleLE(n, 0, true)
+ return buffer.readUInt32LE(4, true)
+ }
+ module.exports.hi = highUint
+}
+
+module.exports.sign = function(n) {
+ return module.exports.hi(n) >>> 31
+}
+
+module.exports.exponent = function(n) {
+ var b = module.exports.hi(n)
+ return ((b<<1) >>> 21) - 1023
+}
+
+module.exports.fraction = function(n) {
+ var lo = module.exports.lo(n)
+ var hi = module.exports.hi(n)
+ var b = hi & ((1<<20) - 1)
+ if(hi & 0x7ff00000) {
+ b += (1<<20)
+ }
+ return [lo, b]
+}
+
+module.exports.denormalized = function(n) {
+ var hi = module.exports.hi(n)
+ return !(hi & 0x7ff00000)
+}
+}).call(this,_dereq_("buffer").Buffer)
+
+},{"buffer":93}],153:[function(_dereq_,module,exports){
+var abs = _dereq_('abs-svg-path')
+var normalize = _dereq_('normalize-svg-path')
+
+var methods = {
+ 'M': 'moveTo',
+ 'C': 'bezierCurveTo'
+}
+
+module.exports = function(context, segments) {
+ context.beginPath()
+
+ // Make path easy to reproduce.
+ normalize(abs(segments)).forEach(
+ function(segment) {
+ var command = segment[0]
+ var args = segment.slice(1)
+
+ // Convert the path command to a context method.
+ context[methods[command]].apply(context, args)
+ }
+ )
+
+ context.closePath()
+}
+
+},{"abs-svg-path":48,"normalize-svg-path":435}],154:[function(_dereq_,module,exports){
+module.exports = function(dtype) {
+ switch (dtype) {
+ case 'int8':
+ return Int8Array
+ case 'int16':
+ return Int16Array
+ case 'int32':
+ return Int32Array
+ case 'uint8':
+ return Uint8Array
+ case 'uint16':
+ return Uint16Array
+ case 'uint32':
+ return Uint32Array
+ case 'float32':
+ return Float32Array
+ case 'float64':
+ return Float64Array
+ case 'array':
+ return Array
+ case 'uint8_clamped':
+ return Uint8ClampedArray
+ }
+}
+
+},{}],155:[function(_dereq_,module,exports){
+"use strict"
+
+function dupe_array(count, value, i) {
+ var c = count[i]|0
+ if(c <= 0) {
+ return []
+ }
+ var result = new Array(c), j
+ if(i === count.length-1) {
+ for(j=0; j 0) {
+ return dupe_number(count|0, value)
+ }
+ break
+ case "object":
+ if(typeof (count.length) === "number") {
+ return dupe_array(count, value, 0)
+ }
+ break
+ }
+ return []
+}
+
+module.exports = dupe
+},{}],156:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = earcut;
+module.exports.default = earcut;
+
+function earcut(data, holeIndices, dim) {
+
+ dim = dim || 2;
+
+ var hasHoles = holeIndices && holeIndices.length,
+ outerLen = hasHoles ? holeIndices[0] * dim : data.length,
+ outerNode = linkedList(data, 0, outerLen, dim, true),
+ triangles = [];
+
+ if (!outerNode) return triangles;
+
+ var minX, minY, maxX, maxY, x, y, invSize;
+
+ if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+
+ // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+ if (data.length > 80 * dim) {
+ minX = maxX = data[0];
+ minY = maxY = data[1];
+
+ for (var i = dim; i < outerLen; i += dim) {
+ x = data[i];
+ y = data[i + 1];
+ if (x < minX) minX = x;
+ if (y < minY) minY = y;
+ if (x > maxX) maxX = x;
+ if (y > maxY) maxY = y;
+ }
+
+ // minX, minY and invSize are later used to transform coords into integers for z-order calculation
+ invSize = Math.max(maxX - minX, maxY - minY);
+ invSize = invSize !== 0 ? 1 / invSize : 0;
+ }
+
+ earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+
+ return triangles;
+}
+
+// create a circular doubly linked list from polygon points in the specified winding order
+function linkedList(data, start, end, dim, clockwise) {
+ var i, last;
+
+ if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+ for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
+ } else {
+ for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
+ }
+
+ if (last && equals(last, last.next)) {
+ removeNode(last);
+ last = last.next;
+ }
+
+ return last;
+}
+
+// eliminate colinear or duplicate points
+function filterPoints(start, end) {
+ if (!start) return start;
+ if (!end) end = start;
+
+ var p = start,
+ again;
+ do {
+ again = false;
+
+ if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+ removeNode(p);
+ p = end = p.prev;
+ if (p === p.next) break;
+ again = true;
+
+ } else {
+ p = p.next;
+ }
+ } while (again || p !== end);
+
+ return end;
+}
+
+// main ear slicing loop which triangulates a polygon (given as a linked list)
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+ if (!ear) return;
+
+ // interlink polygon nodes in z-order
+ if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+
+ var stop = ear,
+ prev, next;
+
+ // iterate through ears, slicing them one by one
+ while (ear.prev !== ear.next) {
+ prev = ear.prev;
+ next = ear.next;
+
+ if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+ // cut off the triangle
+ triangles.push(prev.i / dim);
+ triangles.push(ear.i / dim);
+ triangles.push(next.i / dim);
+
+ removeNode(ear);
+
+ // skipping the next vertice leads to less sliver triangles
+ ear = next.next;
+ stop = next.next;
+
+ continue;
+ }
+
+ ear = next;
+
+ // if we looped through the whole remaining polygon and can't find any more ears
+ if (ear === stop) {
+ // try filtering points and slicing again
+ if (!pass) {
+ earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+
+ // if this didn't work, try curing all small self-intersections locally
+ } else if (pass === 1) {
+ ear = cureLocalIntersections(ear, triangles, dim);
+ earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+
+ // as a last resort, try splitting the remaining polygon into two
+ } else if (pass === 2) {
+ splitEarcut(ear, triangles, dim, minX, minY, invSize);
+ }
+
+ break;
+ }
+ }
+}
+
+// check whether a polygon node forms a valid ear with adjacent nodes
+function isEar(ear) {
+ var a = ear.prev,
+ b = ear,
+ c = ear.next;
+
+ if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+ // now make sure we don't have other points inside the potential ear
+ var p = ear.next.next;
+
+ while (p !== ear.prev) {
+ if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+ area(p.prev, p, p.next) >= 0) return false;
+ p = p.next;
+ }
+
+ return true;
+}
+
+function isEarHashed(ear, minX, minY, invSize) {
+ var a = ear.prev,
+ b = ear,
+ c = ear.next;
+
+ if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+ // triangle bbox; min & max are calculated like this for speed
+ var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x),
+ minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y),
+ maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x),
+ maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y);
+
+ // z-order range for the current triangle bbox;
+ var minZ = zOrder(minTX, minTY, minX, minY, invSize),
+ maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+
+ var p = ear.prevZ,
+ n = ear.nextZ;
+
+ // look for points inside the triangle in both directions
+ while (p && p.z >= minZ && n && n.z <= maxZ) {
+ if (p !== ear.prev && p !== ear.next &&
+ pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+ area(p.prev, p, p.next) >= 0) return false;
+ p = p.prevZ;
+
+ if (n !== ear.prev && n !== ear.next &&
+ pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+ area(n.prev, n, n.next) >= 0) return false;
+ n = n.nextZ;
+ }
+
+ // look for remaining points in decreasing z-order
+ while (p && p.z >= minZ) {
+ if (p !== ear.prev && p !== ear.next &&
+ pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+ area(p.prev, p, p.next) >= 0) return false;
+ p = p.prevZ;
+ }
+
+ // look for remaining points in increasing z-order
+ while (n && n.z <= maxZ) {
+ if (n !== ear.prev && n !== ear.next &&
+ pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+ area(n.prev, n, n.next) >= 0) return false;
+ n = n.nextZ;
+ }
+
+ return true;
+}
+
+// go through all polygon nodes and cure small local self-intersections
+function cureLocalIntersections(start, triangles, dim) {
+ var p = start;
+ do {
+ var a = p.prev,
+ b = p.next.next;
+
+ if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+
+ triangles.push(a.i / dim);
+ triangles.push(p.i / dim);
+ triangles.push(b.i / dim);
+
+ // remove two nodes involved
+ removeNode(p);
+ removeNode(p.next);
+
+ p = start = b;
+ }
+ p = p.next;
+ } while (p !== start);
+
+ return p;
+}
+
+// try splitting polygon into two and triangulate them independently
+function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+ // look for a valid diagonal that divides the polygon into two
+ var a = start;
+ do {
+ var b = a.next.next;
+ while (b !== a.prev) {
+ if (a.i !== b.i && isValidDiagonal(a, b)) {
+ // split the polygon in two by the diagonal
+ var c = splitPolygon(a, b);
+
+ // filter colinear points around the cuts
+ a = filterPoints(a, a.next);
+ c = filterPoints(c, c.next);
+
+ // run earcut on each half
+ earcutLinked(a, triangles, dim, minX, minY, invSize);
+ earcutLinked(c, triangles, dim, minX, minY, invSize);
+ return;
+ }
+ b = b.next;
+ }
+ a = a.next;
+ } while (a !== start);
+}
+
+// link every hole into the outer loop, producing a single-ring polygon without holes
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+ var queue = [],
+ i, len, start, end, list;
+
+ for (i = 0, len = holeIndices.length; i < len; i++) {
+ start = holeIndices[i] * dim;
+ end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+ list = linkedList(data, start, end, dim, false);
+ if (list === list.next) list.steiner = true;
+ queue.push(getLeftmost(list));
+ }
+
+ queue.sort(compareX);
+
+ // process holes from left to right
+ for (i = 0; i < queue.length; i++) {
+ eliminateHole(queue[i], outerNode);
+ outerNode = filterPoints(outerNode, outerNode.next);
+ }
+
+ return outerNode;
+}
+
+function compareX(a, b) {
+ return a.x - b.x;
+}
+
+// find a bridge between vertices that connects hole with an outer ring and and link it
+function eliminateHole(hole, outerNode) {
+ outerNode = findHoleBridge(hole, outerNode);
+ if (outerNode) {
+ var b = splitPolygon(outerNode, hole);
+ filterPoints(b, b.next);
+ }
+}
+
+// David Eberly's algorithm for finding a bridge between hole and outer polygon
+function findHoleBridge(hole, outerNode) {
+ var p = outerNode,
+ hx = hole.x,
+ hy = hole.y,
+ qx = -Infinity,
+ m;
+
+ // find a segment intersected by a ray from the hole's leftmost point to the left;
+ // segment's endpoint with lesser x will be potential connection point
+ do {
+ if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+ var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+ if (x <= hx && x > qx) {
+ qx = x;
+ if (x === hx) {
+ if (hy === p.y) return p;
+ if (hy === p.next.y) return p.next;
+ }
+ m = p.x < p.next.x ? p : p.next;
+ }
+ }
+ p = p.next;
+ } while (p !== outerNode);
+
+ if (!m) return null;
+
+ if (hx === qx) return m.prev; // hole touches outer segment; pick lower endpoint
+
+ // look for points inside the triangle of hole point, segment intersection and endpoint;
+ // if there are no points found, we have a valid connection;
+ // otherwise choose the point of the minimum angle with the ray as connection point
+
+ var stop = m,
+ mx = m.x,
+ my = m.y,
+ tanMin = Infinity,
+ tan;
+
+ p = m.next;
+
+ while (p !== stop) {
+ if (hx >= p.x && p.x >= mx && hx !== p.x &&
+ pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+
+ tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+
+ if ((tan < tanMin || (tan === tanMin && p.x > m.x)) && locallyInside(p, hole)) {
+ m = p;
+ tanMin = tan;
+ }
+ }
+
+ p = p.next;
+ }
+
+ return m;
+}
+
+// interlink polygon nodes in z-order
+function indexCurve(start, minX, minY, invSize) {
+ var p = start;
+ do {
+ if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+ p.prevZ = p.prev;
+ p.nextZ = p.next;
+ p = p.next;
+ } while (p !== start);
+
+ p.prevZ.nextZ = null;
+ p.prevZ = null;
+
+ sortLinked(p);
+}
+
+// Simon Tatham's linked list merge sort algorithm
+// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+function sortLinked(list) {
+ var i, p, q, e, tail, numMerges, pSize, qSize,
+ inSize = 1;
+
+ do {
+ p = list;
+ list = null;
+ tail = null;
+ numMerges = 0;
+
+ while (p) {
+ numMerges++;
+ q = p;
+ pSize = 0;
+ for (i = 0; i < inSize; i++) {
+ pSize++;
+ q = q.nextZ;
+ if (!q) break;
+ }
+ qSize = inSize;
+
+ while (pSize > 0 || (qSize > 0 && q)) {
+
+ if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+ e = p;
+ p = p.nextZ;
+ pSize--;
+ } else {
+ e = q;
+ q = q.nextZ;
+ qSize--;
+ }
+
+ if (tail) tail.nextZ = e;
+ else list = e;
+
+ e.prevZ = tail;
+ tail = e;
+ }
+
+ p = q;
+ }
+
+ tail.nextZ = null;
+ inSize *= 2;
+
+ } while (numMerges > 1);
+
+ return list;
+}
+
+// z-order of a point given coords and inverse of the longer side of data bbox
+function zOrder(x, y, minX, minY, invSize) {
+ // coords are transformed into non-negative 15-bit integer range
+ x = 32767 * (x - minX) * invSize;
+ y = 32767 * (y - minY) * invSize;
+
+ x = (x | (x << 8)) & 0x00FF00FF;
+ x = (x | (x << 4)) & 0x0F0F0F0F;
+ x = (x | (x << 2)) & 0x33333333;
+ x = (x | (x << 1)) & 0x55555555;
+
+ y = (y | (y << 8)) & 0x00FF00FF;
+ y = (y | (y << 4)) & 0x0F0F0F0F;
+ y = (y | (y << 2)) & 0x33333333;
+ y = (y | (y << 1)) & 0x55555555;
+
+ return x | (y << 1);
+}
+
+// find the leftmost node of a polygon ring
+function getLeftmost(start) {
+ var p = start,
+ leftmost = start;
+ do {
+ if (p.x < leftmost.x) leftmost = p;
+ p = p.next;
+ } while (p !== start);
+
+ return leftmost;
+}
+
+// check if a point lies within a convex triangle
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+ return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
+ (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
+ (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+}
+
+// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+function isValidDiagonal(a, b) {
+ return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) &&
+ locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
+}
+
+// signed area of a triangle
+function area(p, q, r) {
+ return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+
+// check if two points are equal
+function equals(p1, p2) {
+ return p1.x === p2.x && p1.y === p2.y;
+}
+
+// check if two segments intersect
+function intersects(p1, q1, p2, q2) {
+ if ((equals(p1, q1) && equals(p2, q2)) ||
+ (equals(p1, q2) && equals(p2, q1))) return true;
+ return area(p1, q1, p2) > 0 !== area(p1, q1, q2) > 0 &&
+ area(p2, q2, p1) > 0 !== area(p2, q2, q1) > 0;
+}
+
+// check if a polygon diagonal intersects any polygon segments
+function intersectsPolygon(a, b) {
+ var p = a;
+ do {
+ if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+ intersects(p, p.next, a, b)) return true;
+ p = p.next;
+ } while (p !== a);
+
+ return false;
+}
+
+// check if a polygon diagonal is locally inside the polygon
+function locallyInside(a, b) {
+ return area(a.prev, a, a.next) < 0 ?
+ area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
+ area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+
+// check if the middle point of a polygon diagonal is inside the polygon
+function middleInside(a, b) {
+ var p = a,
+ inside = false,
+ px = (a.x + b.x) / 2,
+ py = (a.y + b.y) / 2;
+ do {
+ if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+ (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
+ inside = !inside;
+ p = p.next;
+ } while (p !== a);
+
+ return inside;
+}
+
+// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
+// if one belongs to the outer ring and another to a hole, it merges it into a single ring
+function splitPolygon(a, b) {
+ var a2 = new Node(a.i, a.x, a.y),
+ b2 = new Node(b.i, b.x, b.y),
+ an = a.next,
+ bp = b.prev;
+
+ a.next = b;
+ b.prev = a;
+
+ a2.next = an;
+ an.prev = a2;
+
+ b2.next = a2;
+ a2.prev = b2;
+
+ bp.next = b2;
+ b2.prev = bp;
+
+ return b2;
+}
+
+// create a node and optionally link it with previous one (in a circular doubly linked list)
+function insertNode(i, x, y, last) {
+ var p = new Node(i, x, y);
+
+ if (!last) {
+ p.prev = p;
+ p.next = p;
+
+ } else {
+ p.next = last.next;
+ p.prev = last;
+ last.next.prev = p;
+ last.next = p;
+ }
+ return p;
+}
+
+function removeNode(p) {
+ p.next.prev = p.prev;
+ p.prev.next = p.next;
+
+ if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+ if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+}
+
+function Node(i, x, y) {
+ // vertice index in coordinates array
+ this.i = i;
+
+ // vertex coordinates
+ this.x = x;
+ this.y = y;
+
+ // previous and next vertice nodes in a polygon ring
+ this.prev = null;
+ this.next = null;
+
+ // z-order curve value
+ this.z = null;
+
+ // previous and next nodes in z-order
+ this.prevZ = null;
+ this.nextZ = null;
+
+ // indicates whether this is a steiner point
+ this.steiner = false;
+}
+
+// return a percentage difference between the polygon area and its triangulation area;
+// used to verify correctness of triangulation
+earcut.deviation = function (data, holeIndices, dim, triangles) {
+ var hasHoles = holeIndices && holeIndices.length;
+ var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+
+ var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+ if (hasHoles) {
+ for (var i = 0, len = holeIndices.length; i < len; i++) {
+ var start = holeIndices[i] * dim;
+ var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+ polygonArea -= Math.abs(signedArea(data, start, end, dim));
+ }
+ }
+
+ var trianglesArea = 0;
+ for (i = 0; i < triangles.length; i += 3) {
+ var a = triangles[i] * dim;
+ var b = triangles[i + 1] * dim;
+ var c = triangles[i + 2] * dim;
+ trianglesArea += Math.abs(
+ (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
+ (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
+ }
+
+ return polygonArea === 0 && trianglesArea === 0 ? 0 :
+ Math.abs((trianglesArea - polygonArea) / polygonArea);
+};
+
+function signedArea(data, start, end, dim) {
+ var sum = 0;
+ for (var i = start, j = end - dim; i < end; i += dim) {
+ sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+ j = i;
+ }
+ return sum;
+}
+
+// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
+earcut.flatten = function (data) {
+ var dim = data[0][0].length,
+ result = {vertices: [], holes: [], dimensions: dim},
+ holeIndex = 0;
+
+ for (var i = 0; i < data.length; i++) {
+ for (var j = 0; j < data[i].length; j++) {
+ for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
+ }
+ if (i > 0) {
+ holeIndex += data[i - 1].length;
+ result.holes.push(holeIndex);
+ }
+ }
+ return result;
+};
+
+},{}],157:[function(_dereq_,module,exports){
+"use strict"
+
+module.exports = edgeToAdjacency
+
+var uniq = _dereq_("uniq")
+
+function edgeToAdjacency(edges, numVertices) {
+ var numEdges = edges.length
+ if(typeof numVertices !== "number") {
+ numVertices = 0
+ for(var i=0; i= 0xd800 && code <= 0xdbff) value += arrayLike[++i];
+ }
+ value = mapFn ? call.call(mapFn, thisArg, value, j) : value;
+ if (Context) {
+ desc.value = value;
+ defineProperty(arr, j, desc);
+ } else {
+ arr[j] = value;
+ }
+ ++j;
+ }
+ length = j;
+ }
+ }
+ if (length === undefined) {
+ // Source: array or array-like
+ length = toPosInt(arrayLike.length);
+ if (Context) arr = new Context(length);
+ for (i = 0; i < length; ++i) {
+ value = mapFn ? call.call(mapFn, thisArg, arrayLike[i], i) : arrayLike[i];
+ if (Context) {
+ desc.value = value;
+ defineProperty(arr, i, desc);
+ } else {
+ arr[i] = value;
+ }
+ }
+ }
+ if (Context) {
+ desc.value = null;
+ arr.length = length;
+ }
+ return arr;
+};
+
+},{"../../function/is-arguments":162,"../../function/is-function":163,"../../number/to-pos-integer":169,"../../object/is-value":179,"../../object/valid-callable":188,"../../object/valid-value":190,"../../string/is-string":194,"es6-symbol":204}],162:[function(_dereq_,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString
+ , id = objToString.call(
+ (function () {
+ return arguments;
+ })()
+);
+
+module.exports = function (value) {
+ return objToString.call(value) === id;
+};
+
+},{}],163:[function(_dereq_,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString, id = objToString.call(_dereq_("./noop"));
+
+module.exports = function (value) {
+ return typeof value === "function" && objToString.call(value) === id;
+};
+
+},{"./noop":164}],164:[function(_dereq_,module,exports){
+"use strict";
+
+// eslint-disable-next-line no-empty-function
+module.exports = function () {};
+
+},{}],165:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./is-implemented")()
+ ? Math.sign
+ : _dereq_("./shim");
+
+},{"./is-implemented":166,"./shim":167}],166:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = function () {
+ var sign = Math.sign;
+ if (typeof sign !== "function") return false;
+ return (sign(10) === 1) && (sign(-20) === -1);
+};
+
+},{}],167:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = function (value) {
+ value = Number(value);
+ if (isNaN(value) || (value === 0)) return value;
+ return value > 0 ? 1 : -1;
+};
+
+},{}],168:[function(_dereq_,module,exports){
+"use strict";
+
+var sign = _dereq_("../math/sign")
+
+ , abs = Math.abs, floor = Math.floor;
+
+module.exports = function (value) {
+ if (isNaN(value)) return 0;
+ value = Number(value);
+ if ((value === 0) || !isFinite(value)) return value;
+ return sign(value) * floor(abs(value));
+};
+
+},{"../math/sign":165}],169:[function(_dereq_,module,exports){
+"use strict";
+
+var toInteger = _dereq_("./to-integer")
+
+ , max = Math.max;
+
+module.exports = function (value) {
+ return max(0, toInteger(value));
+};
+
+},{"./to-integer":168}],170:[function(_dereq_,module,exports){
+// Internal method, used by iteration functions.
+// Calls a function for each key-value pair found in object
+// Optionally takes compareFn to iterate object in specific order
+
+"use strict";
+
+var callable = _dereq_("./valid-callable")
+ , value = _dereq_("./valid-value")
+ , bind = Function.prototype.bind
+ , call = Function.prototype.call
+ , keys = Object.keys
+ , objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = function (method, defVal) {
+ return function (obj, cb /*, thisArg, compareFn*/) {
+ var list, thisArg = arguments[2], compareFn = arguments[3];
+ obj = Object(value(obj));
+ callable(cb);
+
+ list = keys(obj);
+ if (compareFn) {
+ list.sort(typeof compareFn === "function" ? bind.call(compareFn, obj) : undefined);
+ }
+ if (typeof method !== "function") method = list[method];
+ return call.call(method, list, function (key, index) {
+ if (!objPropertyIsEnumerable.call(obj, key)) return defVal;
+ return call.call(cb, thisArg, obj[key], key, obj, index);
+ });
+ };
+};
+
+},{"./valid-callable":188,"./valid-value":190}],171:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./is-implemented")()
+ ? Object.assign
+ : _dereq_("./shim");
+
+},{"./is-implemented":172,"./shim":173}],172:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = function () {
+ var assign = Object.assign, obj;
+ if (typeof assign !== "function") return false;
+ obj = { foo: "raz" };
+ assign(obj, { bar: "dwa" }, { trzy: "trzy" });
+ return (obj.foo + obj.bar + obj.trzy) === "razdwatrzy";
+};
+
+},{}],173:[function(_dereq_,module,exports){
+"use strict";
+
+var keys = _dereq_("../keys")
+ , value = _dereq_("../valid-value")
+ , max = Math.max;
+
+module.exports = function (dest, src /*, …srcn*/) {
+ var error, i, length = max(arguments.length, 2), assign;
+ dest = Object(value(dest));
+ assign = function (key) {
+ try {
+ dest[key] = src[key];
+ } catch (e) {
+ if (!error) error = e;
+ }
+ };
+ for (i = 1; i < length; ++i) {
+ src = arguments[i];
+ keys(src).forEach(assign);
+ }
+ if (error !== undefined) throw error;
+ return dest;
+};
+
+},{"../keys":180,"../valid-value":190}],174:[function(_dereq_,module,exports){
+"use strict";
+
+var aFrom = _dereq_("../array/from")
+ , assign = _dereq_("./assign")
+ , value = _dereq_("./valid-value");
+
+module.exports = function (obj/*, propertyNames, options*/) {
+ var copy = Object(value(obj)), propertyNames = arguments[1], options = Object(arguments[2]);
+ if (copy !== obj && !propertyNames) return copy;
+ var result = {};
+ if (propertyNames) {
+ aFrom(propertyNames, function (propertyName) {
+ if (options.ensure || propertyName in obj) result[propertyName] = obj[propertyName];
+ });
+ } else {
+ assign(result, obj);
+ }
+ return result;
+};
+
+},{"../array/from":159,"./assign":171,"./valid-value":190}],175:[function(_dereq_,module,exports){
+// Workaround for http://code.google.com/p/v8/issues/detail?id=2804
+
+"use strict";
+
+var create = Object.create, shim;
+
+if (!_dereq_("./set-prototype-of/is-implemented")()) {
+ shim = _dereq_("./set-prototype-of/shim");
+}
+
+module.exports = (function () {
+ var nullObject, polyProps, desc;
+ if (!shim) return create;
+ if (shim.level !== 1) return create;
+
+ nullObject = {};
+ polyProps = {};
+ desc = {
+ configurable: false,
+ enumerable: false,
+ writable: true,
+ value: undefined
+ };
+ Object.getOwnPropertyNames(Object.prototype).forEach(function (name) {
+ if (name === "__proto__") {
+ polyProps[name] = {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: undefined
+ };
+ return;
+ }
+ polyProps[name] = desc;
+ });
+ Object.defineProperties(nullObject, polyProps);
+
+ Object.defineProperty(shim, "nullPolyfill", {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: nullObject
+ });
+
+ return function (prototype, props) {
+ return create(prototype === null ? nullObject : prototype, props);
+ };
+}());
+
+},{"./set-prototype-of/is-implemented":186,"./set-prototype-of/shim":187}],176:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./_iterate")("forEach");
+
+},{"./_iterate":170}],177:[function(_dereq_,module,exports){
+// Deprecated
+
+"use strict";
+
+module.exports = function (obj) {
+ return typeof obj === "function";
+};
+
+},{}],178:[function(_dereq_,module,exports){
+"use strict";
+
+var isValue = _dereq_("./is-value");
+
+var map = { function: true, object: true };
+
+module.exports = function (value) {
+ return (isValue(value) && map[typeof value]) || false;
+};
+
+},{"./is-value":179}],179:[function(_dereq_,module,exports){
+"use strict";
+
+var _undefined = _dereq_("../function/noop")(); // Support ES3 engines
+
+module.exports = function (val) {
+ return (val !== _undefined) && (val !== null);
+};
+
+},{"../function/noop":164}],180:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./is-implemented")() ? Object.keys : _dereq_("./shim");
+
+},{"./is-implemented":181,"./shim":182}],181:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = function () {
+ try {
+ Object.keys("primitive");
+ return true;
+ } catch (e) {
+ return false;
+ }
+};
+
+},{}],182:[function(_dereq_,module,exports){
+"use strict";
+
+var isValue = _dereq_("../is-value");
+
+var keys = Object.keys;
+
+module.exports = function (object) { return keys(isValue(object) ? Object(object) : object); };
+
+},{"../is-value":179}],183:[function(_dereq_,module,exports){
+"use strict";
+
+var callable = _dereq_("./valid-callable")
+ , forEach = _dereq_("./for-each")
+ , call = Function.prototype.call;
+
+module.exports = function (obj, cb /*, thisArg*/) {
+ var result = {}, thisArg = arguments[2];
+ callable(cb);
+ forEach(obj, function (value, key, targetObj, index) {
+ result[key] = call.call(cb, thisArg, value, key, targetObj, index);
+ });
+ return result;
+};
+
+},{"./for-each":176,"./valid-callable":188}],184:[function(_dereq_,module,exports){
+"use strict";
+
+var isValue = _dereq_("./is-value");
+
+var forEach = Array.prototype.forEach, create = Object.create;
+
+var process = function (src, obj) {
+ var key;
+ for (key in src) obj[key] = src[key];
+};
+
+// eslint-disable-next-line no-unused-vars
+module.exports = function (opts1 /*, …options*/) {
+ var result = create(null);
+ forEach.call(arguments, function (options) {
+ if (!isValue(options)) return;
+ process(Object(options), result);
+ });
+ return result;
+};
+
+},{"./is-value":179}],185:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./is-implemented")()
+ ? Object.setPrototypeOf
+ : _dereq_("./shim");
+
+},{"./is-implemented":186,"./shim":187}],186:[function(_dereq_,module,exports){
+"use strict";
+
+var create = Object.create, getPrototypeOf = Object.getPrototypeOf, plainObject = {};
+
+module.exports = function (/* CustomCreate*/) {
+ var setPrototypeOf = Object.setPrototypeOf, customCreate = arguments[0] || create;
+ if (typeof setPrototypeOf !== "function") return false;
+ return getPrototypeOf(setPrototypeOf(customCreate(null), plainObject)) === plainObject;
+};
+
+},{}],187:[function(_dereq_,module,exports){
+/* eslint no-proto: "off" */
+
+// Big thanks to @WebReflection for sorting this out
+// https://gist.github.com/WebReflection/5593554
+
+"use strict";
+
+var isObject = _dereq_("../is-object")
+ , value = _dereq_("../valid-value")
+ , objIsPrototypeOf = Object.prototype.isPrototypeOf
+ , defineProperty = Object.defineProperty
+ , nullDesc = {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: undefined
+}
+ , validate;
+
+validate = function (obj, prototype) {
+ value(obj);
+ if (prototype === null || isObject(prototype)) return obj;
+ throw new TypeError("Prototype must be null or an object");
+};
+
+module.exports = (function (status) {
+ var fn, set;
+ if (!status) return null;
+ if (status.level === 2) {
+ if (status.set) {
+ set = status.set;
+ fn = function (obj, prototype) {
+ set.call(validate(obj, prototype), prototype);
+ return obj;
+ };
+ } else {
+ fn = function (obj, prototype) {
+ validate(obj, prototype).__proto__ = prototype;
+ return obj;
+ };
+ }
+ } else {
+ fn = function self(obj, prototype) {
+ var isNullBase;
+ validate(obj, prototype);
+ isNullBase = objIsPrototypeOf.call(self.nullPolyfill, obj);
+ if (isNullBase) delete self.nullPolyfill.__proto__;
+ if (prototype === null) prototype = self.nullPolyfill;
+ obj.__proto__ = prototype;
+ if (isNullBase) defineProperty(self.nullPolyfill, "__proto__", nullDesc);
+ return obj;
+ };
+ }
+ return Object.defineProperty(fn, "level", {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: status.level
+ });
+}(
+ (function () {
+ var tmpObj1 = Object.create(null)
+ , tmpObj2 = {}
+ , set
+ , desc = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");
+
+ if (desc) {
+ try {
+ set = desc.set; // Opera crashes at this point
+ set.call(tmpObj1, tmpObj2);
+ } catch (ignore) {}
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { set: set, level: 2 };
+ }
+
+ tmpObj1.__proto__ = tmpObj2;
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 2 };
+
+ tmpObj1 = {};
+ tmpObj1.__proto__ = tmpObj2;
+ if (Object.getPrototypeOf(tmpObj1) === tmpObj2) return { level: 1 };
+
+ return false;
+ })()
+));
+
+_dereq_("../create");
+
+},{"../create":175,"../is-object":178,"../valid-value":190}],188:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = function (fn) {
+ if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+ return fn;
+};
+
+},{}],189:[function(_dereq_,module,exports){
+"use strict";
+
+var isObject = _dereq_("./is-object");
+
+module.exports = function (value) {
+ if (!isObject(value)) throw new TypeError(value + " is not an Object");
+ return value;
+};
+
+},{"./is-object":178}],190:[function(_dereq_,module,exports){
+"use strict";
+
+var isValue = _dereq_("./is-value");
+
+module.exports = function (value) {
+ if (!isValue(value)) throw new TypeError("Cannot use null or undefined");
+ return value;
+};
+
+},{"./is-value":179}],191:[function(_dereq_,module,exports){
+"use strict";
+
+module.exports = _dereq_("./is-implemented")()
+ ? String.prototype.contains
+ : _dereq_("./shim");
+
+},{"./is-implemented":192,"./shim":193}],192:[function(_dereq_,module,exports){
+"use strict";
+
+var str = "razdwatrzy";
+
+module.exports = function () {
+ if (typeof str.contains !== "function") return false;
+ return (str.contains("dwa") === true) && (str.contains("foo") === false);
+};
+
+},{}],193:[function(_dereq_,module,exports){
+"use strict";
+
+var indexOf = String.prototype.indexOf;
+
+module.exports = function (searchString/*, position*/) {
+ return indexOf.call(this, searchString, arguments[1]) > -1;
+};
+
+},{}],194:[function(_dereq_,module,exports){
+"use strict";
+
+var objToString = Object.prototype.toString, id = objToString.call("");
+
+module.exports = function (value) {
+ return (
+ typeof value === "string" ||
+ (value &&
+ typeof value === "object" &&
+ (value instanceof String || objToString.call(value) === id)) ||
+ false
+ );
+};
+
+},{}],195:[function(_dereq_,module,exports){
+"use strict";
+
+var generated = Object.create(null), random = Math.random;
+
+module.exports = function () {
+ var str;
+ do {
+ str = random()
+ .toString(36)
+ .slice(2);
+ } while (generated[str]);
+ return str;
+};
+
+},{}],196:[function(_dereq_,module,exports){
+"use strict";
+
+var setPrototypeOf = _dereq_("es5-ext/object/set-prototype-of")
+ , contains = _dereq_("es5-ext/string/#/contains")
+ , d = _dereq_("d")
+ , Symbol = _dereq_("es6-symbol")
+ , Iterator = _dereq_("./");
+
+var defineProperty = Object.defineProperty, ArrayIterator;
+
+ArrayIterator = module.exports = function (arr, kind) {
+ if (!(this instanceof ArrayIterator)) throw new TypeError("Constructor requires 'new'");
+ Iterator.call(this, arr);
+ if (!kind) kind = "value";
+ else if (contains.call(kind, "key+value")) kind = "key+value";
+ else if (contains.call(kind, "key")) kind = "key";
+ else kind = "value";
+ defineProperty(this, "__kind__", d("", kind));
+};
+if (setPrototypeOf) setPrototypeOf(ArrayIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete ArrayIterator.prototype.constructor;
+
+ArrayIterator.prototype = Object.create(Iterator.prototype, {
+ _resolve: d(function (i) {
+ if (this.__kind__ === "value") return this.__list__[i];
+ if (this.__kind__ === "key+value") return [i, this.__list__[i]];
+ return i;
+ })
+});
+defineProperty(ArrayIterator.prototype, Symbol.toStringTag, d("c", "Array Iterator"));
+
+},{"./":199,"d":139,"es5-ext/object/set-prototype-of":185,"es5-ext/string/#/contains":191,"es6-symbol":204}],197:[function(_dereq_,module,exports){
+"use strict";
+
+var isArguments = _dereq_("es5-ext/function/is-arguments")
+ , callable = _dereq_("es5-ext/object/valid-callable")
+ , isString = _dereq_("es5-ext/string/is-string")
+ , get = _dereq_("./get");
+
+var isArray = Array.isArray, call = Function.prototype.call, some = Array.prototype.some;
+
+module.exports = function (iterable, cb /*, thisArg*/) {
+ var mode, thisArg = arguments[2], result, doBreak, broken, i, length, char, code;
+ if (isArray(iterable) || isArguments(iterable)) mode = "array";
+ else if (isString(iterable)) mode = "string";
+ else iterable = get(iterable);
+
+ callable(cb);
+ doBreak = function () {
+ broken = true;
+ };
+ if (mode === "array") {
+ some.call(iterable, function (value) {
+ call.call(cb, thisArg, value, doBreak);
+ return broken;
+ });
+ return;
+ }
+ if (mode === "string") {
+ length = iterable.length;
+ for (i = 0; i < length; ++i) {
+ char = iterable[i];
+ if (i + 1 < length) {
+ code = char.charCodeAt(0);
+ if (code >= 0xd800 && code <= 0xdbff) char += iterable[++i];
+ }
+ call.call(cb, thisArg, char, doBreak);
+ if (broken) break;
+ }
+ return;
+ }
+ result = iterable.next();
+
+ while (!result.done) {
+ call.call(cb, thisArg, result.value, doBreak);
+ if (broken) return;
+ result = iterable.next();
+ }
+};
+
+},{"./get":198,"es5-ext/function/is-arguments":162,"es5-ext/object/valid-callable":188,"es5-ext/string/is-string":194}],198:[function(_dereq_,module,exports){
+"use strict";
+
+var isArguments = _dereq_("es5-ext/function/is-arguments")
+ , isString = _dereq_("es5-ext/string/is-string")
+ , ArrayIterator = _dereq_("./array")
+ , StringIterator = _dereq_("./string")
+ , iterable = _dereq_("./valid-iterable")
+ , iteratorSymbol = _dereq_("es6-symbol").iterator;
+
+module.exports = function (obj) {
+ if (typeof iterable(obj)[iteratorSymbol] === "function") return obj[iteratorSymbol]();
+ if (isArguments(obj)) return new ArrayIterator(obj);
+ if (isString(obj)) return new StringIterator(obj);
+ return new ArrayIterator(obj);
+};
+
+},{"./array":196,"./string":201,"./valid-iterable":202,"es5-ext/function/is-arguments":162,"es5-ext/string/is-string":194,"es6-symbol":204}],199:[function(_dereq_,module,exports){
+"use strict";
+
+var clear = _dereq_("es5-ext/array/#/clear")
+ , assign = _dereq_("es5-ext/object/assign")
+ , callable = _dereq_("es5-ext/object/valid-callable")
+ , value = _dereq_("es5-ext/object/valid-value")
+ , d = _dereq_("d")
+ , autoBind = _dereq_("d/auto-bind")
+ , Symbol = _dereq_("es6-symbol");
+
+var defineProperty = Object.defineProperty, defineProperties = Object.defineProperties, Iterator;
+
+module.exports = Iterator = function (list, context) {
+ if (!(this instanceof Iterator)) throw new TypeError("Constructor requires 'new'");
+ defineProperties(this, {
+ __list__: d("w", value(list)),
+ __context__: d("w", context),
+ __nextIndex__: d("w", 0)
+ });
+ if (!context) return;
+ callable(context.on);
+ context.on("_add", this._onAdd);
+ context.on("_delete", this._onDelete);
+ context.on("_clear", this._onClear);
+};
+
+// Internal %IteratorPrototype% doesn't expose its constructor
+delete Iterator.prototype.constructor;
+
+defineProperties(
+ Iterator.prototype,
+ assign(
+ {
+ _next: d(function () {
+ var i;
+ if (!this.__list__) return undefined;
+ if (this.__redo__) {
+ i = this.__redo__.shift();
+ if (i !== undefined) return i;
+ }
+ if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;
+ this._unBind();
+ return undefined;
+ }),
+ next: d(function () {
+ return this._createResult(this._next());
+ }),
+ _createResult: d(function (i) {
+ if (i === undefined) return { done: true, value: undefined };
+ return { done: false, value: this._resolve(i) };
+ }),
+ _resolve: d(function (i) {
+ return this.__list__[i];
+ }),
+ _unBind: d(function () {
+ this.__list__ = null;
+ delete this.__redo__;
+ if (!this.__context__) return;
+ this.__context__.off("_add", this._onAdd);
+ this.__context__.off("_delete", this._onDelete);
+ this.__context__.off("_clear", this._onClear);
+ this.__context__ = null;
+ }),
+ toString: d(function () {
+ return "[object " + (this[Symbol.toStringTag] || "Object") + "]";
+ })
+ },
+ autoBind({
+ _onAdd: d(function (index) {
+ if (index >= this.__nextIndex__) return;
+ ++this.__nextIndex__;
+ if (!this.__redo__) {
+ defineProperty(this, "__redo__", d("c", [index]));
+ return;
+ }
+ this.__redo__.forEach(function (redo, i) {
+ if (redo >= index) this.__redo__[i] = ++redo;
+ }, this);
+ this.__redo__.push(index);
+ }),
+ _onDelete: d(function (index) {
+ var i;
+ if (index >= this.__nextIndex__) return;
+ --this.__nextIndex__;
+ if (!this.__redo__) return;
+ i = this.__redo__.indexOf(index);
+ if (i !== -1) this.__redo__.splice(i, 1);
+ this.__redo__.forEach(function (redo, j) {
+ if (redo > index) this.__redo__[j] = --redo;
+ }, this);
+ }),
+ _onClear: d(function () {
+ if (this.__redo__) clear.call(this.__redo__);
+ this.__nextIndex__ = 0;
+ })
+ })
+ )
+);
+
+defineProperty(
+ Iterator.prototype,
+ Symbol.iterator,
+ d(function () {
+ return this;
+ })
+);
+
+},{"d":139,"d/auto-bind":138,"es5-ext/array/#/clear":158,"es5-ext/object/assign":171,"es5-ext/object/valid-callable":188,"es5-ext/object/valid-value":190,"es6-symbol":204}],200:[function(_dereq_,module,exports){
+"use strict";
+
+var isArguments = _dereq_("es5-ext/function/is-arguments")
+ , isValue = _dereq_("es5-ext/object/is-value")
+ , isString = _dereq_("es5-ext/string/is-string");
+
+var iteratorSymbol = _dereq_("es6-symbol").iterator
+ , isArray = Array.isArray;
+
+module.exports = function (value) {
+ if (!isValue(value)) return false;
+ if (isArray(value)) return true;
+ if (isString(value)) return true;
+ if (isArguments(value)) return true;
+ return typeof value[iteratorSymbol] === "function";
+};
+
+},{"es5-ext/function/is-arguments":162,"es5-ext/object/is-value":179,"es5-ext/string/is-string":194,"es6-symbol":204}],201:[function(_dereq_,module,exports){
+// Thanks @mathiasbynens
+// http://mathiasbynens.be/notes/javascript-unicode#iterating-over-symbols
+
+"use strict";
+
+var setPrototypeOf = _dereq_("es5-ext/object/set-prototype-of")
+ , d = _dereq_("d")
+ , Symbol = _dereq_("es6-symbol")
+ , Iterator = _dereq_("./");
+
+var defineProperty = Object.defineProperty, StringIterator;
+
+StringIterator = module.exports = function (str) {
+ if (!(this instanceof StringIterator)) throw new TypeError("Constructor requires 'new'");
+ str = String(str);
+ Iterator.call(this, str);
+ defineProperty(this, "__length__", d("", str.length));
+};
+if (setPrototypeOf) setPrototypeOf(StringIterator, Iterator);
+
+// Internal %ArrayIteratorPrototype% doesn't expose its constructor
+delete StringIterator.prototype.constructor;
+
+StringIterator.prototype = Object.create(Iterator.prototype, {
+ _next: d(function () {
+ if (!this.__list__) return undefined;
+ if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;
+ this._unBind();
+ return undefined;
+ }),
+ _resolve: d(function (i) {
+ var char = this.__list__[i], code;
+ if (this.__nextIndex__ === this.__length__) return char;
+ code = char.charCodeAt(0);
+ if (code >= 0xd800 && code <= 0xdbff) return char + this.__list__[this.__nextIndex__++];
+ return char;
+ })
+});
+defineProperty(StringIterator.prototype, Symbol.toStringTag, d("c", "String Iterator"));
+
+},{"./":199,"d":139,"es5-ext/object/set-prototype-of":185,"es6-symbol":204}],202:[function(_dereq_,module,exports){
+"use strict";
+
+var isIterable = _dereq_("./is-iterable");
+
+module.exports = function (value) {
+ if (!isIterable(value)) throw new TypeError(value + " is not iterable");
+ return value;
+};
+
+},{"./is-iterable":200}],203:[function(_dereq_,module,exports){
+(function (process,global){
+/*!
+ * @overview es6-promise - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+ * @license Licensed under MIT license
+ * See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
+ * @version 3.3.1
+ */
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global.ES6Promise = factory());
+}(this, (function () { 'use strict';
+
+function objectOrFunction(x) {
+ return typeof x === 'function' || typeof x === 'object' && x !== null;
+}
+
+function isFunction(x) {
+ return typeof x === 'function';
+}
+
+var _isArray = undefined;
+if (!Array.isArray) {
+ _isArray = function (x) {
+ return Object.prototype.toString.call(x) === '[object Array]';
+ };
+} else {
+ _isArray = Array.isArray;
+}
+
+var isArray = _isArray;
+
+var len = 0;
+var vertxNext = undefined;
+var customSchedulerFn = undefined;
+
+var asap = function asap(callback, arg) {
+ queue[len] = callback;
+ queue[len + 1] = arg;
+ len += 2;
+ if (len === 2) {
+ // If len is 2, that means that we need to schedule an async flush.
+ // If additional callbacks are queued before the queue is flushed, they
+ // will be processed by this flush that we are scheduling.
+ if (customSchedulerFn) {
+ customSchedulerFn(flush);
+ } else {
+ scheduleFlush();
+ }
+ }
+};
+
+function setScheduler(scheduleFn) {
+ customSchedulerFn = scheduleFn;
+}
+
+function setAsap(asapFn) {
+ asap = asapFn;
+}
+
+var browserWindow = typeof window !== 'undefined' ? window : undefined;
+var browserGlobal = browserWindow || {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && ({}).toString.call(process) === '[object process]';
+
+// test for web worker but not in IE10
+var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+
+// node
+function useNextTick() {
+ // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+ // see https://github.com/cujojs/when/issues/410 for details
+ return function () {
+ return process.nextTick(flush);
+ };
+}
+
+// vertx
+function useVertxTimer() {
+ return function () {
+ vertxNext(flush);
+ };
+}
+
+function useMutationObserver() {
+ var iterations = 0;
+ var observer = new BrowserMutationObserver(flush);
+ var node = document.createTextNode('');
+ observer.observe(node, { characterData: true });
+
+ return function () {
+ node.data = iterations = ++iterations % 2;
+ };
+}
+
+// web worker
+function useMessageChannel() {
+ var channel = new MessageChannel();
+ channel.port1.onmessage = flush;
+ return function () {
+ return channel.port2.postMessage(0);
+ };
+}
+
+function useSetTimeout() {
+ // Store setTimeout reference so es6-promise will be unaffected by
+ // other code modifying setTimeout (like sinon.useFakeTimers())
+ var globalSetTimeout = setTimeout;
+ return function () {
+ return globalSetTimeout(flush, 1);
+ };
+}
+
+var queue = new Array(1000);
+function flush() {
+ for (var i = 0; i < len; i += 2) {
+ var callback = queue[i];
+ var arg = queue[i + 1];
+
+ callback(arg);
+
+ queue[i] = undefined;
+ queue[i + 1] = undefined;
+ }
+
+ len = 0;
+}
+
+function attemptVertx() {
+ try {
+ var r = _dereq_;
+ var vertx = r('vertx');
+ vertxNext = vertx.runOnLoop || vertx.runOnContext;
+ return useVertxTimer();
+ } catch (e) {
+ return useSetTimeout();
+ }
+}
+
+var scheduleFlush = undefined;
+// Decide what async method to use to triggering processing of queued callbacks:
+if (isNode) {
+ scheduleFlush = useNextTick();
+} else if (BrowserMutationObserver) {
+ scheduleFlush = useMutationObserver();
+} else if (isWorker) {
+ scheduleFlush = useMessageChannel();
+} else if (browserWindow === undefined && typeof _dereq_ === 'function') {
+ scheduleFlush = attemptVertx();
+} else {
+ scheduleFlush = useSetTimeout();
+}
+
+function then(onFulfillment, onRejection) {
+ var _arguments = arguments;
+
+ var parent = this;
+
+ var child = new this.constructor(noop);
+
+ if (child[PROMISE_ID] === undefined) {
+ makePromise(child);
+ }
+
+ var _state = parent._state;
+
+ if (_state) {
+ (function () {
+ var callback = _arguments[_state - 1];
+ asap(function () {
+ return invokeCallback(_state, child, callback, parent._result);
+ });
+ })();
+ } else {
+ subscribe(parent, child, onFulfillment, onRejection);
+ }
+
+ return child;
+}
+
+/**
+ `Promise.resolve` returns a promise that will become resolved with the
+ passed `value`. It is shorthand for the following:
+
+ ```javascript
+ let promise = new Promise(function(resolve, reject){
+ resolve(1);
+ });
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ let promise = Promise.resolve(1);
+
+ promise.then(function(value){
+ // value === 1
+ });
+ ```
+
+ @method resolve
+ @static
+ @param {Any} value value that the returned promise will be resolved with
+ Useful for tooling.
+ @return {Promise} a promise that will become fulfilled with the given
+ `value`
+*/
+function resolve(object) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ if (object && typeof object === 'object' && object.constructor === Constructor) {
+ return object;
+ }
+
+ var promise = new Constructor(noop);
+ _resolve(promise, object);
+ return promise;
+}
+
+var PROMISE_ID = Math.random().toString(36).substring(16);
+
+function noop() {}
+
+var PENDING = void 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+
+var GET_THEN_ERROR = new ErrorObject();
+
+function selfFulfillment() {
+ return new TypeError("You cannot resolve a promise with itself");
+}
+
+function cannotReturnOwn() {
+ return new TypeError('A promises callback cannot return that same promise.');
+}
+
+function getThen(promise) {
+ try {
+ return promise.then;
+ } catch (error) {
+ GET_THEN_ERROR.error = error;
+ return GET_THEN_ERROR;
+ }
+}
+
+function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
+ try {
+ then.call(value, fulfillmentHandler, rejectionHandler);
+ } catch (e) {
+ return e;
+ }
+}
+
+function handleForeignThenable(promise, thenable, then) {
+ asap(function (promise) {
+ var sealed = false;
+ var error = tryThen(then, thenable, function (value) {
+ if (sealed) {
+ return;
+ }
+ sealed = true;
+ if (thenable !== value) {
+ _resolve(promise, value);
+ } else {
+ fulfill(promise, value);
+ }
+ }, function (reason) {
+ if (sealed) {
+ return;
+ }
+ sealed = true;
+
+ _reject(promise, reason);
+ }, 'Settle: ' + (promise._label || ' unknown promise'));
+
+ if (!sealed && error) {
+ sealed = true;
+ _reject(promise, error);
+ }
+ }, promise);
+}
+
+function handleOwnThenable(promise, thenable) {
+ if (thenable._state === FULFILLED) {
+ fulfill(promise, thenable._result);
+ } else if (thenable._state === REJECTED) {
+ _reject(promise, thenable._result);
+ } else {
+ subscribe(thenable, undefined, function (value) {
+ return _resolve(promise, value);
+ }, function (reason) {
+ return _reject(promise, reason);
+ });
+ }
+}
+
+function handleMaybeThenable(promise, maybeThenable, then$$) {
+ if (maybeThenable.constructor === promise.constructor && then$$ === then && maybeThenable.constructor.resolve === resolve) {
+ handleOwnThenable(promise, maybeThenable);
+ } else {
+ if (then$$ === GET_THEN_ERROR) {
+ _reject(promise, GET_THEN_ERROR.error);
+ } else if (then$$ === undefined) {
+ fulfill(promise, maybeThenable);
+ } else if (isFunction(then$$)) {
+ handleForeignThenable(promise, maybeThenable, then$$);
+ } else {
+ fulfill(promise, maybeThenable);
+ }
+ }
+}
+
+function _resolve(promise, value) {
+ if (promise === value) {
+ _reject(promise, selfFulfillment());
+ } else if (objectOrFunction(value)) {
+ handleMaybeThenable(promise, value, getThen(value));
+ } else {
+ fulfill(promise, value);
+ }
+}
+
+function publishRejection(promise) {
+ if (promise._onerror) {
+ promise._onerror(promise._result);
+ }
+
+ publish(promise);
+}
+
+function fulfill(promise, value) {
+ if (promise._state !== PENDING) {
+ return;
+ }
+
+ promise._result = value;
+ promise._state = FULFILLED;
+
+ if (promise._subscribers.length !== 0) {
+ asap(publish, promise);
+ }
+}
+
+function _reject(promise, reason) {
+ if (promise._state !== PENDING) {
+ return;
+ }
+ promise._state = REJECTED;
+ promise._result = reason;
+
+ asap(publishRejection, promise);
+}
+
+function subscribe(parent, child, onFulfillment, onRejection) {
+ var _subscribers = parent._subscribers;
+ var length = _subscribers.length;
+
+ parent._onerror = null;
+
+ _subscribers[length] = child;
+ _subscribers[length + FULFILLED] = onFulfillment;
+ _subscribers[length + REJECTED] = onRejection;
+
+ if (length === 0 && parent._state) {
+ asap(publish, parent);
+ }
+}
+
+function publish(promise) {
+ var subscribers = promise._subscribers;
+ var settled = promise._state;
+
+ if (subscribers.length === 0) {
+ return;
+ }
+
+ var child = undefined,
+ callback = undefined,
+ detail = promise._result;
+
+ for (var i = 0; i < subscribers.length; i += 3) {
+ child = subscribers[i];
+ callback = subscribers[i + settled];
+
+ if (child) {
+ invokeCallback(settled, child, callback, detail);
+ } else {
+ callback(detail);
+ }
+ }
+
+ promise._subscribers.length = 0;
+}
+
+function ErrorObject() {
+ this.error = null;
+}
+
+var TRY_CATCH_ERROR = new ErrorObject();
+
+function tryCatch(callback, detail) {
+ try {
+ return callback(detail);
+ } catch (e) {
+ TRY_CATCH_ERROR.error = e;
+ return TRY_CATCH_ERROR;
+ }
+}
+
+function invokeCallback(settled, promise, callback, detail) {
+ var hasCallback = isFunction(callback),
+ value = undefined,
+ error = undefined,
+ succeeded = undefined,
+ failed = undefined;
+
+ if (hasCallback) {
+ value = tryCatch(callback, detail);
+
+ if (value === TRY_CATCH_ERROR) {
+ failed = true;
+ error = value.error;
+ value = null;
+ } else {
+ succeeded = true;
+ }
+
+ if (promise === value) {
+ _reject(promise, cannotReturnOwn());
+ return;
+ }
+ } else {
+ value = detail;
+ succeeded = true;
+ }
+
+ if (promise._state !== PENDING) {
+ // noop
+ } else if (hasCallback && succeeded) {
+ _resolve(promise, value);
+ } else if (failed) {
+ _reject(promise, error);
+ } else if (settled === FULFILLED) {
+ fulfill(promise, value);
+ } else if (settled === REJECTED) {
+ _reject(promise, value);
+ }
+}
+
+function initializePromise(promise, resolver) {
+ try {
+ resolver(function resolvePromise(value) {
+ _resolve(promise, value);
+ }, function rejectPromise(reason) {
+ _reject(promise, reason);
+ });
+ } catch (e) {
+ _reject(promise, e);
+ }
+}
+
+var id = 0;
+function nextId() {
+ return id++;
+}
+
+function makePromise(promise) {
+ promise[PROMISE_ID] = id++;
+ promise._state = undefined;
+ promise._result = undefined;
+ promise._subscribers = [];
+}
+
+function Enumerator(Constructor, input) {
+ this._instanceConstructor = Constructor;
+ this.promise = new Constructor(noop);
+
+ if (!this.promise[PROMISE_ID]) {
+ makePromise(this.promise);
+ }
+
+ if (isArray(input)) {
+ this._input = input;
+ this.length = input.length;
+ this._remaining = input.length;
+
+ this._result = new Array(this.length);
+
+ if (this.length === 0) {
+ fulfill(this.promise, this._result);
+ } else {
+ this.length = this.length || 0;
+ this._enumerate();
+ if (this._remaining === 0) {
+ fulfill(this.promise, this._result);
+ }
+ }
+ } else {
+ _reject(this.promise, validationError());
+ }
+}
+
+function validationError() {
+ return new Error('Array Methods must be provided an Array');
+};
+
+Enumerator.prototype._enumerate = function () {
+ var length = this.length;
+ var _input = this._input;
+
+ for (var i = 0; this._state === PENDING && i < length; i++) {
+ this._eachEntry(_input[i], i);
+ }
+};
+
+Enumerator.prototype._eachEntry = function (entry, i) {
+ var c = this._instanceConstructor;
+ var resolve$$ = c.resolve;
+
+ if (resolve$$ === resolve) {
+ var _then = getThen(entry);
+
+ if (_then === then && entry._state !== PENDING) {
+ this._settledAt(entry._state, i, entry._result);
+ } else if (typeof _then !== 'function') {
+ this._remaining--;
+ this._result[i] = entry;
+ } else if (c === Promise) {
+ var promise = new c(noop);
+ handleMaybeThenable(promise, entry, _then);
+ this._willSettleAt(promise, i);
+ } else {
+ this._willSettleAt(new c(function (resolve$$) {
+ return resolve$$(entry);
+ }), i);
+ }
+ } else {
+ this._willSettleAt(resolve$$(entry), i);
+ }
+};
+
+Enumerator.prototype._settledAt = function (state, i, value) {
+ var promise = this.promise;
+
+ if (promise._state === PENDING) {
+ this._remaining--;
+
+ if (state === REJECTED) {
+ _reject(promise, value);
+ } else {
+ this._result[i] = value;
+ }
+ }
+
+ if (this._remaining === 0) {
+ fulfill(promise, this._result);
+ }
+};
+
+Enumerator.prototype._willSettleAt = function (promise, i) {
+ var enumerator = this;
+
+ subscribe(promise, undefined, function (value) {
+ return enumerator._settledAt(FULFILLED, i, value);
+ }, function (reason) {
+ return enumerator._settledAt(REJECTED, i, reason);
+ });
+};
+
+/**
+ `Promise.all` accepts an array of promises, and returns a new promise which
+ is fulfilled with an array of fulfillment values for the passed promises, or
+ rejected with the reason of the first passed promise to be rejected. It casts all
+ elements of the passed iterable to promises as it runs this algorithm.
+
+ Example:
+
+ ```javascript
+ let promise1 = resolve(1);
+ let promise2 = resolve(2);
+ let promise3 = resolve(3);
+ let promises = [ promise1, promise2, promise3 ];
+
+ Promise.all(promises).then(function(array){
+ // The array here would be [ 1, 2, 3 ];
+ });
+ ```
+
+ If any of the `promises` given to `all` are rejected, the first promise
+ that is rejected will be given as an argument to the returned promises's
+ rejection handler. For example:
+
+ Example:
+
+ ```javascript
+ let promise1 = resolve(1);
+ let promise2 = reject(new Error("2"));
+ let promise3 = reject(new Error("3"));
+ let promises = [ promise1, promise2, promise3 ];
+
+ Promise.all(promises).then(function(array){
+ // Code here never runs because there are rejected promises!
+ }, function(error) {
+ // error.message === "2"
+ });
+ ```
+
+ @method all
+ @static
+ @param {Array} entries array of promises
+ @param {String} label optional string for labeling the promise.
+ Useful for tooling.
+ @return {Promise} promise that is fulfilled when all `promises` have been
+ fulfilled, or rejected if any of them become rejected.
+ @static
+*/
+function all(entries) {
+ return new Enumerator(this, entries).promise;
+}
+
+/**
+ `Promise.race` returns a new promise which is settled in the same way as the
+ first passed promise to settle.
+
+ Example:
+
+ ```javascript
+ let promise1 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ let promise2 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 2');
+ }, 100);
+ });
+
+ Promise.race([promise1, promise2]).then(function(result){
+ // result === 'promise 2' because it was resolved before promise1
+ // was resolved.
+ });
+ ```
+
+ `Promise.race` is deterministic in that only the state of the first
+ settled promise matters. For example, even if other promises given to the
+ `promises` array argument are resolved, but the first settled promise has
+ become rejected before the other promises became fulfilled, the returned
+ promise will become rejected:
+
+ ```javascript
+ let promise1 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ resolve('promise 1');
+ }, 200);
+ });
+
+ let promise2 = new Promise(function(resolve, reject){
+ setTimeout(function(){
+ reject(new Error('promise 2'));
+ }, 100);
+ });
+
+ Promise.race([promise1, promise2]).then(function(result){
+ // Code here never runs
+ }, function(reason){
+ // reason.message === 'promise 2' because promise 2 became rejected before
+ // promise 1 became fulfilled
+ });
+ ```
+
+ An example real-world use case is implementing timeouts:
+
+ ```javascript
+ Promise.race([ajax('foo.json'), timeout(5000)])
+ ```
+
+ @method race
+ @static
+ @param {Array} promises array of promises to observe
+ Useful for tooling.
+ @return {Promise} a promise which settles in the same way as the first passed
+ promise to settle.
+*/
+function race(entries) {
+ /*jshint validthis:true */
+ var Constructor = this;
+
+ if (!isArray(entries)) {
+ return new Constructor(function (_, reject) {
+ return reject(new TypeError('You must pass an array to race.'));
+ });
+ } else {
+ return new Constructor(function (resolve, reject) {
+ var length = entries.length;
+ for (var i = 0; i < length; i++) {
+ Constructor.resolve(entries[i]).then(resolve, reject);
+ }
+ });
+ }
+}
+
+/**
+ `Promise.reject` returns a promise rejected with the passed `reason`.
+ It is shorthand for the following:
+
+ ```javascript
+ let promise = new Promise(function(resolve, reject){
+ reject(new Error('WHOOPS'));
+ });
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ Instead of writing the above, your code now simply becomes the following:
+
+ ```javascript
+ let promise = Promise.reject(new Error('WHOOPS'));
+
+ promise.then(function(value){
+ // Code here doesn't run because the promise is rejected!
+ }, function(reason){
+ // reason.message === 'WHOOPS'
+ });
+ ```
+
+ @method reject
+ @static
+ @param {Any} reason value that the returned promise will be rejected with.
+ Useful for tooling.
+ @return {Promise} a promise rejected with the given `reason`.
+*/
+function reject(reason) {
+ /*jshint validthis:true */
+ var Constructor = this;
+ var promise = new Constructor(noop);
+ _reject(promise, reason);
+ return promise;
+}
+
+function needsResolver() {
+ throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+}
+
+function needsNew() {
+ throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+}
+
+/**
+ Promise objects represent the eventual result of an asynchronous operation. The
+ primary way of interacting with a promise is through its `then` method, which
+ registers callbacks to receive either a promise's eventual value or the reason
+ why the promise cannot be fulfilled.
+
+ Terminology
+ -----------
+
+ - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+ - `thenable` is an object or function that defines a `then` method.
+ - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+ - `exception` is a value that is thrown using the throw statement.
+ - `reason` is a value that indicates why a promise was rejected.
+ - `settled` the final resting state of a promise, fulfilled or rejected.
+
+ A promise can be in one of three states: pending, fulfilled, or rejected.
+
+ Promises that are fulfilled have a fulfillment value and are in the fulfilled
+ state. Promises that are rejected have a rejection reason and are in the
+ rejected state. A fulfillment value is never a thenable.
+
+ Promises can also be said to *resolve* a value. If this value is also a
+ promise, then the original promise's settled state will match the value's
+ settled state. So a promise that *resolves* a promise that rejects will
+ itself reject, and a promise that *resolves* a promise that fulfills will
+ itself fulfill.
+
+
+ Basic Usage:
+ ------------
+
+ ```js
+ let promise = new Promise(function(resolve, reject) {
+ // on success
+ resolve(value);
+
+ // on failure
+ reject(reason);
+ });
+
+ promise.then(function(value) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Advanced Usage:
+ ---------------
+
+ Promises shine when abstracting away asynchronous interactions such as
+ `XMLHttpRequest`s.
+
+ ```js
+ function getJSON(url) {
+ return new Promise(function(resolve, reject){
+ let xhr = new XMLHttpRequest();
+
+ xhr.open('GET', url);
+ xhr.onreadystatechange = handler;
+ xhr.responseType = 'json';
+ xhr.setRequestHeader('Accept', 'application/json');
+ xhr.send();
+
+ function handler() {
+ if (this.readyState === this.DONE) {
+ if (this.status === 200) {
+ resolve(this.response);
+ } else {
+ reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+ }
+ }
+ };
+ });
+ }
+
+ getJSON('/posts.json').then(function(json) {
+ // on fulfillment
+ }, function(reason) {
+ // on rejection
+ });
+ ```
+
+ Unlike callbacks, promises are great composable primitives.
+
+ ```js
+ Promise.all([
+ getJSON('/posts'),
+ getJSON('/comments')
+ ]).then(function(values){
+ values[0] // => postsJSON
+ values[1] // => commentsJSON
+
+ return values;
+ });
+ ```
+
+ @class Promise
+ @param {function} resolver
+ Useful for tooling.
+ @constructor
+*/
+function Promise(resolver) {
+ this[PROMISE_ID] = nextId();
+ this._result = this._state = undefined;
+ this._subscribers = [];
+
+ if (noop !== resolver) {
+ typeof resolver !== 'function' && needsResolver();
+ this instanceof Promise ? initializePromise(this, resolver) : needsNew();
+ }
+}
+
+Promise.all = all;
+Promise.race = race;
+Promise.resolve = resolve;
+Promise.reject = reject;
+Promise._setScheduler = setScheduler;
+Promise._setAsap = setAsap;
+Promise._asap = asap;
+
+Promise.prototype = {
+ constructor: Promise,
+
+ /**
+ The primary way of interacting with a promise is through its `then` method,
+ which registers callbacks to receive either a promise's eventual value or the
+ reason why the promise cannot be fulfilled.
+
+ ```js
+ findUser().then(function(user){
+ // user is available
+ }, function(reason){
+ // user is unavailable, and you are given the reason why
+ });
+ ```
+
+ Chaining
+ --------
+
+ The return value of `then` is itself a promise. This second, 'downstream'
+ promise is resolved with the return value of the first promise's fulfillment
+ or rejection handler, or rejected if the handler throws an exception.
+
+ ```js
+ findUser().then(function (user) {
+ return user.name;
+ }, function (reason) {
+ return 'default name';
+ }).then(function (userName) {
+ // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+ // will be `'default name'`
+ });
+
+ findUser().then(function (user) {
+ throw new Error('Found user, but still unhappy');
+ }, function (reason) {
+ throw new Error('`findUser` rejected and we're unhappy');
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+ // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+ });
+ ```
+ If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+
+ ```js
+ findUser().then(function (user) {
+ throw new PedagogicalException('Upstream error');
+ }).then(function (value) {
+ // never reached
+ }).then(function (value) {
+ // never reached
+ }, function (reason) {
+ // The `PedgagocialException` is propagated all the way down to here
+ });
+ ```
+
+ Assimilation
+ ------------
+
+ Sometimes the value you want to propagate to a downstream promise can only be
+ retrieved asynchronously. This can be achieved by returning a promise in the
+ fulfillment or rejection handler. The downstream promise will then be pending
+ until the returned promise is settled. This is called *assimilation*.
+
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // The user's comments are now available
+ });
+ ```
+
+ If the assimliated promise rejects, then the downstream promise will also reject.
+
+ ```js
+ findUser().then(function (user) {
+ return findCommentsByAuthor(user);
+ }).then(function (comments) {
+ // If `findCommentsByAuthor` fulfills, we'll have the value here
+ }, function (reason) {
+ // If `findCommentsByAuthor` rejects, we'll have the reason here
+ });
+ ```
+
+ Simple Example
+ --------------
+
+ Synchronous Example
+
+ ```javascript
+ let result;
+
+ try {
+ result = findResult();
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+
+ Errback Example
+
+ ```js
+ findResult(function(result, err){
+ if (err) {
+ // failure
+ } else {
+ // success
+ }
+ });
+ ```
+
+ Promise Example;
+
+ ```javascript
+ findResult().then(function(result){
+ // success
+ }, function(reason){
+ // failure
+ });
+ ```
+
+ Advanced Example
+ --------------
+
+ Synchronous Example
+
+ ```javascript
+ let author, books;
+
+ try {
+ author = findAuthor();
+ books = findBooksByAuthor(author);
+ // success
+ } catch(reason) {
+ // failure
+ }
+ ```
+
+ Errback Example
+
+ ```js
+
+ function foundBooks(books) {
+
+ }
+
+ function failure(reason) {
+
+ }
+
+ findAuthor(function(author, err){
+ if (err) {
+ failure(err);
+ // failure
+ } else {
+ try {
+ findBoooksByAuthor(author, function(books, err) {
+ if (err) {
+ failure(err);
+ } else {
+ try {
+ foundBooks(books);
+ } catch(reason) {
+ failure(reason);
+ }
+ }
+ });
+ } catch(error) {
+ failure(err);
+ }
+ // success
+ }
+ });
+ ```
+
+ Promise Example;
+
+ ```javascript
+ findAuthor().
+ then(findBooksByAuthor).
+ then(function(books){
+ // found books
+ }).catch(function(reason){
+ // something went wrong
+ });
+ ```
+
+ @method then
+ @param {Function} onFulfilled
+ @param {Function} onRejected
+ Useful for tooling.
+ @return {Promise}
+ */
+ then: then,
+
+ /**
+ `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+ as the catch block of a try/catch statement.
+
+ ```js
+ function findAuthor(){
+ throw new Error('couldn't find that author');
+ }
+
+ // synchronous
+ try {
+ findAuthor();
+ } catch(reason) {
+ // something went wrong
+ }
+
+ // async with promises
+ findAuthor().catch(function(reason){
+ // something went wrong
+ });
+ ```
+
+ @method catch
+ @param {Function} onRejection
+ Useful for tooling.
+ @return {Promise}
+ */
+ 'catch': function _catch(onRejection) {
+ return this.then(null, onRejection);
+ }
+};
+
+function polyfill() {
+ var local = undefined;
+
+ if (typeof global !== 'undefined') {
+ local = global;
+ } else if (typeof self !== 'undefined') {
+ local = self;
+ } else {
+ try {
+ local = Function('return this')();
+ } catch (e) {
+ throw new Error('polyfill failed because global object is unavailable in this environment');
+ }
+ }
+
+ var P = local.Promise;
+
+ if (P) {
+ var promiseToString = null;
+ try {
+ promiseToString = Object.prototype.toString.call(P.resolve());
+ } catch (e) {
+ // silently ignored
+ }
+
+ if (promiseToString === '[object Promise]' && !P.cast) {
+ return;
+ }
+ }
+
+ local.Promise = Promise;
+}
+
+polyfill();
+// Strange compat..
+Promise.polyfill = polyfill;
+Promise.Promise = Promise;
+
+return Promise;
+
+})));
+
+}).call(this,_dereq_('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"_process":465}],204:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')() ? Symbol : _dereq_('./polyfill');
+
+},{"./is-implemented":205,"./polyfill":207}],205:[function(_dereq_,module,exports){
+'use strict';
+
+var validTypes = { object: true, symbol: true };
+
+module.exports = function () {
+ var symbol;
+ if (typeof Symbol !== 'function') return false;
+ symbol = Symbol('test symbol');
+ try { String(symbol); } catch (e) { return false; }
+
+ // Return 'true' also for polyfills
+ if (!validTypes[typeof Symbol.iterator]) return false;
+ if (!validTypes[typeof Symbol.toPrimitive]) return false;
+ if (!validTypes[typeof Symbol.toStringTag]) return false;
+
+ return true;
+};
+
+},{}],206:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function (x) {
+ if (!x) return false;
+ if (typeof x === 'symbol') return true;
+ if (!x.constructor) return false;
+ if (x.constructor.name !== 'Symbol') return false;
+ return (x[x.constructor.toStringTag] === 'Symbol');
+};
+
+},{}],207:[function(_dereq_,module,exports){
+// ES2015 Symbol polyfill for environments that do not (or partially) support it
+
+'use strict';
+
+var d = _dereq_('d')
+ , validateSymbol = _dereq_('./validate-symbol')
+
+ , create = Object.create, defineProperties = Object.defineProperties
+ , defineProperty = Object.defineProperty, objPrototype = Object.prototype
+ , NativeSymbol, SymbolPolyfill, HiddenSymbol, globalSymbols = create(null)
+ , isNativeSafe;
+
+if (typeof Symbol === 'function') {
+ NativeSymbol = Symbol;
+ try {
+ String(NativeSymbol());
+ isNativeSafe = true;
+ } catch (ignore) {}
+}
+
+var generateName = (function () {
+ var created = create(null);
+ return function (desc) {
+ var postfix = 0, name, ie11BugWorkaround;
+ while (created[desc + (postfix || '')]) ++postfix;
+ desc += (postfix || '');
+ created[desc] = true;
+ name = '@@' + desc;
+ defineProperty(objPrototype, name, d.gs(null, function (value) {
+ // For IE11 issue see:
+ // https://connect.microsoft.com/IE/feedbackdetail/view/1928508/
+ // ie11-broken-getters-on-dom-objects
+ // https://github.com/medikoo/es6-symbol/issues/12
+ if (ie11BugWorkaround) return;
+ ie11BugWorkaround = true;
+ defineProperty(this, name, d(value));
+ ie11BugWorkaround = false;
+ }));
+ return name;
+ };
+}());
+
+// Internal constructor (not one exposed) for creating Symbol instances.
+// This one is used to ensure that `someSymbol instanceof Symbol` always return false
+HiddenSymbol = function Symbol(description) {
+ if (this instanceof HiddenSymbol) throw new TypeError('Symbol is not a constructor');
+ return SymbolPolyfill(description);
+};
+
+// Exposed `Symbol` constructor
+// (returns instances of HiddenSymbol)
+module.exports = SymbolPolyfill = function Symbol(description) {
+ var symbol;
+ if (this instanceof Symbol) throw new TypeError('Symbol is not a constructor');
+ if (isNativeSafe) return NativeSymbol(description);
+ symbol = create(HiddenSymbol.prototype);
+ description = (description === undefined ? '' : String(description));
+ return defineProperties(symbol, {
+ __description__: d('', description),
+ __name__: d('', generateName(description))
+ });
+};
+defineProperties(SymbolPolyfill, {
+ for: d(function (key) {
+ if (globalSymbols[key]) return globalSymbols[key];
+ return (globalSymbols[key] = SymbolPolyfill(String(key)));
+ }),
+ keyFor: d(function (s) {
+ var key;
+ validateSymbol(s);
+ for (key in globalSymbols) if (globalSymbols[key] === s) return key;
+ }),
+
+ // To ensure proper interoperability with other native functions (e.g. Array.from)
+ // fallback to eventual native implementation of given symbol
+ hasInstance: d('', (NativeSymbol && NativeSymbol.hasInstance) || SymbolPolyfill('hasInstance')),
+ isConcatSpreadable: d('', (NativeSymbol && NativeSymbol.isConcatSpreadable) ||
+ SymbolPolyfill('isConcatSpreadable')),
+ iterator: d('', (NativeSymbol && NativeSymbol.iterator) || SymbolPolyfill('iterator')),
+ match: d('', (NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match')),
+ replace: d('', (NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace')),
+ search: d('', (NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search')),
+ species: d('', (NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species')),
+ split: d('', (NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split')),
+ toPrimitive: d('', (NativeSymbol && NativeSymbol.toPrimitive) || SymbolPolyfill('toPrimitive')),
+ toStringTag: d('', (NativeSymbol && NativeSymbol.toStringTag) || SymbolPolyfill('toStringTag')),
+ unscopables: d('', (NativeSymbol && NativeSymbol.unscopables) || SymbolPolyfill('unscopables'))
+});
+
+// Internal tweaks for real symbol producer
+defineProperties(HiddenSymbol.prototype, {
+ constructor: d(SymbolPolyfill),
+ toString: d('', function () { return this.__name__; })
+});
+
+// Proper implementation of methods exposed on Symbol.prototype
+// They won't be accessible on produced symbol instances as they derive from HiddenSymbol.prototype
+defineProperties(SymbolPolyfill.prototype, {
+ toString: d(function () { return 'Symbol (' + validateSymbol(this).__description__ + ')'; }),
+ valueOf: d(function () { return validateSymbol(this); })
+});
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toPrimitive, d('', function () {
+ var symbol = validateSymbol(this);
+ if (typeof symbol === 'symbol') return symbol;
+ return symbol.toString();
+}));
+defineProperty(SymbolPolyfill.prototype, SymbolPolyfill.toStringTag, d('c', 'Symbol'));
+
+// Proper implementaton of toPrimitive and toStringTag for returned symbol instances
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toStringTag,
+ d('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]));
+
+// Note: It's important to define `toPrimitive` as last one, as some implementations
+// implement `toPrimitive` natively without implementing `toStringTag` (or other specified symbols)
+// And that may invoke error in definition flow:
+// See: https://github.com/medikoo/es6-symbol/issues/13#issuecomment-164146149
+defineProperty(HiddenSymbol.prototype, SymbolPolyfill.toPrimitive,
+ d('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]));
+
+},{"./validate-symbol":208,"d":139}],208:[function(_dereq_,module,exports){
+'use strict';
+
+var isSymbol = _dereq_('./is-symbol');
+
+module.exports = function (value) {
+ if (!isSymbol(value)) throw new TypeError(value + " is not a symbol");
+ return value;
+};
+
+},{"./is-symbol":206}],209:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')() ? WeakMap : _dereq_('./polyfill');
+
+},{"./is-implemented":210,"./polyfill":212}],210:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function () {
+ var weakMap, x;
+ if (typeof WeakMap !== 'function') return false;
+ try {
+ // WebKit doesn't support arguments and crashes
+ weakMap = new WeakMap([[x = {}, 'one'], [{}, 'two'], [{}, 'three']]);
+ } catch (e) {
+ return false;
+ }
+ if (String(weakMap) !== '[object WeakMap]') return false;
+ if (typeof weakMap.set !== 'function') return false;
+ if (weakMap.set({}, 1) !== weakMap) return false;
+ if (typeof weakMap.delete !== 'function') return false;
+ if (typeof weakMap.has !== 'function') return false;
+ if (weakMap.get(x) !== 'one') return false;
+
+ return true;
+};
+
+},{}],211:[function(_dereq_,module,exports){
+// Exports true if environment provides native `WeakMap` implementation, whatever that is.
+
+'use strict';
+
+module.exports = (function () {
+ if (typeof WeakMap !== 'function') return false;
+ return (Object.prototype.toString.call(new WeakMap()) === '[object WeakMap]');
+}());
+
+},{}],212:[function(_dereq_,module,exports){
+'use strict';
+
+var setPrototypeOf = _dereq_('es5-ext/object/set-prototype-of')
+ , object = _dereq_('es5-ext/object/valid-object')
+ , value = _dereq_('es5-ext/object/valid-value')
+ , randomUniq = _dereq_('es5-ext/string/random-uniq')
+ , d = _dereq_('d')
+ , getIterator = _dereq_('es6-iterator/get')
+ , forOf = _dereq_('es6-iterator/for-of')
+ , toStringTagSymbol = _dereq_('es6-symbol').toStringTag
+ , isNative = _dereq_('./is-native-implemented')
+
+ , isArray = Array.isArray, defineProperty = Object.defineProperty
+ , hasOwnProperty = Object.prototype.hasOwnProperty, getPrototypeOf = Object.getPrototypeOf
+ , WeakMapPoly;
+
+module.exports = WeakMapPoly = function (/*iterable*/) {
+ var iterable = arguments[0], self;
+ if (!(this instanceof WeakMapPoly)) throw new TypeError('Constructor requires \'new\'');
+ if (isNative && setPrototypeOf && (WeakMap !== WeakMapPoly)) {
+ self = setPrototypeOf(new WeakMap(), getPrototypeOf(this));
+ } else {
+ self = this;
+ }
+ if (iterable != null) {
+ if (!isArray(iterable)) iterable = getIterator(iterable);
+ }
+ defineProperty(self, '__weakMapData__', d('c', '$weakMap$' + randomUniq()));
+ if (!iterable) return self;
+ forOf(iterable, function (val) {
+ value(val);
+ self.set(val[0], val[1]);
+ });
+ return self;
+};
+
+if (isNative) {
+ if (setPrototypeOf) setPrototypeOf(WeakMapPoly, WeakMap);
+ WeakMapPoly.prototype = Object.create(WeakMap.prototype, {
+ constructor: d(WeakMapPoly)
+ });
+}
+
+Object.defineProperties(WeakMapPoly.prototype, {
+ delete: d(function (key) {
+ if (hasOwnProperty.call(object(key), this.__weakMapData__)) {
+ delete key[this.__weakMapData__];
+ return true;
+ }
+ return false;
+ }),
+ get: d(function (key) {
+ if (hasOwnProperty.call(object(key), this.__weakMapData__)) {
+ return key[this.__weakMapData__];
+ }
+ }),
+ has: d(function (key) {
+ return hasOwnProperty.call(object(key), this.__weakMapData__);
+ }),
+ set: d(function (key, value) {
+ defineProperty(object(key), this.__weakMapData__, d('c', value));
+ return this;
+ }),
+ toString: d(function () { return '[object WeakMap]'; })
+});
+defineProperty(WeakMapPoly.prototype, toStringTagSymbol, d('c', 'WeakMap'));
+
+},{"./is-native-implemented":211,"d":139,"es5-ext/object/set-prototype-of":185,"es5-ext/object/valid-object":189,"es5-ext/object/valid-value":190,"es5-ext/string/random-uniq":195,"es6-iterator/for-of":197,"es6-iterator/get":198,"es6-symbol":204}],213:[function(_dereq_,module,exports){
+"use strict"
+
+module.exports = extractPlanes
+
+function extractPlanes(M, zNear, zFar) {
+ var z = zNear || 0.0
+ var zf = zFar || 1.0
+ return [
+ [ M[12] + M[0], M[13] + M[1], M[14] + M[2], M[15] + M[3] ],
+ [ M[12] - M[0], M[13] - M[1], M[14] - M[2], M[15] - M[3] ],
+ [ M[12] + M[4], M[13] + M[5], M[14] + M[6], M[15] + M[7] ],
+ [ M[12] - M[4], M[13] - M[5], M[14] - M[6], M[15] - M[7] ],
+ [ z*M[12] + M[8], z*M[13] + M[9], z*M[14] + M[10], z*M[15] + M[11] ],
+ [ zf*M[12] - M[8], zf*M[13] - M[9], zf*M[14] - M[10], zf*M[15] - M[11] ]
+ ]
+}
+},{}],214:[function(_dereq_,module,exports){
+/**
+ * inspired by is-number
+ * but significantly simplified and sped up by ignoring number and string constructors
+ * ie these return false:
+ * new Number(1)
+ * new String('1')
+ */
+
+'use strict';
+
+var allBlankCharCodes = _dereq_('is-string-blank');
+
+module.exports = function(n) {
+ var type = typeof n;
+ if(type === 'string') {
+ var original = n;
+ n = +n;
+ // whitespace strings cast to zero - filter them out
+ if(n===0 && allBlankCharCodes(original)) return false;
+ }
+ else if(type !== 'number') return false;
+
+ return n - n < 1;
+};
+
+},{"is-string-blank":406}],215:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createFilteredVector
+
+var cubicHermite = _dereq_('cubic-hermite')
+var bsearch = _dereq_('binary-search-bounds')
+
+function clamp(lo, hi, x) {
+ return Math.min(hi, Math.max(lo, x))
+}
+
+function FilteredVector(state0, velocity0, t0) {
+ this.dimension = state0.length
+ this.bounds = [ new Array(this.dimension), new Array(this.dimension) ]
+ for(var i=0; i= n-1) {
+ var ptr = state.length-1
+ var tf = t - time[n-1]
+ for(var i=0; i= n-1) {
+ var ptr = state.length-1
+ var tf = t - time[n-1]
+ for(var i=0; i=0; --i) {
+ if(velocity[--ptr]) {
+ return false
+ }
+ }
+ return true
+}
+
+proto.jump = function(t) {
+ var t0 = this.lastT()
+ var d = this.dimension
+ if(t < t0 || arguments.length !== d+1) {
+ return
+ }
+ var state = this._state
+ var velocity = this._velocity
+ var ptr = state.length-this.dimension
+ var bounds = this.bounds
+ var lo = bounds[0]
+ var hi = bounds[1]
+ this._time.push(t0, t)
+ for(var j=0; j<2; ++j) {
+ for(var i=0; i0; --i) {
+ state.push(clamp(lo[i-1], hi[i-1], arguments[i]))
+ velocity.push(0)
+ }
+}
+
+proto.push = function(t) {
+ var t0 = this.lastT()
+ var d = this.dimension
+ if(t < t0 || arguments.length !== d+1) {
+ return
+ }
+ var state = this._state
+ var velocity = this._velocity
+ var ptr = state.length-this.dimension
+ var dt = t - t0
+ var bounds = this.bounds
+ var lo = bounds[0]
+ var hi = bounds[1]
+ var sf = (dt > 1e-6) ? 1/dt : 0
+ this._time.push(t)
+ for(var i=d; i>0; --i) {
+ var xc = clamp(lo[i-1], hi[i-1], arguments[i])
+ state.push(xc)
+ velocity.push((xc - state[ptr++]) * sf)
+ }
+}
+
+proto.set = function(t) {
+ var d = this.dimension
+ if(t < this.lastT() || arguments.length !== d+1) {
+ return
+ }
+ var state = this._state
+ var velocity = this._velocity
+ var bounds = this.bounds
+ var lo = bounds[0]
+ var hi = bounds[1]
+ this._time.push(t)
+ for(var i=d; i>0; --i) {
+ state.push(clamp(lo[i-1], hi[i-1], arguments[i]))
+ velocity.push(0)
+ }
+}
+
+proto.move = function(t) {
+ var t0 = this.lastT()
+ var d = this.dimension
+ if(t <= t0 || arguments.length !== d+1) {
+ return
+ }
+ var state = this._state
+ var velocity = this._velocity
+ var statePtr = state.length - this.dimension
+ var bounds = this.bounds
+ var lo = bounds[0]
+ var hi = bounds[1]
+ var dt = t - t0
+ var sf = (dt > 1e-6) ? 1/dt : 0.0
+ this._time.push(t)
+ for(var i=d; i>0; --i) {
+ var dx = arguments[i]
+ state.push(clamp(lo[i-1], hi[i-1], state[statePtr++] + dx))
+ velocity.push(dx * sf)
+ }
+}
+
+proto.idle = function(t) {
+ var t0 = this.lastT()
+ if(t < t0) {
+ return
+ }
+ var d = this.dimension
+ var state = this._state
+ var velocity = this._velocity
+ var statePtr = state.length-d
+ var bounds = this.bounds
+ var lo = bounds[0]
+ var hi = bounds[1]
+ var dt = t - t0
+ this._time.push(t)
+ for(var i=d-1; i>=0; --i) {
+ state.push(clamp(lo[i], hi[i], state[statePtr] + dt * velocity[statePtr]))
+ velocity.push(0)
+ statePtr += 1
+ }
+}
+
+function getZero(d) {
+ var result = new Array(d)
+ for(var i=0; i shape[0] - step[0]/2) (x = step[0]/2), (y += step[1])
+ }
+
+ return canvas
+}
+
+},{"css-font/stringify":130}],218:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = measure
+
+measure.canvas = document.createElement('canvas')
+measure.cache = {}
+
+function measure (font, o) {
+ if (!o) o = {}
+
+ if (typeof font === 'string' || Array.isArray(font)) {
+ o.family = font
+ }
+
+ var family = Array.isArray(o.family) ? o.family.join(', ') : o.family
+ if (!family) throw Error('`family` must be defined')
+
+ var fs = o.size || o.fontSize || o.em || 48
+ var weight = o.weight || o.fontWeight || ''
+ var style = o.style || o.fontStyle || ''
+ var font = [style, weight, fs].join(' ') + 'px ' + family
+ var origin = o.origin || 'top'
+
+ if (measure.cache[family]) {
+ // return more precise values if cache has them
+ if (fs <= measure.cache[family].em) {
+ return applyOrigin(measure.cache[family], origin)
+ }
+ }
+
+ var canvas = o.canvas || measure.canvas
+ var ctx = canvas.getContext('2d')
+ var chars = {
+ upper: o.upper !== undefined ? o.upper : 'H',
+ lower: o.lower !== undefined ? o.lower : 'x',
+ descent: o.descent !== undefined ? o.descent : 'p',
+ ascent: o.ascent !== undefined ? o.ascent : 'h',
+ tittle: o.tittle !== undefined ? o.tittle : 'i',
+ overshoot: o.overshoot !== undefined ? o.overshoot : 'O'
+ }
+ var l = Math.ceil(fs * 1.5)
+ canvas.height = l
+ canvas.width = l * .5
+ ctx.font = font
+
+ var char = 'H'
+ var result = {
+ top: 0
+ }
+
+ // measure line-height
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillStyle = 'black'
+ ctx.fillText(char, 0, 0)
+ var topPx = firstTop(ctx.getImageData(0, 0, l, l))
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'bottom'
+ ctx.fillText(char, 0, l)
+ var bottomPx = firstTop(ctx.getImageData(0, 0, l, l))
+ result.lineHeight =
+ result.bottom = l - bottomPx + topPx
+
+ // measure baseline
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'alphabetic'
+ ctx.fillText(char, 0, l)
+ var baselinePx = firstTop(ctx.getImageData(0, 0, l, l))
+ var baseline = l - baselinePx - 1 + topPx
+ result.baseline =
+ result.alphabetic = baseline
+
+ // measure median
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'middle'
+ ctx.fillText(char, 0, l * .5)
+ var medianPx = firstTop(ctx.getImageData(0, 0, l, l))
+ result.median =
+ result.middle = l - medianPx - 1 + topPx - l * .5
+
+ // measure hanging
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'hanging'
+ ctx.fillText(char, 0, l * .5)
+ var hangingPx = firstTop(ctx.getImageData(0, 0, l, l))
+ result.hanging = l - hangingPx - 1 + topPx - l * .5
+
+ // measure ideographic
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'ideographic'
+ ctx.fillText(char, 0, l)
+ var ideographicPx = firstTop(ctx.getImageData(0, 0, l, l))
+ result.ideographic = l - ideographicPx - 1 + topPx
+
+ // measure cap
+ if (chars.upper) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.upper, 0, 0)
+ result.upper = firstTop(ctx.getImageData(0, 0, l, l))
+ result.capHeight = (result.baseline - result.upper)
+ }
+
+ // measure x
+ if (chars.lower) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.lower, 0, 0)
+ result.lower = firstTop(ctx.getImageData(0, 0, l, l))
+ result.xHeight = (result.baseline - result.lower)
+ }
+
+ // measure tittle
+ if (chars.tittle) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.tittle, 0, 0)
+ result.tittle = firstTop(ctx.getImageData(0, 0, l, l))
+ }
+
+ // measure ascent
+ if (chars.ascent) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.ascent, 0, 0)
+ result.ascent = firstTop(ctx.getImageData(0, 0, l, l))
+ }
+
+ // measure descent
+ if (chars.descent) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.descent, 0, 0)
+ result.descent = firstBottom(ctx.getImageData(0, 0, l, l))
+ }
+
+ // measure overshoot
+ if (chars.overshoot) {
+ ctx.clearRect(0, 0, l, l)
+ ctx.textBaseline = 'top'
+ ctx.fillText(chars.overshoot, 0, 0)
+ var overshootPx = firstBottom(ctx.getImageData(0, 0, l, l))
+ result.overshoot = overshootPx - baseline
+ }
+
+ // normalize result
+ for (var name in result) {
+ result[name] /= fs
+ }
+
+ result.em = fs
+ measure.cache[family] = result
+
+ return applyOrigin(result, origin)
+}
+
+function applyOrigin(obj, origin) {
+ var res = {}
+ if (typeof origin === 'string') origin = obj[origin]
+ for (var name in obj) {
+ if (name === 'em') continue
+ res[name] = obj[name] - origin
+ }
+ return res
+}
+
+function firstTop(iData) {
+ var l = iData.height
+ var data = iData.data
+ for (var i = 3; i < data.length; i+=4) {
+ if (data[i] !== 0) {
+ return Math.floor((i - 3) *.25 / l)
+ }
+ }
+}
+
+function firstBottom(iData) {
+ var l = iData.height
+ var data = iData.data
+ for (var i = data.length - 1; i > 0; i -= 4) {
+ if (data[i] !== 0) {
+ return Math.floor((i - 3) *.25 / l)
+ }
+ }
+}
+
+},{}],219:[function(_dereq_,module,exports){
+"use strict"
+
+module.exports = createRBTree
+
+var RED = 0
+var BLACK = 1
+
+function RBNode(color, key, value, left, right, count) {
+ this._color = color
+ this.key = key
+ this.value = value
+ this.left = left
+ this.right = right
+ this._count = count
+}
+
+function cloneNode(node) {
+ return new RBNode(node._color, node.key, node.value, node.left, node.right, node._count)
+}
+
+function repaint(color, node) {
+ return new RBNode(color, node.key, node.value, node.left, node.right, node._count)
+}
+
+function recount(node) {
+ node._count = 1 + (node.left ? node.left._count : 0) + (node.right ? node.right._count : 0)
+}
+
+function RedBlackTree(compare, root) {
+ this._compare = compare
+ this.root = root
+}
+
+var proto = RedBlackTree.prototype
+
+Object.defineProperty(proto, "keys", {
+ get: function() {
+ var result = []
+ this.forEach(function(k,v) {
+ result.push(k)
+ })
+ return result
+ }
+})
+
+Object.defineProperty(proto, "values", {
+ get: function() {
+ var result = []
+ this.forEach(function(k,v) {
+ result.push(v)
+ })
+ return result
+ }
+})
+
+//Returns the number of nodes in the tree
+Object.defineProperty(proto, "length", {
+ get: function() {
+ if(this.root) {
+ return this.root._count
+ }
+ return 0
+ }
+})
+
+//Insert a new item into the tree
+proto.insert = function(key, value) {
+ var cmp = this._compare
+ //Find point to insert new node at
+ var n = this.root
+ var n_stack = []
+ var d_stack = []
+ while(n) {
+ var d = cmp(key, n.key)
+ n_stack.push(n)
+ d_stack.push(d)
+ if(d <= 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ //Rebuild path to leaf node
+ n_stack.push(new RBNode(RED, key, value, null, null, 1))
+ for(var s=n_stack.length-2; s>=0; --s) {
+ var n = n_stack[s]
+ if(d_stack[s] <= 0) {
+ n_stack[s] = new RBNode(n._color, n.key, n.value, n_stack[s+1], n.right, n._count+1)
+ } else {
+ n_stack[s] = new RBNode(n._color, n.key, n.value, n.left, n_stack[s+1], n._count+1)
+ }
+ }
+ //Rebalance tree using rotations
+ //console.log("start insert", key, d_stack)
+ for(var s=n_stack.length-1; s>1; --s) {
+ var p = n_stack[s-1]
+ var n = n_stack[s]
+ if(p._color === BLACK || n._color === BLACK) {
+ break
+ }
+ var pp = n_stack[s-2]
+ if(pp.left === p) {
+ if(p.left === n) {
+ var y = pp.right
+ if(y && y._color === RED) {
+ //console.log("LLr")
+ p._color = BLACK
+ pp.right = repaint(BLACK, y)
+ pp._color = RED
+ s -= 1
+ } else {
+ //console.log("LLb")
+ pp._color = RED
+ pp.left = p.right
+ p._color = BLACK
+ p.right = pp
+ n_stack[s-2] = p
+ n_stack[s-1] = n
+ recount(pp)
+ recount(p)
+ if(s >= 3) {
+ var ppp = n_stack[s-3]
+ if(ppp.left === pp) {
+ ppp.left = p
+ } else {
+ ppp.right = p
+ }
+ }
+ break
+ }
+ } else {
+ var y = pp.right
+ if(y && y._color === RED) {
+ //console.log("LRr")
+ p._color = BLACK
+ pp.right = repaint(BLACK, y)
+ pp._color = RED
+ s -= 1
+ } else {
+ //console.log("LRb")
+ p.right = n.left
+ pp._color = RED
+ pp.left = n.right
+ n._color = BLACK
+ n.left = p
+ n.right = pp
+ n_stack[s-2] = n
+ n_stack[s-1] = p
+ recount(pp)
+ recount(p)
+ recount(n)
+ if(s >= 3) {
+ var ppp = n_stack[s-3]
+ if(ppp.left === pp) {
+ ppp.left = n
+ } else {
+ ppp.right = n
+ }
+ }
+ break
+ }
+ }
+ } else {
+ if(p.right === n) {
+ var y = pp.left
+ if(y && y._color === RED) {
+ //console.log("RRr", y.key)
+ p._color = BLACK
+ pp.left = repaint(BLACK, y)
+ pp._color = RED
+ s -= 1
+ } else {
+ //console.log("RRb")
+ pp._color = RED
+ pp.right = p.left
+ p._color = BLACK
+ p.left = pp
+ n_stack[s-2] = p
+ n_stack[s-1] = n
+ recount(pp)
+ recount(p)
+ if(s >= 3) {
+ var ppp = n_stack[s-3]
+ if(ppp.right === pp) {
+ ppp.right = p
+ } else {
+ ppp.left = p
+ }
+ }
+ break
+ }
+ } else {
+ var y = pp.left
+ if(y && y._color === RED) {
+ //console.log("RLr")
+ p._color = BLACK
+ pp.left = repaint(BLACK, y)
+ pp._color = RED
+ s -= 1
+ } else {
+ //console.log("RLb")
+ p.left = n.right
+ pp._color = RED
+ pp.right = n.left
+ n._color = BLACK
+ n.right = p
+ n.left = pp
+ n_stack[s-2] = n
+ n_stack[s-1] = p
+ recount(pp)
+ recount(p)
+ recount(n)
+ if(s >= 3) {
+ var ppp = n_stack[s-3]
+ if(ppp.right === pp) {
+ ppp.right = n
+ } else {
+ ppp.left = n
+ }
+ }
+ break
+ }
+ }
+ }
+ }
+ //Return new tree
+ n_stack[0]._color = BLACK
+ return new RedBlackTree(cmp, n_stack[0])
+}
+
+
+//Visit all nodes inorder
+function doVisitFull(visit, node) {
+ if(node.left) {
+ var v = doVisitFull(visit, node.left)
+ if(v) { return v }
+ }
+ var v = visit(node.key, node.value)
+ if(v) { return v }
+ if(node.right) {
+ return doVisitFull(visit, node.right)
+ }
+}
+
+//Visit half nodes in order
+function doVisitHalf(lo, compare, visit, node) {
+ var l = compare(lo, node.key)
+ if(l <= 0) {
+ if(node.left) {
+ var v = doVisitHalf(lo, compare, visit, node.left)
+ if(v) { return v }
+ }
+ var v = visit(node.key, node.value)
+ if(v) { return v }
+ }
+ if(node.right) {
+ return doVisitHalf(lo, compare, visit, node.right)
+ }
+}
+
+//Visit all nodes within a range
+function doVisit(lo, hi, compare, visit, node) {
+ var l = compare(lo, node.key)
+ var h = compare(hi, node.key)
+ var v
+ if(l <= 0) {
+ if(node.left) {
+ v = doVisit(lo, hi, compare, visit, node.left)
+ if(v) { return v }
+ }
+ if(h > 0) {
+ v = visit(node.key, node.value)
+ if(v) { return v }
+ }
+ }
+ if(h > 0 && node.right) {
+ return doVisit(lo, hi, compare, visit, node.right)
+ }
+}
+
+
+proto.forEach = function rbTreeForEach(visit, lo, hi) {
+ if(!this.root) {
+ return
+ }
+ switch(arguments.length) {
+ case 1:
+ return doVisitFull(visit, this.root)
+ break
+
+ case 2:
+ return doVisitHalf(lo, this._compare, visit, this.root)
+ break
+
+ case 3:
+ if(this._compare(lo, hi) >= 0) {
+ return
+ }
+ return doVisit(lo, hi, this._compare, visit, this.root)
+ break
+ }
+}
+
+//First item in list
+Object.defineProperty(proto, "begin", {
+ get: function() {
+ var stack = []
+ var n = this.root
+ while(n) {
+ stack.push(n)
+ n = n.left
+ }
+ return new RedBlackTreeIterator(this, stack)
+ }
+})
+
+//Last item in list
+Object.defineProperty(proto, "end", {
+ get: function() {
+ var stack = []
+ var n = this.root
+ while(n) {
+ stack.push(n)
+ n = n.right
+ }
+ return new RedBlackTreeIterator(this, stack)
+ }
+})
+
+//Find the ith item in the tree
+proto.at = function(idx) {
+ if(idx < 0) {
+ return new RedBlackTreeIterator(this, [])
+ }
+ var n = this.root
+ var stack = []
+ while(true) {
+ stack.push(n)
+ if(n.left) {
+ if(idx < n.left._count) {
+ n = n.left
+ continue
+ }
+ idx -= n.left._count
+ }
+ if(!idx) {
+ return new RedBlackTreeIterator(this, stack)
+ }
+ idx -= 1
+ if(n.right) {
+ if(idx >= n.right._count) {
+ break
+ }
+ n = n.right
+ } else {
+ break
+ }
+ }
+ return new RedBlackTreeIterator(this, [])
+}
+
+proto.ge = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ var stack = []
+ var last_ptr = 0
+ while(n) {
+ var d = cmp(key, n.key)
+ stack.push(n)
+ if(d <= 0) {
+ last_ptr = stack.length
+ }
+ if(d <= 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ stack.length = last_ptr
+ return new RedBlackTreeIterator(this, stack)
+}
+
+proto.gt = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ var stack = []
+ var last_ptr = 0
+ while(n) {
+ var d = cmp(key, n.key)
+ stack.push(n)
+ if(d < 0) {
+ last_ptr = stack.length
+ }
+ if(d < 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ stack.length = last_ptr
+ return new RedBlackTreeIterator(this, stack)
+}
+
+proto.lt = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ var stack = []
+ var last_ptr = 0
+ while(n) {
+ var d = cmp(key, n.key)
+ stack.push(n)
+ if(d > 0) {
+ last_ptr = stack.length
+ }
+ if(d <= 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ stack.length = last_ptr
+ return new RedBlackTreeIterator(this, stack)
+}
+
+proto.le = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ var stack = []
+ var last_ptr = 0
+ while(n) {
+ var d = cmp(key, n.key)
+ stack.push(n)
+ if(d >= 0) {
+ last_ptr = stack.length
+ }
+ if(d < 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ stack.length = last_ptr
+ return new RedBlackTreeIterator(this, stack)
+}
+
+//Finds the item with key if it exists
+proto.find = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ var stack = []
+ while(n) {
+ var d = cmp(key, n.key)
+ stack.push(n)
+ if(d === 0) {
+ return new RedBlackTreeIterator(this, stack)
+ }
+ if(d <= 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ return new RedBlackTreeIterator(this, [])
+}
+
+//Removes item with key from tree
+proto.remove = function(key) {
+ var iter = this.find(key)
+ if(iter) {
+ return iter.remove()
+ }
+ return this
+}
+
+//Returns the item at `key`
+proto.get = function(key) {
+ var cmp = this._compare
+ var n = this.root
+ while(n) {
+ var d = cmp(key, n.key)
+ if(d === 0) {
+ return n.value
+ }
+ if(d <= 0) {
+ n = n.left
+ } else {
+ n = n.right
+ }
+ }
+ return
+}
+
+//Iterator for red black tree
+function RedBlackTreeIterator(tree, stack) {
+ this.tree = tree
+ this._stack = stack
+}
+
+var iproto = RedBlackTreeIterator.prototype
+
+//Test if iterator is valid
+Object.defineProperty(iproto, "valid", {
+ get: function() {
+ return this._stack.length > 0
+ }
+})
+
+//Node of the iterator
+Object.defineProperty(iproto, "node", {
+ get: function() {
+ if(this._stack.length > 0) {
+ return this._stack[this._stack.length-1]
+ }
+ return null
+ },
+ enumerable: true
+})
+
+//Makes a copy of an iterator
+iproto.clone = function() {
+ return new RedBlackTreeIterator(this.tree, this._stack.slice())
+}
+
+//Swaps two nodes
+function swapNode(n, v) {
+ n.key = v.key
+ n.value = v.value
+ n.left = v.left
+ n.right = v.right
+ n._color = v._color
+ n._count = v._count
+}
+
+//Fix up a double black node in a tree
+function fixDoubleBlack(stack) {
+ var n, p, s, z
+ for(var i=stack.length-1; i>=0; --i) {
+ n = stack[i]
+ if(i === 0) {
+ n._color = BLACK
+ return
+ }
+ //console.log("visit node:", n.key, i, stack[i].key, stack[i-1].key)
+ p = stack[i-1]
+ if(p.left === n) {
+ //console.log("left child")
+ s = p.right
+ if(s.right && s.right._color === RED) {
+ //console.log("case 1: right sibling child red")
+ s = p.right = cloneNode(s)
+ z = s.right = cloneNode(s.right)
+ p.right = s.left
+ s.left = p
+ s.right = z
+ s._color = p._color
+ n._color = BLACK
+ p._color = BLACK
+ z._color = BLACK
+ recount(p)
+ recount(s)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.left === p) {
+ pp.left = s
+ } else {
+ pp.right = s
+ }
+ }
+ stack[i-1] = s
+ return
+ } else if(s.left && s.left._color === RED) {
+ //console.log("case 1: left sibling child red")
+ s = p.right = cloneNode(s)
+ z = s.left = cloneNode(s.left)
+ p.right = z.left
+ s.left = z.right
+ z.left = p
+ z.right = s
+ z._color = p._color
+ p._color = BLACK
+ s._color = BLACK
+ n._color = BLACK
+ recount(p)
+ recount(s)
+ recount(z)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.left === p) {
+ pp.left = z
+ } else {
+ pp.right = z
+ }
+ }
+ stack[i-1] = z
+ return
+ }
+ if(s._color === BLACK) {
+ if(p._color === RED) {
+ //console.log("case 2: black sibling, red parent", p.right.value)
+ p._color = BLACK
+ p.right = repaint(RED, s)
+ return
+ } else {
+ //console.log("case 2: black sibling, black parent", p.right.value)
+ p.right = repaint(RED, s)
+ continue
+ }
+ } else {
+ //console.log("case 3: red sibling")
+ s = cloneNode(s)
+ p.right = s.left
+ s.left = p
+ s._color = p._color
+ p._color = RED
+ recount(p)
+ recount(s)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.left === p) {
+ pp.left = s
+ } else {
+ pp.right = s
+ }
+ }
+ stack[i-1] = s
+ stack[i] = p
+ if(i+1 < stack.length) {
+ stack[i+1] = n
+ } else {
+ stack.push(n)
+ }
+ i = i+2
+ }
+ } else {
+ //console.log("right child")
+ s = p.left
+ if(s.left && s.left._color === RED) {
+ //console.log("case 1: left sibling child red", p.value, p._color)
+ s = p.left = cloneNode(s)
+ z = s.left = cloneNode(s.left)
+ p.left = s.right
+ s.right = p
+ s.left = z
+ s._color = p._color
+ n._color = BLACK
+ p._color = BLACK
+ z._color = BLACK
+ recount(p)
+ recount(s)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.right === p) {
+ pp.right = s
+ } else {
+ pp.left = s
+ }
+ }
+ stack[i-1] = s
+ return
+ } else if(s.right && s.right._color === RED) {
+ //console.log("case 1: right sibling child red")
+ s = p.left = cloneNode(s)
+ z = s.right = cloneNode(s.right)
+ p.left = z.right
+ s.right = z.left
+ z.right = p
+ z.left = s
+ z._color = p._color
+ p._color = BLACK
+ s._color = BLACK
+ n._color = BLACK
+ recount(p)
+ recount(s)
+ recount(z)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.right === p) {
+ pp.right = z
+ } else {
+ pp.left = z
+ }
+ }
+ stack[i-1] = z
+ return
+ }
+ if(s._color === BLACK) {
+ if(p._color === RED) {
+ //console.log("case 2: black sibling, red parent")
+ p._color = BLACK
+ p.left = repaint(RED, s)
+ return
+ } else {
+ //console.log("case 2: black sibling, black parent")
+ p.left = repaint(RED, s)
+ continue
+ }
+ } else {
+ //console.log("case 3: red sibling")
+ s = cloneNode(s)
+ p.left = s.right
+ s.right = p
+ s._color = p._color
+ p._color = RED
+ recount(p)
+ recount(s)
+ if(i > 1) {
+ var pp = stack[i-2]
+ if(pp.right === p) {
+ pp.right = s
+ } else {
+ pp.left = s
+ }
+ }
+ stack[i-1] = s
+ stack[i] = p
+ if(i+1 < stack.length) {
+ stack[i+1] = n
+ } else {
+ stack.push(n)
+ }
+ i = i+2
+ }
+ }
+ }
+}
+
+//Removes item at iterator from tree
+iproto.remove = function() {
+ var stack = this._stack
+ if(stack.length === 0) {
+ return this.tree
+ }
+ //First copy path to node
+ var cstack = new Array(stack.length)
+ var n = stack[stack.length-1]
+ cstack[cstack.length-1] = new RBNode(n._color, n.key, n.value, n.left, n.right, n._count)
+ for(var i=stack.length-2; i>=0; --i) {
+ var n = stack[i]
+ if(n.left === stack[i+1]) {
+ cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i+1], n.right, n._count)
+ } else {
+ cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count)
+ }
+ }
+
+ //Get node
+ n = cstack[cstack.length-1]
+ //console.log("start remove: ", n.value)
+
+ //If not leaf, then swap with previous node
+ if(n.left && n.right) {
+ //console.log("moving to leaf")
+
+ //First walk to previous leaf
+ var split = cstack.length
+ n = n.left
+ while(n.right) {
+ cstack.push(n)
+ n = n.right
+ }
+ //Copy path to leaf
+ var v = cstack[split-1]
+ cstack.push(new RBNode(n._color, v.key, v.value, n.left, n.right, n._count))
+ cstack[split-1].key = n.key
+ cstack[split-1].value = n.value
+
+ //Fix up stack
+ for(var i=cstack.length-2; i>=split; --i) {
+ n = cstack[i]
+ cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count)
+ }
+ cstack[split-1].left = cstack[split]
+ }
+ //console.log("stack=", cstack.map(function(v) { return v.value }))
+
+ //Remove leaf node
+ n = cstack[cstack.length-1]
+ if(n._color === RED) {
+ //Easy case: removing red leaf
+ //console.log("RED leaf")
+ var p = cstack[cstack.length-2]
+ if(p.left === n) {
+ p.left = null
+ } else if(p.right === n) {
+ p.right = null
+ }
+ cstack.pop()
+ for(var i=0; i 0) {
+ return this._stack[this._stack.length-1].key
+ }
+ return
+ },
+ enumerable: true
+})
+
+//Returns value
+Object.defineProperty(iproto, "value", {
+ get: function() {
+ if(this._stack.length > 0) {
+ return this._stack[this._stack.length-1].value
+ }
+ return
+ },
+ enumerable: true
+})
+
+
+//Returns the position of this iterator in the sorted list
+Object.defineProperty(iproto, "index", {
+ get: function() {
+ var idx = 0
+ var stack = this._stack
+ if(stack.length === 0) {
+ var r = this.tree.root
+ if(r) {
+ return r._count
+ }
+ return 0
+ } else if(stack[stack.length-1].left) {
+ idx = stack[stack.length-1].left._count
+ }
+ for(var s=stack.length-2; s>=0; --s) {
+ if(stack[s+1] === stack[s].right) {
+ ++idx
+ if(stack[s].left) {
+ idx += stack[s].left._count
+ }
+ }
+ }
+ return idx
+ },
+ enumerable: true
+})
+
+//Advances iterator to next element in list
+iproto.next = function() {
+ var stack = this._stack
+ if(stack.length === 0) {
+ return
+ }
+ var n = stack[stack.length-1]
+ if(n.right) {
+ n = n.right
+ while(n) {
+ stack.push(n)
+ n = n.left
+ }
+ } else {
+ stack.pop()
+ while(stack.length > 0 && stack[stack.length-1].right === n) {
+ n = stack[stack.length-1]
+ stack.pop()
+ }
+ }
+}
+
+//Checks if iterator is at end of tree
+Object.defineProperty(iproto, "hasNext", {
+ get: function() {
+ var stack = this._stack
+ if(stack.length === 0) {
+ return false
+ }
+ if(stack[stack.length-1].right) {
+ return true
+ }
+ for(var s=stack.length-1; s>0; --s) {
+ if(stack[s-1].left === stack[s]) {
+ return true
+ }
+ }
+ return false
+ }
+})
+
+//Update value
+iproto.update = function(value) {
+ var stack = this._stack
+ if(stack.length === 0) {
+ throw new Error("Can't update empty node!")
+ }
+ var cstack = new Array(stack.length)
+ var n = stack[stack.length-1]
+ cstack[cstack.length-1] = new RBNode(n._color, n.key, value, n.left, n.right, n._count)
+ for(var i=stack.length-2; i>=0; --i) {
+ n = stack[i]
+ if(n.left === stack[i+1]) {
+ cstack[i] = new RBNode(n._color, n.key, n.value, cstack[i+1], n.right, n._count)
+ } else {
+ cstack[i] = new RBNode(n._color, n.key, n.value, n.left, cstack[i+1], n._count)
+ }
+ }
+ return new RedBlackTree(this.tree._compare, cstack[0])
+}
+
+//Moves iterator backward one element
+iproto.prev = function() {
+ var stack = this._stack
+ if(stack.length === 0) {
+ return
+ }
+ var n = stack[stack.length-1]
+ if(n.left) {
+ n = n.left
+ while(n) {
+ stack.push(n)
+ n = n.right
+ }
+ } else {
+ stack.pop()
+ while(stack.length > 0 && stack[stack.length-1].left === n) {
+ n = stack[stack.length-1]
+ stack.pop()
+ }
+ }
+}
+
+//Checks if iterator is at start of tree
+Object.defineProperty(iproto, "hasPrev", {
+ get: function() {
+ var stack = this._stack
+ if(stack.length === 0) {
+ return false
+ }
+ if(stack[stack.length-1].left) {
+ return true
+ }
+ for(var s=stack.length-1; s>0; --s) {
+ if(stack[s-1].right === stack[s]) {
+ return true
+ }
+ }
+ return false
+ }
+})
+
+//Default comparison function
+function defaultCompare(a, b) {
+ if(a < b) {
+ return -1
+ }
+ if(a > b) {
+ return 1
+ }
+ return 0
+}
+
+//Build a tree
+function createRBTree(compare) {
+ return new RedBlackTree(compare || defaultCompare, null)
+}
+},{}],220:[function(_dereq_,module,exports){
+// transliterated from the python snippet here:
+// http://en.wikipedia.org/wiki/Lanczos_approximation
+
+var g = 7;
+var p = [
+ 0.99999999999980993,
+ 676.5203681218851,
+ -1259.1392167224028,
+ 771.32342877765313,
+ -176.61502916214059,
+ 12.507343278686905,
+ -0.13857109526572012,
+ 9.9843695780195716e-6,
+ 1.5056327351493116e-7
+];
+
+var g_ln = 607/128;
+var p_ln = [
+ 0.99999999999999709182,
+ 57.156235665862923517,
+ -59.597960355475491248,
+ 14.136097974741747174,
+ -0.49191381609762019978,
+ 0.33994649984811888699e-4,
+ 0.46523628927048575665e-4,
+ -0.98374475304879564677e-4,
+ 0.15808870322491248884e-3,
+ -0.21026444172410488319e-3,
+ 0.21743961811521264320e-3,
+ -0.16431810653676389022e-3,
+ 0.84418223983852743293e-4,
+ -0.26190838401581408670e-4,
+ 0.36899182659531622704e-5
+];
+
+// Spouge approximation (suitable for large arguments)
+function lngamma(z) {
+
+ if(z < 0) return Number('0/0');
+ var x = p_ln[0];
+ for(var i = p_ln.length - 1; i > 0; --i) x += p_ln[i] / (z + i);
+ var t = z + g_ln + 0.5;
+ return .5*Math.log(2*Math.PI)+(z+.5)*Math.log(t)-t+Math.log(x)-Math.log(z);
+}
+
+module.exports = function gamma (z) {
+ if (z < 0.5) {
+ return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
+ }
+ else if(z > 100) return Math.exp(lngamma(z));
+ else {
+ z -= 1;
+ var x = p[0];
+ for (var i = 1; i < g + 2; i++) {
+ x += p[i] / (z + i);
+ }
+ var t = z + g + 0.5;
+
+ return Math.sqrt(2 * Math.PI)
+ * Math.pow(t, z + 0.5)
+ * Math.exp(-t)
+ * x
+ ;
+ }
+};
+
+module.exports.log = lngamma;
+
+},{}],221:[function(_dereq_,module,exports){
+module.exports = getCanvasContext
+function getCanvasContext (type, opts) {
+ if (typeof type !== 'string') {
+ throw new TypeError('must specify type string')
+ }
+
+ opts = opts || {}
+
+ if (typeof document === 'undefined' && !opts.canvas) {
+ return null // check for Node
+ }
+
+ var canvas = opts.canvas || document.createElement('canvas')
+ if (typeof opts.width === 'number') {
+ canvas.width = opts.width
+ }
+ if (typeof opts.height === 'number') {
+ canvas.height = opts.height
+ }
+
+ var attribs = opts
+ var gl
+ try {
+ var names = [ type ]
+ // prefix GL contexts
+ if (type.indexOf('webgl') === 0) {
+ names.push('experimental-' + type)
+ }
+
+ for (var i = 0; i < names.length; i++) {
+ gl = canvas.getContext(names[i], attribs)
+ if (gl) return gl
+ }
+ } catch (e) {
+ gl = null
+ }
+ return (gl || null) // ensure null on fail
+}
+
+},{}],222:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createAxes
+
+var createText = _dereq_('./lib/text.js')
+var createLines = _dereq_('./lib/lines.js')
+var createBackground = _dereq_('./lib/background.js')
+var getCubeProperties = _dereq_('./lib/cube.js')
+var Ticks = _dereq_('./lib/ticks.js')
+
+var identity = new Float32Array([
+ 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1])
+
+function copyVec3(a, b) {
+ a[0] = b[0]
+ a[1] = b[1]
+ a[2] = b[2]
+ return a
+}
+
+function Axes(gl) {
+ this.gl = gl
+
+ this.pixelRatio = 1
+
+ this.bounds = [ [-10, -10, -10],
+ [ 10, 10, 10] ]
+ this.ticks = [ [], [], [] ]
+ this.autoTicks = true
+ this.tickSpacing = [ 1, 1, 1 ]
+
+ this.tickEnable = [ true, true, true ]
+ this.tickFont = [ 'sans-serif', 'sans-serif', 'sans-serif' ]
+ this.tickSize = [ 12, 12, 12 ]
+ this.tickAngle = [ 0, 0, 0 ]
+ this._tickAlign = [ 'auto', 'auto', 'auto' ]
+ this.tickColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+ this.tickPad = [ 10, 10, 10 ]
+
+ this.lastCubeProps = {
+ cubeEdges: [0,0,0],
+ axis: [0,0,0]
+ }
+
+ this.labels = [ 'x', 'y', 'z' ]
+ this.labelEnable = [ true, true, true ]
+ this.labelFont = 'sans-serif'
+ this.labelSize = [ 20, 20, 20 ]
+ this._labelAngle = [ 0, 0, 0 ]
+ this._labelAlign = [ 'auto', 'auto', 'auto' ]
+ this.labelColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+ this.labelPad = [ 10, 10, 10 ]
+
+ this.lineEnable = [ true, true, true ]
+ this.lineMirror = [ false, false, false ]
+ this.lineWidth = [ 1, 1, 1 ]
+ this.lineColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+
+ this.lineTickEnable = [ true, true, true ]
+ this.lineTickMirror = [ false, false, false ]
+ this.lineTickLength = [ 0, 0, 0 ]
+ this.lineTickWidth = [ 1, 1, 1 ]
+ this.lineTickColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+
+ this.gridEnable = [ true, true, true ]
+ this.gridWidth = [ 1, 1, 1 ]
+ this.gridColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+
+ this.zeroEnable = [ true, true, true ]
+ this.zeroLineColor = [ [0,0,0,1], [0,0,0,1], [0,0,0,1] ]
+ this.zeroLineWidth = [ 2, 2, 2 ]
+
+ this.backgroundEnable = [ false, false, false ]
+ this.backgroundColor = [ [0.8, 0.8, 0.8, 0.5],
+ [0.8, 0.8, 0.8, 0.5],
+ [0.8, 0.8, 0.8, 0.5] ]
+
+ this._firstInit = true
+ this._text = null
+ this._lines = null
+ this._background = createBackground(gl)
+}
+
+var proto = Axes.prototype
+
+proto.update = function(options) {
+ options = options || {}
+
+ //Option parsing helper functions
+ function parseOption(nest, cons, name) {
+ if(name in options) {
+ var opt = options[name]
+ var prev = this[name]
+ var next
+ if(nest ? (Array.isArray(opt) && Array.isArray(opt[0])) :
+ Array.isArray(opt) ) {
+ this[name] = next = [ cons(opt[0]), cons(opt[1]), cons(opt[2]) ]
+ } else {
+ this[name] = next = [ cons(opt), cons(opt), cons(opt) ]
+ }
+ for(var i=0; i<3; ++i) {
+ if(next[i] !== prev[i]) {
+ return true
+ }
+ }
+ }
+ return false
+ }
+
+ var NUMBER = parseOption.bind(this, false, Number)
+ var BOOLEAN = parseOption.bind(this, false, Boolean)
+ var STRING = parseOption.bind(this, false, String)
+ var COLOR = parseOption.bind(this, true, function(v) {
+ if(Array.isArray(v)) {
+ if(v.length === 3) {
+ return [ +v[0], +v[1], +v[2], 1.0 ]
+ } else if(v.length === 4) {
+ return [ +v[0], +v[1], +v[2], +v[3] ]
+ }
+ }
+ return [ 0, 0, 0, 1 ]
+ })
+
+ //Tick marks and bounds
+ var nextTicks
+ var ticksUpdate = false
+ var boundsChanged = false
+ if('bounds' in options) {
+ var bounds = options.bounds
+i_loop:
+ for(var i=0; i<2; ++i) {
+ for(var j=0; j<3; ++j) {
+ if(bounds[i][j] !== this.bounds[i][j]) {
+ boundsChanged = true
+ }
+ this.bounds[i][j] = bounds[i][j]
+ }
+ }
+ }
+ if('ticks' in options) {
+ nextTicks = options.ticks
+ ticksUpdate = true
+ this.autoTicks = false
+ for(var i=0; i<3; ++i) {
+ this.tickSpacing[i] = 0.0
+ }
+ } else if(NUMBER('tickSpacing')) {
+ this.autoTicks = true
+ boundsChanged = true
+ }
+
+ if(this._firstInit) {
+ if(!('ticks' in options || 'tickSpacing' in options)) {
+ this.autoTicks = true
+ }
+
+ //Force tick recomputation on first update
+ boundsChanged = true
+ ticksUpdate = true
+ this._firstInit = false
+ }
+
+ if(boundsChanged && this.autoTicks) {
+ nextTicks = Ticks.create(this.bounds, this.tickSpacing)
+ ticksUpdate = true
+ }
+
+ //Compare next ticks to previous ticks, only update if needed
+ if(ticksUpdate) {
+ for(var i=0; i<3; ++i) {
+ nextTicks[i].sort(function(a,b) {
+ return a.x-b.x
+ })
+ }
+ if(Ticks.equal(nextTicks, this.ticks)) {
+ ticksUpdate = false
+ } else {
+ this.ticks = nextTicks
+ }
+ }
+
+ //Parse tick properties
+ BOOLEAN('tickEnable')
+ if(STRING('tickFont')) {
+ ticksUpdate = true //If font changes, must rebuild vbo
+ }
+ NUMBER('tickSize')
+ NUMBER('tickAngle')
+ NUMBER('tickPad')
+ COLOR('tickColor')
+
+ //Axis labels
+ var labelUpdate = STRING('labels')
+ if(STRING('labelFont')) {
+ labelUpdate = true
+ }
+ BOOLEAN('labelEnable')
+ NUMBER('labelSize')
+ NUMBER('labelPad')
+ COLOR('labelColor')
+
+ //Axis lines
+ BOOLEAN('lineEnable')
+ BOOLEAN('lineMirror')
+ NUMBER('lineWidth')
+ COLOR('lineColor')
+
+ //Axis line ticks
+ BOOLEAN('lineTickEnable')
+ BOOLEAN('lineTickMirror')
+ NUMBER('lineTickLength')
+ NUMBER('lineTickWidth')
+ COLOR('lineTickColor')
+
+ //Grid lines
+ BOOLEAN('gridEnable')
+ NUMBER('gridWidth')
+ COLOR('gridColor')
+
+ //Zero line
+ BOOLEAN('zeroEnable')
+ COLOR('zeroLineColor')
+ NUMBER('zeroLineWidth')
+
+ //Background
+ BOOLEAN('backgroundEnable')
+ COLOR('backgroundColor')
+
+ //Update text if necessary
+ if(!this._text) {
+ this._text = createText(
+ this.gl,
+ this.bounds,
+ this.labels,
+ this.labelFont,
+ this.ticks,
+ this.tickFont)
+ } else if(this._text && (labelUpdate || ticksUpdate)) {
+ this._text.update(
+ this.bounds,
+ this.labels,
+ this.labelFont,
+ this.ticks,
+ this.tickFont)
+ }
+
+ //Update lines if necessary
+ if(this._lines && ticksUpdate) {
+ this._lines.dispose()
+ this._lines = null
+ }
+ if(!this._lines) {
+ this._lines = createLines(this.gl, this.bounds, this.ticks)
+ }
+}
+
+function OffsetInfo() {
+ this.primalOffset = [0,0,0]
+ this.primalMinor = [0,0,0]
+ this.mirrorOffset = [0,0,0]
+ this.mirrorMinor = [0,0,0]
+}
+
+var LINE_OFFSET = [ new OffsetInfo(), new OffsetInfo(), new OffsetInfo() ]
+
+function computeLineOffset(result, i, bounds, cubeEdges, cubeAxis) {
+ var primalOffset = result.primalOffset
+ var primalMinor = result.primalMinor
+ var dualOffset = result.mirrorOffset
+ var dualMinor = result.mirrorMinor
+ var e = cubeEdges[i]
+
+ //Calculate offsets
+ for(var j=0; j<3; ++j) {
+ if(i === j) {
+ continue
+ }
+ var a = primalOffset,
+ b = dualOffset,
+ c = primalMinor,
+ d = dualMinor
+ if(e & (1< 0) {
+ c[j] = -1
+ d[j] = 0
+ } else {
+ c[j] = 0
+ d[j] = +1
+ }
+ }
+}
+
+var CUBE_ENABLE = [0,0,0]
+var DEFAULT_PARAMS = {
+ model: identity,
+ view: identity,
+ projection: identity
+}
+
+proto.isOpaque = function() {
+ return true
+}
+
+proto.isTransparent = function() {
+ return false
+}
+
+proto.drawTransparent = function(params) {}
+
+var ALIGN_OPTION_AUTO = 0 // i.e. as defined in the shader the text would rotate to stay upwards range: [-90,90]
+
+var PRIMAL_MINOR = [0,0,0]
+var MIRROR_MINOR = [0,0,0]
+var PRIMAL_OFFSET = [0,0,0]
+
+proto.draw = function(params) {
+ params = params || DEFAULT_PARAMS
+
+ var gl = this.gl
+
+ //Geometry for camera and axes
+ var model = params.model || identity
+ var view = params.view || identity
+ var projection = params.projection || identity
+ var bounds = this.bounds
+
+ //Unpack axis info
+ var cubeParams = getCubeProperties(model, view, projection, bounds)
+ var cubeEdges = cubeParams.cubeEdges
+ var cubeAxis = cubeParams.axis
+
+ var cx = view[12]
+ var cy = view[13]
+ var cz = view[14]
+ var cw = view[15]
+
+ var pixelScaleF = this.pixelRatio * (projection[3]*cx + projection[7]*cy + projection[11]*cz + projection[15]*cw) / gl.drawingBufferHeight
+
+ for(var i=0; i<3; ++i) {
+ this.lastCubeProps.cubeEdges[i] = cubeEdges[i]
+ this.lastCubeProps.axis[i] = cubeAxis[i]
+ }
+
+ //Compute axis info
+ var lineOffset = LINE_OFFSET
+ for(var i=0; i<3; ++i) {
+ computeLineOffset(
+ LINE_OFFSET[i],
+ i,
+ this.bounds,
+ cubeEdges,
+ cubeAxis)
+ }
+
+ //Set up state parameters
+ var gl = this.gl
+
+ //Draw background first
+ var cubeEnable = CUBE_ENABLE
+ for(var i=0; i<3; ++i) {
+ if(this.backgroundEnable[i]) {
+ cubeEnable[i] = cubeAxis[i]
+ } else {
+ cubeEnable[i] = 0
+ }
+ }
+
+ this._background.draw(
+ model,
+ view,
+ projection,
+ bounds,
+ cubeEnable,
+ this.backgroundColor)
+
+ //Draw lines
+ this._lines.bind(
+ model,
+ view,
+ projection,
+ this)
+
+ //First draw grid lines and zero lines
+ for(var i=0; i<3; ++i) {
+ var x = [0,0,0]
+ if(cubeAxis[i] > 0) {
+ x[i] = bounds[1][i]
+ } else {
+ x[i] = bounds[0][i]
+ }
+
+ //Draw grid lines
+ for(var j=0; j<2; ++j) {
+ var u = (i + 1 + j) % 3
+ var v = (i + 1 + (j^1)) % 3
+ if(this.gridEnable[u]) {
+ this._lines.drawGrid(u, v, this.bounds, x, this.gridColor[u], this.gridWidth[u]*this.pixelRatio)
+ }
+ }
+
+ //Draw zero lines (need to do this AFTER all grid lines are drawn)
+ for(var j=0; j<2; ++j) {
+ var u = (i + 1 + j) % 3
+ var v = (i + 1 + (j^1)) % 3
+ if(this.zeroEnable[v]) {
+ //Check if zero line in bounds
+ if(Math.min(bounds[0][v], bounds[1][v]) <= 0 && Math.max(bounds[0][v], bounds[1][v]) >= 0) {
+ this._lines.drawZero(u, v, this.bounds, x, this.zeroLineColor[v], this.zeroLineWidth[v]*this.pixelRatio)
+ }
+ }
+ }
+ }
+
+ //Then draw axis lines and tick marks
+ for(var i=0; i<3; ++i) {
+
+ //Draw axis lines
+ if(this.lineEnable[i]) {
+ this._lines.drawAxisLine(i, this.bounds, lineOffset[i].primalOffset, this.lineColor[i], this.lineWidth[i]*this.pixelRatio)
+ }
+ if(this.lineMirror[i]) {
+ this._lines.drawAxisLine(i, this.bounds, lineOffset[i].mirrorOffset, this.lineColor[i], this.lineWidth[i]*this.pixelRatio)
+ }
+
+ //Compute minor axes
+ var primalMinor = copyVec3(PRIMAL_MINOR, lineOffset[i].primalMinor)
+ var mirrorMinor = copyVec3(MIRROR_MINOR, lineOffset[i].mirrorMinor)
+ var tickLength = this.lineTickLength
+ var op = 0
+ for(var j=0; j<3; ++j) {
+ var scaleFactor = pixelScaleF / model[5*j]
+ primalMinor[j] *= tickLength[j] * scaleFactor
+ mirrorMinor[j] *= tickLength[j] * scaleFactor
+ }
+
+ //Draw axis line ticks
+ if(this.lineTickEnable[i]) {
+ this._lines.drawAxisTicks(i, lineOffset[i].primalOffset, primalMinor, this.lineTickColor[i], this.lineTickWidth[i]*this.pixelRatio)
+ }
+ if(this.lineTickMirror[i]) {
+ this._lines.drawAxisTicks(i, lineOffset[i].mirrorOffset, mirrorMinor, this.lineTickColor[i], this.lineTickWidth[i]*this.pixelRatio)
+ }
+ }
+ this._lines.unbind()
+
+ //Draw text sprites
+ this._text.bind(
+ model,
+ view,
+ projection,
+ this.pixelRatio)
+
+ var alignOpt // options in shader are from this list {-1, 0, 1, 2, 3, ..., n}
+ // -1: backward compatible
+ // 0: raw data
+ // 1: auto align, free angles
+ // 2: auto align, horizontal or vertical
+ //3-n: auto align, round to n directions e.g. 12 -> round to angles with 30-degree steps
+
+ var hv_ratio = 0.5 // can have an effect on the ratio between horizontals and verticals when using option 2
+
+ var enableAlign
+ var alignDir
+
+ function alignTo(i) {
+ alignDir = [0,0,0]
+ alignDir[i] = 1
+ }
+
+ function solveTickAlignments(i, minor, major) {
+
+ var i1 = (i + 1) % 3
+ var i2 = (i + 2) % 3
+
+ var A = minor[i1]
+ var B = minor[i2]
+ var C = major[i1]
+ var D = major[i2]
+
+ if ((A > 0) && (D > 0)) { alignTo(i1); return; }
+ else if ((A > 0) && (D < 0)) { alignTo(i1); return; }
+ else if ((A < 0) && (D > 0)) { alignTo(i1); return; }
+ else if ((A < 0) && (D < 0)) { alignTo(i1); return; }
+ else if ((B > 0) && (C > 0)) { alignTo(i2); return; }
+ else if ((B > 0) && (C < 0)) { alignTo(i2); return; }
+ else if ((B < 0) && (C > 0)) { alignTo(i2); return; }
+ else if ((B < 0) && (C < 0)) { alignTo(i2); return; }
+ }
+
+ for(var i=0; i<3; ++i) {
+
+ var minor = lineOffset[i].primalMinor
+ var major = lineOffset[i].mirrorMinor
+
+ var offset = copyVec3(PRIMAL_OFFSET, lineOffset[i].primalOffset)
+
+ for(var j=0; j<3; ++j) {
+ if(this.lineTickEnable[i]) {
+ offset[j] += pixelScaleF * minor[j] * Math.max(this.lineTickLength[j], 0) / model[5*j]
+ }
+ }
+
+ var axis = [0,0,0]
+ axis[i] = 1
+
+ //Draw tick text
+ if(this.tickEnable[i]) {
+
+ if(this.tickAngle[i] === -3600) {
+ this.tickAngle[i] = 0
+ this._tickAlign[i] = 'auto'
+ } else {
+ this._tickAlign[i] = -1
+ }
+
+ enableAlign = 1;
+
+ alignOpt = [this._tickAlign[i], hv_ratio, enableAlign]
+ if(alignOpt[0] === 'auto') alignOpt[0] = ALIGN_OPTION_AUTO
+ else alignOpt[0] = parseInt('' + alignOpt[0])
+
+ alignDir = [0,0,0]
+ solveTickAlignments(i, minor, major)
+
+ //Add tick padding
+ for(var j=0; j<3; ++j) {
+ offset[j] += pixelScaleF * minor[j] * this.tickPad[j] / model[5*j]
+ }
+
+ //Draw axis
+ this._text.drawTicks(
+ i,
+ this.tickSize[i],
+ this.tickAngle[i],
+ offset,
+ this.tickColor[i],
+ axis,
+ alignDir,
+ alignOpt)
+ }
+
+ //Draw labels
+ if(this.labelEnable[i]) {
+
+ enableAlign = 0
+ alignDir = [0,0,0]
+ if(this.labels[i].length > 4) { // for large label axis enable alignDir to axis
+ alignTo(i)
+ enableAlign = 1
+ }
+
+ alignOpt = [this._labelAlign[i], hv_ratio, enableAlign]
+ if(alignOpt[0] === 'auto') alignOpt[0] = ALIGN_OPTION_AUTO
+ else alignOpt[0] = parseInt('' + alignOpt[0])
+
+ //Add label padding
+ for(var j=0; j<3; ++j) {
+ offset[j] += pixelScaleF * minor[j] * this.labelPad[j] / model[5*j]
+ }
+ offset[i] += 0.5 * (bounds[0][i] + bounds[1][i])
+
+ //Draw axis
+ this._text.drawLabel(
+ i,
+ this.labelSize[i],
+ this._labelAngle[i],
+ offset,
+ this.labelColor[i],
+ [0,0,0],
+ alignDir,
+ alignOpt)
+ }
+ }
+
+ this._text.unbind()
+}
+
+proto.dispose = function() {
+ this._text.dispose()
+ this._lines.dispose()
+ this._background.dispose()
+ this._lines = null
+ this._text = null
+ this._background = null
+ this.gl = null
+}
+
+function createAxes(gl, options) {
+ var axes = new Axes(gl)
+ axes.update(options)
+ return axes
+}
+
+},{"./lib/background.js":223,"./lib/cube.js":224,"./lib/lines.js":225,"./lib/text.js":227,"./lib/ticks.js":228}],223:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createBackgroundCube
+
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createShader = _dereq_('./shaders').bg
+
+function BackgroundCube(gl, buffer, vao, shader) {
+ this.gl = gl
+ this.buffer = buffer
+ this.vao = vao
+ this.shader = shader
+}
+
+var proto = BackgroundCube.prototype
+
+proto.draw = function(model, view, projection, bounds, enable, colors) {
+ var needsBG = false
+ for(var i=0; i<3; ++i) {
+ needsBG = needsBG || enable[i]
+ }
+ if(!needsBG) {
+ return
+ }
+
+ var gl = this.gl
+
+ gl.enable(gl.POLYGON_OFFSET_FILL)
+ gl.polygonOffset(1, 2)
+
+ this.shader.bind()
+ this.shader.uniforms = {
+ model: model,
+ view: view,
+ projection: projection,
+ bounds: bounds,
+ enable: enable,
+ colors: colors
+ }
+ this.vao.bind()
+ this.vao.draw(this.gl.TRIANGLES, 36)
+ this.vao.unbind()
+
+ gl.disable(gl.POLYGON_OFFSET_FILL)
+}
+
+proto.dispose = function() {
+ this.vao.dispose()
+ this.buffer.dispose()
+ this.shader.dispose()
+}
+
+function createBackgroundCube(gl) {
+ //Create cube vertices
+ var vertices = []
+ var indices = []
+ var ptr = 0
+ for(var d=0; d<3; ++d) {
+ var u = (d+1) % 3
+ var v = (d+2) % 3
+ var x = [0,0,0]
+ var c = [0,0,0]
+ for(var s=-1; s<=1; s+=2) {
+ indices.push(ptr, ptr+2, ptr+1,
+ ptr+1, ptr+2, ptr+3)
+ x[d] = s
+ c[d] = s
+ for(var i=-1; i<=1; i+=2) {
+ x[u] = i
+ for(var j=-1; j<=1; j+=2) {
+ x[v] = j
+ vertices.push(x[0], x[1], x[2],
+ c[0], c[1], c[2])
+ ptr += 1
+ }
+ }
+ //Swap u and v
+ var tt = u
+ u = v
+ v = tt
+ }
+ }
+
+ //Allocate buffer and vertex array
+ var buffer = createBuffer(gl, new Float32Array(vertices))
+ var elements = createBuffer(gl, new Uint16Array(indices), gl.ELEMENT_ARRAY_BUFFER)
+ var vao = createVAO(gl, [
+ {
+ buffer: buffer,
+ type: gl.FLOAT,
+ size: 3,
+ offset: 0,
+ stride: 24
+ },
+ {
+ buffer: buffer,
+ type: gl.FLOAT,
+ size: 3,
+ offset: 12,
+ stride: 24
+ }
+ ], elements)
+
+ //Create shader object
+ var shader = createShader(gl)
+ shader.attributes.position.location = 0
+ shader.attributes.normal.location = 1
+
+ return new BackgroundCube(gl, buffer, vao, shader)
+}
+
+},{"./shaders":226,"gl-buffer":230,"gl-vao":310}],224:[function(_dereq_,module,exports){
+"use strict"
+
+module.exports = getCubeEdges
+
+var bits = _dereq_('bit-twiddle')
+var multiply = _dereq_('gl-mat4/multiply')
+var invert = _dereq_('gl-mat4/invert')
+var splitPoly = _dereq_('split-polygon')
+var orient = _dereq_('robust-orientation')
+
+var mvp = new Array(16)
+var imvp = new Array(16)
+var pCubeVerts = new Array(8)
+var cubeVerts = new Array(8)
+var x = new Array(3)
+var zero3 = [0,0,0]
+
+;(function() {
+ for(var i=0; i<8; ++i) {
+ pCubeVerts[i] =[1,1,1,1]
+ cubeVerts[i] = [1,1,1]
+ }
+})()
+
+
+function transformHg(result, x, mat) {
+ for(var i=0; i<4; ++i) {
+ result[i] = mat[12+i]
+ for(var j=0; j<3; ++j) {
+ result[i] += x[j]*mat[4*j+i]
+ }
+ }
+}
+
+var FRUSTUM_PLANES = [
+ [ 0, 0, 1, 0, 0],
+ [ 0, 0,-1, 1, 0],
+ [ 0,-1, 0, 1, 0],
+ [ 0, 1, 0, 1, 0],
+ [-1, 0, 0, 1, 0],
+ [ 1, 0, 0, 1, 0]
+]
+
+function polygonArea(p) {
+ for(var i=0; i o0) {
+ closest |= 1< o0) {
+ closest |= 1< cubeVerts[i][1]) {
+ bottom = i
+ }
+ }
+
+ //Find left/right neighbors of bottom vertex
+ var left = -1
+ for(var i=0; i<3; ++i) {
+ var idx = bottom ^ (1< cubeVerts[right][0]) {
+ right = idx
+ }
+ }
+
+ //Determine edge axis coordinates
+ var cubeEdges = CUBE_EDGES
+ cubeEdges[0] = cubeEdges[1] = cubeEdges[2] = 0
+ cubeEdges[bits.log2(left^bottom)] = bottom&left
+ cubeEdges[bits.log2(bottom^right)] = bottom&right
+ var top = right ^ 7
+ if(top === closest || top === farthest) {
+ top = left ^ 7
+ cubeEdges[bits.log2(right^top)] = top&right
+ } else {
+ cubeEdges[bits.log2(left^top)] = top&left
+ }
+
+ //Determine visible faces
+ var axis = CUBE_AXIS
+ var cutCorner = closest
+ for(var d=0; d<3; ++d) {
+ if(cutCorner & (1< HALF_PI) && (b <= ONE_AND_HALF_PI)) ?\n b - PI :\n b;\n}\n\nfloat look_horizontal_or_vertical(float a, float ratio) {\n // ratio controls the ratio between being horizontal to (vertical + horizontal)\n // if ratio is set to 0.5 then it is 50%, 50%.\n // when using a higher ratio e.g. 0.75 the result would\n // likely be more horizontal than vertical.\n\n float b = positive_angle(a);\n\n return\n (b < ( ratio) * HALF_PI) ? 0.0 :\n (b < (2.0 - ratio) * HALF_PI) ? -HALF_PI :\n (b < (2.0 + ratio) * HALF_PI) ? 0.0 :\n (b < (4.0 - ratio) * HALF_PI) ? HALF_PI :\n 0.0;\n}\n\nfloat roundTo(float a, float b) {\n return float(b * floor((a + 0.5 * b) / b));\n}\n\nfloat look_round_n_directions(float a, int n) {\n float b = positive_angle(a);\n float div = TWO_PI / float(n);\n float c = roundTo(b, div);\n return look_upwards(c);\n}\n\nfloat applyAlignOption(float rawAngle, float delta) {\n return\n (option > 2) ? look_round_n_directions(rawAngle + delta, option) : // option 3-n: round to n directions\n (option == 2) ? look_horizontal_or_vertical(rawAngle + delta, hv_ratio) : // horizontal or vertical\n (option == 1) ? rawAngle + delta : // use free angle, and flip to align with one direction of the axis\n (option == 0) ? look_upwards(rawAngle) : // use free angle, and stay upwards\n (option ==-1) ? 0.0 : // useful for backward compatibility, all texts remains horizontal\n rawAngle; // otherwise return back raw input angle\n}\n\nbool isAxisTitle = (axis.x == 0.0) &&\n (axis.y == 0.0) &&\n (axis.z == 0.0);\n\nvoid main() {\n //Compute world offset\n float axisDistance = position.z;\n vec3 dataPosition = axisDistance * axis + offset;\n\n float beta = angle; // i.e. user defined attributes for each tick\n\n float axisAngle;\n float clipAngle;\n float flip;\n\n if (enableAlign) {\n axisAngle = (isAxisTitle) ? HALF_PI :\n computeViewAngle(dataPosition, dataPosition + axis);\n clipAngle = computeViewAngle(dataPosition, dataPosition + alignDir);\n\n axisAngle += (sin(axisAngle) < 0.0) ? PI : 0.0;\n clipAngle += (sin(clipAngle) < 0.0) ? PI : 0.0;\n\n flip = (dot(vec2(cos(axisAngle), sin(axisAngle)),\n vec2(sin(clipAngle),-cos(clipAngle))) > 0.0) ? 1.0 : 0.0;\n\n beta += applyAlignOption(clipAngle, flip * PI);\n }\n\n //Compute plane offset\n vec2 planeCoord = position.xy * pixelScale;\n\n mat2 planeXform = scale * mat2(\n cos(beta), sin(beta),\n -sin(beta), cos(beta)\n );\n\n vec2 viewOffset = 2.0 * planeXform * planeCoord / resolution;\n\n //Compute clip position\n vec3 clipPosition = project(dataPosition);\n\n //Apply text offset in clip coordinates\n clipPosition += vec3(viewOffset, 0.0);\n\n //Done\n gl_Position = vec4(clipPosition, 1.0);\n}"])
+var textFrag = glslify(["precision mediump float;\n#define GLSLIFY 1\nuniform vec4 color;\nvoid main() {\n gl_FragColor = color;\n}"])
+exports.text = function(gl) {
+ return createShader(gl, textVert, textFrag, null, [
+ {name: 'position', type: 'vec3'}
+ ])
+}
+
+var bgVert = glslify(["#define GLSLIFY 1\nattribute vec3 position;\nattribute vec3 normal;\n\nuniform mat4 model, view, projection;\nuniform vec3 enable;\nuniform vec3 bounds[2];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n\n vec3 signAxis = sign(bounds[1] - bounds[0]);\n\n vec3 realNormal = signAxis * normal;\n\n if(dot(realNormal, enable) > 0.0) {\n vec3 minRange = min(bounds[0], bounds[1]);\n vec3 maxRange = max(bounds[0], bounds[1]);\n vec3 nPosition = mix(minRange, maxRange, 0.5 * (position + 1.0));\n gl_Position = projection * view * model * vec4(nPosition, 1.0);\n } else {\n gl_Position = vec4(0,0,0,0);\n }\n\n colorChannel = abs(realNormal);\n}"])
+var bgFrag = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec4 colors[3];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n gl_FragColor = colorChannel.x * colors[0] +\n colorChannel.y * colors[1] +\n colorChannel.z * colors[2];\n}"])
+exports.bg = function(gl) {
+ return createShader(gl, bgVert, bgFrag, null, [
+ {name: 'position', type: 'vec3'},
+ {name: 'normal', type: 'vec3'}
+ ])
+}
+
+},{"gl-shader":288,"glslify":392}],227:[function(_dereq_,module,exports){
+(function (process){
+"use strict"
+
+module.exports = createTextSprites
+
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var vectorizeText = _dereq_('vectorize-text')
+var createShader = _dereq_('./shaders').text
+
+var globals = window || process.global || {}
+var __TEXT_CACHE = globals.__TEXT_CACHE || {}
+globals.__TEXT_CACHE = {}
+
+//Vertex buffer format for text is:
+//
+/// [x,y,z] = Spatial coordinate
+//
+
+var VERTEX_SIZE = 3
+var VERTEX_STRIDE = VERTEX_SIZE * 4
+
+function TextSprites(
+ gl,
+ shader,
+ buffer,
+ vao) {
+ this.gl = gl
+ this.shader = shader
+ this.buffer = buffer
+ this.vao = vao
+ this.tickOffset =
+ this.tickCount =
+ this.labelOffset =
+ this.labelCount = null
+}
+
+var proto = TextSprites.prototype
+
+//Bind textures for rendering
+var SHAPE = [0,0]
+proto.bind = function(model, view, projection, pixelScale) {
+ this.vao.bind()
+ this.shader.bind()
+ var uniforms = this.shader.uniforms
+ uniforms.model = model
+ uniforms.view = view
+ uniforms.projection = projection
+ uniforms.pixelScale = pixelScale
+ SHAPE[0] = this.gl.drawingBufferWidth
+ SHAPE[1] = this.gl.drawingBufferHeight
+ this.shader.uniforms.resolution = SHAPE
+}
+
+proto.unbind = function() {
+ this.vao.unbind()
+}
+
+proto.update = function(bounds, labels, labelFont, ticks, tickFont) {
+ var gl = this.gl
+ var data = []
+
+ function addItem(t, text, font, size) {
+ var fontcache = __TEXT_CACHE[font]
+ if(!fontcache) {
+ fontcache = __TEXT_CACHE[font] = {}
+ }
+ var mesh = fontcache[text]
+ if(!mesh) {
+ mesh = fontcache[text] = tryVectorizeText(text, {
+ triangles: true,
+ font: font,
+ textAlign: 'center',
+ textBaseline: 'middle'
+ })
+ }
+ var scale = (size || 12) / 12
+ var positions = mesh.positions
+ var cells = mesh.cells
+ var lo = [ Infinity, Infinity]
+ var hi = [-Infinity,-Infinity]
+ for(var i=0, nc=cells.length; i=0; --j) {
+ var p = positions[c[j]]
+ data.push(scale*p[0], -scale*p[1], t)
+ }
+ }
+ }
+
+ //Generate sprites for all 3 axes, store data in texture atlases
+ var tickOffset = [0,0,0]
+ var tickCount = [0,0,0]
+ var labelOffset = [0,0,0]
+ var labelCount = [0,0,0]
+ for(var d=0; d<3; ++d) {
+
+ //Generate label
+ labelOffset[d] = (data.length/VERTEX_SIZE)|0
+ addItem(0.5*(bounds[0][d]+bounds[1][d]), labels[d], labelFont)
+ labelCount[d] = ((data.length/VERTEX_SIZE)|0) - labelOffset[d]
+
+ //Generate sprites for tick marks
+ tickOffset[d] = (data.length/VERTEX_SIZE)|0
+ for(var i=0; i= 0) {
+ sigFigs = stepStr.length - u - 1
+ }
+ var shift = Math.pow(10, sigFigs)
+ var x = Math.round(spacing * i * shift)
+ var xstr = x + ""
+ if(xstr.indexOf("e") >= 0) {
+ return xstr
+ }
+ var xi = x / shift, xf = x % shift
+ if(x < 0) {
+ xi = -Math.ceil(xi)|0
+ xf = (-xf)|0
+ } else {
+ xi = Math.floor(xi)|0
+ xf = xf|0
+ }
+ var xis = "" + xi
+ if(x < 0) {
+ xis = "-" + xis
+ }
+ if(sigFigs) {
+ var xs = "" + xf
+ while(xs.length < sigFigs) {
+ xs = "0" + xs
+ }
+ return xis + "." + xs
+ } else {
+ return xis
+ }
+}
+
+function defaultTicks(bounds, tickSpacing) {
+ var array = []
+ for(var d=0; d<3; ++d) {
+ var ticks = []
+ var m = 0.5*(bounds[0][d]+bounds[1][d])
+ for(var t=0; t*tickSpacing[d]<=bounds[1][d]; ++t) {
+ ticks.push({x: t*tickSpacing[d], text: prettyPrint(tickSpacing[d], t)})
+ }
+ for(var t=-1; t*tickSpacing[d]>=bounds[0][d]; --t) {
+ ticks.push({x: t*tickSpacing[d], text: prettyPrint(tickSpacing[d], t)})
+ }
+ array.push(ticks)
+ }
+ return array
+}
+
+function ticksEqual(ticksA, ticksB) {
+ for(var i=0; i<3; ++i) {
+ if(ticksA[i].length !== ticksB[i].length) {
+ return false
+ }
+ for(var j=0; j len) {
+ throw new Error("gl-buffer: If resizing buffer, must not specify offset")
+ }
+ gl.bufferSubData(type, offset, data)
+ return len
+}
+
+function makeScratchTypeArray(array, dtype) {
+ var res = pool.malloc(array.length, dtype)
+ var n = array.length
+ for(var i=0; i=0; --i) {
+ if(stride[i] !== n) {
+ return false
+ }
+ n *= shape[i]
+ }
+ return true
+}
+
+proto.update = function(array, offset) {
+ if(typeof offset !== "number") {
+ offset = -1
+ }
+ this.bind()
+ if(typeof array === "object" && typeof array.shape !== "undefined") { //ndarray
+ var dtype = array.dtype
+ if(SUPPORTED_TYPES.indexOf(dtype) < 0) {
+ dtype = "float32"
+ }
+ if(this.type === this.gl.ELEMENT_ARRAY_BUFFER) {
+ var ext = gl.getExtension('OES_element_index_uint')
+ if(ext && dtype !== "uint16") {
+ dtype = "uint32"
+ } else {
+ dtype = "uint16"
+ }
+ }
+ if(dtype === array.dtype && isPacked(array.shape, array.stride)) {
+ if(array.offset === 0 && array.data.length === array.shape[0]) {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array.data, offset)
+ } else {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array.data.subarray(array.offset, array.shape[0]), offset)
+ }
+ } else {
+ var tmp = pool.malloc(array.size, dtype)
+ var ndt = ndarray(tmp, array.shape)
+ ops.assign(ndt, array)
+ if(offset < 0) {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, tmp, offset)
+ } else {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, tmp.subarray(0, array.size), offset)
+ }
+ pool.free(tmp)
+ }
+ } else if(Array.isArray(array)) { //Vanilla array
+ var t
+ if(this.type === this.gl.ELEMENT_ARRAY_BUFFER) {
+ t = makeScratchTypeArray(array, "uint16")
+ } else {
+ t = makeScratchTypeArray(array, "float32")
+ }
+ if(offset < 0) {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, t, offset)
+ } else {
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, t.subarray(0, array.length), offset)
+ }
+ pool.free(t)
+ } else if(typeof array === "object" && typeof array.length === "number") { //Typed array
+ this.length = updateTypeArray(this.gl, this.type, this.length, this.usage, array, offset)
+ } else if(typeof array === "number" || array === undefined) { //Number/default
+ if(offset >= 0) {
+ throw new Error("gl-buffer: Cannot specify offset when resizing buffer")
+ }
+ array = array | 0
+ if(array <= 0) {
+ array = 1
+ }
+ this.gl.bufferData(this.type, array|0, this.usage)
+ this.length = array
+ } else { //Error, case should not happen
+ throw new Error("gl-buffer: Invalid data type")
+ }
+}
+
+function createBuffer(gl, data, type, usage) {
+ type = type || gl.ARRAY_BUFFER
+ usage = usage || gl.DYNAMIC_DRAW
+ if(type !== gl.ARRAY_BUFFER && type !== gl.ELEMENT_ARRAY_BUFFER) {
+ throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER")
+ }
+ if(usage !== gl.DYNAMIC_DRAW && usage !== gl.STATIC_DRAW && usage !== gl.STREAM_DRAW) {
+ throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW")
+ }
+ var handle = gl.createBuffer()
+ var result = new GLBuffer(gl, type, handle, 0, usage)
+ result.update(data)
+ return result
+}
+
+module.exports = createBuffer
+
+},{"ndarray":433,"ndarray-ops":427,"typedarray-pool":522}],231:[function(_dereq_,module,exports){
+"use strict";
+
+var V = _dereq_('gl-vec3');
+var V4 = _dereq_('gl-vec4');
+
+var vec3 = function(x, y, z) {
+ var v = V.create();
+ if (x !== undefined) {
+ V.set(v, x, y, z);
+ }
+ return v;
+}
+
+var createPositionsForMeshgrid = function(meshgrid) {
+ var xs = meshgrid[0], ys = meshgrid[1], zs = meshgrid[2];
+ var positions = [];
+ for (var z=0; z= v) {
+ return i-1;
+ }
+ }
+ return i;
+};
+
+var tmp = V.create();
+var tmp2 = V.create();
+
+var clamp = function(v, min, max) {
+ return v < min ? min : (v > max ? max : v);
+};
+
+var sampleMeshgrid = function(point, array, meshgrid, clampOverflow) {
+ var x = point[0];
+ var y = point[1];
+ var z = point[2];
+
+ var w = meshgrid[0].length;
+ var h = meshgrid[1].length;
+ var d = meshgrid[2].length;
+
+ // Find the index of the nearest smaller value in the meshgrid for each coordinate of (x,y,z).
+ // The nearest smaller value index for x is the index x0 such that
+ // meshgrid[0][x0] < x and for all x1 > x0, meshgrid[0][x1] >= x.
+ var x0 = findLastSmallerIndex(meshgrid[0], x);
+ var y0 = findLastSmallerIndex(meshgrid[1], y);
+ var z0 = findLastSmallerIndex(meshgrid[2], z);
+
+ // Get the nearest larger meshgrid value indices.
+ // From the above "nearest smaller value", we know that
+ // meshgrid[0][x0] < x
+ // meshgrid[0][x0+1] >= x
+ var x1 = x0 + 1;
+ var y1 = y0 + 1;
+ var z1 = z0 + 1;
+
+ if (clampOverflow) {
+ x0 = clamp(x0, 0, w-1);
+ x1 = clamp(x1, 0, w-1);
+ y0 = clamp(y0, 0, h-1);
+ y1 = clamp(y1, 0, h-1);
+ z0 = clamp(z0, 0, d-1);
+ z1 = clamp(z1, 0, d-1);
+ }
+
+ // Reject points outside the meshgrid, return a zero vector.
+ if (x0 < 0 || y0 < 0 || z0 < 0 || x1 >= w || y1 >= h || z1 >= d) {
+ return V.create();
+ }
+
+ // Normalize point coordinates to 0..1 scaling factor between x0 and x1.
+ var xf = (x - meshgrid[0][x0]) / (meshgrid[0][x1] - meshgrid[0][x0]);
+ var yf = (y - meshgrid[1][y0]) / (meshgrid[1][y1] - meshgrid[1][y0]);
+ var zf = (z - meshgrid[2][z0]) / (meshgrid[2][z1] - meshgrid[2][z0]);
+
+ if (xf < 0 || xf > 1 || isNaN(xf)) xf = 0;
+ if (yf < 0 || yf > 1 || isNaN(yf)) yf = 0;
+ if (zf < 0 || zf > 1 || isNaN(zf)) zf = 0;
+
+ var z0off = z0*w*h;
+ var z1off = z1*w*h;
+
+ var y0off = y0*w;
+ var y1off = y1*w;
+
+ var x0off = x0;
+ var x1off = x1;
+
+ // Sample data array around the (x,y,z) point.
+ // vZYX = array[zZoff + yYoff + xXoff]
+ var v000 = array[y0off + z0off + x0off];
+ var v001 = array[y0off + z0off + x1off];
+ var v010 = array[y1off + z0off + x0off];
+ var v011 = array[y1off + z0off + x1off];
+ var v100 = array[y0off + z1off + x0off];
+ var v101 = array[y0off + z1off + x1off];
+ var v110 = array[y1off + z1off + x0off];
+ var v111 = array[y1off + z1off + x1off];
+
+ var result = V.create();
+
+ // Average samples according to distance to point.
+ V.lerp(result, v000, v001, xf);
+ V.lerp(tmp, v010, v011, xf);
+ V.lerp(result, result, tmp, yf);
+ V.lerp(tmp, v100, v101, xf);
+ V.lerp(tmp2, v110, v111, xf);
+ V.lerp(tmp, tmp, tmp2, yf);
+ V.lerp(result, result, tmp, zf);
+
+ return result;
+};
+
+var getOrthogonalVector = function(dst, v) {
+ // Return up-vector for only-z vector.
+ if (v[0] === 0 && v[1] === 0) {
+ V.set(dst, 0, 1, 0);
+ } else {
+ // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).
+ // From the above if-statement we have ||a|| > 0 U ||b|| > 0.
+ // Assign z = 0, x = -b, y = a:
+ // a*-b + b*a + c*0 = -ba + ba + 0 = 0
+ V.set(dst, -v[1], v[0], 0);
+ }
+ return dst;
+};
+
+module.exports = function(vectorfield, bounds) {
+ var positions;
+ if (vectorfield.positions) {
+ positions = vectorfield.positions;
+ } else {
+ positions = createPositionsForMeshgrid(vectorfield.meshgrid);
+ }
+ var meshgrid = vectorfield.meshgrid;
+ var vectors = vectorfield.vectors;
+ var geo = {
+ positions: [],
+ vertexIntensity: [],
+ vertexIntensityBounds: vectorfield.vertexIntensityBounds,
+ vertexNormals: [],
+ vectors: [],
+ cells: [],
+ coneOffset: vectorfield.coneOffset,
+ colormap: vectorfield.colormap
+ };
+
+ if (vectorfield.positions.length === 0) {
+ if (bounds) {
+ bounds[0] = [0,0,0];
+ bounds[1] = [0,0,0];
+ }
+ return geo;
+ }
+
+ // Compute bounding box for the dataset.
+ // Compute maximum velocity for the dataset to use for scaling the cones.
+ var maxNorm = 0;
+ var minX = 1/0, maxX = -1/0;
+ var minY = 1/0, maxY = -1/0;
+ var minZ = 1/0, maxZ = -1/0;
+ var p2 = null;
+ var u2 = null;
+ var positionVectors = [];
+ var vectorScale = 1/0;
+ for (var i = 0; i < positions.length; i++) {
+ var p = positions[i];
+ minX = Math.min(p[0], minX);
+ maxX = Math.max(p[0], maxX);
+ minY = Math.min(p[1], minY);
+ maxY = Math.max(p[1], maxY);
+ minZ = Math.min(p[2], minZ);
+ maxZ = Math.max(p[2], maxZ);
+ var u;
+ if (meshgrid) {
+ u = sampleMeshgrid(p, vectors, meshgrid, true);
+ } else {
+ u = vectors[i];
+ }
+ if (V.length(u) > maxNorm) {
+ maxNorm = V.length(u);
+ }
+ if (i) {
+ // Find vector scale [w/ units of time] using "successive" positions
+ // (not "adjacent" with would be O(n^2)),
+ //
+ // The vector scale corresponds to the minimum "time" to travel across two
+ // two adjacent positions at the average velocity of those two adjacent positions
+ vectorScale = Math.min(vectorScale,
+ 2 * V.distance(p2, p) / (V.length(u2) + V.length(u))
+ );
+ }
+ p2 = p;
+ u2 = u;
+ positionVectors.push(u);
+ }
+ var minV = [minX, minY, minZ];
+ var maxV = [maxX, maxY, maxZ];
+ if (bounds) {
+ bounds[0] = minV;
+ bounds[1] = maxV;
+ }
+ if (maxNorm === 0) {
+ maxNorm = 1;
+ }
+
+ // Inverted max norm would map vector with norm maxNorm to 1 coord space units in length
+ var invertedMaxNorm = 1 / maxNorm;
+
+ if (!isFinite(vectorScale) || isNaN(vectorScale)) {
+ vectorScale = 1.0;
+ }
+ geo.vectorScale = vectorScale;
+
+ var nml = vec3(0,1,0);
+
+ var coneScale = vectorfield.coneSize || 0.5;
+
+ if (vectorfield.absoluteConeSize) {
+ coneScale = vectorfield.absoluteConeSize * invertedMaxNorm;
+ }
+
+ geo.coneScale = coneScale;
+
+ // Build the cone model.
+ for (var i = 0, j = 0; i < positions.length; i++) {
+ var p = positions[i];
+ var x = p[0], y = p[1], z = p[2];
+ var d = positionVectors[i];
+ var intensity = V.length(d) * invertedMaxNorm;
+ for (var k = 0, l = 8; k < l; k++) {
+ geo.positions.push([x, y, z, j++]);
+ geo.positions.push([x, y, z, j++]);
+ geo.positions.push([x, y, z, j++]);
+ geo.positions.push([x, y, z, j++]);
+ geo.positions.push([x, y, z, j++]);
+ geo.positions.push([x, y, z, j++]);
+
+ geo.vectors.push(d);
+ geo.vectors.push(d);
+ geo.vectors.push(d);
+ geo.vectors.push(d);
+ geo.vectors.push(d);
+ geo.vectors.push(d);
+
+ geo.vertexIntensity.push(intensity, intensity, intensity);
+ geo.vertexIntensity.push(intensity, intensity, intensity);
+
+ geo.vertexNormals.push(nml, nml, nml);
+ geo.vertexNormals.push(nml, nml, nml);
+
+ var m = geo.positions.length;
+ geo.cells.push([m-6, m-5, m-4], [m-3, m-2, m-1]);
+ }
+ }
+
+ return geo;
+};
+
+module.exports.createConeMesh = _dereq_('./lib/conemesh');
+
+},{"./lib/conemesh":233,"gl-vec3":329,"gl-vec4":365}],232:[function(_dereq_,module,exports){
+'use strict'
+
+var barycentric = _dereq_('barycentric')
+var closestPointToTriangle = _dereq_('polytope-closest-point/lib/closest_point_2d.js')
+
+module.exports = closestPointToPickLocation
+
+function xformMatrix(m, v) {
+ var out = [0,0,0,0]
+ for(var i=0; i<4; ++i) {
+ for(var j=0; j<4; ++j) {
+ out[j] += m[4*i + j] * v[i]
+ }
+ }
+ return out
+}
+
+function projectVertex(v, model, view, projection, resolution) {
+ var p = xformMatrix(projection,
+ xformMatrix(view,
+ xformMatrix(model, [v[0], v[1], v[2], 1])))
+ for(var i=0; i<3; ++i) {
+ p[i] /= p[3]
+ }
+ return [ 0.5 * resolution[0] * (1.0+p[0]), 0.5 * resolution[1] * (1.0-p[1]) ]
+}
+
+function barycentricCoord(simplex, point) {
+ if(simplex.length === 2) {
+ var d0 = 0.0
+ var d1 = 0.0
+ for(var i=0; i<2; ++i) {
+ d0 += Math.pow(point[i] - simplex[0][i], 2)
+ d1 += Math.pow(point[i] - simplex[1][i], 2)
+ }
+ d0 = Math.sqrt(d0)
+ d1 = Math.sqrt(d1)
+ if(d0+d1 < 1e-6) {
+ return [1,0]
+ }
+ return [d1/(d0+d1),d0/(d1+d0)]
+ } else if(simplex.length === 3) {
+ var closestPoint = [0,0]
+ closestPointToTriangle(simplex[0], simplex[1], simplex[2], point, closestPoint)
+ return barycentric(simplex, closestPoint)
+ }
+ return []
+}
+
+function interpolate(simplex, weights) {
+ var result = [0,0,0]
+ for(var i=0; i 1.0001) {
+ return null
+ }
+ s += weights[i]
+ }
+ if(Math.abs(s - 1.0) > 0.001) {
+ return null
+ }
+ return [closestIndex, interpolate(simplex, weights), weights]
+}
+},{"barycentric":61,"polytope-closest-point/lib/closest_point_2d.js":464}],233:[function(_dereq_,module,exports){
+'use strict'
+
+var DEFAULT_VERTEX_NORMALS_EPSILON = 1e-6; // may be too large if triangles are very small
+var DEFAULT_FACE_NORMALS_EPSILON = 1e-6;
+
+var createShader = _dereq_('gl-shader')
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createTexture = _dereq_('gl-texture2d')
+var normals = _dereq_('normals')
+var multiply = _dereq_('gl-mat4/multiply')
+var invert = _dereq_('gl-mat4/invert')
+var ndarray = _dereq_('ndarray')
+var colormap = _dereq_('colormap')
+var getContour = _dereq_('simplicial-complex-contour')
+var pool = _dereq_('typedarray-pool')
+var shaders = _dereq_('./shaders')
+var closestPoint = _dereq_('./closest-point')
+
+var meshShader = shaders.meshShader
+var pickShader = shaders.pickShader
+
+var identityMatrix = [
+ 1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1]
+
+function SimplicialMesh(gl
+ , texture
+ , triShader
+ , lineShader
+ , pointShader
+ , pickShader
+ , pointPickShader
+ , contourShader
+ , trianglePositions
+ , triangleVectors
+ , triangleIds
+ , triangleColors
+ , triangleUVs
+ , triangleNormals
+ , triangleVAO
+ , edgePositions
+ , edgeIds
+ , edgeColors
+ , edgeUVs
+ , edgeVAO
+ , pointPositions
+ , pointIds
+ , pointColors
+ , pointUVs
+ , pointSizes
+ , pointVAO
+ , contourPositions
+ , contourVAO) {
+
+ this.gl = gl
+ this.cells = []
+ this.positions = []
+ this.intensity = []
+ this.texture = texture
+ this.dirty = true
+
+ this.triShader = triShader
+ this.lineShader = lineShader
+ this.pointShader = pointShader
+ this.pickShader = pickShader
+ this.pointPickShader = pointPickShader
+ this.contourShader = contourShader
+
+ this.trianglePositions = trianglePositions
+ this.triangleVectors = triangleVectors
+ this.triangleColors = triangleColors
+ this.triangleNormals = triangleNormals
+ this.triangleUVs = triangleUVs
+ this.triangleIds = triangleIds
+ this.triangleVAO = triangleVAO
+ this.triangleCount = 0
+
+ this.lineWidth = 1
+ this.edgePositions = edgePositions
+ this.edgeColors = edgeColors
+ this.edgeUVs = edgeUVs
+ this.edgeIds = edgeIds
+ this.edgeVAO = edgeVAO
+ this.edgeCount = 0
+
+ this.pointPositions = pointPositions
+ this.pointColors = pointColors
+ this.pointUVs = pointUVs
+ this.pointSizes = pointSizes
+ this.pointIds = pointIds
+ this.pointVAO = pointVAO
+ this.pointCount = 0
+
+ this.contourLineWidth = 1
+ this.contourPositions = contourPositions
+ this.contourVAO = contourVAO
+ this.contourCount = 0
+ this.contourColor = [0,0,0]
+ this.contourEnable = true
+
+ this.pickId = 1
+ this.bounds = [
+ [ Infinity, Infinity, Infinity],
+ [-Infinity,-Infinity,-Infinity] ]
+ this.clipBounds = [
+ [-Infinity,-Infinity,-Infinity],
+ [ Infinity, Infinity, Infinity] ]
+
+ this.lightPosition = [1e5, 1e5, 0]
+ this.ambientLight = 0.8
+ this.diffuseLight = 0.8
+ this.specularLight = 2.0
+ this.roughness = 0.5
+ this.fresnel = 1.5
+
+ this.opacity = 1.0
+
+ this.coneScale = 2.0
+ this.vectorScale = 1.0
+ this.coneOffset = 1.0 / 4.0;
+
+ this._model = identityMatrix
+ this._view = identityMatrix
+ this._projection = identityMatrix
+ this._resolution = [1,1]
+}
+
+var proto = SimplicialMesh.prototype
+
+proto.isOpaque = function() {
+ return this.opacity >= 1
+}
+
+proto.isTransparent = function() {
+ return this.opacity < 1
+}
+
+proto.pickSlots = 1
+
+proto.setPickBase = function(id) {
+ this.pickId = id
+}
+
+function genColormap(param) {
+ var colors = colormap({
+ colormap: param
+ , nshades: 256
+ , format: 'rgba'
+ })
+
+ var result = new Uint8Array(256*4)
+ for(var i=0; i<256; ++i) {
+ var c = colors[i]
+ for(var j=0; j<3; ++j) {
+ result[4*i+j] = c[j]
+ }
+ result[4*i+3] = c[3]*255
+ }
+
+ return ndarray(result, [256,256,4], [4,0,1])
+}
+
+function unpackIntensity(cells, numVerts, cellIntensity) {
+ var result = new Array(numVerts)
+ for(var i=0; i 0) {
+ var shader = this.triShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0 && this.lineWidth > 0) {
+ var shader = this.lineShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+
+ if(this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {
+ var shader = this.contourShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.contourVAO.bind()
+ gl.drawArrays(gl.LINES, 0, this.contourCount)
+ this.contourVAO.unbind()
+ }
+}
+
+proto.drawPick = function(params) {
+ params = params || {}
+
+ var gl = this.gl
+
+ var model = params.model || identityMatrix
+ var view = params.view || identityMatrix
+ var projection = params.projection || identityMatrix
+
+ var clipBounds = [[-1e6,-1e6,-1e6],[1e6,1e6,1e6]]
+ for(var i=0; i<3; ++i) {
+ clipBounds[0][i] = Math.max(clipBounds[0][i], this.clipBounds[0][i])
+ clipBounds[1][i] = Math.min(clipBounds[1][i], this.clipBounds[1][i])
+ }
+
+ //Save camera parameters
+ this._model = [].slice.call(model)
+ this._view = [].slice.call(view)
+ this._projection = [].slice.call(projection)
+ this._resolution = [gl.drawingBufferWidth, gl.drawingBufferHeight]
+
+ var uniforms = {
+ model: model,
+ view: view,
+ projection: projection,
+ clipBounds: clipBounds,
+
+ vectorScale: this.vectorScale,
+ coneScale: this.coneScale,
+ coneOffset: this.coneOffset,
+
+ pickId: this.pickId / 255.0,
+ }
+
+ var shader = this.pickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ if(this.triangleCount > 0) {
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0) {
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointPickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+}
+
+
+proto.pick = function(pickData) {
+ if(!pickData) {
+ return null
+ }
+ if(pickData.id !== this.pickId) {
+ return null
+ }
+
+ var cellId = pickData.value[0] + 256*pickData.value[1] + 65536*pickData.value[2]
+ var cell = this.cells[cellId]
+ var pos = this.positions[cell[1]].slice(0, 3)
+
+ return {
+ // corresponding to input indices
+ index: Math.floor(cell[1] / 48),
+ position: pos,
+ dataCoordinate: pos
+ }
+}
+
+
+proto.dispose = function() {
+ this.texture.dispose()
+
+ this.triShader.dispose()
+ // this.lineShader.dispose()
+ // this.pointShader.dispose()
+ this.pickShader.dispose()
+ // this.pointPickShader.dispose()
+
+ this.triangleVAO.dispose()
+ this.trianglePositions.dispose()
+ this.triangleVectors.dispose()
+ this.triangleColors.dispose()
+ this.triangleUVs.dispose()
+ this.triangleNormals.dispose()
+ this.triangleIds.dispose()
+
+ this.edgeVAO.dispose()
+ this.edgePositions.dispose()
+ this.edgeColors.dispose()
+ this.edgeUVs.dispose()
+ this.edgeIds.dispose()
+
+ this.pointVAO.dispose()
+ this.pointPositions.dispose()
+ this.pointColors.dispose()
+ this.pointUVs.dispose()
+ this.pointSizes.dispose()
+ this.pointIds.dispose()
+
+ this.contourVAO.dispose()
+ this.contourPositions.dispose()
+ // this.contourShader.dispose()
+}
+
+function createMeshShader(gl) {
+ // need to pass meshShader attributes manually,
+ // to make this work on etpinard's Ubuntu Thinkpad
+ var shader = createShader(gl, meshShader.vertex, meshShader.fragment, null, meshShader.attributes)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ shader.attributes.vector.location = 5
+ return shader
+}
+
+function createWireShader(gl) {
+ var shader = createShader(gl, wireShader.vertex, wireShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ return shader
+}
+
+function createPointShader(gl) {
+ var shader = createShader(gl, pointShader.vertex, pointShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ shader.attributes.pointSize.location = 4
+ return shader
+}
+
+function createPickShader(gl) {
+ var shader = createShader(gl, pickShader.vertex, pickShader.fragment, null, pickShader.attributes)
+ shader.attributes.position.location = 0
+ shader.attributes.id.location = 1
+ shader.attributes.vector.location = 5
+ return shader
+}
+
+function createPointPickShader(gl) {
+ var shader = createShader(gl, pointPickShader.vertex, pointPickShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.id.location = 1
+ shader.attributes.pointSize.location = 4
+ return shader
+}
+
+function createContourShader(gl) {
+ var shader = createShader(gl, contourShader.vertex, contourShader.fragment)
+ shader.attributes.position.location = 0
+ return shader
+}
+
+function createSimplicialMesh(gl, params) {
+ if (arguments.length === 1) {
+ params = gl;
+ gl = params.gl;
+ }
+
+ var triShader = params.triShader || createMeshShader(gl)
+ var lineShader = null; //createWireShader(gl)
+ var pointShader = null; //createPointShader(gl)
+ var pickShader = createPickShader(gl)
+ var pointPickShader = null; //createPointPickShader(gl)
+ var contourShader = null; //createContourShader(gl)
+
+ var meshTexture = createTexture(gl,
+ ndarray(new Uint8Array([255,255,255,255]), [1,1,4]))
+ meshTexture.generateMipmap()
+ meshTexture.minFilter = gl.LINEAR_MIPMAP_LINEAR
+ meshTexture.magFilter = gl.LINEAR
+
+ var trianglePositions = createBuffer(gl)
+ var triangleVectors = createBuffer(gl)
+ var triangleColors = createBuffer(gl)
+ var triangleUVs = createBuffer(gl)
+ var triangleNormals = createBuffer(gl)
+ var triangleIds = createBuffer(gl)
+ var triangleVAO = createVAO(gl, [
+ { buffer: trianglePositions,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: triangleIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: triangleColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: triangleUVs,
+ type: gl.FLOAT,
+ size: 2
+ },
+ { buffer: triangleNormals,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: triangleVectors,
+ type: gl.FLOAT,
+ size: 3
+ }
+ ])
+
+ var edgePositions = createBuffer(gl)
+ var edgeColors = createBuffer(gl)
+ var edgeUVs = createBuffer(gl)
+ var edgeIds = createBuffer(gl)
+ var edgeVAO = createVAO(gl, [
+ { buffer: edgePositions,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: edgeIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: edgeColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: edgeUVs,
+ type: gl.FLOAT,
+ size: 2
+ }
+ ])
+
+ var pointPositions = createBuffer(gl)
+ var pointColors = createBuffer(gl)
+ var pointUVs = createBuffer(gl)
+ var pointSizes = createBuffer(gl)
+ var pointIds = createBuffer(gl)
+ var pointVAO = createVAO(gl, [
+ { buffer: pointPositions,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: pointIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: pointColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: pointUVs,
+ type: gl.FLOAT,
+ size: 2
+ },
+ { buffer: pointSizes,
+ type: gl.FLOAT,
+ size: 1
+ }
+ ])
+
+ var contourPositions = createBuffer(gl)
+ var contourVAO = createVAO(gl, [
+ { buffer: contourPositions,
+ type: gl.FLOAT,
+ size: 3
+ }])
+
+ var mesh = new SimplicialMesh(gl
+ , meshTexture
+ , triShader
+ , lineShader
+ , pointShader
+ , pickShader
+ , pointPickShader
+ , contourShader
+ , trianglePositions
+ , triangleVectors
+ , triangleIds
+ , triangleColors
+ , triangleUVs
+ , triangleNormals
+ , triangleVAO
+ , edgePositions
+ , edgeIds
+ , edgeColors
+ , edgeUVs
+ , edgeVAO
+ , pointPositions
+ , pointIds
+ , pointColors
+ , pointUVs
+ , pointSizes
+ , pointVAO
+ , contourPositions
+ , contourVAO)
+
+ mesh.update(params)
+
+ return mesh
+}
+
+module.exports = createSimplicialMesh
+
+},{"./closest-point":232,"./shaders":234,"colormap":114,"gl-buffer":230,"gl-mat4/invert":254,"gl-mat4/multiply":256,"gl-shader":288,"gl-texture2d":305,"gl-vao":310,"ndarray":433,"normals":436,"simplicial-complex-contour":494,"typedarray-pool":522}],234:[function(_dereq_,module,exports){
+var glslify = _dereq_('glslify')
+
+var triVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nfloat inverse(float m) {\n return 1.0 / m;\n}\n\nmat2 inverse(mat2 m) {\n return mat2(m[1][1],-m[0][1],\n -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n}\n\nmat3 inverse(mat3 m) {\n float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n float b01 = a22 * a11 - a12 * a21;\n float b11 = -a22 * a10 + a12 * a20;\n float b21 = a21 * a10 - a11 * a20;\n\n float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n}\n\nmat4 inverse(mat4 m) {\n float\n a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n b00 = a00 * a11 - a01 * a10,\n b01 = a00 * a12 - a02 * a10,\n b02 = a00 * a13 - a03 * a10,\n b03 = a01 * a12 - a02 * a11,\n b04 = a01 * a13 - a03 * a11,\n b05 = a02 * a13 - a03 * a12,\n b06 = a20 * a31 - a21 * a30,\n b07 = a20 * a32 - a22 * a30,\n b08 = a20 * a33 - a23 * a30,\n b09 = a21 * a32 - a22 * a31,\n b10 = a21 * a33 - a23 * a31,\n b11 = a22 * a33 - a23 * a32,\n\n det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n return mat4(\n a11 * b11 - a12 * b10 + a13 * b09,\n a02 * b10 - a01 * b11 - a03 * b09,\n a31 * b05 - a32 * b04 + a33 * b03,\n a22 * b04 - a21 * b05 - a23 * b03,\n a12 * b08 - a10 * b11 - a13 * b07,\n a00 * b11 - a02 * b08 + a03 * b07,\n a32 * b02 - a30 * b05 - a33 * b01,\n a20 * b05 - a22 * b02 + a23 * b01,\n a10 * b10 - a11 * b08 + a13 * b06,\n a01 * b08 - a00 * b10 - a03 * b06,\n a30 * b04 - a31 * b02 + a33 * b00,\n a21 * b02 - a20 * b04 - a23 * b00,\n a11 * b07 - a10 * b09 - a12 * b06,\n a00 * b09 - a01 * b07 + a02 * b06,\n a31 * b01 - a30 * b03 - a32 * b00,\n a20 * b03 - a21 * b01 + a22 * b00) / det;\n}\n\nvec3 getOrthogonalVector(vec3 v) {\n // Return up-vector for only-z vector.\n // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n // From the above if-statement we have ||a|| > 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n// segment + 0 top vertex\n// segment + 1 perimeter vertex a+1\n// segment + 2 perimeter vertex a\n// segment + 3 center base vertex\n// segment + 4 perimeter vertex a\n// segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float index, float coneOffset, out vec3 normal) {\n\n const float segmentCount = 8.0;\n\n index = mod(index, segmentCount * 6.0);\n\n float segment = floor(index/6.0);\n float segmentIndex = index - (segment*6.0);\n\n normal = -normalize(d);\n\n if (segmentIndex == 3.0) {\n return mix(vec3(0.0), -d, coneOffset);\n }\n\n // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)\n float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);\n float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n vec3 v1 = mix(d, vec3(0.0), coneOffset);\n vec3 v2 = v1 - d;\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d)*0.25;\n vec3 y = v * sin(angle) * length(d)*0.25;\n vec3 v3 = v2 + x + y;\n if (segmentIndex <= 2.0) {\n vec3 tx = u * sin(angle);\n vec3 ty = v * -cos(angle);\n vec3 tangent = tx + ty;\n normal = normalize(cross(v3 - v1, tangent));\n }\n\n if (segmentIndex == 0.0) {\n return mix(d, vec3(0.0), coneOffset);\n }\n return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\nuniform float vectorScale;\nuniform float coneScale;\n\nuniform float coneOffset;\n\nuniform mat4 model\n , view\n , projection;\nuniform vec3 eyePosition\n , lightPosition;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data\n , f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n // Scale the vector magnitude to stay constant with\n // model & view changes.\n vec3 normal;\n vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal);\n vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n normal = normalize(normal * inverse(mat3(model)));\n\n // vec4 m_position = model * vec4(conePosition, 1.0);\n vec4 t_position = view * conePosition;\n gl_Position = projection * t_position;\n f_color = color; //vec4(position.w, color.r, 0, 0);\n f_normal = normal;\n f_data = conePosition.xyz;\n f_position = position.xyz;\n f_eyeDirection = eyePosition - conePosition.xyz;\n f_lightDirection = lightPosition - conePosition.xyz;\n f_uv = uv;\n}\n"])
+var triFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n float NdotH = max(x, 0.0001);\n float cos2Alpha = NdotH * NdotH;\n float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n float roughness2 = roughness * roughness;\n float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n vec3 lightDirection,\n vec3 viewDirection,\n vec3 surfaceNormal,\n float roughness,\n float fresnel) {\n\n float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n //Half angle vector\n vec3 H = normalize(lightDirection + viewDirection);\n\n //Geometric term\n float NdotH = max(dot(surfaceNormal, H), 0.0);\n float VdotH = max(dot(viewDirection, H), 0.000001);\n float LdotH = max(dot(lightDirection, H), 0.000001);\n float G1 = (2.0 * NdotH * VdotN) / VdotH;\n float G2 = (2.0 * NdotH * LdotN) / LdotH;\n float G = min(1.0, min(G1, G2));\n \n //Distribution term\n float D = beckmannDistribution(NdotH, roughness);\n\n //Fresnel term\n float F = pow(1.0 - VdotN, fresnel);\n\n //Multiply terms and done\n return G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n , fresnel\n , kambient\n , kdiffuse\n , kspecular\n , opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data\n , f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n\n if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n vec3 N = normalize(f_normal);\n vec3 L = normalize(f_lightDirection);\n vec3 V = normalize(f_eyeDirection);\n\n if(!gl_FrontFacing) {\n N = -N;\n }\n\n float specular = cookTorranceSpecular(L, V, N, roughness, fresnel);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n vec4 surfaceColor = texture2D(texture, f_uv);\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = litColor * opacity;\n}"])
+var pickVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n // Return up-vector for only-z vector.\n // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n // From the above if-statement we have ||a|| > 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n// segment + 0 top vertex\n// segment + 1 perimeter vertex a+1\n// segment + 2 perimeter vertex a\n// segment + 3 center base vertex\n// segment + 4 perimeter vertex a\n// segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float index, float coneOffset, out vec3 normal) {\n\n const float segmentCount = 8.0;\n\n index = mod(index, segmentCount * 6.0);\n\n float segment = floor(index/6.0);\n float segmentIndex = index - (segment*6.0);\n\n normal = -normalize(d);\n\n if (segmentIndex == 3.0) {\n return mix(vec3(0.0), -d, coneOffset);\n }\n\n // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)\n float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);\n float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n vec3 v1 = mix(d, vec3(0.0), coneOffset);\n vec3 v2 = v1 - d;\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d)*0.25;\n vec3 y = v * sin(angle) * length(d)*0.25;\n vec3 v3 = v2 + x + y;\n if (segmentIndex <= 2.0) {\n vec3 tx = u * sin(angle);\n vec3 ty = v * -cos(angle);\n vec3 tangent = tx + ty;\n normal = normalize(cross(v3 - v1, tangent));\n }\n\n if (segmentIndex == 0.0) {\n return mix(d, vec3(0.0), coneOffset);\n }\n return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nuniform float vectorScale;\nuniform float coneScale;\nuniform float coneOffset;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n vec3 normal;\n vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal);\n vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n gl_Position = projection * view * conePosition;\n f_id = id;\n f_position = position.xyz;\n}\n"])
+var pickFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"])
+
+exports.meshShader = {
+ vertex: triVertSrc,
+ fragment: triFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec4'},
+ {name: 'normal', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'uv', type: 'vec2'},
+ {name: 'vector', type: 'vec3'}
+ ]
+}
+exports.pickShader = {
+ vertex: pickVertSrc,
+ fragment: pickFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec4'},
+ {name: 'id', type: 'vec4'},
+ {name: 'vector', type: 'vec3'}
+ ]
+}
+
+},{"glslify":392}],235:[function(_dereq_,module,exports){
+module.exports = {
+ 0: 'NONE',
+ 1: 'ONE',
+ 2: 'LINE_LOOP',
+ 3: 'LINE_STRIP',
+ 4: 'TRIANGLES',
+ 5: 'TRIANGLE_STRIP',
+ 6: 'TRIANGLE_FAN',
+ 256: 'DEPTH_BUFFER_BIT',
+ 512: 'NEVER',
+ 513: 'LESS',
+ 514: 'EQUAL',
+ 515: 'LEQUAL',
+ 516: 'GREATER',
+ 517: 'NOTEQUAL',
+ 518: 'GEQUAL',
+ 519: 'ALWAYS',
+ 768: 'SRC_COLOR',
+ 769: 'ONE_MINUS_SRC_COLOR',
+ 770: 'SRC_ALPHA',
+ 771: 'ONE_MINUS_SRC_ALPHA',
+ 772: 'DST_ALPHA',
+ 773: 'ONE_MINUS_DST_ALPHA',
+ 774: 'DST_COLOR',
+ 775: 'ONE_MINUS_DST_COLOR',
+ 776: 'SRC_ALPHA_SATURATE',
+ 1024: 'STENCIL_BUFFER_BIT',
+ 1028: 'FRONT',
+ 1029: 'BACK',
+ 1032: 'FRONT_AND_BACK',
+ 1280: 'INVALID_ENUM',
+ 1281: 'INVALID_VALUE',
+ 1282: 'INVALID_OPERATION',
+ 1285: 'OUT_OF_MEMORY',
+ 1286: 'INVALID_FRAMEBUFFER_OPERATION',
+ 2304: 'CW',
+ 2305: 'CCW',
+ 2849: 'LINE_WIDTH',
+ 2884: 'CULL_FACE',
+ 2885: 'CULL_FACE_MODE',
+ 2886: 'FRONT_FACE',
+ 2928: 'DEPTH_RANGE',
+ 2929: 'DEPTH_TEST',
+ 2930: 'DEPTH_WRITEMASK',
+ 2931: 'DEPTH_CLEAR_VALUE',
+ 2932: 'DEPTH_FUNC',
+ 2960: 'STENCIL_TEST',
+ 2961: 'STENCIL_CLEAR_VALUE',
+ 2962: 'STENCIL_FUNC',
+ 2963: 'STENCIL_VALUE_MASK',
+ 2964: 'STENCIL_FAIL',
+ 2965: 'STENCIL_PASS_DEPTH_FAIL',
+ 2966: 'STENCIL_PASS_DEPTH_PASS',
+ 2967: 'STENCIL_REF',
+ 2968: 'STENCIL_WRITEMASK',
+ 2978: 'VIEWPORT',
+ 3024: 'DITHER',
+ 3042: 'BLEND',
+ 3088: 'SCISSOR_BOX',
+ 3089: 'SCISSOR_TEST',
+ 3106: 'COLOR_CLEAR_VALUE',
+ 3107: 'COLOR_WRITEMASK',
+ 3317: 'UNPACK_ALIGNMENT',
+ 3333: 'PACK_ALIGNMENT',
+ 3379: 'MAX_TEXTURE_SIZE',
+ 3386: 'MAX_VIEWPORT_DIMS',
+ 3408: 'SUBPIXEL_BITS',
+ 3410: 'RED_BITS',
+ 3411: 'GREEN_BITS',
+ 3412: 'BLUE_BITS',
+ 3413: 'ALPHA_BITS',
+ 3414: 'DEPTH_BITS',
+ 3415: 'STENCIL_BITS',
+ 3553: 'TEXTURE_2D',
+ 4352: 'DONT_CARE',
+ 4353: 'FASTEST',
+ 4354: 'NICEST',
+ 5120: 'BYTE',
+ 5121: 'UNSIGNED_BYTE',
+ 5122: 'SHORT',
+ 5123: 'UNSIGNED_SHORT',
+ 5124: 'INT',
+ 5125: 'UNSIGNED_INT',
+ 5126: 'FLOAT',
+ 5386: 'INVERT',
+ 5890: 'TEXTURE',
+ 6401: 'STENCIL_INDEX',
+ 6402: 'DEPTH_COMPONENT',
+ 6406: 'ALPHA',
+ 6407: 'RGB',
+ 6408: 'RGBA',
+ 6409: 'LUMINANCE',
+ 6410: 'LUMINANCE_ALPHA',
+ 7680: 'KEEP',
+ 7681: 'REPLACE',
+ 7682: 'INCR',
+ 7683: 'DECR',
+ 7936: 'VENDOR',
+ 7937: 'RENDERER',
+ 7938: 'VERSION',
+ 9728: 'NEAREST',
+ 9729: 'LINEAR',
+ 9984: 'NEAREST_MIPMAP_NEAREST',
+ 9985: 'LINEAR_MIPMAP_NEAREST',
+ 9986: 'NEAREST_MIPMAP_LINEAR',
+ 9987: 'LINEAR_MIPMAP_LINEAR',
+ 10240: 'TEXTURE_MAG_FILTER',
+ 10241: 'TEXTURE_MIN_FILTER',
+ 10242: 'TEXTURE_WRAP_S',
+ 10243: 'TEXTURE_WRAP_T',
+ 10497: 'REPEAT',
+ 10752: 'POLYGON_OFFSET_UNITS',
+ 16384: 'COLOR_BUFFER_BIT',
+ 32769: 'CONSTANT_COLOR',
+ 32770: 'ONE_MINUS_CONSTANT_COLOR',
+ 32771: 'CONSTANT_ALPHA',
+ 32772: 'ONE_MINUS_CONSTANT_ALPHA',
+ 32773: 'BLEND_COLOR',
+ 32774: 'FUNC_ADD',
+ 32777: 'BLEND_EQUATION_RGB',
+ 32778: 'FUNC_SUBTRACT',
+ 32779: 'FUNC_REVERSE_SUBTRACT',
+ 32819: 'UNSIGNED_SHORT_4_4_4_4',
+ 32820: 'UNSIGNED_SHORT_5_5_5_1',
+ 32823: 'POLYGON_OFFSET_FILL',
+ 32824: 'POLYGON_OFFSET_FACTOR',
+ 32854: 'RGBA4',
+ 32855: 'RGB5_A1',
+ 32873: 'TEXTURE_BINDING_2D',
+ 32926: 'SAMPLE_ALPHA_TO_COVERAGE',
+ 32928: 'SAMPLE_COVERAGE',
+ 32936: 'SAMPLE_BUFFERS',
+ 32937: 'SAMPLES',
+ 32938: 'SAMPLE_COVERAGE_VALUE',
+ 32939: 'SAMPLE_COVERAGE_INVERT',
+ 32968: 'BLEND_DST_RGB',
+ 32969: 'BLEND_SRC_RGB',
+ 32970: 'BLEND_DST_ALPHA',
+ 32971: 'BLEND_SRC_ALPHA',
+ 33071: 'CLAMP_TO_EDGE',
+ 33170: 'GENERATE_MIPMAP_HINT',
+ 33189: 'DEPTH_COMPONENT16',
+ 33306: 'DEPTH_STENCIL_ATTACHMENT',
+ 33635: 'UNSIGNED_SHORT_5_6_5',
+ 33648: 'MIRRORED_REPEAT',
+ 33901: 'ALIASED_POINT_SIZE_RANGE',
+ 33902: 'ALIASED_LINE_WIDTH_RANGE',
+ 33984: 'TEXTURE0',
+ 33985: 'TEXTURE1',
+ 33986: 'TEXTURE2',
+ 33987: 'TEXTURE3',
+ 33988: 'TEXTURE4',
+ 33989: 'TEXTURE5',
+ 33990: 'TEXTURE6',
+ 33991: 'TEXTURE7',
+ 33992: 'TEXTURE8',
+ 33993: 'TEXTURE9',
+ 33994: 'TEXTURE10',
+ 33995: 'TEXTURE11',
+ 33996: 'TEXTURE12',
+ 33997: 'TEXTURE13',
+ 33998: 'TEXTURE14',
+ 33999: 'TEXTURE15',
+ 34000: 'TEXTURE16',
+ 34001: 'TEXTURE17',
+ 34002: 'TEXTURE18',
+ 34003: 'TEXTURE19',
+ 34004: 'TEXTURE20',
+ 34005: 'TEXTURE21',
+ 34006: 'TEXTURE22',
+ 34007: 'TEXTURE23',
+ 34008: 'TEXTURE24',
+ 34009: 'TEXTURE25',
+ 34010: 'TEXTURE26',
+ 34011: 'TEXTURE27',
+ 34012: 'TEXTURE28',
+ 34013: 'TEXTURE29',
+ 34014: 'TEXTURE30',
+ 34015: 'TEXTURE31',
+ 34016: 'ACTIVE_TEXTURE',
+ 34024: 'MAX_RENDERBUFFER_SIZE',
+ 34041: 'DEPTH_STENCIL',
+ 34055: 'INCR_WRAP',
+ 34056: 'DECR_WRAP',
+ 34067: 'TEXTURE_CUBE_MAP',
+ 34068: 'TEXTURE_BINDING_CUBE_MAP',
+ 34069: 'TEXTURE_CUBE_MAP_POSITIVE_X',
+ 34070: 'TEXTURE_CUBE_MAP_NEGATIVE_X',
+ 34071: 'TEXTURE_CUBE_MAP_POSITIVE_Y',
+ 34072: 'TEXTURE_CUBE_MAP_NEGATIVE_Y',
+ 34073: 'TEXTURE_CUBE_MAP_POSITIVE_Z',
+ 34074: 'TEXTURE_CUBE_MAP_NEGATIVE_Z',
+ 34076: 'MAX_CUBE_MAP_TEXTURE_SIZE',
+ 34338: 'VERTEX_ATTRIB_ARRAY_ENABLED',
+ 34339: 'VERTEX_ATTRIB_ARRAY_SIZE',
+ 34340: 'VERTEX_ATTRIB_ARRAY_STRIDE',
+ 34341: 'VERTEX_ATTRIB_ARRAY_TYPE',
+ 34342: 'CURRENT_VERTEX_ATTRIB',
+ 34373: 'VERTEX_ATTRIB_ARRAY_POINTER',
+ 34466: 'NUM_COMPRESSED_TEXTURE_FORMATS',
+ 34467: 'COMPRESSED_TEXTURE_FORMATS',
+ 34660: 'BUFFER_SIZE',
+ 34661: 'BUFFER_USAGE',
+ 34816: 'STENCIL_BACK_FUNC',
+ 34817: 'STENCIL_BACK_FAIL',
+ 34818: 'STENCIL_BACK_PASS_DEPTH_FAIL',
+ 34819: 'STENCIL_BACK_PASS_DEPTH_PASS',
+ 34877: 'BLEND_EQUATION_ALPHA',
+ 34921: 'MAX_VERTEX_ATTRIBS',
+ 34922: 'VERTEX_ATTRIB_ARRAY_NORMALIZED',
+ 34930: 'MAX_TEXTURE_IMAGE_UNITS',
+ 34962: 'ARRAY_BUFFER',
+ 34963: 'ELEMENT_ARRAY_BUFFER',
+ 34964: 'ARRAY_BUFFER_BINDING',
+ 34965: 'ELEMENT_ARRAY_BUFFER_BINDING',
+ 34975: 'VERTEX_ATTRIB_ARRAY_BUFFER_BINDING',
+ 35040: 'STREAM_DRAW',
+ 35044: 'STATIC_DRAW',
+ 35048: 'DYNAMIC_DRAW',
+ 35632: 'FRAGMENT_SHADER',
+ 35633: 'VERTEX_SHADER',
+ 35660: 'MAX_VERTEX_TEXTURE_IMAGE_UNITS',
+ 35661: 'MAX_COMBINED_TEXTURE_IMAGE_UNITS',
+ 35663: 'SHADER_TYPE',
+ 35664: 'FLOAT_VEC2',
+ 35665: 'FLOAT_VEC3',
+ 35666: 'FLOAT_VEC4',
+ 35667: 'INT_VEC2',
+ 35668: 'INT_VEC3',
+ 35669: 'INT_VEC4',
+ 35670: 'BOOL',
+ 35671: 'BOOL_VEC2',
+ 35672: 'BOOL_VEC3',
+ 35673: 'BOOL_VEC4',
+ 35674: 'FLOAT_MAT2',
+ 35675: 'FLOAT_MAT3',
+ 35676: 'FLOAT_MAT4',
+ 35678: 'SAMPLER_2D',
+ 35680: 'SAMPLER_CUBE',
+ 35712: 'DELETE_STATUS',
+ 35713: 'COMPILE_STATUS',
+ 35714: 'LINK_STATUS',
+ 35715: 'VALIDATE_STATUS',
+ 35716: 'INFO_LOG_LENGTH',
+ 35717: 'ATTACHED_SHADERS',
+ 35718: 'ACTIVE_UNIFORMS',
+ 35719: 'ACTIVE_UNIFORM_MAX_LENGTH',
+ 35720: 'SHADER_SOURCE_LENGTH',
+ 35721: 'ACTIVE_ATTRIBUTES',
+ 35722: 'ACTIVE_ATTRIBUTE_MAX_LENGTH',
+ 35724: 'SHADING_LANGUAGE_VERSION',
+ 35725: 'CURRENT_PROGRAM',
+ 36003: 'STENCIL_BACK_REF',
+ 36004: 'STENCIL_BACK_VALUE_MASK',
+ 36005: 'STENCIL_BACK_WRITEMASK',
+ 36006: 'FRAMEBUFFER_BINDING',
+ 36007: 'RENDERBUFFER_BINDING',
+ 36048: 'FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
+ 36049: 'FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
+ 36050: 'FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',
+ 36051: 'FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
+ 36053: 'FRAMEBUFFER_COMPLETE',
+ 36054: 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT',
+ 36055: 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',
+ 36057: 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS',
+ 36061: 'FRAMEBUFFER_UNSUPPORTED',
+ 36064: 'COLOR_ATTACHMENT0',
+ 36096: 'DEPTH_ATTACHMENT',
+ 36128: 'STENCIL_ATTACHMENT',
+ 36160: 'FRAMEBUFFER',
+ 36161: 'RENDERBUFFER',
+ 36162: 'RENDERBUFFER_WIDTH',
+ 36163: 'RENDERBUFFER_HEIGHT',
+ 36164: 'RENDERBUFFER_INTERNAL_FORMAT',
+ 36168: 'STENCIL_INDEX8',
+ 36176: 'RENDERBUFFER_RED_SIZE',
+ 36177: 'RENDERBUFFER_GREEN_SIZE',
+ 36178: 'RENDERBUFFER_BLUE_SIZE',
+ 36179: 'RENDERBUFFER_ALPHA_SIZE',
+ 36180: 'RENDERBUFFER_DEPTH_SIZE',
+ 36181: 'RENDERBUFFER_STENCIL_SIZE',
+ 36194: 'RGB565',
+ 36336: 'LOW_FLOAT',
+ 36337: 'MEDIUM_FLOAT',
+ 36338: 'HIGH_FLOAT',
+ 36339: 'LOW_INT',
+ 36340: 'MEDIUM_INT',
+ 36341: 'HIGH_INT',
+ 36346: 'SHADER_COMPILER',
+ 36347: 'MAX_VERTEX_UNIFORM_VECTORS',
+ 36348: 'MAX_VARYING_VECTORS',
+ 36349: 'MAX_FRAGMENT_UNIFORM_VECTORS',
+ 37440: 'UNPACK_FLIP_Y_WEBGL',
+ 37441: 'UNPACK_PREMULTIPLY_ALPHA_WEBGL',
+ 37442: 'CONTEXT_LOST_WEBGL',
+ 37443: 'UNPACK_COLORSPACE_CONVERSION_WEBGL',
+ 37444: 'BROWSER_DEFAULT_WEBGL'
+}
+
+},{}],236:[function(_dereq_,module,exports){
+var gl10 = _dereq_('./1.0/numbers')
+
+module.exports = function lookupConstant (number) {
+ return gl10[number]
+}
+
+},{"./1.0/numbers":235}],237:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createErrorBars
+
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createShader = _dereq_('./shaders/index')
+
+var IDENTITY = [1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1]
+
+function ErrorBars(gl, buffer, vao, shader) {
+ this.gl = gl
+ this.shader = shader
+ this.buffer = buffer
+ this.vao = vao
+ this.pixelRatio = 1
+ this.bounds = [[ Infinity, Infinity, Infinity], [-Infinity,-Infinity,-Infinity]]
+ this.clipBounds = [[-Infinity,-Infinity,-Infinity], [ Infinity, Infinity, Infinity]]
+ this.lineWidth = [1,1,1]
+ this.capSize = [10,10,10]
+ this.lineCount = [0,0,0]
+ this.lineOffset = [0,0,0]
+ this.opacity = 1
+}
+
+var proto = ErrorBars.prototype
+
+proto.isOpaque = function() {
+ return this.opacity >= 1
+}
+
+proto.isTransparent = function() {
+ return this.opacity < 1
+}
+
+proto.drawTransparent = proto.draw = function(cameraParams) {
+ var gl = this.gl
+ var uniforms = this.shader.uniforms
+
+ this.shader.bind()
+ var view = uniforms.view = cameraParams.view || IDENTITY
+ var projection = uniforms.projection = cameraParams.projection || IDENTITY
+ uniforms.model = cameraParams.model || IDENTITY
+ uniforms.clipBounds = this.clipBounds
+ uniforms.opacity = this.opacity
+
+
+ var cx = view[12]
+ var cy = view[13]
+ var cz = view[14]
+ var cw = view[15]
+ var pixelScaleF = this.pixelRatio * (projection[3]*cx + projection[7]*cy + projection[11]*cz + projection[15]*cw) / gl.drawingBufferHeight
+
+ this.vao.bind()
+ for(var i=0; i<3; ++i) {
+ gl.lineWidth(this.lineWidth[i])
+ uniforms.capSize = this.capSize[i] * pixelScaleF
+ if (this.lineCount[i]) {
+ gl.drawArrays(gl.LINES, this.lineOffset[i], this.lineCount[i])
+ }
+ }
+ this.vao.unbind()
+}
+
+function updateBounds(bounds, point) {
+ for(var i=0; i<3; ++i) {
+ bounds[0][i] = Math.min(bounds[0][i], point[i])
+ bounds[1][i] = Math.max(bounds[1][i], point[i])
+ }
+}
+
+var FACE_TABLE = (function(){
+ var table = new Array(3)
+ for(var d=0; d<3; ++d) {
+ var row = []
+ for(var j=1; j<=2; ++j) {
+ for(var s=-1; s<=1; s+=2) {
+ var u = (j+d) % 3
+ var y = [0,0,0]
+ y[u] = s
+ row.push(y)
+ }
+ }
+ table[d] = row
+ }
+ return table
+})()
+
+
+function emitFace(verts, x, c, d) {
+ var offsets = FACE_TABLE[d]
+ for(var i=0; i 0) {
+ var x = p.slice()
+ x[j] += e[1][j]
+ verts.push(p[0], p[1], p[2],
+ c[0], c[1], c[2], c[3],
+ 0, 0, 0,
+ x[0], x[1], x[2],
+ c[0], c[1], c[2], c[3],
+ 0, 0, 0)
+ updateBounds(this.bounds, x)
+ vertexCount += 2 + emitFace(verts, x, c, j)
+ }
+ }
+ this.lineCount[j] = vertexCount - this.lineOffset[j]
+ }
+ this.buffer.update(verts)
+ }
+}
+
+proto.dispose = function() {
+ this.shader.dispose()
+ this.buffer.dispose()
+ this.vao.dispose()
+}
+
+function createErrorBars(options) {
+ var gl = options.gl
+ var buffer = createBuffer(gl)
+ var vao = createVAO(gl, [
+ {
+ buffer: buffer,
+ type: gl.FLOAT,
+ size: 3,
+ offset: 0,
+ stride: 40
+ },
+ {
+ buffer: buffer,
+ type: gl.FLOAT,
+ size: 4,
+ offset: 12,
+ stride: 40
+ },
+ {
+ buffer: buffer,
+ type: gl.FLOAT,
+ size: 3,
+ offset: 28,
+ stride: 40
+ }
+ ])
+
+ var shader = createShader(gl)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 1
+ shader.attributes.offset.location = 2
+
+ var result = new ErrorBars(gl, buffer, vao, shader)
+ result.update(options)
+ return result
+}
+
+},{"./shaders/index":238,"gl-buffer":230,"gl-vao":310}],238:[function(_dereq_,module,exports){
+'use strict'
+
+var glslify = _dereq_('glslify')
+var createShader = _dereq_('gl-shader')
+
+var vertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, offset;\nattribute vec4 color;\nuniform mat4 model, view, projection;\nuniform float capSize;\nvarying vec4 fragColor;\nvarying vec3 fragPosition;\n\nvoid main() {\n vec4 worldPosition = model * vec4(position, 1.0);\n worldPosition = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);\n gl_Position = projection * view * worldPosition;\n fragColor = color;\n fragPosition = position;\n}"])
+var fragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float opacity;\nvarying vec3 fragPosition;\nvarying vec4 fragColor;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], fragPosition)) discard;\n\n gl_FragColor = opacity * fragColor;\n}"])
+
+module.exports = function(gl) {
+ return createShader(gl, vertSrc, fragSrc, null, [
+ {name: 'position', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'offset', type: 'vec3'}
+ ])
+}
+
+},{"gl-shader":288,"glslify":392}],239:[function(_dereq_,module,exports){
+'use strict'
+
+var createTexture = _dereq_('gl-texture2d')
+
+module.exports = createFBO
+
+var colorAttachmentArrays = null
+var FRAMEBUFFER_UNSUPPORTED
+var FRAMEBUFFER_INCOMPLETE_ATTACHMENT
+var FRAMEBUFFER_INCOMPLETE_DIMENSIONS
+var FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
+
+function saveFBOState(gl) {
+ var fbo = gl.getParameter(gl.FRAMEBUFFER_BINDING)
+ var rbo = gl.getParameter(gl.RENDERBUFFER_BINDING)
+ var tex = gl.getParameter(gl.TEXTURE_BINDING_2D)
+ return [fbo, rbo, tex]
+}
+
+function restoreFBOState(gl, data) {
+ gl.bindFramebuffer(gl.FRAMEBUFFER, data[0])
+ gl.bindRenderbuffer(gl.RENDERBUFFER, data[1])
+ gl.bindTexture(gl.TEXTURE_2D, data[2])
+}
+
+function lazyInitColorAttachments(gl, ext) {
+ var maxColorAttachments = gl.getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL)
+ colorAttachmentArrays = new Array(maxColorAttachments + 1)
+ for(var i=0; i<=maxColorAttachments; ++i) {
+ var x = new Array(maxColorAttachments)
+ for(var j=0; j 1) {
+ ext.drawBuffersWEBGL(colorAttachmentArrays[numColors])
+ }
+
+ //Allocate depth/stencil buffers
+ var WEBGL_depth_texture = gl.getExtension('WEBGL_depth_texture')
+ if(WEBGL_depth_texture) {
+ if(useStencil) {
+ fbo.depth = initTexture(gl, width, height,
+ WEBGL_depth_texture.UNSIGNED_INT_24_8_WEBGL,
+ gl.DEPTH_STENCIL,
+ gl.DEPTH_STENCIL_ATTACHMENT)
+ } else if(useDepth) {
+ fbo.depth = initTexture(gl, width, height,
+ gl.UNSIGNED_SHORT,
+ gl.DEPTH_COMPONENT,
+ gl.DEPTH_ATTACHMENT)
+ }
+ } else {
+ if(useDepth && useStencil) {
+ fbo._depth_rb = initRenderBuffer(gl, width, height, gl.DEPTH_STENCIL, gl.DEPTH_STENCIL_ATTACHMENT)
+ } else if(useDepth) {
+ fbo._depth_rb = initRenderBuffer(gl, width, height, gl.DEPTH_COMPONENT16, gl.DEPTH_ATTACHMENT)
+ } else if(useStencil) {
+ fbo._depth_rb = initRenderBuffer(gl, width, height, gl.STENCIL_INDEX, gl.STENCIL_ATTACHMENT)
+ }
+ }
+
+ //Check frame buffer state
+ var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER)
+ if(status !== gl.FRAMEBUFFER_COMPLETE) {
+
+ //Release all partially allocated resources
+ fbo._destroyed = true
+
+ //Release all resources
+ gl.bindFramebuffer(gl.FRAMEBUFFER, null)
+ gl.deleteFramebuffer(fbo.handle)
+ fbo.handle = null
+ if(fbo.depth) {
+ fbo.depth.dispose()
+ fbo.depth = null
+ }
+ if(fbo._depth_rb) {
+ gl.deleteRenderbuffer(fbo._depth_rb)
+ fbo._depth_rb = null
+ }
+ for(var i=0; i maxFBOSize ||
+ h < 0 || h > maxFBOSize) {
+ throw new Error('gl-fbo: Can\'t resize FBO, invalid dimensions')
+ }
+
+ //Update shape
+ fbo._shape[0] = w
+ fbo._shape[1] = h
+
+ //Save framebuffer state
+ var state = saveFBOState(gl)
+
+ //Resize framebuffer attachments
+ for(var i=0; i maxFBOSize || height < 0 || height > maxFBOSize) {
+ throw new Error('gl-fbo: Parameters are too large for FBO')
+ }
+
+ //Handle each option type
+ options = options || {}
+
+ //Figure out number of color buffers to use
+ var numColors = 1
+ if('color' in options) {
+ numColors = Math.max(options.color|0, 0)
+ if(numColors < 0) {
+ throw new Error('gl-fbo: Must specify a nonnegative number of colors')
+ }
+ if(numColors > 1) {
+ //Check if multiple render targets supported
+ if(!WEBGL_draw_buffers) {
+ throw new Error('gl-fbo: Multiple draw buffer extension not supported')
+ } else if(numColors > gl.getParameter(WEBGL_draw_buffers.MAX_COLOR_ATTACHMENTS_WEBGL)) {
+ throw new Error('gl-fbo: Context does not support ' + numColors + ' draw buffers')
+ }
+ }
+ }
+
+ //Determine whether to use floating point textures
+ var colorType = gl.UNSIGNED_BYTE
+ var OES_texture_float = gl.getExtension('OES_texture_float')
+ if(options.float && numColors > 0) {
+ if(!OES_texture_float) {
+ throw new Error('gl-fbo: Context does not support floating point textures')
+ }
+ colorType = gl.FLOAT
+ } else if(options.preferFloat && numColors > 0) {
+ if(OES_texture_float) {
+ colorType = gl.FLOAT
+ }
+ }
+
+ //Check if we should use depth buffer
+ var useDepth = true
+ if('depth' in options) {
+ useDepth = !!options.depth
+ }
+
+ //Check if we should use a stencil buffer
+ var useStencil = false
+ if('stencil' in options) {
+ useStencil = !!options.stencil
+ }
+
+ return new Framebuffer(
+ gl,
+ width,
+ height,
+ colorType,
+ numColors,
+ useDepth,
+ useStencil,
+ WEBGL_draw_buffers)
+}
+
+},{"gl-texture2d":305}],240:[function(_dereq_,module,exports){
+
+var sprintf = _dereq_('sprintf-js').sprintf;
+var glConstants = _dereq_('gl-constants/lookup');
+var shaderName = _dereq_('glsl-shader-name');
+var addLineNumbers = _dereq_('add-line-numbers');
+
+module.exports = formatCompilerError;
+
+function formatCompilerError(errLog, src, type) {
+ "use strict";
+
+ var name = shaderName(src) || 'of unknown name (see npm glsl-shader-name)';
+
+ var typeName = 'unknown type';
+ if (type !== undefined) {
+ typeName = type === glConstants.FRAGMENT_SHADER ? 'fragment' : 'vertex'
+ }
+
+ var longForm = sprintf('Error compiling %s shader %s:\n', typeName, name);
+ var shortForm = sprintf("%s%s", longForm, errLog);
+
+ var errorStrings = errLog.split('\n');
+ var errors = {};
+
+ for (var i = 0; i < errorStrings.length; i++) {
+ var errorString = errorStrings[i];
+ if (errorString === '' || errorString === "\0") continue;
+ var lineNo = parseInt(errorString.split(':')[2]);
+ if (isNaN(lineNo)) {
+ throw new Error(sprintf('Could not parse error: %s', errorString));
+ }
+ errors[lineNo] = errorString;
+ }
+
+ var lines = addLineNumbers(src).split('\n');
+
+ for (var i = 0; i < lines.length; i++) {
+ if (!errors[i+3] && !errors[i+2] && !errors[i+1]) continue;
+ var line = lines[i];
+ longForm += line + '\n';
+ if (errors[i+1]) {
+ var e = errors[i+1];
+ e = e.substr(e.split(':', 3).join(':').length + 1).trim();
+ longForm += sprintf('^^^ %s\n\n', e);
+ }
+ }
+
+ return {
+ long: longForm.trim(),
+ short: shortForm.trim()
+ };
+}
+
+
+},{"add-line-numbers":49,"gl-constants/lookup":236,"glsl-shader-name":384,"sprintf-js":504}],241:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createHeatmap2D
+
+var bsearch = _dereq_('binary-search-bounds')
+var iota = _dereq_('iota-array')
+var pool = _dereq_('typedarray-pool')
+var createShader = _dereq_('gl-shader')
+var createBuffer = _dereq_('gl-buffer')
+
+var shaders = _dereq_('./lib/shaders')
+
+function GLHeatmap2D (
+ plot,
+ shader,
+ pickShader,
+ positionBuffer,
+ weightBuffer,
+ colorBuffer,
+ idBuffer) {
+ this.plot = plot
+ this.shader = shader
+ this.pickShader = pickShader
+ this.positionBuffer = positionBuffer
+ this.weightBuffer = weightBuffer
+ this.colorBuffer = colorBuffer
+ this.idBuffer = idBuffer
+ this.xData = []
+ this.yData = []
+ this.shape = [0, 0]
+ this.bounds = [Infinity, Infinity, -Infinity, -Infinity]
+ this.pickOffset = 0
+}
+
+var proto = GLHeatmap2D.prototype
+
+var WEIGHTS = [
+ 0, 0,
+ 1, 0,
+ 0, 1,
+ 1, 0,
+ 1, 1,
+ 0, 1
+]
+
+proto.draw = (function () {
+ var MATRIX = [
+ 1, 0, 0,
+ 0, 1, 0,
+ 0, 0, 1
+ ]
+
+ return function () {
+ var plot = this.plot
+ var shader = this.shader
+ var bounds = this.bounds
+ var numVertices = this.numVertices
+
+ if (numVertices <= 0) {
+ return
+ }
+
+ var gl = plot.gl
+ var dataBox = plot.dataBox
+
+ var boundX = bounds[2] - bounds[0]
+ var boundY = bounds[3] - bounds[1]
+ var dataX = dataBox[2] - dataBox[0]
+ var dataY = dataBox[3] - dataBox[1]
+
+ MATRIX[0] = 2.0 * boundX / dataX
+ MATRIX[4] = 2.0 * boundY / dataY
+ MATRIX[6] = 2.0 * (bounds[0] - dataBox[0]) / dataX - 1.0
+ MATRIX[7] = 2.0 * (bounds[1] - dataBox[1]) / dataY - 1.0
+
+ shader.bind()
+
+ var uniforms = shader.uniforms
+ uniforms.viewTransform = MATRIX
+
+ uniforms.shape = this.shape
+
+ var attributes = shader.attributes
+ this.positionBuffer.bind()
+ attributes.position.pointer()
+
+ this.weightBuffer.bind()
+ attributes.weight.pointer(gl.UNSIGNED_BYTE, false)
+
+ this.colorBuffer.bind()
+ attributes.color.pointer(gl.UNSIGNED_BYTE, true)
+
+ gl.drawArrays(gl.TRIANGLES, 0, numVertices)
+ }
+})()
+
+proto.drawPick = (function () {
+ var MATRIX = [
+ 1, 0, 0,
+ 0, 1, 0,
+ 0, 0, 1
+ ]
+
+ var PICK_VECTOR = [0, 0, 0, 0]
+
+ return function (pickOffset) {
+ var plot = this.plot
+ var shader = this.pickShader
+ var bounds = this.bounds
+ var numVertices = this.numVertices
+
+ if (numVertices <= 0) {
+ return
+ }
+
+ var gl = plot.gl
+ var dataBox = plot.dataBox
+
+ var boundX = bounds[2] - bounds[0]
+ var boundY = bounds[3] - bounds[1]
+ var dataX = dataBox[2] - dataBox[0]
+ var dataY = dataBox[3] - dataBox[1]
+
+ MATRIX[0] = 2.0 * boundX / dataX
+ MATRIX[4] = 2.0 * boundY / dataY
+ MATRIX[6] = 2.0 * (bounds[0] - dataBox[0]) / dataX - 1.0
+ MATRIX[7] = 2.0 * (bounds[1] - dataBox[1]) / dataY - 1.0
+
+ for (var i = 0; i < 4; ++i) {
+ PICK_VECTOR[i] = (pickOffset >> (i * 8)) & 0xff
+ }
+
+ this.pickOffset = pickOffset
+
+ shader.bind()
+
+ var uniforms = shader.uniforms
+ uniforms.viewTransform = MATRIX
+ uniforms.pickOffset = PICK_VECTOR
+ uniforms.shape = this.shape
+
+ var attributes = shader.attributes
+ this.positionBuffer.bind()
+ attributes.position.pointer()
+
+ this.weightBuffer.bind()
+ attributes.weight.pointer(gl.UNSIGNED_BYTE, false)
+
+ this.idBuffer.bind()
+ attributes.pickId.pointer(gl.UNSIGNED_BYTE, false)
+
+ gl.drawArrays(gl.TRIANGLES, 0, numVertices)
+
+ return pickOffset + this.shape[0] * this.shape[1]
+ }
+})()
+
+proto.pick = function (x, y, value) {
+ var pickOffset = this.pickOffset
+ var pointCount = this.shape[0] * this.shape[1]
+ if (value < pickOffset || value >= pickOffset + pointCount) {
+ return null
+ }
+ var pointId = value - pickOffset
+ var xData = this.xData
+ var yData = this.yData
+ return {
+ object: this,
+ pointId: pointId,
+ dataCoord: [
+ xData[pointId % this.shape[0]],
+ yData[(pointId / this.shape[0]) | 0]]
+ }
+}
+
+proto.update = function (options) {
+ options = options || {}
+
+ var shape = options.shape || [0, 0]
+
+ var x = options.x || iota(shape[0])
+ var y = options.y || iota(shape[1])
+ var z = options.z || new Float32Array(shape[0] * shape[1])
+
+ this.xData = x
+ this.yData = y
+
+ var colorLevels = options.colorLevels || [0]
+ var colorValues = options.colorValues || [0, 0, 0, 1]
+ var colorCount = colorLevels.length
+
+ var bounds = this.bounds
+ var lox = bounds[0] = x[0]
+ var loy = bounds[1] = y[0]
+ var hix = bounds[2] = x[x.length - 1]
+ var hiy = bounds[3] = y[y.length - 1]
+
+ var xs = 1.0 / (hix - lox)
+ var ys = 1.0 / (hiy - loy)
+
+ var numX = shape[0]
+ var numY = shape[1]
+
+ this.shape = [numX, numY]
+
+ var numVerts = (numX - 1) * (numY - 1) * (WEIGHTS.length >>> 1)
+
+ this.numVertices = numVerts
+
+ var colors = pool.mallocUint8(numVerts * 4)
+ var positions = pool.mallocFloat32(numVerts * 2)
+ var weights = pool.mallocUint8 (numVerts * 2)
+ var ids = pool.mallocUint32(numVerts)
+
+ var ptr = 0
+
+ for (var j = 0; j < numY - 1; ++j) {
+ var yc0 = ys * (y[j] - loy)
+ var yc1 = ys * (y[j + 1] - loy)
+ for (var i = 0; i < numX - 1; ++i) {
+ var xc0 = xs * (x[i] - lox)
+ var xc1 = xs * (x[i + 1] - lox)
+
+ for (var dd = 0; dd < WEIGHTS.length; dd += 2) {
+ var dx = WEIGHTS[dd]
+ var dy = WEIGHTS[dd + 1]
+ var offset = (j + dy) * numX + (i + dx)
+ var zc = z[offset]
+ var colorIdx = bsearch.le(colorLevels, zc)
+ var r, g, b, a
+ if (colorIdx < 0) {
+ r = colorValues[0]
+ g = colorValues[1]
+ b = colorValues[2]
+ a = colorValues[3]
+ } else if (colorIdx === colorCount - 1) {
+ r = colorValues[4 * colorCount - 4]
+ g = colorValues[4 * colorCount - 3]
+ b = colorValues[4 * colorCount - 2]
+ a = colorValues[4 * colorCount - 1]
+ } else {
+ var t = (zc - colorLevels[colorIdx]) /
+ (colorLevels[colorIdx + 1] - colorLevels[colorIdx])
+ var ti = 1.0 - t
+ var i0 = 4 * colorIdx
+ var i1 = 4 * (colorIdx + 1)
+ r = ti * colorValues[i0] + t * colorValues[i1]
+ g = ti * colorValues[i0 + 1] + t * colorValues[i1 + 1]
+ b = ti * colorValues[i0 + 2] + t * colorValues[i1 + 2]
+ a = ti * colorValues[i0 + 3] + t * colorValues[i1 + 3]
+ }
+
+ colors[4 * ptr] = 255 * r
+ colors[4 * ptr + 1] = 255 * g
+ colors[4 * ptr + 2] = 255 * b
+ colors[4 * ptr + 3] = 255 * a
+
+ positions[2*ptr] = xc0*.5 + xc1*.5;
+ positions[2*ptr+1] = yc0*.5 + yc1*.5;
+
+ weights[2*ptr] = dx;
+ weights[2*ptr+1] = dy;
+
+ ids[ptr] = j * numX + i
+
+ ptr += 1
+ }
+ }
+ }
+
+ this.positionBuffer.update(positions)
+ this.weightBuffer.update(weights)
+ this.colorBuffer.update(colors)
+ this.idBuffer.update(ids)
+
+ pool.free(positions)
+ pool.free(colors)
+ pool.free(weights)
+ pool.free(ids)
+}
+
+proto.dispose = function () {
+ this.shader.dispose()
+ this.pickShader.dispose()
+ this.positionBuffer.dispose()
+ this.weightBuffer.dispose()
+ this.colorBuffer.dispose()
+ this.idBuffer.dispose()
+ this.plot.removeObject(this)
+}
+
+function createHeatmap2D (plot, options) {
+ var gl = plot.gl
+
+ var shader = createShader(gl, shaders.vertex, shaders.fragment)
+ var pickShader = createShader(gl, shaders.pickVertex, shaders.pickFragment)
+
+ var positionBuffer = createBuffer(gl)
+ var weightBuffer = createBuffer(gl)
+ var colorBuffer = createBuffer(gl)
+ var idBuffer = createBuffer(gl)
+
+ var heatmap = new GLHeatmap2D(
+ plot,
+ shader,
+ pickShader,
+ positionBuffer,
+ weightBuffer,
+ colorBuffer,
+ idBuffer)
+
+ heatmap.update(options)
+ plot.addObject(heatmap)
+
+ return heatmap
+}
+
+},{"./lib/shaders":242,"binary-search-bounds":243,"gl-buffer":230,"gl-shader":288,"iota-array":399,"typedarray-pool":522}],242:[function(_dereq_,module,exports){
+'use strict'
+
+var glslify = _dereq_('glslify')
+
+module.exports = {
+ fragment: glslify(["precision lowp float;\n#define GLSLIFY 1\nvarying vec4 fragColor;\nvoid main() {\n gl_FragColor = vec4(fragColor.rgb * fragColor.a, fragColor.a);\n}\n"]),
+ vertex: glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\nattribute vec4 color;\nattribute vec2 weight;\n\nuniform vec2 shape;\nuniform mat3 viewTransform;\n\nvarying vec4 fragColor;\n\nvoid main() {\n vec3 vPosition = viewTransform * vec3( position + (weight-.5)/(shape-1.) , 1.0);\n fragColor = color;\n gl_Position = vec4(vPosition.xy, 0, vPosition.z);\n}\n"]),
+ pickFragment: glslify(["precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragId;\nvarying vec2 vWeight;\n\nuniform vec2 shape;\nuniform vec4 pickOffset;\n\nvoid main() {\n vec2 d = step(.5, vWeight);\n vec4 id = fragId + pickOffset;\n id.x += d.x + d.y*shape.x;\n\n id.y += floor(id.x / 256.0);\n id.x -= floor(id.x / 256.0) * 256.0;\n\n id.z += floor(id.y / 256.0);\n id.y -= floor(id.y / 256.0) * 256.0;\n\n id.w += floor(id.z / 256.0);\n id.z -= floor(id.z / 256.0) * 256.0;\n\n gl_FragColor = id/255.;\n}\n"]),
+ pickVertex: glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\nattribute vec4 pickId;\nattribute vec2 weight;\n\nuniform vec2 shape;\nuniform mat3 viewTransform;\n\nvarying vec4 fragId;\nvarying vec2 vWeight;\n\nvoid main() {\n vWeight = weight;\n\n fragId = pickId;\n\n vec3 vPosition = viewTransform * vec3( position + (weight-.5)/(shape-1.) , 1.0);\n gl_Position = vec4(vPosition.xy, 0, vPosition.z);\n}\n"])
+}
+
+},{"glslify":392}],243:[function(_dereq_,module,exports){
+arguments[4][99][0].apply(exports,arguments)
+},{"dup":99}],244:[function(_dereq_,module,exports){
+var glslify = _dereq_('glslify')
+var createShader = _dereq_('gl-shader')
+
+var vertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, nextPosition;\nattribute float arcLength, lineWidth;\nattribute vec4 color;\n\nuniform vec2 screenShape;\nuniform float pixelRatio;\nuniform mat4 model, view, projection;\n\nvarying vec4 fragColor;\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\n\nvec4 project(vec3 p) {\n return projection * view * model * vec4(p, 1.0);\n}\n\nvoid main() {\n vec4 startPoint = project(position);\n vec4 endPoint = project(nextPosition);\n\n vec2 A = startPoint.xy / startPoint.w;\n vec2 B = endPoint.xy / endPoint.w;\n\n float clipAngle = atan(\n (B.y - A.y) * screenShape.y,\n (B.x - A.x) * screenShape.x\n );\n\n vec2 offset = 0.5 * pixelRatio * lineWidth * vec2(\n sin(clipAngle),\n -cos(clipAngle)\n ) / screenShape;\n\n gl_Position = vec4(startPoint.xy + startPoint.w * offset, startPoint.zw);\n\n worldPosition = position;\n pixelArcLength = arcLength;\n fragColor = color;\n}\n"])
+var forwardFrag = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform sampler2D dashTexture;\nuniform float dashScale;\nuniform float opacity;\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], worldPosition)) discard;\n\n float dashWeight = texture2D(dashTexture, vec2(dashScale * pixelArcLength, 0)).r;\n if(dashWeight < 0.5) {\n discard;\n }\n gl_FragColor = fragColor * opacity;\n}\n"])
+var pickFrag = glslify(["precision mediump float;\n#define GLSLIFY 1\n\n#define FLOAT_MAX 1.70141184e38\n#define FLOAT_MIN 1.17549435e-38\n\nlowp vec4 encode_float_1540259130(highp float v) {\n highp float av = abs(v);\n\n //Handle special cases\n if(av < FLOAT_MIN) {\n return vec4(0.0, 0.0, 0.0, 0.0);\n } else if(v > FLOAT_MAX) {\n return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;\n } else if(v < -FLOAT_MAX) {\n return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;\n }\n\n highp vec4 c = vec4(0,0,0,0);\n\n //Compute exponent and mantissa\n highp float e = floor(log2(av));\n highp float m = av * pow(2.0, -e) - 1.0;\n \n //Unpack mantissa\n c[1] = floor(128.0 * m);\n m -= c[1] / 128.0;\n c[2] = floor(32768.0 * m);\n m -= c[2] / 32768.0;\n c[3] = floor(8388608.0 * m);\n \n //Unpack exponent\n highp float ebias = e + 127.0;\n c[0] = floor(ebias / 2.0);\n ebias -= c[0] * 2.0;\n c[1] += floor(ebias) * 128.0; \n\n //Unpack sign bit\n c[0] += 128.0 * step(0.0, -v);\n\n //Scale back to range\n return c / 255.0;\n}\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform float pickId;\nuniform vec3 clipBounds[2];\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], worldPosition)) discard;\n\n gl_FragColor = vec4(pickId/255.0, encode_float_1540259130(pixelArcLength).xyz);\n}"])
+
+var ATTRIBUTES = [
+ {name: 'position', type: 'vec3'},
+ {name: 'nextPosition', type: 'vec3'},
+ {name: 'arcLength', type: 'float'},
+ {name: 'lineWidth', type: 'float'},
+ {name: 'color', type: 'vec4'}
+]
+
+exports.createShader = function(gl) {
+ return createShader(gl, vertSrc, forwardFrag, null, ATTRIBUTES)
+}
+
+exports.createPickShader = function(gl) {
+ return createShader(gl, vertSrc, pickFrag, null, ATTRIBUTES)
+}
+
+},{"gl-shader":288,"glslify":392}],245:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createLinePlot
+
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createTexture = _dereq_('gl-texture2d')
+var unpackFloat = _dereq_('glsl-read-float')
+var bsearch = _dereq_('binary-search-bounds')
+var ndarray = _dereq_('ndarray')
+var shaders = _dereq_('./lib/shaders')
+
+var createShader = shaders.createShader
+var createPickShader = shaders.createPickShader
+
+var identity = [1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1]
+
+function distance (a, b) {
+ var s = 0.0
+ for (var i = 0; i < 3; ++i) {
+ var d = a[i] - b[i]
+ s += d * d
+ }
+ return Math.sqrt(s)
+}
+
+function filterClipBounds (bounds) {
+ var result = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]]
+ for (var i = 0; i < 3; ++i) {
+ result[0][i] = Math.max(bounds[0][i], result[0][i])
+ result[1][i] = Math.min(bounds[1][i], result[1][i])
+ }
+ return result
+}
+
+function PickResult (tau, position, index, dataCoordinate) {
+ this.arcLength = tau
+ this.position = position
+ this.index = index
+ this.dataCoordinate = dataCoordinate
+}
+
+function LinePlot (gl, shader, pickShader, buffer, vao, texture) {
+ this.gl = gl
+ this.shader = shader
+ this.pickShader = pickShader
+ this.buffer = buffer
+ this.vao = vao
+ this.clipBounds = [
+ [ -Infinity, -Infinity, -Infinity ],
+ [ Infinity, Infinity, Infinity ]]
+ this.points = []
+ this.arcLength = []
+ this.vertexCount = 0
+ this.bounds = [[0, 0, 0], [0, 0, 0]]
+ this.pickId = 0
+ this.lineWidth = 1
+ this.texture = texture
+ this.dashScale = 1
+ this.opacity = 1
+ this.dirty = true
+ this.pixelRatio = 1
+}
+
+var proto = LinePlot.prototype
+
+proto.isTransparent = function () {
+ return this.opacity < 1
+}
+
+proto.isOpaque = function () {
+ return this.opacity >= 1
+}
+
+proto.pickSlots = 1
+
+proto.setPickBase = function (id) {
+ this.pickId = id
+}
+
+proto.drawTransparent = proto.draw = function (camera) {
+ if (!this.vertexCount) return
+ var gl = this.gl
+ var shader = this.shader
+ var vao = this.vao
+ shader.bind()
+ shader.uniforms = {
+ model: camera.model || identity,
+ view: camera.view || identity,
+ projection: camera.projection || identity,
+ clipBounds: filterClipBounds(this.clipBounds),
+ dashTexture: this.texture.bind(),
+ dashScale: this.dashScale / this.arcLength[this.arcLength.length - 1],
+ opacity: this.opacity,
+ screenShape: [gl.drawingBufferWidth, gl.drawingBufferHeight],
+ pixelRatio: this.pixelRatio
+ }
+ vao.bind()
+ vao.draw(gl.TRIANGLE_STRIP, this.vertexCount)
+ vao.unbind()
+}
+
+proto.drawPick = function (camera) {
+ if (!this.vertexCount) return
+ var gl = this.gl
+ var shader = this.pickShader
+ var vao = this.vao
+ shader.bind()
+ shader.uniforms = {
+ model: camera.model || identity,
+ view: camera.view || identity,
+ projection: camera.projection || identity,
+ pickId: this.pickId,
+ clipBounds: filterClipBounds(this.clipBounds),
+ screenShape: [gl.drawingBufferWidth, gl.drawingBufferHeight],
+ pixelRatio: this.pixelRatio
+ }
+ vao.bind()
+ vao.draw(gl.TRIANGLE_STRIP, this.vertexCount)
+ vao.unbind()
+}
+
+proto.update = function (options) {
+ var i, j
+
+ this.dirty = true
+
+ var connectGaps = !!options.connectGaps
+
+ if ('dashScale' in options) {
+ this.dashScale = options.dashScale
+ }
+ if ('opacity' in options) {
+ this.opacity = +options.opacity
+ }
+
+ // Recalculate buffer data
+ var buffer = []
+ var arcLengthArray = []
+ var pointArray = []
+ var arcLength = 0.0
+ var vertexCount = 0
+ var bounds = [
+ [ Infinity, Infinity, Infinity ],
+ [ -Infinity, -Infinity, -Infinity ]]
+
+ var positions = options.position || options.positions
+ if (positions) {
+
+ // Default color
+ var colors = options.color || options.colors || [0, 0, 0, 1]
+
+ var lineWidth = options.lineWidth || 1
+
+ var hadGap = false
+
+ fill_loop:
+ for (i = 1; i < positions.length; ++i) {
+ var a = positions[i - 1]
+ var b = positions[i]
+
+ arcLengthArray.push(arcLength)
+ pointArray.push(a.slice())
+
+ for (j = 0; j < 3; ++j) {
+ if (isNaN(a[j]) || isNaN(b[j]) ||
+ !isFinite(a[j]) || !isFinite(b[j])) {
+
+ if (!connectGaps && buffer.length > 0) {
+ for (var k = 0; k < 24; ++k) {
+ buffer.push(buffer[buffer.length - 12])
+ }
+ vertexCount += 2
+ hadGap = true
+ }
+
+ continue fill_loop
+ }
+ bounds[0][j] = Math.min(bounds[0][j], a[j], b[j])
+ bounds[1][j] = Math.max(bounds[1][j], a[j], b[j])
+ }
+
+ var acolor, bcolor
+ if (Array.isArray(colors[0])) {
+ acolor = (colors.length > i - 1) ? colors[i - 1] : // using index value
+ (colors.length > 0) ? colors[colors.length - 1] : // using last item
+ [0, 0, 0, 1]; // using black
+
+ bcolor = (colors.length > i) ? colors[i] : // using index value
+ (colors.length > 0) ? colors[colors.length - 1] : // using last item
+ [0, 0, 0, 1]; // using black
+ } else {
+ acolor = bcolor = colors
+ }
+
+ if (acolor.length === 3) {
+ acolor = [acolor[0], acolor[1], acolor[2], 1]
+ }
+ if (bcolor.length === 3) {
+ bcolor = [bcolor[0], bcolor[1], bcolor[2], 1]
+ }
+
+ var w0
+ if (Array.isArray(lineWidth)) {
+ w0 = (lineWidth.length > i - 1) ? lineWidth[i - 1] : // using index value
+ (lineWidth.length > 0) ? lineWidth[lineWidth.length - 1] : // using last item
+ [0, 0, 0, 1]; // using black
+ } else {
+ w0 = lineWidth
+ }
+
+ var t0 = arcLength
+ arcLength += distance(a, b)
+
+ if (hadGap) {
+ for (j = 0; j < 2; ++j) {
+ buffer.push(
+ a[0], a[1], a[2], b[0], b[1], b[2], t0, w0, acolor[0], acolor[1], acolor[2], acolor[3])
+ }
+ vertexCount += 2
+ hadGap = false
+ }
+
+ buffer.push(
+ a[0], a[1], a[2], b[0], b[1], b[2], t0, w0, acolor[0], acolor[1], acolor[2], acolor[3],
+ a[0], a[1], a[2], b[0], b[1], b[2], t0, -w0, acolor[0], acolor[1], acolor[2], acolor[3],
+ b[0], b[1], b[2], a[0], a[1], a[2], arcLength, -w0, bcolor[0], bcolor[1], bcolor[2], bcolor[3],
+ b[0], b[1], b[2], a[0], a[1], a[2], arcLength, w0, bcolor[0], bcolor[1], bcolor[2], bcolor[3])
+
+ vertexCount += 4
+ }
+ }
+ this.buffer.update(buffer)
+
+ arcLengthArray.push(arcLength)
+ pointArray.push(positions[positions.length - 1].slice())
+
+ this.bounds = bounds
+
+ this.vertexCount = vertexCount
+
+ this.points = pointArray
+ this.arcLength = arcLengthArray
+
+ if ('dashes' in options) {
+ var dashArray = options.dashes
+
+ // Calculate prefix sum
+ var prefixSum = dashArray.slice()
+ prefixSum.unshift(0)
+ for (i = 1; i < prefixSum.length; ++i) {
+ prefixSum[i] = prefixSum[i - 1] + prefixSum[i]
+ }
+
+ var dashTexture = ndarray(new Array(256 * 4), [256, 1, 4])
+ for (i = 0; i < 256; ++i) {
+ for (j = 0; j < 4; ++j) {
+ dashTexture.set(i, 0, j, 0)
+ }
+ if (bsearch.le(prefixSum, prefixSum[prefixSum.length - 1] * i / 255.0) & 1) {
+ dashTexture.set(i, 0, 0, 0)
+ } else {
+ dashTexture.set(i, 0, 0, 255)
+ }
+ }
+
+ this.texture.setPixels(dashTexture)
+ }
+}
+
+proto.dispose = function () {
+ this.shader.dispose()
+ this.vao.dispose()
+ this.buffer.dispose()
+}
+
+proto.pick = function (selection) {
+ if (!selection) {
+ return null
+ }
+ if (selection.id !== this.pickId) {
+ return null
+ }
+ var tau = unpackFloat(
+ selection.value[0],
+ selection.value[1],
+ selection.value[2],
+ 0)
+ var index = bsearch.le(this.arcLength, tau)
+ if (index < 0) {
+ return null
+ }
+ if (index === this.arcLength.length - 1) {
+ return new PickResult(
+ this.arcLength[this.arcLength.length - 1],
+ this.points[this.points.length - 1].slice(),
+ index)
+ }
+ var a = this.points[index]
+ var b = this.points[Math.min(index + 1, this.points.length - 1)]
+ var t = (tau - this.arcLength[index]) / (this.arcLength[index + 1] - this.arcLength[index])
+ var ti = 1.0 - t
+ var x = [0, 0, 0]
+ for (var i = 0; i < 3; ++i) {
+ x[i] = ti * a[i] + t * b[i]
+ }
+ var dataIndex = Math.min((t < 0.5) ? index : (index + 1), this.points.length - 1)
+ return new PickResult(
+ tau,
+ x,
+ dataIndex,
+ this.points[dataIndex])
+}
+
+function createLinePlot (options) {
+ var gl = options.gl || (options.scene && options.scene.gl)
+
+ var shader = createShader(gl)
+ shader.attributes.position.location = 0
+ shader.attributes.nextPosition.location = 1
+ shader.attributes.arcLength.location = 2
+ shader.attributes.lineWidth.location = 3
+ shader.attributes.color.location = 4
+
+ var pickShader = createPickShader(gl)
+ pickShader.attributes.position.location = 0
+ pickShader.attributes.nextPosition.location = 1
+ pickShader.attributes.arcLength.location = 2
+ pickShader.attributes.lineWidth.location = 3
+ pickShader.attributes.color.location = 4
+
+ var buffer = createBuffer(gl)
+ var vao = createVAO(gl, [
+ {
+ 'buffer': buffer,
+ 'size': 3,
+ 'offset': 0,
+ 'stride': 48
+ },
+ {
+ 'buffer': buffer,
+ 'size': 3,
+ 'offset': 12,
+ 'stride': 48
+ },
+ {
+ 'buffer': buffer,
+ 'size': 1,
+ 'offset': 24,
+ 'stride': 48
+ },
+ {
+ 'buffer': buffer,
+ 'size': 1,
+ 'offset': 28,
+ 'stride': 48
+ },
+ {
+ 'buffer': buffer,
+ 'size': 4,
+ 'offset': 32,
+ 'stride': 48
+ }
+ ])
+
+ // Create texture for dash pattern
+ var defaultTexture = ndarray(new Array(256 * 4), [256, 1, 4])
+ for (var i = 0; i < 256 * 4; ++i) {
+ defaultTexture.data[i] = 255
+ }
+ var texture = createTexture(gl, defaultTexture)
+ texture.wrap = gl.REPEAT
+
+ var linePlot = new LinePlot(gl, shader, pickShader, buffer, vao, texture)
+ linePlot.update(options)
+ return linePlot
+}
+
+},{"./lib/shaders":244,"binary-search-bounds":79,"gl-buffer":230,"gl-texture2d":305,"gl-vao":310,"glsl-read-float":383,"ndarray":433}],246:[function(_dereq_,module,exports){
+module.exports = invert
+
+/**
+ * Inverts a mat2
+ *
+ * @alias mat2.invert
+ * @param {mat2} out the receiving matrix
+ * @param {mat2} a the source matrix
+ * @returns {mat2} out
+ */
+function invert(out, a) {
+ var a0 = a[0]
+ var a1 = a[1]
+ var a2 = a[2]
+ var a3 = a[3]
+ var det = a0 * a3 - a2 * a1
+
+ if (!det) return null
+ det = 1.0 / det
+
+ out[0] = a3 * det
+ out[1] = -a1 * det
+ out[2] = -a2 * det
+ out[3] = a0 * det
+
+ return out
+}
+
+},{}],247:[function(_dereq_,module,exports){
+module.exports = invert
+
+/**
+ * Inverts a mat3
+ *
+ * @alias mat3.invert
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the source matrix
+ * @returns {mat3} out
+ */
+function invert(out, a) {
+ var a00 = a[0], a01 = a[1], a02 = a[2]
+ var a10 = a[3], a11 = a[4], a12 = a[5]
+ var a20 = a[6], a21 = a[7], a22 = a[8]
+
+ var b01 = a22 * a11 - a12 * a21
+ var b11 = -a22 * a10 + a12 * a20
+ var b21 = a21 * a10 - a11 * a20
+
+ // Calculate the determinant
+ var det = a00 * b01 + a01 * b11 + a02 * b21
+
+ if (!det) return null
+ det = 1.0 / det
+
+ out[0] = b01 * det
+ out[1] = (-a22 * a01 + a02 * a21) * det
+ out[2] = (a12 * a01 - a02 * a11) * det
+ out[3] = b11 * det
+ out[4] = (a22 * a00 - a02 * a20) * det
+ out[5] = (-a12 * a00 + a02 * a10) * det
+ out[6] = b21 * det
+ out[7] = (-a21 * a00 + a01 * a20) * det
+ out[8] = (a11 * a00 - a01 * a10) * det
+
+ return out
+}
+
+},{}],248:[function(_dereq_,module,exports){
+module.exports = clone;
+
+/**
+ * Creates a new mat4 initialized with values from an existing matrix
+ *
+ * @param {mat4} a matrix to clone
+ * @returns {mat4} a new 4x4 matrix
+ */
+function clone(a) {
+ var out = new Float32Array(16);
+ out[0] = a[0];
+ out[1] = a[1];
+ out[2] = a[2];
+ out[3] = a[3];
+ out[4] = a[4];
+ out[5] = a[5];
+ out[6] = a[6];
+ out[7] = a[7];
+ out[8] = a[8];
+ out[9] = a[9];
+ out[10] = a[10];
+ out[11] = a[11];
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ return out;
+};
+},{}],249:[function(_dereq_,module,exports){
+module.exports = create;
+
+/**
+ * Creates a new identity mat4
+ *
+ * @returns {mat4} a new 4x4 matrix
+ */
+function create() {
+ var out = new Float32Array(16);
+ out[0] = 1;
+ out[1] = 0;
+ out[2] = 0;
+ out[3] = 0;
+ out[4] = 0;
+ out[5] = 1;
+ out[6] = 0;
+ out[7] = 0;
+ out[8] = 0;
+ out[9] = 0;
+ out[10] = 1;
+ out[11] = 0;
+ out[12] = 0;
+ out[13] = 0;
+ out[14] = 0;
+ out[15] = 1;
+ return out;
+};
+},{}],250:[function(_dereq_,module,exports){
+module.exports = determinant;
+
+/**
+ * Calculates the determinant of a mat4
+ *
+ * @param {mat4} a the source matrix
+ * @returns {Number} determinant of a
+ */
+function determinant(a) {
+ var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
+ a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
+ a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
+ a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15],
+
+ b00 = a00 * a11 - a01 * a10,
+ b01 = a00 * a12 - a02 * a10,
+ b02 = a00 * a13 - a03 * a10,
+ b03 = a01 * a12 - a02 * a11,
+ b04 = a01 * a13 - a03 * a11,
+ b05 = a02 * a13 - a03 * a12,
+ b06 = a20 * a31 - a21 * a30,
+ b07 = a20 * a32 - a22 * a30,
+ b08 = a20 * a33 - a23 * a30,
+ b09 = a21 * a32 - a22 * a31,
+ b10 = a21 * a33 - a23 * a31,
+ b11 = a22 * a33 - a23 * a32;
+
+ // Calculate the determinant
+ return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+};
+},{}],251:[function(_dereq_,module,exports){
+module.exports = fromQuat;
+
+/**
+ * Creates a matrix from a quaternion rotation.
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @returns {mat4} out
+ */
+function fromQuat(out, q) {
+ var x = q[0], y = q[1], z = q[2], w = q[3],
+ x2 = x + x,
+ y2 = y + y,
+ z2 = z + z,
+
+ xx = x * x2,
+ yx = y * x2,
+ yy = y * y2,
+ zx = z * x2,
+ zy = z * y2,
+ zz = z * z2,
+ wx = w * x2,
+ wy = w * y2,
+ wz = w * z2;
+
+ out[0] = 1 - yy - zz;
+ out[1] = yx + wz;
+ out[2] = zx - wy;
+ out[3] = 0;
+
+ out[4] = yx - wz;
+ out[5] = 1 - xx - zz;
+ out[6] = zy + wx;
+ out[7] = 0;
+
+ out[8] = zx + wy;
+ out[9] = zy - wx;
+ out[10] = 1 - xx - yy;
+ out[11] = 0;
+
+ out[12] = 0;
+ out[13] = 0;
+ out[14] = 0;
+ out[15] = 1;
+
+ return out;
+};
+},{}],252:[function(_dereq_,module,exports){
+module.exports = fromRotationTranslation;
+
+/**
+ * Creates a matrix from a quaternion rotation and vector translation
+ * This is equivalent to (but much faster than):
+ *
+ * mat4.identity(dest);
+ * mat4.translate(dest, vec);
+ * var quatMat = mat4.create();
+ * quat4.toMat4(quat, quatMat);
+ * mat4.multiply(dest, quatMat);
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @param {vec3} v Translation vector
+ * @returns {mat4} out
+ */
+function fromRotationTranslation(out, q, v) {
+ // Quaternion math
+ var x = q[0], y = q[1], z = q[2], w = q[3],
+ x2 = x + x,
+ y2 = y + y,
+ z2 = z + z,
+
+ xx = x * x2,
+ xy = x * y2,
+ xz = x * z2,
+ yy = y * y2,
+ yz = y * z2,
+ zz = z * z2,
+ wx = w * x2,
+ wy = w * y2,
+ wz = w * z2;
+
+ out[0] = 1 - (yy + zz);
+ out[1] = xy + wz;
+ out[2] = xz - wy;
+ out[3] = 0;
+ out[4] = xy - wz;
+ out[5] = 1 - (xx + zz);
+ out[6] = yz + wx;
+ out[7] = 0;
+ out[8] = xz + wy;
+ out[9] = yz - wx;
+ out[10] = 1 - (xx + yy);
+ out[11] = 0;
+ out[12] = v[0];
+ out[13] = v[1];
+ out[14] = v[2];
+ out[15] = 1;
+
+ return out;
+};
+},{}],253:[function(_dereq_,module,exports){
+module.exports = identity;
+
+/**
+ * Set a mat4 to the identity matrix
+ *
+ * @param {mat4} out the receiving matrix
+ * @returns {mat4} out
+ */
+function identity(out) {
+ out[0] = 1;
+ out[1] = 0;
+ out[2] = 0;
+ out[3] = 0;
+ out[4] = 0;
+ out[5] = 1;
+ out[6] = 0;
+ out[7] = 0;
+ out[8] = 0;
+ out[9] = 0;
+ out[10] = 1;
+ out[11] = 0;
+ out[12] = 0;
+ out[13] = 0;
+ out[14] = 0;
+ out[15] = 1;
+ return out;
+};
+},{}],254:[function(_dereq_,module,exports){
+module.exports = invert;
+
+/**
+ * Inverts a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the source matrix
+ * @returns {mat4} out
+ */
+function invert(out, a) {
+ var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
+ a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
+ a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
+ a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15],
+
+ b00 = a00 * a11 - a01 * a10,
+ b01 = a00 * a12 - a02 * a10,
+ b02 = a00 * a13 - a03 * a10,
+ b03 = a01 * a12 - a02 * a11,
+ b04 = a01 * a13 - a03 * a11,
+ b05 = a02 * a13 - a03 * a12,
+ b06 = a20 * a31 - a21 * a30,
+ b07 = a20 * a32 - a22 * a30,
+ b08 = a20 * a33 - a23 * a30,
+ b09 = a21 * a32 - a22 * a31,
+ b10 = a21 * a33 - a23 * a31,
+ b11 = a22 * a33 - a23 * a32,
+
+ // Calculate the determinant
+ det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+
+ if (!det) {
+ return null;
+ }
+ det = 1.0 / det;
+
+ out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+ out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+ out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+ out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+ out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+ out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+ out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+ out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+ out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+ out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+ out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+ out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+ out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+ out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+ out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+ out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+
+ return out;
+};
+},{}],255:[function(_dereq_,module,exports){
+var identity = _dereq_('./identity');
+
+module.exports = lookAt;
+
+/**
+ * Generates a look-at matrix with the given eye position, focal point, and up axis
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {vec3} eye Position of the viewer
+ * @param {vec3} center Point the viewer is looking at
+ * @param {vec3} up vec3 pointing up
+ * @returns {mat4} out
+ */
+function lookAt(out, eye, center, up) {
+ var x0, x1, x2, y0, y1, y2, z0, z1, z2, len,
+ eyex = eye[0],
+ eyey = eye[1],
+ eyez = eye[2],
+ upx = up[0],
+ upy = up[1],
+ upz = up[2],
+ centerx = center[0],
+ centery = center[1],
+ centerz = center[2];
+
+ if (Math.abs(eyex - centerx) < 0.000001 &&
+ Math.abs(eyey - centery) < 0.000001 &&
+ Math.abs(eyez - centerz) < 0.000001) {
+ return identity(out);
+ }
+
+ z0 = eyex - centerx;
+ z1 = eyey - centery;
+ z2 = eyez - centerz;
+
+ len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+ z0 *= len;
+ z1 *= len;
+ z2 *= len;
+
+ x0 = upy * z2 - upz * z1;
+ x1 = upz * z0 - upx * z2;
+ x2 = upx * z1 - upy * z0;
+ len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+ if (!len) {
+ x0 = 0;
+ x1 = 0;
+ x2 = 0;
+ } else {
+ len = 1 / len;
+ x0 *= len;
+ x1 *= len;
+ x2 *= len;
+ }
+
+ y0 = z1 * x2 - z2 * x1;
+ y1 = z2 * x0 - z0 * x2;
+ y2 = z0 * x1 - z1 * x0;
+
+ len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+ if (!len) {
+ y0 = 0;
+ y1 = 0;
+ y2 = 0;
+ } else {
+ len = 1 / len;
+ y0 *= len;
+ y1 *= len;
+ y2 *= len;
+ }
+
+ out[0] = x0;
+ out[1] = y0;
+ out[2] = z0;
+ out[3] = 0;
+ out[4] = x1;
+ out[5] = y1;
+ out[6] = z1;
+ out[7] = 0;
+ out[8] = x2;
+ out[9] = y2;
+ out[10] = z2;
+ out[11] = 0;
+ out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+ out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+ out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+ out[15] = 1;
+
+ return out;
+};
+},{"./identity":253}],256:[function(_dereq_,module,exports){
+module.exports = multiply;
+
+/**
+ * Multiplies two mat4's
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the first operand
+ * @param {mat4} b the second operand
+ * @returns {mat4} out
+ */
+function multiply(out, a, b) {
+ var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
+ a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
+ a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
+ a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+
+ // Cache only the current line of the second matrix
+ var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+ out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+ out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+ out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+ out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+ b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7];
+ out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+ out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+ out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+ out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+ b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11];
+ out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+ out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+ out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+ out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+ b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15];
+ out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+ out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+ out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+ out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+ return out;
+};
+},{}],257:[function(_dereq_,module,exports){
+module.exports = perspective;
+
+/**
+ * Generates a perspective projection matrix with the given bounds
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {number} fovy Vertical field of view in radians
+ * @param {number} aspect Aspect ratio. typically viewport width/height
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+function perspective(out, fovy, aspect, near, far) {
+ var f = 1.0 / Math.tan(fovy / 2),
+ nf = 1 / (near - far);
+ out[0] = f / aspect;
+ out[1] = 0;
+ out[2] = 0;
+ out[3] = 0;
+ out[4] = 0;
+ out[5] = f;
+ out[6] = 0;
+ out[7] = 0;
+ out[8] = 0;
+ out[9] = 0;
+ out[10] = (far + near) * nf;
+ out[11] = -1;
+ out[12] = 0;
+ out[13] = 0;
+ out[14] = (2 * far * near) * nf;
+ out[15] = 0;
+ return out;
+};
+},{}],258:[function(_dereq_,module,exports){
+module.exports = rotate;
+
+/**
+ * Rotates a mat4 by the given angle
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @param {vec3} axis the axis to rotate around
+ * @returns {mat4} out
+ */
+function rotate(out, a, rad, axis) {
+ var x = axis[0], y = axis[1], z = axis[2],
+ len = Math.sqrt(x * x + y * y + z * z),
+ s, c, t,
+ a00, a01, a02, a03,
+ a10, a11, a12, a13,
+ a20, a21, a22, a23,
+ b00, b01, b02,
+ b10, b11, b12,
+ b20, b21, b22;
+
+ if (Math.abs(len) < 0.000001) { return null; }
+
+ len = 1 / len;
+ x *= len;
+ y *= len;
+ z *= len;
+
+ s = Math.sin(rad);
+ c = Math.cos(rad);
+ t = 1 - c;
+
+ a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
+ a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
+ a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
+
+ // Construct the elements of the rotation matrix
+ b00 = x * x * t + c; b01 = y * x * t + z * s; b02 = z * x * t - y * s;
+ b10 = x * y * t - z * s; b11 = y * y * t + c; b12 = z * y * t + x * s;
+ b20 = x * z * t + y * s; b21 = y * z * t - x * s; b22 = z * z * t + c;
+
+ // Perform rotation-specific matrix multiplication
+ out[0] = a00 * b00 + a10 * b01 + a20 * b02;
+ out[1] = a01 * b00 + a11 * b01 + a21 * b02;
+ out[2] = a02 * b00 + a12 * b01 + a22 * b02;
+ out[3] = a03 * b00 + a13 * b01 + a23 * b02;
+ out[4] = a00 * b10 + a10 * b11 + a20 * b12;
+ out[5] = a01 * b10 + a11 * b11 + a21 * b12;
+ out[6] = a02 * b10 + a12 * b11 + a22 * b12;
+ out[7] = a03 * b10 + a13 * b11 + a23 * b12;
+ out[8] = a00 * b20 + a10 * b21 + a20 * b22;
+ out[9] = a01 * b20 + a11 * b21 + a21 * b22;
+ out[10] = a02 * b20 + a12 * b21 + a22 * b22;
+ out[11] = a03 * b20 + a13 * b21 + a23 * b22;
+
+ if (a !== out) { // If the source and destination differ, copy the unchanged last row
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ }
+ return out;
+};
+},{}],259:[function(_dereq_,module,exports){
+module.exports = rotateX;
+
+/**
+ * Rotates a matrix by the given angle around the X axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+function rotateX(out, a, rad) {
+ var s = Math.sin(rad),
+ c = Math.cos(rad),
+ a10 = a[4],
+ a11 = a[5],
+ a12 = a[6],
+ a13 = a[7],
+ a20 = a[8],
+ a21 = a[9],
+ a22 = a[10],
+ a23 = a[11];
+
+ if (a !== out) { // If the source and destination differ, copy the unchanged rows
+ out[0] = a[0];
+ out[1] = a[1];
+ out[2] = a[2];
+ out[3] = a[3];
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ }
+
+ // Perform axis-specific matrix multiplication
+ out[4] = a10 * c + a20 * s;
+ out[5] = a11 * c + a21 * s;
+ out[6] = a12 * c + a22 * s;
+ out[7] = a13 * c + a23 * s;
+ out[8] = a20 * c - a10 * s;
+ out[9] = a21 * c - a11 * s;
+ out[10] = a22 * c - a12 * s;
+ out[11] = a23 * c - a13 * s;
+ return out;
+};
+},{}],260:[function(_dereq_,module,exports){
+module.exports = rotateY;
+
+/**
+ * Rotates a matrix by the given angle around the Y axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+function rotateY(out, a, rad) {
+ var s = Math.sin(rad),
+ c = Math.cos(rad),
+ a00 = a[0],
+ a01 = a[1],
+ a02 = a[2],
+ a03 = a[3],
+ a20 = a[8],
+ a21 = a[9],
+ a22 = a[10],
+ a23 = a[11];
+
+ if (a !== out) { // If the source and destination differ, copy the unchanged rows
+ out[4] = a[4];
+ out[5] = a[5];
+ out[6] = a[6];
+ out[7] = a[7];
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ }
+
+ // Perform axis-specific matrix multiplication
+ out[0] = a00 * c - a20 * s;
+ out[1] = a01 * c - a21 * s;
+ out[2] = a02 * c - a22 * s;
+ out[3] = a03 * c - a23 * s;
+ out[8] = a00 * s + a20 * c;
+ out[9] = a01 * s + a21 * c;
+ out[10] = a02 * s + a22 * c;
+ out[11] = a03 * s + a23 * c;
+ return out;
+};
+},{}],261:[function(_dereq_,module,exports){
+module.exports = rotateZ;
+
+/**
+ * Rotates a matrix by the given angle around the Z axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat4} out
+ */
+function rotateZ(out, a, rad) {
+ var s = Math.sin(rad),
+ c = Math.cos(rad),
+ a00 = a[0],
+ a01 = a[1],
+ a02 = a[2],
+ a03 = a[3],
+ a10 = a[4],
+ a11 = a[5],
+ a12 = a[6],
+ a13 = a[7];
+
+ if (a !== out) { // If the source and destination differ, copy the unchanged last row
+ out[8] = a[8];
+ out[9] = a[9];
+ out[10] = a[10];
+ out[11] = a[11];
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ }
+
+ // Perform axis-specific matrix multiplication
+ out[0] = a00 * c + a10 * s;
+ out[1] = a01 * c + a11 * s;
+ out[2] = a02 * c + a12 * s;
+ out[3] = a03 * c + a13 * s;
+ out[4] = a10 * c - a00 * s;
+ out[5] = a11 * c - a01 * s;
+ out[6] = a12 * c - a02 * s;
+ out[7] = a13 * c - a03 * s;
+ return out;
+};
+},{}],262:[function(_dereq_,module,exports){
+module.exports = scale;
+
+/**
+ * Scales the mat4 by the dimensions in the given vec3
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to scale
+ * @param {vec3} v the vec3 to scale the matrix by
+ * @returns {mat4} out
+ **/
+function scale(out, a, v) {
+ var x = v[0], y = v[1], z = v[2];
+
+ out[0] = a[0] * x;
+ out[1] = a[1] * x;
+ out[2] = a[2] * x;
+ out[3] = a[3] * x;
+ out[4] = a[4] * y;
+ out[5] = a[5] * y;
+ out[6] = a[6] * y;
+ out[7] = a[7] * y;
+ out[8] = a[8] * z;
+ out[9] = a[9] * z;
+ out[10] = a[10] * z;
+ out[11] = a[11] * z;
+ out[12] = a[12];
+ out[13] = a[13];
+ out[14] = a[14];
+ out[15] = a[15];
+ return out;
+};
+},{}],263:[function(_dereq_,module,exports){
+module.exports = translate;
+
+/**
+ * Translate a mat4 by the given vector
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to translate
+ * @param {vec3} v vector to translate by
+ * @returns {mat4} out
+ */
+function translate(out, a, v) {
+ var x = v[0], y = v[1], z = v[2],
+ a00, a01, a02, a03,
+ a10, a11, a12, a13,
+ a20, a21, a22, a23;
+
+ if (a === out) {
+ out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+ out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+ out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+ out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+ } else {
+ a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
+ a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
+ a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
+
+ out[0] = a00; out[1] = a01; out[2] = a02; out[3] = a03;
+ out[4] = a10; out[5] = a11; out[6] = a12; out[7] = a13;
+ out[8] = a20; out[9] = a21; out[10] = a22; out[11] = a23;
+
+ out[12] = a00 * x + a10 * y + a20 * z + a[12];
+ out[13] = a01 * x + a11 * y + a21 * z + a[13];
+ out[14] = a02 * x + a12 * y + a22 * z + a[14];
+ out[15] = a03 * x + a13 * y + a23 * z + a[15];
+ }
+
+ return out;
+};
+},{}],264:[function(_dereq_,module,exports){
+module.exports = transpose;
+
+/**
+ * Transpose the values of a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the source matrix
+ * @returns {mat4} out
+ */
+function transpose(out, a) {
+ // If we are transposing ourselves we can skip a few steps but have to cache some values
+ if (out === a) {
+ var a01 = a[1], a02 = a[2], a03 = a[3],
+ a12 = a[6], a13 = a[7],
+ a23 = a[11];
+
+ out[1] = a[4];
+ out[2] = a[8];
+ out[3] = a[12];
+ out[4] = a01;
+ out[6] = a[9];
+ out[7] = a[13];
+ out[8] = a02;
+ out[9] = a12;
+ out[11] = a[14];
+ out[12] = a03;
+ out[13] = a13;
+ out[14] = a23;
+ } else {
+ out[0] = a[0];
+ out[1] = a[4];
+ out[2] = a[8];
+ out[3] = a[12];
+ out[4] = a[1];
+ out[5] = a[5];
+ out[6] = a[9];
+ out[7] = a[13];
+ out[8] = a[2];
+ out[9] = a[6];
+ out[10] = a[10];
+ out[11] = a[14];
+ out[12] = a[3];
+ out[13] = a[7];
+ out[14] = a[11];
+ out[15] = a[15];
+ }
+
+ return out;
+};
+},{}],265:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = invert
+
+var invert2 = _dereq_('gl-mat2/invert')
+var invert3 = _dereq_('gl-mat3/invert')
+var invert4 = _dereq_('gl-mat4/invert')
+
+function invert(out, M) {
+ switch(M.length) {
+ case 0:
+ break
+ case 1:
+ out[0] = 1.0 / M[0]
+ break
+ case 4:
+ invert2(out, M)
+ break
+ case 9:
+ invert3(out, M)
+ break
+ case 16:
+ invert4(out, M)
+ break
+ default:
+ throw new Error('currently supports matrices up to 4x4')
+ break
+ }
+ return out
+}
+},{"gl-mat2/invert":246,"gl-mat3/invert":247,"gl-mat4/invert":254}],266:[function(_dereq_,module,exports){
+arguments[4][232][0].apply(exports,arguments)
+},{"barycentric":61,"dup":232,"polytope-closest-point/lib/closest_point_2d.js":464}],267:[function(_dereq_,module,exports){
+var glslify = _dereq_('glslify')
+
+var triVertSrc = glslify(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, normal;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model\n , view\n , projection;\nuniform vec3 eyePosition\n , lightPosition;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n vec4 m_position = model * vec4(position, 1.0);\n vec4 t_position = view * m_position;\n gl_Position = projection * t_position;\n f_color = color;\n f_normal = normal;\n f_data = position;\n f_eyeDirection = eyePosition - position;\n f_lightDirection = lightPosition - position;\n f_uv = uv;\n}\n"])
+var triFragSrc = glslify(["#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n float NdotH = max(x, 0.0001);\n float cos2Alpha = NdotH * NdotH;\n float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n float roughness2 = roughness * roughness;\n float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n vec3 lightDirection,\n vec3 viewDirection,\n vec3 surfaceNormal,\n float roughness,\n float fresnel) {\n\n float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n //Half angle vector\n vec3 H = normalize(lightDirection + viewDirection);\n\n //Geometric term\n float NdotH = max(dot(surfaceNormal, H), 0.0);\n float VdotH = max(dot(viewDirection, H), 0.000001);\n float LdotH = max(dot(lightDirection, H), 0.000001);\n float G1 = (2.0 * NdotH * VdotN) / VdotH;\n float G2 = (2.0 * NdotH * LdotN) / LdotH;\n float G = min(1.0, min(G1, G2));\n \n //Distribution term\n float D = beckmannDistribution(NdotH, roughness);\n\n //Fresnel term\n float F = pow(1.0 - VdotN, fresnel);\n\n //Multiply terms and done\n return G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nvec3 normals(vec3 pos) {\n vec3 fdx = dFdx(pos);\n vec3 fdy = dFdy(pos);\n return normalize(cross(fdx, fdy));\n}\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n , fresnel\n , kambient\n , kdiffuse\n , kspecular\n , opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], f_data)) discard;\n\n vec3 N = normalize(f_normal);\n vec3 L = normalize(f_lightDirection);\n vec3 V = normalize(f_eyeDirection);\n\n vec3 normal = normals(f_data);\n\n if (dot(N, normal) < 0.0) {\n N = -N;\n }\n\n float specular = cookTorranceSpecular(L, V, N, roughness, fresnel);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n vec4 surfaceColor = f_color * texture2D(texture, f_uv);\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = litColor * opacity;\n}\n"])
+var edgeVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model, view, projection;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n f_color = color;\n f_data = position;\n f_uv = uv;\n}"])
+var edgeFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], f_data)) discard;\n\n gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"])
+var pointVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\nattribute float pointSize;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n gl_Position = vec4(0,0,0,0);\n } else {\n gl_Position = projection * view * model * vec4(position, 1.0);\n }\n gl_PointSize = pointSize;\n f_color = color;\n f_uv = uv;\n}"])
+var pointFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n vec2 pointR = gl_PointCoord.xy - vec2(0.5,0.5);\n if(dot(pointR, pointR) > 0.25) {\n discard;\n }\n gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"])
+var pickVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n f_id = id;\n f_position = position;\n}"])
+var pickFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"])
+var pickPointVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute float pointSize;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n gl_Position = vec4(0,0,0,0);\n } else {\n gl_Position = projection * view * model * vec4(position, 1.0);\n gl_PointSize = pointSize;\n }\n f_id = id;\n f_position = position;\n}"])
+var contourVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n}"])
+var contourFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 contourColor;\n\nvoid main() {\n gl_FragColor = vec4(contourColor,1);\n}\n"])
+
+exports.meshShader = {
+ vertex: triVertSrc,
+ fragment: triFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'},
+ {name: 'normal', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'uv', type: 'vec2'}
+ ]
+}
+exports.wireShader = {
+ vertex: edgeVertSrc,
+ fragment: edgeFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'uv', type: 'vec2'}
+ ]
+}
+exports.pointShader = {
+ vertex: pointVertSrc,
+ fragment: pointFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'uv', type: 'vec2'},
+ {name: 'pointSize', type: 'float'}
+ ]
+}
+exports.pickShader = {
+ vertex: pickVertSrc,
+ fragment: pickFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'},
+ {name: 'id', type: 'vec4'}
+ ]
+}
+exports.pointPickShader = {
+ vertex: pickPointVertSrc,
+ fragment: pickFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'},
+ {name: 'pointSize', type: 'float'},
+ {name: 'id', type: 'vec4'}
+ ]
+}
+exports.contourShader = {
+ vertex: contourVertSrc,
+ fragment: contourFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec3'}
+ ]
+}
+
+},{"glslify":392}],268:[function(_dereq_,module,exports){
+'use strict'
+
+var DEFAULT_VERTEX_NORMALS_EPSILON = 1e-6; // may be too large if triangles are very small
+var DEFAULT_FACE_NORMALS_EPSILON = 1e-6;
+
+var createShader = _dereq_('gl-shader')
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createTexture = _dereq_('gl-texture2d')
+var normals = _dereq_('normals')
+var multiply = _dereq_('gl-mat4/multiply')
+var invert = _dereq_('gl-mat4/invert')
+var ndarray = _dereq_('ndarray')
+var colormap = _dereq_('colormap')
+var getContour = _dereq_('simplicial-complex-contour')
+var pool = _dereq_('typedarray-pool')
+var shaders = _dereq_('./lib/shaders')
+var closestPoint = _dereq_('./lib/closest-point')
+
+var meshShader = shaders.meshShader
+var wireShader = shaders.wireShader
+var pointShader = shaders.pointShader
+var pickShader = shaders.pickShader
+var pointPickShader = shaders.pointPickShader
+var contourShader = shaders.contourShader
+
+var identityMatrix = [
+ 1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1]
+
+
+function SimplicialMesh(gl
+ , texture
+ , triShader
+ , lineShader
+ , pointShader
+ , pickShader
+ , pointPickShader
+ , contourShader
+ , trianglePositions
+ , triangleIds
+ , triangleColors
+ , triangleUVs
+ , triangleNormals
+ , triangleVAO
+ , edgePositions
+ , edgeIds
+ , edgeColors
+ , edgeUVs
+ , edgeVAO
+ , pointPositions
+ , pointIds
+ , pointColors
+ , pointUVs
+ , pointSizes
+ , pointVAO
+ , contourPositions
+ , contourVAO) {
+
+ this.gl = gl
+ this.cells = []
+ this.positions = []
+ this.intensity = []
+ this.texture = texture
+ this.dirty = true
+
+ this.triShader = triShader
+ this.lineShader = lineShader
+ this.pointShader = pointShader
+ this.pickShader = pickShader
+ this.pointPickShader = pointPickShader
+ this.contourShader = contourShader
+
+ this.trianglePositions = trianglePositions
+ this.triangleColors = triangleColors
+ this.triangleNormals = triangleNormals
+ this.triangleUVs = triangleUVs
+ this.triangleIds = triangleIds
+ this.triangleVAO = triangleVAO
+ this.triangleCount = 0
+
+ this.lineWidth = 1
+ this.edgePositions = edgePositions
+ this.edgeColors = edgeColors
+ this.edgeUVs = edgeUVs
+ this.edgeIds = edgeIds
+ this.edgeVAO = edgeVAO
+ this.edgeCount = 0
+
+ this.pointPositions = pointPositions
+ this.pointColors = pointColors
+ this.pointUVs = pointUVs
+ this.pointSizes = pointSizes
+ this.pointIds = pointIds
+ this.pointVAO = pointVAO
+ this.pointCount = 0
+
+ this.contourLineWidth = 1
+ this.contourPositions = contourPositions
+ this.contourVAO = contourVAO
+ this.contourCount = 0
+ this.contourColor = [0,0,0]
+ this.contourEnable = true
+
+ this.pickId = 1
+ this.bounds = [
+ [ Infinity, Infinity, Infinity],
+ [-Infinity,-Infinity,-Infinity] ]
+ this.clipBounds = [
+ [-Infinity,-Infinity,-Infinity],
+ [ Infinity, Infinity, Infinity] ]
+
+ this.lightPosition = [1e5, 1e5, 0]
+ this.ambientLight = 0.8
+ this.diffuseLight = 0.8
+ this.specularLight = 2.0
+ this.roughness = 0.5
+ this.fresnel = 1.5
+
+ this.opacity = 1.0
+
+ this._model = identityMatrix
+ this._view = identityMatrix
+ this._projection = identityMatrix
+ this._resolution = [1,1]
+}
+
+var proto = SimplicialMesh.prototype
+
+proto.isOpaque = function() {
+ return this.opacity >= 1
+}
+
+proto.isTransparent = function() {
+ return this.opacity < 1
+}
+
+proto.pickSlots = 1
+
+proto.setPickBase = function(id) {
+ this.pickId = id
+}
+
+function genColormap(param) {
+ var colors = colormap({
+ colormap: param
+ , nshades: 256
+ , format: 'rgba'
+ })
+
+ var result = new Uint8Array(256*4)
+ for(var i=0; i<256; ++i) {
+ var c = colors[i]
+ for(var j=0; j<3; ++j) {
+ result[4*i+j] = c[j]
+ }
+ result[4*i+3] = c[3]*255
+ }
+
+ return ndarray(result, [256,256,4], [4,0,1])
+}
+
+function unpackIntensity(cells, numVerts, cellIntensity) {
+ var result = new Array(numVerts)
+ for(var i=0; i 0) {
+ var shader = this.triShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0 && this.lineWidth > 0) {
+ var shader = this.lineShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+
+ if(this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {
+ var shader = this.contourShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.contourVAO.bind()
+ gl.drawArrays(gl.LINES, 0, this.contourCount)
+ this.contourVAO.unbind()
+ }
+}
+
+proto.drawPick = function(params) {
+ params = params || {}
+
+ var gl = this.gl
+
+ var model = params.model || identityMatrix
+ var view = params.view || identityMatrix
+ var projection = params.projection || identityMatrix
+
+ var clipBounds = [[-1e6,-1e6,-1e6],[1e6,1e6,1e6]]
+ for(var i=0; i<3; ++i) {
+ clipBounds[0][i] = Math.max(clipBounds[0][i], this.clipBounds[0][i])
+ clipBounds[1][i] = Math.min(clipBounds[1][i], this.clipBounds[1][i])
+ }
+
+ //Save camera parameters
+ this._model = [].slice.call(model)
+ this._view = [].slice.call(view)
+ this._projection = [].slice.call(projection)
+ this._resolution = [gl.drawingBufferWidth, gl.drawingBufferHeight]
+
+ var uniforms = {
+ model: model,
+ view: view,
+ projection: projection,
+ clipBounds: clipBounds,
+ pickId: this.pickId / 255.0,
+ }
+
+ var shader = this.pickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ if(this.triangleCount > 0) {
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0) {
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointPickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+}
+
+
+proto.pick = function(pickData) {
+ if(!pickData) {
+ return null
+ }
+ if(pickData.id !== this.pickId) {
+ return null
+ }
+
+ var cellId = pickData.value[0] + 256*pickData.value[1] + 65536*pickData.value[2]
+ var cell = this.cells[cellId]
+ var positions = this.positions
+
+ var simplex = new Array(cell.length)
+ for(var i=0; i tickOffset[start]) {
+ shader.uniforms.dataAxis = DATA_AXIS
+ shader.uniforms.screenOffset = SCREEN_OFFSET
+ shader.uniforms.color = textColor[axis]
+ shader.uniforms.angle = textAngle[axis]
+ gl.drawArrays(
+ gl.TRIANGLES,
+ tickOffset[start],
+ tickOffset[end] - tickOffset[start])
+ }
+ }
+ if(labelEnable[axis] && labelCount) {
+ SCREEN_OFFSET[axis^1] -= screenScale * pixelRatio * labelPad[axis]
+ shader.uniforms.dataAxis = ZERO_2
+ shader.uniforms.screenOffset = SCREEN_OFFSET
+ shader.uniforms.color = labelColor[axis]
+ shader.uniforms.angle = labelAngle[axis]
+ gl.drawArrays(
+ gl.TRIANGLES,
+ labelOffset,
+ labelCount)
+ }
+
+ SCREEN_OFFSET[axis^1] = screenScale * viewBox[2+(axis^1)] - 1.0
+ if(tickEnable[axis+2]) {
+ SCREEN_OFFSET[axis^1] += screenScale * pixelRatio * tickPad[axis+2]
+ if(start < end && tickOffset[end] > tickOffset[start]) {
+ shader.uniforms.dataAxis = DATA_AXIS
+ shader.uniforms.screenOffset = SCREEN_OFFSET
+ shader.uniforms.color = textColor[axis+2]
+ shader.uniforms.angle = textAngle[axis+2]
+ gl.drawArrays(
+ gl.TRIANGLES,
+ tickOffset[start],
+ tickOffset[end] - tickOffset[start])
+ }
+ }
+ if(labelEnable[axis+2] && labelCount) {
+ SCREEN_OFFSET[axis^1] += screenScale * pixelRatio * labelPad[axis+2]
+ shader.uniforms.dataAxis = ZERO_2
+ shader.uniforms.screenOffset = SCREEN_OFFSET
+ shader.uniforms.color = labelColor[axis+2]
+ shader.uniforms.angle = labelAngle[axis+2]
+ gl.drawArrays(
+ gl.TRIANGLES,
+ labelOffset,
+ labelCount)
+ }
+
+ }
+})()
+
+proto.drawTitle = (function() {
+ var DATA_AXIS = [0,0]
+ var SCREEN_OFFSET = [0,0]
+
+ return function() {
+ var plot = this.plot
+ var shader = this.shader
+ var gl = plot.gl
+ var screenBox = plot.screenBox
+ var titleCenter = plot.titleCenter
+ var titleAngle = plot.titleAngle
+ var titleColor = plot.titleColor
+ var pixelRatio = plot.pixelRatio
+
+ if(!this.titleCount) {
+ return
+ }
+
+ for(var i=0; i<2; ++i) {
+ SCREEN_OFFSET[i] = 2.0 * (titleCenter[i]*pixelRatio - screenBox[i]) /
+ (screenBox[2+i] - screenBox[i]) - 1
+ }
+
+ shader.bind()
+ shader.uniforms.dataAxis = DATA_AXIS
+ shader.uniforms.screenOffset = SCREEN_OFFSET
+ shader.uniforms.angle = titleAngle
+ shader.uniforms.color = titleColor
+
+ gl.drawArrays(gl.TRIANGLES, this.titleOffset, this.titleCount)
+ }
+})()
+
+proto.bind = (function() {
+ var DATA_SHIFT = [0,0]
+ var DATA_SCALE = [0,0]
+ var TEXT_SCALE = [0,0]
+
+ return function() {
+ var plot = this.plot
+ var shader = this.shader
+ var bounds = plot._tickBounds
+ var dataBox = plot.dataBox
+ var screenBox = plot.screenBox
+ var viewBox = plot.viewBox
+
+ shader.bind()
+
+ //Set up coordinate scaling uniforms
+ for(var i=0; i<2; ++i) {
+
+ var lo = bounds[i]
+ var hi = bounds[i+2]
+ var boundScale = hi - lo
+ var dataCenter = 0.5 * (dataBox[i+2] + dataBox[i])
+ var dataWidth = (dataBox[i+2] - dataBox[i])
+
+ var viewLo = viewBox[i]
+ var viewHi = viewBox[i+2]
+ var viewScale = viewHi - viewLo
+ var screenLo = screenBox[i]
+ var screenHi = screenBox[i+2]
+ var screenScale = screenHi - screenLo
+
+ DATA_SCALE[i] = 2.0 * boundScale / dataWidth * viewScale / screenScale
+ DATA_SHIFT[i] = 2.0 * (lo - dataCenter) / dataWidth * viewScale / screenScale
+ }
+
+ TEXT_SCALE[1] = 2.0 * plot.pixelRatio / (screenBox[3] - screenBox[1])
+ TEXT_SCALE[0] = TEXT_SCALE[1] * (screenBox[3] - screenBox[1]) / (screenBox[2] - screenBox[0])
+
+ shader.uniforms.dataScale = DATA_SCALE
+ shader.uniforms.dataShift = DATA_SHIFT
+ shader.uniforms.textScale = TEXT_SCALE
+
+ //Set attributes
+ this.vbo.bind()
+ shader.attributes.textCoordinate.pointer()
+ }
+})()
+
+proto.update = function(options) {
+ var vertices = []
+ var axesTicks = options.ticks
+ var bounds = options.bounds
+ var i, j, k, data, scale, dimension
+
+ for(dimension=0; dimension<2; ++dimension) {
+ var offsets = [Math.floor(vertices.length/3)], tickX = [-Infinity]
+
+ //Copy vertices over to buffer
+ var ticks = axesTicks[dimension]
+ for(i=0; i= 0)) {
+ continue
+ }
+
+ var zeroIntercept = screenBox[i] -
+ dataBox[i] * (screenBox[i+2] - screenBox[i]) / (dataBox[i+2] - dataBox[i])
+
+ if(i === 0) {
+ line.drawLine(
+ zeroIntercept, screenBox[1], zeroIntercept, screenBox[3],
+ zeroLineWidth[i],
+ zeroLineColor[i])
+ } else {
+ line.drawLine(
+ screenBox[0], zeroIntercept, screenBox[2], zeroIntercept,
+ zeroLineWidth[i],
+ zeroLineColor[i])
+ }
+ }
+ }
+
+ //Draw traces
+ for(var i=0; i=0; --i) {
+ this.objects[i].dispose()
+ }
+ this.objects.length = 0
+ for(var i=this.overlays.length-1; i>=0; --i) {
+ this.overlays[i].dispose()
+ }
+ this.overlays.length = 0
+
+ this.gl = null
+}
+
+proto.addObject = function(object) {
+ if(this.objects.indexOf(object) < 0) {
+ this.objects.push(object)
+ this.setDirty()
+ }
+}
+
+proto.removeObject = function(object) {
+ var objects = this.objects
+ for(var i=0; i 0) {
+ var base = Math.round(Math.pow(10, y))
+ return Math.ceil(x/base) * base
+ }
+ return Math.ceil(x)
+}
+
+function defaultBool(x) {
+ if(typeof x === 'boolean') {
+ return x
+ }
+ return true
+}
+
+function createScene(options) {
+ options = options || {}
+
+ var stopped = false
+
+ var pixelRatio = options.pixelRatio || parseFloat(window.devicePixelRatio)
+
+ var canvas = options.canvas
+ if(!canvas) {
+ canvas = document.createElement('canvas')
+ if(options.container) {
+ var container = options.container
+ container.appendChild(canvas)
+ } else {
+ document.body.appendChild(canvas)
+ }
+ }
+
+ var gl = options.gl
+ if(!gl) {
+ gl = getContext(canvas,
+ options.glOptions || {
+ premultipliedAlpha: true,
+ antialias: true,
+ preserveDrawingBuffer: isMobile
+ })
+ }
+ if(!gl) {
+ throw new Error('webgl not supported')
+ }
+
+ //Initial bounds
+ var bounds = options.bounds || [[-10,-10,-10], [10,10,10]]
+
+ //Create selection
+ var selection = new MouseSelect()
+
+ //Accumulation buffer
+ var accumBuffer = createFBO(gl,
+ [gl.drawingBufferWidth, gl.drawingBufferHeight], {
+ preferFloat: !isMobile
+ })
+
+ var accumShader = createShader(gl)
+
+ //Create a camera
+ var cameraOptions = options.camera || {
+ eye: [2,0,0],
+ center: [0,0,0],
+ up: [0,1,0],
+ zoomMin: 0.1,
+ zoomMax: 100,
+ mode: 'turntable'
+ }
+
+ //Create axes
+ var axesOptions = options.axes || {}
+ var axes = createAxes(gl, axesOptions)
+ axes.enable = !axesOptions.disable
+
+ //Create spikes
+ var spikeOptions = options.spikes || {}
+ var spikes = createSpikes(gl, spikeOptions)
+
+ //Object list is empty initially
+ var objects = []
+ var pickBufferIds = []
+ var pickBufferCount = []
+ var pickBuffers = []
+
+ //Dirty flag, skip redraw if scene static
+ var dirty = true
+ var pickDirty = true
+
+ var projection = new Array(16)
+ var model = new Array(16)
+
+ var cameraParams = {
+ view: null,
+ projection: projection,
+ model: model
+ }
+
+ var pickDirty = true
+
+ var viewShape = [ gl.drawingBufferWidth, gl.drawingBufferHeight ]
+
+ //Create scene object
+ var scene = {
+ gl: gl,
+ contextLost: false,
+ pixelRatio: options.pixelRatio || parseFloat(window.devicePixelRatio),
+ canvas: canvas,
+ selection: selection,
+ camera: createCamera(canvas, cameraOptions),
+ axes: axes,
+ axesPixels: null,
+ spikes: spikes,
+ bounds: bounds,
+ objects: objects,
+ shape: viewShape,
+ aspect: options.aspectRatio || [1,1,1],
+ pickRadius: options.pickRadius || 10,
+ zNear: options.zNear || 0.01,
+ zFar: options.zFar || 1000,
+ fovy: options.fovy || Math.PI/4,
+ clearColor: options.clearColor || [0,0,0,0],
+ autoResize: defaultBool(options.autoResize),
+ autoBounds: defaultBool(options.autoBounds),
+ autoScale: !!options.autoScale,
+ autoCenter: defaultBool(options.autoCenter),
+ clipToBounds: defaultBool(options.clipToBounds),
+ snapToData: !!options.snapToData,
+ onselect: options.onselect || null,
+ onrender: options.onrender || null,
+ onclick: options.onclick || null,
+ cameraParams: cameraParams,
+ oncontextloss: null,
+ mouseListener: null
+ }
+
+ var pickShape = [ (gl.drawingBufferWidth/scene.pixelRatio)|0, (gl.drawingBufferHeight/scene.pixelRatio)|0 ]
+
+ function resizeListener() {
+ if(stopped) {
+ return
+ }
+ if(!scene.autoResize) {
+ return
+ }
+ var parent = canvas.parentNode
+ var width = 1
+ var height = 1
+ if(parent && parent !== document.body) {
+ width = parent.clientWidth
+ height = parent.clientHeight
+ } else {
+ width = window.innerWidth
+ height = window.innerHeight
+ }
+ var nextWidth = Math.ceil(width * scene.pixelRatio)|0
+ var nextHeight = Math.ceil(height * scene.pixelRatio)|0
+ if(nextWidth !== canvas.width || nextHeight !== canvas.height) {
+ canvas.width = nextWidth
+ canvas.height = nextHeight
+ var style = canvas.style
+ style.position = style.position || 'absolute'
+ style.left = '0px'
+ style.top = '0px'
+ style.width = width + 'px'
+ style.height = height + 'px'
+ dirty = true
+ }
+ }
+ if(scene.autoResize) {
+ resizeListener()
+ }
+ window.addEventListener('resize', resizeListener)
+
+ function reallocPickIds() {
+ var numObjs = objects.length
+ var numPick = pickBuffers.length
+ for(var i=0; i 0 && pickBufferCount[numPick-1] === 0) {
+ pickBufferCount.pop()
+ pickBuffers.pop().dispose()
+ }
+ }
+
+ scene.update = function(options) {
+ if(stopped) {
+ return
+ }
+ options = options || {}
+ dirty = true
+ pickDirty = true
+ }
+
+ scene.add = function(obj) {
+ if(stopped) {
+ return
+ }
+ obj.axes = axes
+ objects.push(obj)
+ pickBufferIds.push(-1)
+ dirty = true
+ pickDirty = true
+ reallocPickIds()
+ }
+
+ scene.remove = function(obj) {
+ if(stopped) {
+ return
+ }
+ var idx = objects.indexOf(obj)
+ if(idx < 0) {
+ return
+ }
+ objects.splice(idx, 1)
+ pickBufferIds.pop()
+ dirty = true
+ pickDirty = true
+ reallocPickIds()
+ }
+
+ scene.dispose = function() {
+ if(stopped) {
+ return
+ }
+
+ stopped = true
+
+ window.removeEventListener('resize', resizeListener)
+ canvas.removeEventListener('webglcontextlost', checkContextLoss)
+ scene.mouseListener.enabled = false
+
+ if(scene.contextLost) {
+ return
+ }
+
+ //Destroy objects
+ axes.dispose()
+ spikes.dispose()
+ for(var i=0; i selection.distance) {
+ continue
+ }
+ for(var j=0; j 1.0) {\n discard;\n }\n baseColor = mix(borderColor, color, step(radius, centerFraction));\n gl_FragColor = vec4(baseColor.rgb * baseColor.a, baseColor.a);\n }\n}\n"])
+exports.pickVertex = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\nattribute vec4 pickId;\n\nuniform mat3 matrix;\nuniform float pointSize;\nuniform vec4 pickOffset;\n\nvarying vec4 fragId;\n\nvoid main() {\n vec3 hgPosition = matrix * vec3(position, 1);\n gl_Position = vec4(hgPosition.xy, 0, hgPosition.z);\n gl_PointSize = pointSize;\n\n vec4 id = pickId + pickOffset;\n id.y += floor(id.x / 256.0);\n id.x -= floor(id.x / 256.0) * 256.0;\n\n id.z += floor(id.y / 256.0);\n id.y -= floor(id.y / 256.0) * 256.0;\n\n id.w += floor(id.z / 256.0);\n id.z -= floor(id.z / 256.0) * 256.0;\n\n fragId = id;\n}\n"])
+exports.pickFragment = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragId;\n\nvoid main() {\n float radius = length(2.0 * gl_PointCoord.xy - 1.0);\n if(radius > 1.0) {\n discard;\n }\n gl_FragColor = fragId / 255.0;\n}\n"])
+
+},{"glslify":392}],279:[function(_dereq_,module,exports){
+'use strict'
+
+var createShader = _dereq_('gl-shader')
+var createBuffer = _dereq_('gl-buffer')
+
+var pool = _dereq_('typedarray-pool')
+
+var SHADERS = _dereq_('./lib/shader')
+
+module.exports = createPointcloud2D
+
+function Pointcloud2D(plot, offsetBuffer, pickBuffer, shader, pickShader) {
+ this.plot = plot
+ this.offsetBuffer = offsetBuffer
+ this.pickBuffer = pickBuffer
+ this.shader = shader
+ this.pickShader = pickShader
+ this.sizeMin = 0.5
+ this.sizeMinCap = 2
+ this.sizeMax = 20
+ this.areaRatio = 1.0
+ this.pointCount = 0
+ this.color = [1, 0, 0, 1]
+ this.borderColor = [0, 0, 0, 1]
+ this.blend = false
+ this.pickOffset = 0
+ this.points = null
+}
+
+var proto = Pointcloud2D.prototype
+
+proto.dispose = function() {
+ this.shader.dispose()
+ this.pickShader.dispose()
+ this.offsetBuffer.dispose()
+ this.pickBuffer.dispose()
+ this.plot.removeObject(this)
+}
+
+proto.update = function(options) {
+
+ var i
+
+ options = options || {}
+
+ function dflt(opt, value) {
+ if(opt in options) {
+ return options[opt]
+ }
+ return value
+ }
+
+ this.sizeMin = dflt('sizeMin', 0.5)
+ // this.sizeMinCap = dflt('sizeMinCap', 2)
+ this.sizeMax = dflt('sizeMax', 20)
+ this.color = dflt('color', [1, 0, 0, 1]).slice()
+ this.areaRatio = dflt('areaRatio', 1)
+ this.borderColor = dflt('borderColor', [0, 0, 0, 1]).slice()
+ this.blend = dflt('blend', false)
+
+ //Update point data
+
+ // Attempt straight-through processing (STP) to avoid allocation and copy
+ // TODO eventually abstract out STP logic, maybe into `pool` or a layer above
+ var pointCount = options.positions.length >>> 1
+ var dataStraightThrough = options.positions instanceof Float32Array
+ var idStraightThrough = options.idToIndex instanceof Int32Array && options.idToIndex.length >= pointCount // permit larger to help reuse
+
+ var data = options.positions
+ var packed = dataStraightThrough ? data : pool.mallocFloat32(data.length)
+ var packedId = idStraightThrough ? options.idToIndex : pool.mallocInt32(pointCount)
+
+ if(!dataStraightThrough) {
+ packed.set(data)
+ }
+
+ if(!idStraightThrough) {
+ packed.set(data)
+ for(i = 0; i < pointCount; i++) {
+ packedId[i] = i
+ }
+ }
+
+ this.points = data
+
+ this.offsetBuffer.update(packed)
+ this.pickBuffer.update(packedId)
+
+ if(!dataStraightThrough) {
+ pool.free(packed)
+ }
+
+ if(!idStraightThrough) {
+ pool.free(packedId)
+ }
+
+ this.pointCount = pointCount
+ this.pickOffset = 0
+}
+
+function count(points, dataBox) {
+ var visiblePointCountEstimate = 0
+ var length = points.length >>> 1
+ var i
+ for(i = 0; i < length; i++) {
+ var x = points[i * 2]
+ var y = points[i * 2 + 1]
+ if(x >= dataBox[0] && x <= dataBox[2] && y >= dataBox[1] && y <= dataBox[3])
+ visiblePointCountEstimate++
+ }
+ return visiblePointCountEstimate
+}
+
+proto.unifiedDraw = (function() {
+ var MATRIX = [1, 0, 0,
+ 0, 1, 0,
+ 0, 0, 1]
+ var PICK_VEC4 = [0, 0, 0, 0]
+return function(pickOffset) {
+ var pick = pickOffset !== void(0)
+
+ var shader = pick ? this.pickShader : this.shader
+ var gl = this.plot.gl
+ var dataBox = this.plot.dataBox
+
+ if(this.pointCount === 0) {
+ return pickOffset
+ }
+
+ var dataX = dataBox[2] - dataBox[0]
+ var dataY = dataBox[3] - dataBox[1]
+
+ var visiblePointCountEstimate = count(this.points, dataBox)
+ var basicPointSize = this.plot.pickPixelRatio * Math.max(Math.min(this.sizeMinCap, this.sizeMin), Math.min(this.sizeMax, this.sizeMax / Math.pow(visiblePointCountEstimate, 0.33333)))
+
+ MATRIX[0] = 2.0 / dataX
+ MATRIX[4] = 2.0 / dataY
+ MATRIX[6] = -2.0 * dataBox[0] / dataX - 1.0
+ MATRIX[7] = -2.0 * dataBox[1] / dataY - 1.0
+
+ this.offsetBuffer.bind()
+
+ shader.bind()
+ shader.attributes.position.pointer()
+ shader.uniforms.matrix = MATRIX
+ shader.uniforms.color = this.color
+ shader.uniforms.borderColor = this.borderColor
+ shader.uniforms.pointCloud = basicPointSize < 5
+ shader.uniforms.pointSize = basicPointSize
+ shader.uniforms.centerFraction = Math.min(1, Math.max(0, Math.sqrt(1 - this.areaRatio)))
+
+ if(pick) {
+
+ PICK_VEC4[0] = ( pickOffset & 0xff)
+ PICK_VEC4[1] = ((pickOffset >> 8) & 0xff)
+ PICK_VEC4[2] = ((pickOffset >> 16) & 0xff)
+ PICK_VEC4[3] = ((pickOffset >> 24) & 0xff)
+
+ this.pickBuffer.bind()
+ shader.attributes.pickId.pointer(gl.UNSIGNED_BYTE)
+ shader.uniforms.pickOffset = PICK_VEC4
+ this.pickOffset = pickOffset
+ }
+
+ // Worth switching these off, but we can't make assumptions about other
+ // renderers, so let's restore it after each draw
+ var blend = gl.getParameter(gl.BLEND)
+ var dither = gl.getParameter(gl.DITHER)
+
+ if(blend && !this.blend)
+ gl.disable(gl.BLEND)
+ if(dither)
+ gl.disable(gl.DITHER)
+
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+
+ if(blend && !this.blend)
+ gl.enable(gl.BLEND)
+ if(dither)
+ gl.enable(gl.DITHER)
+
+ return pickOffset + this.pointCount
+}
+})()
+
+proto.draw = proto.unifiedDraw
+proto.drawPick = proto.unifiedDraw
+
+proto.pick = function(x, y, value) {
+ var pickOffset = this.pickOffset
+ var pointCount = this.pointCount
+ if(value < pickOffset || value >= pickOffset + pointCount) {
+ return null
+ }
+ var pointId = value - pickOffset
+ var points = this.points
+ return {
+ object: this,
+ pointId: pointId,
+ dataCoord: [points[2 * pointId], points[2 * pointId + 1] ]
+ }
+}
+
+function createPointcloud2D(plot, options) {
+ var gl = plot.gl
+ var buffer = createBuffer(gl)
+ var pickBuffer = createBuffer(gl)
+ var shader = createShader(gl, SHADERS.pointVertex, SHADERS.pointFragment)
+ var pickShader = createShader(gl, SHADERS.pickVertex, SHADERS.pickFragment)
+
+ var result = new Pointcloud2D(plot, buffer, pickBuffer, shader, pickShader)
+ result.update(options)
+
+ //Register with plot
+ plot.addObject(result)
+
+ return result
+}
+
+},{"./lib/shader":278,"gl-buffer":230,"gl-shader":288,"typedarray-pool":522}],280:[function(_dereq_,module,exports){
+module.exports = slerp
+
+/**
+ * Performs a spherical linear interpolation between two quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a the first operand
+ * @param {quat} b the second operand
+ * @param {Number} t interpolation amount between the two inputs
+ * @returns {quat} out
+ */
+function slerp (out, a, b, t) {
+ // benchmarks:
+ // http://jsperf.com/quaternion-slerp-implementations
+
+ var ax = a[0], ay = a[1], az = a[2], aw = a[3],
+ bx = b[0], by = b[1], bz = b[2], bw = b[3]
+
+ var omega, cosom, sinom, scale0, scale1
+
+ // calc cosine
+ cosom = ax * bx + ay * by + az * bz + aw * bw
+ // adjust signs (if necessary)
+ if (cosom < 0.0) {
+ cosom = -cosom
+ bx = -bx
+ by = -by
+ bz = -bz
+ bw = -bw
+ }
+ // calculate coefficients
+ if ((1.0 - cosom) > 0.000001) {
+ // standard case (slerp)
+ omega = Math.acos(cosom)
+ sinom = Math.sin(omega)
+ scale0 = Math.sin((1.0 - t) * omega) / sinom
+ scale1 = Math.sin(t * omega) / sinom
+ } else {
+ // "from" and "to" quaternions are very close
+ // ... so we can do a linear interpolation
+ scale0 = 1.0 - t
+ scale1 = t
+ }
+ // calculate final values
+ out[0] = scale0 * ax + scale1 * bx
+ out[1] = scale0 * ay + scale1 * by
+ out[2] = scale0 * az + scale1 * bz
+ out[3] = scale0 * aw + scale1 * bw
+
+ return out
+}
+
+},{}],281:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function(a){
+ return (!a && a !== 0) ? '' : a.toString();
+}
+
+},{}],282:[function(_dereq_,module,exports){
+"use strict"
+
+var vectorizeText = _dereq_("vectorize-text")
+
+module.exports = getGlyph
+
+var GLYPH_CACHE = {}
+
+function getGlyph(symbol, font) {
+ var fontCache = GLYPH_CACHE[font]
+ if(!fontCache) {
+ fontCache = GLYPH_CACHE[font] = {}
+ }
+ if(symbol in fontCache) {
+ return fontCache[symbol]
+ }
+
+ //Get line and triangle meshes for glyph
+ var lineSymbol = vectorizeText(symbol, {
+ textAlign: "center",
+ textBaseline: "middle",
+ lineHeight: 1.0,
+ font: font
+ })
+ var triSymbol = vectorizeText(symbol, {
+ triangles: true,
+ textAlign: "center",
+ textBaseline: "middle",
+ lineHeight: 1.0,
+ font: font
+ })
+
+ //Calculate bounding box
+ var bounds = [[Infinity,Infinity], [-Infinity,-Infinity]]
+ for(var i=0; i max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform vec4 highlightId;\nuniform float highlightScale;\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n gl_Position = vec4(0,0,0,0);\n } else {\n float scale = 1.0;\n if(distance(highlightId, id) < 0.0001) {\n scale = highlightScale;\n }\n\n vec4 worldPosition = model * vec4(position, 1);\n vec4 viewPosition = view * worldPosition;\n viewPosition = viewPosition / viewPosition.w;\n vec4 clipPosition = projection * (viewPosition + scale * vec4(glyph.x, -glyph.y, 0, 0));\n\n gl_Position = clipPosition;\n interpColor = color;\n pickId = id;\n dataCoordinate = position;\n }\n}"])
+var orthographicVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float highlightScale, pixelRatio;\nuniform vec4 highlightId;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n gl_Position = vec4(0,0,0,0);\n } else {\n float scale = pixelRatio;\n if(distance(highlightId.bgr, id.bgr) < 0.001) {\n scale *= highlightScale;\n }\n\n vec4 worldPosition = model * vec4(position, 1.0);\n vec4 viewPosition = view * worldPosition;\n vec4 clipPosition = projection * viewPosition;\n clipPosition /= clipPosition.w;\n\n gl_Position = clipPosition + vec4(screenSize * scale * vec2(glyph.x, -glyph.y), 0.0, 0.0);\n interpColor = color;\n pickId = id;\n dataCoordinate = position;\n }\n}"])
+var projectionVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform float highlightScale;\nuniform vec4 highlightId;\nuniform vec3 axes[2];\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float scale, pixelRatio;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n gl_Position = vec4(0,0,0,0);\n } else {\n float lscale = pixelRatio * scale;\n if(distance(highlightId, id) < 0.0001) {\n lscale *= highlightScale;\n }\n\n vec4 clipCenter = projection * view * model * vec4(position, 1);\n vec3 dataPosition = position + 0.5*lscale*(axes[0] * glyph.x + axes[1] * glyph.y) * clipCenter.w * screenSize.y;\n vec4 clipPosition = projection * view * model * vec4(dataPosition, 1);\n\n gl_Position = clipPosition;\n interpColor = color;\n pickId = id;\n dataCoordinate = dataPosition;\n }\n}\n"])
+var drawFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float opacity;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n if (outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate)) discard;\n\n gl_FragColor = interpColor * opacity;\n}\n"])
+var pickFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float pickGroup;\n\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n if (outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate)) discard;\n\n gl_FragColor = vec4(pickGroup, pickId.bgr);\n}"])
+
+var ATTRIBUTES = [
+ {name: 'position', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'glyph', type: 'vec2'},
+ {name: 'id', type: 'vec4'}
+]
+
+var perspective = {
+ vertex: perspectiveVertSrc,
+ fragment: drawFragSrc,
+ attributes: ATTRIBUTES
+ },
+ ortho = {
+ vertex: orthographicVertSrc,
+ fragment: drawFragSrc,
+ attributes: ATTRIBUTES
+ },
+ project = {
+ vertex: projectionVertSrc,
+ fragment: drawFragSrc,
+ attributes: ATTRIBUTES
+ },
+ pickPerspective = {
+ vertex: perspectiveVertSrc,
+ fragment: pickFragSrc,
+ attributes: ATTRIBUTES
+ },
+ pickOrtho = {
+ vertex: orthographicVertSrc,
+ fragment: pickFragSrc,
+ attributes: ATTRIBUTES
+ },
+ pickProject = {
+ vertex: projectionVertSrc,
+ fragment: pickFragSrc,
+ attributes: ATTRIBUTES
+ }
+
+function createShader(gl, src) {
+ var shader = createShaderWrapper(gl, src)
+ var attr = shader.attributes
+ attr.position.location = 0
+ attr.color.location = 1
+ attr.glyph.location = 2
+ attr.id.location = 3
+ return shader
+}
+
+exports.createPerspective = function(gl) {
+ return createShader(gl, perspective)
+}
+exports.createOrtho = function(gl) {
+ return createShader(gl, ortho)
+}
+exports.createProject = function(gl) {
+ return createShader(gl, project)
+}
+exports.createPickPerspective = function(gl) {
+ return createShader(gl, pickPerspective)
+}
+exports.createPickOrtho = function(gl) {
+ return createShader(gl, pickOrtho)
+}
+exports.createPickProject = function(gl) {
+ return createShader(gl, pickProject)
+}
+
+},{"gl-shader":288,"glslify":392}],284:[function(_dereq_,module,exports){
+'use strict'
+
+var isAllBlank = _dereq_('is-string-blank')
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var pool = _dereq_('typedarray-pool')
+var mat4mult = _dereq_('gl-mat4/multiply')
+var shaders = _dereq_('./lib/shaders')
+var getGlyph = _dereq_('./lib/glyphs')
+var getSimpleString = _dereq_('./lib/get-simple-string')
+
+var IDENTITY = [1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1]
+
+module.exports = createPointCloud
+
+function transformMat4(x, m) {
+ var x0 = x[0]
+ var x1 = x[1]
+ var x2 = x[2]
+ var x3 = x[3]
+ x[0] = m[0] * x0 + m[4] * x1 + m[8] * x2 + m[12] * x3
+ x[1] = m[1] * x0 + m[5] * x1 + m[9] * x2 + m[13] * x3
+ x[2] = m[2] * x0 + m[6] * x1 + m[10] * x2 + m[14] * x3
+ x[3] = m[3] * x0 + m[7] * x1 + m[11] * x2 + m[15] * x3
+ return x
+}
+
+function project(p, v, m, x) {
+ transformMat4(x, x, m)
+ transformMat4(x, x, v)
+ return transformMat4(x, x, p)
+}
+
+function clampVec(v) {
+ var result = new Array(3)
+ for(var i=0; i<3; ++i) {
+ result[i] = Math.min(Math.max(v[i], -1e8), 1e8)
+ }
+ return result
+}
+
+function ScatterPlotPickResult(index, position) {
+ this.index = index
+ this.dataCoordinate = this.position = position
+}
+
+function PointCloud(
+ gl,
+ shader,
+ orthoShader,
+ projectShader,
+ pointBuffer,
+ colorBuffer,
+ glyphBuffer,
+ idBuffer,
+ vao,
+ pickPerspectiveShader,
+ pickOrthoShader,
+ pickProjectShader) {
+
+ this.gl = gl
+
+ this.pixelRatio = 1
+
+ this.shader = shader
+ this.orthoShader = orthoShader
+ this.projectShader = projectShader
+
+ this.pointBuffer = pointBuffer
+ this.colorBuffer = colorBuffer
+ this.glyphBuffer = glyphBuffer
+ this.idBuffer = idBuffer
+ this.vao = vao
+ this.vertexCount = 0
+ this.lineVertexCount = 0
+
+ this.opacity = 1.0
+
+ this.lineWidth = 0
+ this.projectScale = [2.0/3.0, 2.0/3.0, 2.0/3.0]
+ this.projectOpacity = [1,1,1]
+
+ this.pickId = 0
+ this.pickPerspectiveShader = pickPerspectiveShader
+ this.pickOrthoShader = pickOrthoShader
+ this.pickProjectShader = pickProjectShader
+ this.points = []
+
+ this._selectResult = new ScatterPlotPickResult(0, [0,0,0])
+
+ this.useOrtho = true
+ this.bounds = [[ Infinity,Infinity,Infinity],
+ [-Infinity,-Infinity,-Infinity]]
+
+ //Axes projections
+ this.axesProject = [ true, true, true ]
+ this.axesBounds = [[-Infinity,-Infinity,-Infinity],
+ [ Infinity, Infinity, Infinity]]
+
+ this.highlightId = [1,1,1,1]
+ this.highlightScale = 2
+
+ this.clipBounds = [[-Infinity,-Infinity,-Infinity],
+ [ Infinity, Infinity, Infinity]]
+
+ this.dirty = true
+}
+
+var proto = PointCloud.prototype
+
+proto.pickSlots = 1
+
+proto.setPickBase = function(pickBase) {
+ this.pickId = pickBase
+}
+
+proto.isTransparent = function() {
+ if(this.opacity < 1) {
+ return true
+ }
+ for(var i=0; i<3; ++i) {
+ if(this.axesProject[i] && this.projectOpacity[i] < 1) {
+ return true
+ }
+ }
+ return false
+}
+
+proto.isOpaque = function() {
+ if(this.opacity >= 1) {
+ return true
+ }
+ for(var i=0; i<3; ++i) {
+ if(this.axesProject[i] && this.projectOpacity[i] >= 1) {
+ return true
+ }
+ }
+ return false
+}
+
+var VIEW_SHAPE = [0,0]
+var U_VEC = [0,0,0]
+var V_VEC = [0,0,0]
+var MU_VEC = [0,0,0,1]
+var MV_VEC = [0,0,0,1]
+var SCRATCH_MATRIX = IDENTITY.slice()
+var SCRATCH_VEC = [0,0,0]
+var CLIP_BOUNDS = [[0,0,0], [0,0,0]]
+
+function zeroVec(a) {
+ a[0] = a[1] = a[2] = 0
+ return a
+}
+
+function augment(hg, af) {
+ hg[0] = af[0]
+ hg[1] = af[1]
+ hg[2] = af[2]
+ hg[3] = 1
+ return hg
+}
+
+function setComponent(out, v, i, x) {
+ out[0] = v[0]
+ out[1] = v[1]
+ out[2] = v[2]
+ out[i] = x
+ return out
+}
+
+function getClipBounds(bounds) {
+ var result = CLIP_BOUNDS
+ for(var i=0; i<2; ++i) {
+ for(var j=0; j<3; ++j) {
+ result[i][j] = Math.max(Math.min(bounds[i][j], 1e8), -1e8)
+ }
+ }
+ return result
+}
+
+function drawProject(shader, points, camera, transparent, forceDraw) {
+ var axesProject = points.axesProject
+
+ var gl = points.gl
+ var uniforms = shader.uniforms
+ var model = camera.model || IDENTITY
+ var view = camera.view || IDENTITY
+ var projection = camera.projection || IDENTITY
+ var bounds = points.axesBounds
+ var clipBounds = getClipBounds(points.clipBounds)
+
+ var cubeAxis
+ if(points.axes && points.axes.lastCubeProps) {
+ cubeAxis = points.axes.lastCubeProps.axis
+ } else {
+ cubeAxis = [1,1,1]
+ }
+
+ VIEW_SHAPE[0] = 2.0/gl.drawingBufferWidth
+ VIEW_SHAPE[1] = 2.0/gl.drawingBufferHeight
+
+ shader.bind()
+ uniforms.view = view
+ uniforms.projection = projection
+ uniforms.screenSize = VIEW_SHAPE
+ uniforms.highlightId = points.highlightId
+ uniforms.highlightScale = points.highlightScale
+ uniforms.clipBounds = clipBounds
+ uniforms.pickGroup = points.pickId / 255.0
+ uniforms.pixelRatio = points.pixelRatio
+
+ for(var i=0; i<3; ++i) {
+ if(!axesProject[i]) {
+ continue
+ }
+ if((points.projectOpacity[i] < 1) !== transparent) {
+ continue
+ }
+
+ uniforms.scale = points.projectScale[i]
+ uniforms.opacity = points.projectOpacity[i]
+
+ //Project model matrix
+ var pmodel = SCRATCH_MATRIX
+ for(var j=0; j<16; ++j) {
+ pmodel[j] = 0
+ }
+ for(var j=0; j<4; ++j) {
+ pmodel[5*j] = 1
+ }
+ pmodel[5*i] = 0
+ if(cubeAxis[i] < 0) {
+ pmodel[12+i] = bounds[0][i]
+ } else {
+ pmodel[12+i] = bounds[1][i]
+ }
+ mat4mult(pmodel, model, pmodel)
+ uniforms.model = pmodel
+
+ //Compute initial axes
+ var u = (i+1)%3
+ var v = (i+2)%3
+ var du = zeroVec(U_VEC)
+ var dv = zeroVec(V_VEC)
+ du[u] = 1
+ dv[v] = 1
+
+ //Align orientation relative to viewer
+ var mdu = project(projection, view, model, augment(MU_VEC, du))
+ var mdv = project(projection, view, model, augment(MV_VEC, dv))
+ if(Math.abs(mdu[1]) > Math.abs(mdv[1])) {
+ var tmp = mdu
+ mdu = mdv
+ mdv = tmp
+ tmp = du
+ du = dv
+ dv = tmp
+ var t = u
+ u = v
+ v = t
+ }
+ if(mdu[0] < 0) {
+ du[u] = -1
+ }
+ if(mdv[1] > 0) {
+ dv[v] = -1
+ }
+ var su = 0.0
+ var sv = 0.0
+ for(var j=0; j<4; ++j) {
+ su += Math.pow(model[4*u+j], 2)
+ sv += Math.pow(model[4*v+j], 2)
+ }
+ du[u] /= Math.sqrt(su)
+ dv[v] /= Math.sqrt(sv)
+ uniforms.axes[0] = du
+ uniforms.axes[1] = dv
+
+ //Update fragment clip bounds
+ uniforms.fragClipBounds[0] = setComponent(SCRATCH_VEC, clipBounds[0], i, -1e8)
+ uniforms.fragClipBounds[1] = setComponent(SCRATCH_VEC, clipBounds[1], i, 1e8)
+
+ //Draw interior
+ points.vao.draw(gl.TRIANGLES, points.vertexCount)
+
+ //Draw edges
+ if(points.lineWidth > 0) {
+ gl.lineWidth(points.lineWidth)
+ points.vao.draw(gl.LINES, points.lineVertexCount, points.vertexCount)
+ }
+ }
+}
+
+
+var NEG_INFINITY3 = [-1e8, -1e8, -1e8]
+var POS_INFINITY3 = [1e8, 1e8, 1e8]
+var CLIP_GROUP = [NEG_INFINITY3, POS_INFINITY3]
+
+function drawFull(shader, pshader, points, camera, transparent, forceDraw) {
+ var gl = points.gl
+
+ points.vao.bind()
+
+ if(transparent === (points.opacity < 1) || forceDraw) {
+ shader.bind()
+ var uniforms = shader.uniforms
+
+ uniforms.model = camera.model || IDENTITY
+ uniforms.view = camera.view || IDENTITY
+ uniforms.projection = camera.projection || IDENTITY
+
+ VIEW_SHAPE[0] = 2.0/gl.drawingBufferWidth
+ VIEW_SHAPE[1] = 2.0/gl.drawingBufferHeight
+ uniforms.screenSize = VIEW_SHAPE
+
+ uniforms.highlightId = points.highlightId
+ uniforms.highlightScale = points.highlightScale
+
+ uniforms.fragClipBounds = CLIP_GROUP
+ uniforms.clipBounds = points.axes.bounds
+
+ uniforms.opacity = points.opacity
+ uniforms.pickGroup = points.pickId / 255.0
+
+ uniforms.pixelRatio = points.pixelRatio
+
+ //Draw interior
+ points.vao.draw(gl.TRIANGLES, points.vertexCount)
+
+ //Draw edges
+ if(points.lineWidth > 0) {
+ gl.lineWidth(points.lineWidth)
+ points.vao.draw(gl.LINES, points.lineVertexCount, points.vertexCount)
+ }
+ }
+
+ drawProject(pshader, points, camera, transparent, forceDraw)
+
+ points.vao.unbind()
+}
+
+proto.draw = function(camera) {
+ var shader = this.useOrtho ? this.orthoShader : this.shader
+ drawFull(shader, this.projectShader, this, camera, false, false)
+}
+
+proto.drawTransparent = function(camera) {
+ var shader = this.useOrtho ? this.orthoShader : this.shader
+ drawFull(shader, this.projectShader, this, camera, true, false)
+}
+
+proto.drawPick = function(camera) {
+ var shader = this.useOrtho ? this.pickOrthoShader : this.pickPerspectiveShader
+ drawFull(shader, this.pickProjectShader, this, camera, false, true)
+}
+
+proto.pick = function(selected) {
+ if(!selected) {
+ return null
+ }
+ if(selected.id !== this.pickId) {
+ return null
+ }
+ var x = selected.value[2] + (selected.value[1]<<8) + (selected.value[0]<<16)
+ if(x >= this.pointCount || x < 0) {
+ return null
+ }
+
+ //Unpack result
+ var coord = this.points[x]
+ var result = this._selectResult
+ result.index = x
+ for(var i=0; i<3; ++i) {
+ result.position[i] = result.dataCoordinate[i] = coord[i]
+ }
+ return result
+}
+
+proto.highlight = function(selection) {
+ if(!selection) {
+ this.highlightId = [1,1,1,1]
+ } else {
+ var pointId = selection.index
+ var a0 = pointId &0xff
+ var a1 = (pointId>>8) &0xff
+ var a2 = (pointId>>16)&0xff
+ this.highlightId = [a0/255.0, a1/255.0, a2/255.0, 0]
+ }
+}
+
+function get_glyphData(glyphs, index, font) {
+ var str
+
+ // use the data if presented in an array
+ if(Array.isArray(glyphs)) {
+ if(index < glyphs.length) {
+ str = glyphs[index]
+ } else {
+ str = undefined
+ }
+ } else {
+ str = glyphs
+ }
+
+ str = getSimpleString(str) // this would handle undefined cases
+
+ var visible = true
+ if(isAllBlank(str)) {
+ str = '▼' // Note: this special character may have minimum number of surfaces
+ visible = false
+ }
+
+ var glyph = getGlyph(str, font)
+
+ return { mesh:glyph[0],
+ lines:glyph[1],
+ bounds:glyph[2],
+ visible:visible };
+}
+
+
+
+proto.update = function(options) {
+
+ options = options || {}
+
+ if('perspective' in options) {
+ this.useOrtho = !options.perspective
+ }
+ if('orthographic' in options) {
+ this.useOrtho = !!options.orthographic
+ }
+ if('lineWidth' in options) {
+ this.lineWidth = options.lineWidth
+ }
+ if('project' in options) {
+ if(Array.isArray(options.project)) {
+ this.axesProject = options.project
+ } else {
+ var v = !!options.project
+ this.axesProject = [v,v,v]
+ }
+ }
+ if('projectScale' in options) {
+ if(Array.isArray(options.projectScale)) {
+ this.projectScale = options.projectScale.slice()
+ } else {
+ var s = +options.projectScale
+ this.projectScale = [s,s,s]
+ }
+ }
+ if('projectOpacity' in options) {
+ if(Array.isArray(options.projectOpacity)) {
+ this.projectOpacity = options.projectOpacity.slice()
+ } else {
+ var s = +options.projectOpacity
+ this.projectOpacity = [s,s,s]
+ }
+ }
+ if('opacity' in options) {
+ this.opacity = options.opacity
+ }
+
+ //Set dirty flag
+ this.dirty = true
+
+ //Create new buffers
+ var points = options.position
+
+ //Text font
+ var font = options.font || 'normal'
+ var alignment = options.alignment || [0,0]
+
+ //Bounds
+ var lowerBound = [ Infinity, Infinity, Infinity]
+ var upperBound = [-Infinity,-Infinity,-Infinity]
+
+ //Unpack options
+ var glyphs = options.glyph
+ var colors = options.color
+ var sizes = options.size
+ var angles = options.angle
+ var lineColors = options.lineColor
+
+ //Picking geometry
+ var pickCounter = -1
+
+ //First do pass to compute buffer sizes
+ var triVertexCount = 0
+ var lineVertexCount = 0
+
+ var numPoints = 0;
+
+ if(points.length) {
+
+ //Count number of points and buffer size
+ numPoints = points.length
+
+ count_loop:
+ for(var i=0; i 0) {
+ var triOffset = 0
+ var lineOffset = triVertexCount
+ var color = [0,0,0,1]
+ var lineColor = [0,0,0,1]
+
+ var isColorArray = Array.isArray(colors) && Array.isArray(colors[0])
+ var isLineColorArray = Array.isArray(lineColors) && Array.isArray(lineColors[0])
+
+ fill_loop:
+ for(var i=0; i 0) {
+ textOffset[j] *= (1-glyphBounds[0][j])
+ } else if(alignment[j] < 0) {
+ textOffset[j] *= (1+glyphBounds[1][j])
+ }
+ }
+
+ //Write out inner marker
+ var cells = glyphMesh.cells || []
+ var verts = glyphMesh.positions || []
+
+ for(var j=0; j 0) {
+
+ //Draw border
+ var w = lineWidth * pixelRatio
+ boxes.drawBox(loX-w, loY-w, hiX+w, loY+w, borderColor)
+ boxes.drawBox(loX-w, hiY-w, hiX+w, hiY+w, borderColor)
+ boxes.drawBox(loX-w, loY-w, loX+w, hiY+w, borderColor)
+ boxes.drawBox(hiX-w, loY-w, hiX+w, hiY+w, borderColor)
+ }
+}
+
+proto.update = function(options) {
+ options = options || {}
+
+ this.innerFill = !!options.innerFill
+ this.outerFill = !!options.outerFill
+ this.innerColor = (options.innerColor || [0,0,0,0.5]).slice()
+ this.outerColor = (options.outerColor || [0,0,0,0.5]).slice()
+ this.borderColor = (options.borderColor || [0,0,0,1]).slice()
+ this.borderWidth = options.borderWidth || 0
+ this.selectBox = (options.selectBox || this.selectBox).slice()
+}
+
+proto.dispose = function() {
+ this.boxBuffer.dispose()
+ this.boxShader.dispose()
+ this.plot.removeOverlay(this)
+}
+
+function createSelectBox(plot, options) {
+ var gl = plot.gl
+ var buffer = createBuffer(gl, [
+ 0, 0,
+ 0, 1,
+ 1, 0,
+ 1, 1 ])
+ var shader = createShader(gl, SHADERS.boxVertex, SHADERS.boxFragment)
+ var selectBox = new SelectBox(plot, buffer, shader)
+ selectBox.update(options)
+ plot.addOverlay(selectBox)
+ return selectBox
+}
+
+},{"./lib/shaders":285,"gl-buffer":230,"gl-shader":288}],287:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createSelectBuffer
+
+var createFBO = _dereq_('gl-fbo')
+var pool = _dereq_('typedarray-pool')
+var ndarray = _dereq_('ndarray')
+
+var nextPow2 = _dereq_('bit-twiddle').nextPow2
+
+var selectRange = _dereq_('cwise/lib/wrapper')({"args":["array",{"offset":[0,0,1],"array":0},{"offset":[0,0,2],"array":0},{"offset":[0,0,3],"array":0},"scalar","scalar","index"],"pre":{"body":"{this_closestD2=1e8,this_closestX=-1,this_closestY=-1}","args":[],"thisVars":["this_closestD2","this_closestX","this_closestY"],"localVars":[]},"body":{"body":"{if(_inline_16_arg0_<255||_inline_16_arg1_<255||_inline_16_arg2_<255||_inline_16_arg3_<255){var _inline_16_l=_inline_16_arg4_-_inline_16_arg6_[0],_inline_16_a=_inline_16_arg5_-_inline_16_arg6_[1],_inline_16_f=_inline_16_l*_inline_16_l+_inline_16_a*_inline_16_a;_inline_16_f this.buffer.length) {
+ pool.free(this.buffer)
+ var buffer = this.buffer = pool.mallocUint8(nextPow2(r*c*4))
+ for(var i=0; i oldAttribCount) {
+ for(i = oldAttribCount; i < newAttribCount; i++) {
+ this.gl.enableVertexAttribArray(i)
+ }
+ } else if(oldAttribCount > newAttribCount) {
+ for(i = newAttribCount; i < oldAttribCount; i++) {
+ this.gl.disableVertexAttribArray(i)
+ }
+ }
+
+ this.gl.lastAttribCount = newAttribCount
+
+ this.gl.useProgram(this.program)
+}
+
+proto.dispose = function() {
+
+ // disabling vertex attributes so new shader starts with zero
+ // and it's also useful if all shaders are disposed but the
+ // gl context is reused for subsequent replotting
+ var oldAttribCount = this.gl.lastAttribCount
+ for (var i = 0; i < oldAttribCount; i++) {
+ this.gl.disableVertexAttribArray(i)
+ }
+ this.gl.lastAttribCount = 0
+
+ if(this._fref) {
+ this._fref.dispose()
+ }
+ if(this._vref) {
+ this._vref.dispose()
+ }
+ this.attributes =
+ this.types =
+ this.vertShader =
+ this.fragShader =
+ this.program =
+ this._relink =
+ this._fref =
+ this._vref = null
+}
+
+function compareAttributes(a, b) {
+ if(a.name < b.name) {
+ return -1
+ }
+ return 1
+}
+
+//Update export hook for glslify-live
+proto.update = function(
+ vertSource
+ , fragSource
+ , uniforms
+ , attributes) {
+
+ //If only one object passed, assume glslify style output
+ if(!fragSource || arguments.length === 1) {
+ var obj = vertSource
+ vertSource = obj.vertex
+ fragSource = obj.fragment
+ uniforms = obj.uniforms
+ attributes = obj.attributes
+ }
+
+ var wrapper = this
+ var gl = wrapper.gl
+
+ //Compile vertex and fragment shaders
+ var pvref = wrapper._vref
+ wrapper._vref = shaderCache.shader(gl, gl.VERTEX_SHADER, vertSource)
+ if(pvref) {
+ pvref.dispose()
+ }
+ wrapper.vertShader = wrapper._vref.shader
+ var pfref = this._fref
+ wrapper._fref = shaderCache.shader(gl, gl.FRAGMENT_SHADER, fragSource)
+ if(pfref) {
+ pfref.dispose()
+ }
+ wrapper.fragShader = wrapper._fref.shader
+
+ //If uniforms/attributes is not specified, use RT reflection
+ if(!uniforms || !attributes) {
+
+ //Create initial test program
+ var testProgram = gl.createProgram()
+ gl.attachShader(testProgram, wrapper.fragShader)
+ gl.attachShader(testProgram, wrapper.vertShader)
+ gl.linkProgram(testProgram)
+ if(!gl.getProgramParameter(testProgram, gl.LINK_STATUS)) {
+ var errLog = gl.getProgramInfoLog(testProgram)
+ throw new GLError(errLog, 'Error linking program:' + errLog)
+ }
+
+ //Load data from runtime
+ uniforms = uniforms || runtime.uniforms(gl, testProgram)
+ attributes = attributes || runtime.attributes(gl, testProgram)
+
+ //Release test program
+ gl.deleteProgram(testProgram)
+ }
+
+ //Sort attributes lexicographically
+ // overrides undefined WebGL behavior for attribute locations
+ attributes = attributes.slice()
+ attributes.sort(compareAttributes)
+
+ //Convert attribute types, read out locations
+ var attributeUnpacked = []
+ var attributeNames = []
+ var attributeLocations = []
+ var i
+ for(i=0; i= 0) {
+ var size = attr.type.charAt(attr.type.length-1)|0
+ var locVector = new Array(size)
+ for(var j=0; j= 0) {
+ curLocation += 1
+ }
+ attributeLocations[i] = curLocation
+ }
+ }
+
+ //Rebuild program and recompute all uniform locations
+ var uniformLocations = new Array(uniforms.length)
+ function relink() {
+ wrapper.program = shaderCache.program(
+ gl
+ , wrapper._vref
+ , wrapper._fref
+ , attributeNames
+ , attributeLocations)
+
+ for(var i=0; i= 0) {
+ var d = type.charCodeAt(type.length-1) - 48
+ if(d < 2 || d > 4) {
+ throw new GLError('', 'Invalid data type for attribute ' + name + ': ' + type)
+ }
+ addVectorAttribute(
+ gl
+ , wrapper
+ , locs[0]
+ , locations
+ , d
+ , obj
+ , name)
+ } else if(type.indexOf('mat') >= 0) {
+ var d = type.charCodeAt(type.length-1) - 48
+ if(d < 2 || d > 4) {
+ throw new GLError('', 'Invalid data type for attribute ' + name + ': ' + type)
+ }
+ addMatrixAttribute(
+ gl
+ , wrapper
+ , locs
+ , locations
+ , d
+ , obj
+ , name)
+ } else {
+ throw new GLError('', 'Unknown data type for attribute ' + name + ': ' + type)
+ }
+ break
+ }
+ }
+ return obj
+}
+
+},{"./GLError":289}],291:[function(_dereq_,module,exports){
+'use strict'
+
+var coallesceUniforms = _dereq_('./reflect')
+var GLError = _dereq_("./GLError")
+
+module.exports = createUniformWrapper
+
+//Binds a function and returns a value
+function identity(x) {
+ var c = new Function('y', 'return function(){return y}')
+ return c(x)
+}
+
+function makeVector(length, fill) {
+ var result = new Array(length)
+ for(var i=0; i 4) {
+ throw new GLError('', 'Invalid data type')
+ }
+ switch(type.charAt(0)) {
+ case 'b':
+ case 'i':
+ return 'gl.uniform' + d + 'iv(locations[' + index + '],obj' + path + ')'
+ case 'v':
+ return 'gl.uniform' + d + 'fv(locations[' + index + '],obj' + path + ')'
+ default:
+ throw new GLError('', 'Unrecognized data type for vector ' + name + ': ' + type)
+ }
+ } else if(type.indexOf('mat') === 0 && type.length === 4) {
+ var d = type.charCodeAt(type.length-1) - 48
+ if(d < 2 || d > 4) {
+ throw new GLError('', 'Invalid uniform dimension type for matrix ' + name + ': ' + type)
+ }
+ return 'gl.uniformMatrix' + d + 'fv(locations[' + index + '],false,obj' + path + ')'
+ } else {
+ throw new GLError('', 'Unknown uniform data type for ' + name + ': ' + type)
+ }
+ break
+ }
+ }
+
+ function enumerateIndices(prefix, type) {
+ if(typeof type !== 'object') {
+ return [ [prefix, type] ]
+ }
+ var indices = []
+ for(var id in type) {
+ var prop = type[id]
+ var tprefix = prefix
+ if(parseInt(id) + '' === id) {
+ tprefix += '[' + id + ']'
+ } else {
+ tprefix += '.' + id
+ }
+ if(typeof prop === 'object') {
+ indices.push.apply(indices, enumerateIndices(tprefix, prop))
+ } else {
+ indices.push([tprefix, prop])
+ }
+ }
+ return indices
+ }
+
+ function makeSetter(type) {
+ var code = [ 'return function updateProperty(obj){' ]
+ var indices = enumerateIndices('', type)
+ for(var i=0; i 4) {
+ throw new GLError('', 'Invalid data type')
+ }
+ if(type.charAt(0) === 'b') {
+ return makeVector(d, false)
+ }
+ return makeVector(d, 0)
+ } else if(type.indexOf('mat') === 0 && type.length === 4) {
+ var d = type.charCodeAt(type.length-1) - 48
+ if(d < 2 || d > 4) {
+ throw new GLError('', 'Invalid uniform dimension type for matrix ' + name + ': ' + type)
+ }
+ return makeVector(d*d, 0)
+ } else {
+ throw new GLError('', 'Unknown uniform data type for ' + name + ': ' + type)
+ }
+ break
+ }
+ }
+
+ function storeProperty(obj, prop, type) {
+ if(typeof type === 'object') {
+ var child = processObject(type)
+ Object.defineProperty(obj, prop, {
+ get: identity(child),
+ set: makeSetter(type),
+ enumerable: true,
+ configurable: false
+ })
+ } else {
+ if(locations[type]) {
+ Object.defineProperty(obj, prop, {
+ get: makeGetter(type),
+ set: makeSetter(type),
+ enumerable: true,
+ configurable: false
+ })
+ } else {
+ obj[prop] = defaultValue(uniforms[type].type)
+ }
+ }
+ }
+
+ function processObject(obj) {
+ var result
+ if(Array.isArray(obj)) {
+ result = new Array(obj.length)
+ for(var i=0; i 1) {
+ if(!(x[0] in o)) {
+ o[x[0]] = []
+ }
+ o = o[x[0]]
+ for(var k=1; k 1) {
+ for(var j=0; j 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n float segmentCount = 8.0;\n\n float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d);\n vec3 y = v * sin(angle) * length(d);\n vec3 v3 = x + y;\n\n normal = normalize(v3);\n\n return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\nuniform float tubeScale;\n\nuniform mat4 model\n , view\n , projection;\nuniform vec3 eyePosition\n , lightPosition;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data\n , f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n // Scale the vector magnitude to stay constant with\n // model & view changes.\n vec3 normal;\n vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n normal = normalize(normal * inverse(mat3(model)));\n\n gl_Position = projection * view * tubePosition;\n f_color = color;\n f_normal = normal;\n f_data = tubePosition.xyz;\n f_position = position.xyz;\n f_eyeDirection = eyePosition - tubePosition.xyz;\n f_lightDirection = lightPosition - tubePosition.xyz;\n f_uv = uv;\n}\n"])
+var triFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n float NdotH = max(x, 0.0001);\n float cos2Alpha = NdotH * NdotH;\n float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n float roughness2 = roughness * roughness;\n float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n vec3 lightDirection,\n vec3 viewDirection,\n vec3 surfaceNormal,\n float roughness,\n float fresnel) {\n\n float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n //Half angle vector\n vec3 H = normalize(lightDirection + viewDirection);\n\n //Geometric term\n float NdotH = max(dot(surfaceNormal, H), 0.0);\n float VdotH = max(dot(viewDirection, H), 0.000001);\n float LdotH = max(dot(lightDirection, H), 0.000001);\n float G1 = (2.0 * NdotH * VdotN) / VdotH;\n float G2 = (2.0 * NdotH * LdotN) / LdotH;\n float G = min(1.0, min(G1, G2));\n \n //Distribution term\n float D = beckmannDistribution(NdotH, roughness);\n\n //Fresnel term\n float F = pow(1.0 - VdotN, fresnel);\n\n //Multiply terms and done\n return G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n , fresnel\n , kambient\n , kdiffuse\n , kspecular\n , opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data\n , f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n\n if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n vec3 N = normalize(f_normal);\n vec3 L = normalize(f_lightDirection);\n vec3 V = normalize(f_eyeDirection);\n\n if(!gl_FrontFacing) {\n N = -N;\n }\n\n float specular = cookTorranceSpecular(L, V, N, roughness, fresnel);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n vec4 surfaceColor = texture2D(texture, f_uv);\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = litColor * opacity;\n}"])
+var pickVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n // Return up-vector for only-z vector.\n // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n // From the above if-statement we have ||a|| > 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n float segmentCount = 8.0;\n\n float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d);\n vec3 y = v * sin(angle) * length(d);\n vec3 v3 = x + y;\n\n normal = normalize(v3);\n\n return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform float tubeScale;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n vec3 normal;\n vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n gl_Position = projection * view * tubePosition;\n f_id = id;\n f_position = position.xyz;\n}\n"])
+var pickFragSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"])
+
+exports.meshShader = {
+ vertex: triVertSrc,
+ fragment: triFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec4'},
+ {name: 'normal', type: 'vec3'},
+ {name: 'color', type: 'vec4'},
+ {name: 'uv', type: 'vec2'},
+ {name: 'vector', type: 'vec4'}
+ ]
+}
+exports.pickShader = {
+ vertex: pickVertSrc,
+ fragment: pickFragSrc,
+ attributes: [
+ {name: 'position', type: 'vec4'},
+ {name: 'id', type: 'vec4'},
+ {name: 'vector', type: 'vec4'}
+ ]
+}
+
+},{"glslify":392}],300:[function(_dereq_,module,exports){
+'use strict'
+
+var DEFAULT_VERTEX_NORMALS_EPSILON = 1e-6; // may be too large if triangles are very small
+var DEFAULT_FACE_NORMALS_EPSILON = 1e-6;
+
+var createShader = _dereq_('gl-shader')
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createTexture = _dereq_('gl-texture2d')
+var normals = _dereq_('normals')
+var multiply = _dereq_('gl-mat4/multiply')
+var invert = _dereq_('gl-mat4/invert')
+var ndarray = _dereq_('ndarray')
+var colormap = _dereq_('colormap')
+var getContour = _dereq_('simplicial-complex-contour')
+var pool = _dereq_('typedarray-pool')
+var shaders = _dereq_('./shaders')
+var closestPoint = _dereq_('./closest-point')
+
+var meshShader = shaders.meshShader
+var pickShader = shaders.pickShader
+
+var identityMatrix = [
+ 1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1]
+
+function SimplicialMesh(gl
+ , texture
+ , triShader
+ , lineShader
+ , pointShader
+ , pickShader
+ , pointPickShader
+ , contourShader
+ , trianglePositions
+ , triangleVectors
+ , triangleIds
+ , triangleColors
+ , triangleUVs
+ , triangleNormals
+ , triangleVAO
+ , edgePositions
+ , edgeIds
+ , edgeColors
+ , edgeUVs
+ , edgeVAO
+ , pointPositions
+ , pointIds
+ , pointColors
+ , pointUVs
+ , pointSizes
+ , pointVAO
+ , contourPositions
+ , contourVAO) {
+
+ this.gl = gl
+ this.cells = []
+ this.positions = []
+ this.intensity = []
+ this.texture = texture
+ this.dirty = true
+
+ this.triShader = triShader
+ this.lineShader = lineShader
+ this.pointShader = pointShader
+ this.pickShader = pickShader
+ this.pointPickShader = pointPickShader
+ this.contourShader = contourShader
+
+ this.trianglePositions = trianglePositions
+ this.triangleVectors = triangleVectors
+ this.triangleColors = triangleColors
+ this.triangleNormals = triangleNormals
+ this.triangleUVs = triangleUVs
+ this.triangleIds = triangleIds
+ this.triangleVAO = triangleVAO
+ this.triangleCount = 0
+
+ this.lineWidth = 1
+ this.edgePositions = edgePositions
+ this.edgeColors = edgeColors
+ this.edgeUVs = edgeUVs
+ this.edgeIds = edgeIds
+ this.edgeVAO = edgeVAO
+ this.edgeCount = 0
+
+ this.pointPositions = pointPositions
+ this.pointColors = pointColors
+ this.pointUVs = pointUVs
+ this.pointSizes = pointSizes
+ this.pointIds = pointIds
+ this.pointVAO = pointVAO
+ this.pointCount = 0
+
+ this.contourLineWidth = 1
+ this.contourPositions = contourPositions
+ this.contourVAO = contourVAO
+ this.contourCount = 0
+ this.contourColor = [0,0,0]
+ this.contourEnable = false
+
+ this.pickId = 1
+ this.bounds = [
+ [ Infinity, Infinity, Infinity],
+ [-Infinity,-Infinity,-Infinity] ]
+ this.clipBounds = [
+ [-Infinity,-Infinity,-Infinity],
+ [ Infinity, Infinity, Infinity] ]
+
+ this.lightPosition = [1e5, 1e5, 0]
+ this.ambientLight = 0.8
+ this.diffuseLight = 0.8
+ this.specularLight = 2.0
+ this.roughness = 0.5
+ this.fresnel = 1.5
+
+ this.opacity = 1.0
+
+ this.tubeScale = 1.0
+
+ this._model = identityMatrix
+ this._view = identityMatrix
+ this._projection = identityMatrix
+ this._resolution = [1,1]
+}
+
+var proto = SimplicialMesh.prototype
+
+proto.isOpaque = function() {
+ return this.opacity >= 1
+}
+
+proto.isTransparent = function() {
+ return this.opacity < 1
+}
+
+proto.pickSlots = 1
+
+proto.setPickBase = function(id) {
+ this.pickId = id
+}
+
+function genColormap(param) {
+ var colors = colormap({
+ colormap: param
+ , nshades: 256
+ , format: 'rgba'
+ })
+
+ var result = new Uint8Array(256*4)
+ for(var i=0; i<256; ++i) {
+ var c = colors[i]
+ for(var j=0; j<3; ++j) {
+ result[4*i+j] = c[j]
+ }
+ result[4*i+3] = c[3]*255
+ }
+
+ return ndarray(result, [256,256,4], [4,0,1])
+}
+
+function unpackIntensity(cells, numVerts, cellIntensity) {
+ var result = new Array(numVerts)
+ for(var i=0; i 0) {
+ var shader = this.triShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0 && this.lineWidth > 0) {
+ var shader = this.lineShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+
+ if(this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {
+ var shader = this.contourShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.contourVAO.bind()
+ gl.drawArrays(gl.LINES, 0, this.contourCount)
+ this.contourVAO.unbind()
+ }
+}
+
+proto.drawPick = function(params) {
+ params = params || {}
+
+ var gl = this.gl
+
+ var model = params.model || identityMatrix
+ var view = params.view || identityMatrix
+ var projection = params.projection || identityMatrix
+
+ var clipBounds = [[-1e6,-1e6,-1e6],[1e6,1e6,1e6]]
+ for(var i=0; i<3; ++i) {
+ clipBounds[0][i] = Math.max(clipBounds[0][i], this.clipBounds[0][i])
+ clipBounds[1][i] = Math.min(clipBounds[1][i], this.clipBounds[1][i])
+ }
+
+ //Save camera parameters
+ this._model = [].slice.call(model)
+ this._view = [].slice.call(view)
+ this._projection = [].slice.call(projection)
+ this._resolution = [gl.drawingBufferWidth, gl.drawingBufferHeight]
+
+ var uniforms = {
+ model: model,
+ view: view,
+ projection: projection,
+ clipBounds: clipBounds,
+
+ tubeScale: this.tubeScale,
+
+ pickId: this.pickId / 255.0,
+ }
+
+ var shader = this.pickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ if(this.triangleCount > 0) {
+ this.triangleVAO.bind()
+ gl.drawArrays(gl.TRIANGLES, 0, this.triangleCount*3)
+ this.triangleVAO.unbind()
+ }
+
+ if(this.edgeCount > 0) {
+ this.edgeVAO.bind()
+ gl.lineWidth(this.lineWidth)
+ gl.drawArrays(gl.LINES, 0, this.edgeCount*2)
+ this.edgeVAO.unbind()
+ }
+
+ if(this.pointCount > 0) {
+ var shader = this.pointPickShader
+ shader.bind()
+ shader.uniforms = uniforms
+
+ this.pointVAO.bind()
+ gl.drawArrays(gl.POINTS, 0, this.pointCount)
+ this.pointVAO.unbind()
+ }
+}
+
+
+proto.pick = function(pickData) {
+ if(!pickData) {
+ return null
+ }
+ if(pickData.id !== this.pickId) {
+ return null
+ }
+
+ var cellId = pickData.value[0] + 256*pickData.value[1] + 65536*pickData.value[2]
+ var cell = this.cells[cellId]
+
+ var pos = this.positions[cell[1]].slice(0, 3)
+ var intensity = this.intensity[cell[1]]
+ var velocity = this.vectors[cell[1]].slice(0, 3)
+ var divergence = this.vectors[cell[1]][3]
+
+ return {
+ index: cellId,
+ position: pos,
+ intensity: intensity,
+ velocity: velocity,
+ divergence: divergence,
+ dataCoordinate: pos
+ }
+}
+
+
+proto.dispose = function() {
+ this.texture.dispose()
+
+ this.triShader.dispose()
+ // this.lineShader.dispose()
+ // this.pointShader.dispose()
+ this.pickShader.dispose()
+ // this.pointPickShader.dispose()
+
+ this.triangleVAO.dispose()
+ this.trianglePositions.dispose()
+ this.triangleVectors.dispose()
+ this.triangleColors.dispose()
+ this.triangleUVs.dispose()
+ this.triangleNormals.dispose()
+ this.triangleIds.dispose()
+
+ this.edgeVAO.dispose()
+ this.edgePositions.dispose()
+ this.edgeColors.dispose()
+ this.edgeUVs.dispose()
+ this.edgeIds.dispose()
+
+ this.pointVAO.dispose()
+ this.pointPositions.dispose()
+ this.pointColors.dispose()
+ this.pointUVs.dispose()
+ this.pointSizes.dispose()
+ this.pointIds.dispose()
+
+ this.contourVAO.dispose()
+ this.contourPositions.dispose()
+ // this.contourShader.dispose()
+}
+
+function createMeshShader(gl) {
+ var shader = createShader(gl, meshShader.vertex, meshShader.fragment, null, meshShader.attributes)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ shader.attributes.vector.location = 5
+ return shader
+}
+
+function createWireShader(gl) {
+ var shader = createShader(gl, wireShader.vertex, wireShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ return shader
+}
+
+function createPointShader(gl) {
+ var shader = createShader(gl, pointShader.vertex, pointShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.color.location = 2
+ shader.attributes.uv.location = 3
+ shader.attributes.pointSize.location = 4
+ return shader
+}
+
+function createPickShader(gl) {
+ var shader = createShader(gl, pickShader.vertex, pickShader.fragment, null, pickShader.attributes)
+ shader.attributes.position.location = 0
+ shader.attributes.id.location = 1
+ shader.attributes.vector.location = 5
+ return shader
+}
+
+function createPointPickShader(gl) {
+ var shader = createShader(gl, pointPickShader.vertex, pointPickShader.fragment)
+ shader.attributes.position.location = 0
+ shader.attributes.id.location = 1
+ shader.attributes.pointSize.location = 4
+ return shader
+}
+
+function createContourShader(gl) {
+ var shader = createShader(gl, contourShader.vertex, contourShader.fragment)
+ shader.attributes.position.location = 0
+ return shader
+}
+
+function createSimplicialMesh(gl, params) {
+ if (arguments.length === 1) {
+ params = gl;
+ gl = params.gl;
+ }
+
+ var triShader = params.triShader || createMeshShader(gl)
+ var lineShader = null; //createWireShader(gl)
+ var pointShader = null; //createPointShader(gl)
+ var pickShader = createPickShader(gl)
+ var pointPickShader = null; //createPointPickShader(gl)
+ var contourShader = null; //createContourShader(gl)
+
+ var meshTexture = createTexture(gl,
+ ndarray(new Uint8Array([255,255,255,255]), [1,1,4]))
+ meshTexture.generateMipmap()
+ meshTexture.minFilter = gl.LINEAR_MIPMAP_LINEAR
+ meshTexture.magFilter = gl.LINEAR
+
+ var trianglePositions = createBuffer(gl)
+ var triangleVectors = createBuffer(gl)
+ var triangleColors = createBuffer(gl)
+ var triangleUVs = createBuffer(gl)
+ var triangleNormals = createBuffer(gl)
+ var triangleIds = createBuffer(gl)
+ var triangleVAO = createVAO(gl, [
+ { buffer: trianglePositions,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: triangleIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: triangleColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: triangleUVs,
+ type: gl.FLOAT,
+ size: 2
+ },
+ { buffer: triangleNormals,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: triangleVectors,
+ type: gl.FLOAT,
+ size: 4
+ }
+ ])
+
+ var edgePositions = createBuffer(gl)
+ var edgeColors = createBuffer(gl)
+ var edgeUVs = createBuffer(gl)
+ var edgeIds = createBuffer(gl)
+ var edgeVAO = createVAO(gl, [
+ { buffer: edgePositions,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: edgeIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: edgeColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: edgeUVs,
+ type: gl.FLOAT,
+ size: 2
+ }
+ ])
+
+ var pointPositions = createBuffer(gl)
+ var pointColors = createBuffer(gl)
+ var pointUVs = createBuffer(gl)
+ var pointSizes = createBuffer(gl)
+ var pointIds = createBuffer(gl)
+ var pointVAO = createVAO(gl, [
+ { buffer: pointPositions,
+ type: gl.FLOAT,
+ size: 3
+ },
+ { buffer: pointIds,
+ type: gl.UNSIGNED_BYTE,
+ size: 4,
+ normalized: true
+ },
+ { buffer: pointColors,
+ type: gl.FLOAT,
+ size: 4
+ },
+ { buffer: pointUVs,
+ type: gl.FLOAT,
+ size: 2
+ },
+ { buffer: pointSizes,
+ type: gl.FLOAT,
+ size: 1
+ }
+ ])
+
+ var contourPositions = createBuffer(gl)
+ var contourVAO = createVAO(gl, [
+ { buffer: contourPositions,
+ type: gl.FLOAT,
+ size: 3
+ }])
+
+ var mesh = new SimplicialMesh(gl
+ , meshTexture
+ , triShader
+ , lineShader
+ , pointShader
+ , pickShader
+ , pointPickShader
+ , contourShader
+ , trianglePositions
+ , triangleVectors
+ , triangleIds
+ , triangleColors
+ , triangleUVs
+ , triangleNormals
+ , triangleVAO
+ , edgePositions
+ , edgeIds
+ , edgeColors
+ , edgeUVs
+ , edgeVAO
+ , pointPositions
+ , pointIds
+ , pointColors
+ , pointUVs
+ , pointSizes
+ , pointVAO
+ , contourPositions
+ , contourVAO)
+
+ mesh.update(params)
+
+ return mesh
+}
+
+module.exports = createSimplicialMesh
+
+},{"./closest-point":298,"./shaders":299,"colormap":114,"gl-buffer":230,"gl-mat4/invert":254,"gl-mat4/multiply":256,"gl-shader":288,"gl-texture2d":305,"gl-vao":310,"ndarray":433,"normals":436,"simplicial-complex-contour":494,"typedarray-pool":522}],301:[function(_dereq_,module,exports){
+"use strict";
+
+var vec3 = _dereq_('gl-vec3');
+var vec4 = _dereq_('gl-vec4');
+
+var streamToTube = function(stream, maxDivergence, minDistance, maxNorm) {
+ var points = stream.points;
+ var velocities = stream.velocities;
+ var divergences = stream.divergences;
+
+ var p, fwd, r, u, v, up;
+ up = vec3.set(vec3.create(), 0, 1, 0);
+ u = vec3.create();
+ v = vec3.create();
+ var p2 = vec3.create();
+
+ var verts = [];
+ var faces = [];
+ var vectors = [];
+ var previousVerts = [];
+ var currentVerts = [];
+ var intensities = [];
+ var previousIntensity = 0;
+ var currentIntensity = 0;
+ var currentVector = vec4.create();
+ var previousVector = vec4.create();
+
+ var facets = 8;
+
+ for (var i = 0; i < points.length; i++) {
+ p = points[i];
+ fwd = velocities[i];
+ r = divergences[i];
+ if (maxDivergence === 0) {
+ r = minDistance * 0.05;
+ }
+ currentIntensity = vec3.length(fwd) / maxNorm;
+ currentVector = vec4.create();
+ vec3.copy(currentVector, fwd);
+ currentVector[3] = r;
+
+ for (var a = 0; a < facets; a++) {
+ currentVerts[a] = [p[0], p[1], p[2], a];
+ }
+ if (previousVerts.length > 0) {
+ for (var a = 0; a < facets; a++) {
+ var a1 = (a+1) % facets;
+ verts.push(
+ previousVerts[a],
+ currentVerts[a],
+ currentVerts[a1],
+
+ currentVerts[a1],
+ previousVerts[a1],
+ previousVerts[a]
+ );
+ vectors.push(
+ previousVector,
+ currentVector,
+ currentVector,
+
+ currentVector,
+ previousVector,
+ previousVector
+ );
+ intensities.push(
+ previousIntensity,
+ currentIntensity,
+ currentIntensity,
+
+ currentIntensity,
+ previousIntensity,
+ previousIntensity
+ );
+ faces.push(
+ [verts.length-6, verts.length-5, verts.length-4],
+ [verts.length-3, verts.length-2, verts.length-1]
+ );
+ }
+ }
+ var tmp = previousVerts;
+ previousVerts = currentVerts;
+ currentVerts = tmp;
+ tmp = previousVector;
+ previousVector = currentVector;
+ currentVector = tmp;
+ tmp = previousIntensity;
+ previousIntensity = currentIntensity;
+ currentIntensity = tmp;
+ }
+ return {
+ positions: verts,
+ cells: faces,
+ vectors: vectors,
+ vertexIntensity: intensities
+ };
+
+};
+
+var createTubes = function(streams, colormap, maxDivergence, minDistance) {
+
+ var maxNorm = 0;
+ for (var i=0; i maxNorm) {
+ maxNorm = norm;
+ }
+ }
+ }
+
+ var tubes = streams.map(function(s) {
+ return streamToTube(s, maxDivergence, minDistance, maxNorm);
+ });
+
+ var positions = [];
+ var cells = [];
+ var vectors = [];
+ var vertexIntensity = [];
+ for (var i=0; i < tubes.length; i++) {
+ var tube = tubes[i];
+ var offset = positions.length;
+ positions = positions.concat(tube.positions);
+ vectors = vectors.concat(tube.vectors);
+ vertexIntensity = vertexIntensity.concat(tube.vertexIntensity);
+ for (var j=0; j v) return i-1;
+ }
+ return i;
+};
+
+var tmp = vec3.create();
+var tmp2 = vec3.create();
+
+var clamp = function(v, min, max) {
+ return v < min ? min : (v > max ? max : v);
+};
+
+var sampleMeshgrid = function(point, array, meshgrid, clampOverflow) {
+ var x = point[0];
+ var y = point[1];
+ var z = point[2];
+
+ var w = meshgrid[0].length;
+ var h = meshgrid[1].length;
+ var d = meshgrid[2].length;
+
+ // Find the index of the nearest smaller value in the meshgrid for each coordinate of (x,y,z).
+ // The nearest smaller value index for x is the index x0 such that
+ // meshgrid[0][x0] < x and for all x1 > x0, meshgrid[0][x1] >= x.
+ var x0 = findLastSmallerIndex(meshgrid[0], x);
+ var y0 = findLastSmallerIndex(meshgrid[1], y);
+ var z0 = findLastSmallerIndex(meshgrid[2], z);
+
+ // Get the nearest larger meshgrid value indices.
+ // From the above "nearest smaller value", we know that
+ // meshgrid[0][x0] < x
+ // meshgrid[0][x0+1] >= x
+ var x1 = x0 + 1;
+ var y1 = y0 + 1;
+ var z1 = z0 + 1;
+
+ if (meshgrid[0][x0] === x) x1 = x0;
+ if (meshgrid[1][y0] === y) y1 = y0;
+ if (meshgrid[2][z0] === z) z1 = z0;
+
+ if (clampOverflow) {
+ x0 = clamp(x0, 0, w-1);
+ x1 = clamp(x1, 0, w-1);
+ y0 = clamp(y0, 0, h-1);
+ y1 = clamp(y1, 0, h-1);
+ z0 = clamp(z0, 0, d-1);
+ z1 = clamp(z1, 0, d-1);
+ }
+
+ // Reject points outside the meshgrid, return a zero vector.
+ if (x0 < 0 || y0 < 0 || z0 < 0 || x1 >= w || y1 >= h || z1 >= d) {
+ return vec3.create();
+ }
+
+ // Normalize point coordinates to 0..1 scaling factor between x0 and x1.
+ var xf = (x - meshgrid[0][x0]) / (meshgrid[0][x1] - meshgrid[0][x0]);
+ var yf = (y - meshgrid[1][y0]) / (meshgrid[1][y1] - meshgrid[1][y0]);
+ var zf = (z - meshgrid[2][z0]) / (meshgrid[2][z1] - meshgrid[2][z0]);
+
+ if (xf < 0 || xf > 1 || isNaN(xf)) xf = 0;
+ if (yf < 0 || yf > 1 || isNaN(yf)) yf = 0;
+ if (zf < 0 || zf > 1 || isNaN(zf)) zf = 0;
+
+ var z0off = z0*w*h;
+ var z1off = z1*w*h;
+
+ var y0off = y0*w;
+ var y1off = y1*w;
+
+ var x0off = x0;
+ var x1off = x1;
+
+ // Sample data array around the (x,y,z) point.
+ // vZYX = array[zZoff + yYoff + xXoff]
+ var v000 = array[y0off + z0off + x0off];
+ var v001 = array[y0off + z0off + x1off];
+ var v010 = array[y1off + z0off + x0off];
+ var v011 = array[y1off + z0off + x1off];
+ var v100 = array[y0off + z1off + x0off];
+ var v101 = array[y0off + z1off + x1off];
+ var v110 = array[y1off + z1off + x0off];
+ var v111 = array[y1off + z1off + x1off];
+
+ var result = vec3.create();
+
+ // Average samples according to distance to point.
+ vec3.lerp(result, v000, v001, xf);
+ vec3.lerp(tmp, v010, v011, xf);
+ vec3.lerp(result, result, tmp, yf);
+ vec3.lerp(tmp, v100, v101, xf);
+ vec3.lerp(tmp2, v110, v111, xf);
+ vec3.lerp(tmp, tmp, tmp2, yf);
+ vec3.lerp(result, result, tmp, zf);
+
+ return result;
+};
+
+
+var vabs = function(dst, v) {
+ var x = v[0];
+ var y = v[1];
+ var z = v[2];
+ dst[0] = x >= 0 ? x : -x;
+ dst[1] = y >= 0 ? y : -y;
+ dst[2] = z >= 0 ? z : -z;
+ return dst;
+};
+
+var findMinSeparation = function(xs) {
+ var minSeparation = 1/0;
+ xs.sort(function(a, b) { return a - b; });
+ for (var i=1; i= minX && x <= maxX &&
+ y >= minY && y <= maxY &&
+ z >= minZ && z <= maxZ
+ );
+ };
+
+ var boundsSize = vec3.distance(bounds[0], bounds[1]);
+ var maxStepSize = 10 * boundsSize / maxLength;
+ var maxStepSizeSq = maxStepSize * maxStepSize;
+
+ var minDistance = 1;
+ var maxDivergence = 0; // For component-wise divergence vec3.create();
+ var tmp = vec3.create();
+
+ if (positions.length >= 2) {
+ minDistance = calculateMinPositionDistance(positions);
+ }
+
+ for (var i = 0; i < positions.length; i++) {
+ var p = vec3.create();
+ vec3.copy(p, positions[i]);
+
+ var stream = [p];
+ var velocities = [];
+ var v = vectorField.getVelocity(p);
+ var op = p;
+ velocities.push(v);
+
+ var divergences = [];
+
+ var dv = vectorField.getDivergence(p, v);
+ var dvLength = vec3.length(dv);
+ if (dvLength > maxDivergence && !isNaN(dvLength) && isFinite(dvLength)) {
+ maxDivergence = dvLength;
+ }
+ // In case we need to do component-wise divergence visualization
+ // vec3.max(maxDivergence, maxDivergence, vabs(tmp, dv));
+ divergences.push(dvLength);
+
+ streams.push({points: stream, velocities: velocities, divergences: divergences});
+
+ var j = 0;
+
+ while (j < maxLength * 100 && stream.length < maxLength && inBounds(bounds, p)) {
+ j++;
+ var np = vec3.clone(v);
+ var sqLen = vec3.squaredLength(np);
+ if (sqLen === 0) {
+ break;
+ } else if (sqLen > maxStepSizeSq) {
+ vec3.scale(np, np, maxStepSize / Math.sqrt(sqLen));
+ }
+ vec3.add(np, np, p);
+
+ v = vectorField.getVelocity(np);
+
+ if (vec3.squaredDistance(op, np) - maxStepSizeSq > -0.0001 * maxStepSizeSq) {
+ stream.push(np);
+ op = np;
+ velocities.push(v);
+ var dv = vectorField.getDivergence(np, v);
+ var dvLength = vec3.length(dv);
+ if (dvLength > maxDivergence && !isNaN(dvLength) && isFinite(dvLength)) {
+ maxDivergence = dvLength;
+ }
+ // In case we need to do component-wise divergence visualization
+ //vec3.max(maxDivergence, maxDivergence, vabs(tmp, dv));
+ divergences.push(dvLength);
+ }
+
+ p = np;
+ }
+ }
+
+ // Replace NaNs and Infinities with non-NaN, finite maxDivergence
+ for (var i=0; i max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 lowerBound, upperBound;\nuniform float contourTint;\nuniform vec4 contourColor;\nuniform sampler2D colormap;\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform float vertexColor;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n if ((kill > 0.0) ||\n (outOfRange(clipBounds[0], clipBounds[1], worldCoordinate))) discard;\n\n vec3 N = normalize(surfaceNormal);\n vec3 V = normalize(eyeDirection);\n vec3 L = normalize(lightDirection);\n\n if(gl_FrontFacing) {\n N = -N;\n }\n\n float specular = max(beckmannSpecular(L, V, N, roughness), 0.);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n //decide how to interpolate color — in vertex or in fragment\n vec4 surfaceColor = step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) + step(.5, vertexColor) * vColor;\n\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;\n}\n"])
+var contourVertSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute float f;\n\nuniform mat3 permutation;\nuniform mat4 model, view, projection;\nuniform float height, zOffset;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n vec3 dataCoordinate = permutation * vec3(uv.xy, height);\n vec4 worldPosition = model * vec4(dataCoordinate, 1.0);\n\n vec4 clipPosition = projection * view * worldPosition;\n clipPosition.z = clipPosition.z + zOffset;\n\n gl_Position = clipPosition;\n value = f;\n kill = -1.0;\n worldCoordinate = dataCoordinate;\n planeCoordinate = uv.zw;\n\n vColor = texture2D(colormap, vec2(value, value));\n\n //Don't do lighting for contours\n surfaceNormal = vec3(1,0,0);\n eyeDirection = vec3(0,1,0);\n lightDirection = vec3(0,0,1);\n}\n"])
+var pickSrc = glslify(["precision mediump float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n return ((p > max(a, b)) || \n (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n return (outOfRange(a.x, b.x, p.x) ||\n outOfRange(a.y, b.y, p.y) ||\n outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec2 shape;\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 surfaceNormal;\n\nvec2 splitFloat(float v) {\n float vh = 255.0 * v;\n float upper = floor(vh);\n float lower = fract(vh);\n return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);\n}\n\nvoid main() {\n if ((kill > 0.0) ||\n (outOfRange(clipBounds[0], clipBounds[1], worldCoordinate))) discard;\n\n vec2 ux = splitFloat(planeCoordinate.x / shape.x);\n vec2 uy = splitFloat(planeCoordinate.y / shape.y);\n gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));\n}\n"])
+
+exports.createShader = function (gl) {
+ var shader = createShader(gl, vertSrc, fragSrc, null, [
+ {name: 'uv', type: 'vec4'},
+ {name: 'f', type: 'vec3'},
+ {name: 'normal', type: 'vec3'}
+ ])
+ shader.attributes.uv.location = 0
+ shader.attributes.f.location = 1
+ shader.attributes.normal.location = 2
+ return shader
+}
+exports.createPickShader = function (gl) {
+ var shader = createShader(gl, vertSrc, pickSrc, null, [
+ {name: 'uv', type: 'vec4'},
+ {name: 'f', type: 'vec3'},
+ {name: 'normal', type: 'vec3'}
+ ])
+ shader.attributes.uv.location = 0
+ shader.attributes.f.location = 1
+ shader.attributes.normal.location = 2
+ return shader
+}
+exports.createContourShader = function (gl) {
+ var shader = createShader(gl, contourVertSrc, fragSrc, null, [
+ {name: 'uv', type: 'vec4'},
+ {name: 'f', type: 'float'}
+ ])
+ shader.attributes.uv.location = 0
+ shader.attributes.f.location = 1
+ return shader
+}
+exports.createPickContourShader = function (gl) {
+ var shader = createShader(gl, contourVertSrc, pickSrc, null, [
+ {name: 'uv', type: 'vec4'},
+ {name: 'f', type: 'float'}
+ ])
+ shader.attributes.uv.location = 0
+ shader.attributes.f.location = 1
+ return shader
+}
+
+},{"gl-shader":288,"glslify":392}],303:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = createSurfacePlot
+
+var bits = _dereq_('bit-twiddle')
+var createBuffer = _dereq_('gl-buffer')
+var createVAO = _dereq_('gl-vao')
+var createTexture = _dereq_('gl-texture2d')
+var pool = _dereq_('typedarray-pool')
+var colormap = _dereq_('colormap')
+var ops = _dereq_('ndarray-ops')
+var pack = _dereq_('ndarray-pack')
+var ndarray = _dereq_('ndarray')
+var surfaceNets = _dereq_('surface-nets')
+var multiply = _dereq_('gl-mat4/multiply')
+var invert = _dereq_('gl-mat4/invert')
+var bsearch = _dereq_('binary-search-bounds')
+var gradient = _dereq_('ndarray-gradient')
+var shaders = _dereq_('./lib/shaders')
+
+var createShader = shaders.createShader
+var createContourShader = shaders.createContourShader
+var createPickShader = shaders.createPickShader
+var createPickContourShader = shaders.createPickContourShader
+
+var SURFACE_VERTEX_SIZE = 4 * (4 + 3 + 3)
+
+var IDENTITY = [
+ 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 0, 0, 0, 1 ]
+
+var QUAD = [
+ [0, 0],
+ [0, 1],
+ [1, 0],
+ [1, 1],
+ [1, 0],
+ [0, 1]
+]
+
+var PERMUTATIONS = [
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0],
+ [0, 0, 0, 0, 0, 0, 0, 0, 0]
+]
+
+;(function () {
+ for (var i = 0; i < 3; ++i) {
+ var p = PERMUTATIONS[i]
+ var u = (i + 1) % 3
+ var v = (i + 2) % 3
+ p[u + 0] = 1
+ p[v + 3] = 1
+ p[i + 6] = 1
+ }
+})()
+
+function SurfacePickResult (position, index, uv, level, dataCoordinate) {
+ this.position = position
+ this.index = index
+ this.uv = uv
+ this.level = level
+ this.dataCoordinate = dataCoordinate
+}
+
+var N_COLORS = 256
+
+function genColormap (name) {
+ var x = pack([colormap({
+ colormap: name,
+ nshades: N_COLORS,
+ format: 'rgba'
+ }).map(function (c) {
+ return [c[0], c[1], c[2], 255 * c[3]]
+ })])
+ ops.divseq(x, 255.0)
+ return x
+}
+
+function SurfacePlot (
+ gl,
+ shape,
+ bounds,
+ shader,
+ pickShader,
+ coordinates,
+ vao,
+ colorMap,
+ contourShader,
+ contourPickShader,
+ contourBuffer,
+ contourVAO,
+ dynamicBuffer,
+ dynamicVAO) {
+ this.gl = gl
+ this.shape = shape
+ this.bounds = bounds
+ this.intensityBounds = [];
+
+ this._shader = shader
+ this._pickShader = pickShader
+ this._coordinateBuffer = coordinates
+ this._vao = vao
+ this._colorMap = colorMap
+
+ this._contourShader = contourShader
+ this._contourPickShader = contourPickShader
+ this._contourBuffer = contourBuffer
+ this._contourVAO = contourVAO
+ this._contourOffsets = [[], [], []]
+ this._contourCounts = [[], [], []]
+ this._vertexCount = 0
+
+ this._pickResult = new SurfacePickResult([0, 0, 0], [0, 0], [0, 0], [0, 0, 0], [0, 0, 0])
+
+ this._dynamicBuffer = dynamicBuffer
+ this._dynamicVAO = dynamicVAO
+ this._dynamicOffsets = [0, 0, 0]
+ this._dynamicCounts = [0, 0, 0]
+
+ this.contourWidth = [ 1, 1, 1 ]
+ this.contourLevels = [[1], [1], [1]]
+ this.contourTint = [0, 0, 0]
+ this.contourColor = [[0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1]]
+
+ this.showContour = true
+ this.showSurface = true
+
+ this.enableHighlight = [true, true, true]
+ this.highlightColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]]
+ this.highlightTint = [ 1, 1, 1 ]
+ this.highlightLevel = [-1, -1, -1]
+
+ // Dynamic contour options
+ this.enableDynamic = [ true, true, true ]
+ this.dynamicLevel = [ NaN, NaN, NaN ]
+ this.dynamicColor = [ [0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1] ]
+ this.dynamicTint = [ 1, 1, 1 ]
+ this.dynamicWidth = [ 1, 1, 1 ]
+
+ this.axesBounds = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]]
+ this.surfaceProject = [ false, false, false ]
+ this.contourProject = [[ false, false, false ],
+ [ false, false, false ],
+ [ false, false, false ]]
+
+ this.colorBounds = [ false, false ]
+
+ // Store xyz fields, need this for picking
+ this._field = [
+ ndarray(pool.mallocFloat(1024), [0, 0]),
+ ndarray(pool.mallocFloat(1024), [0, 0]),
+ ndarray(pool.mallocFloat(1024), [0, 0]) ]
+
+ this.pickId = 1
+ this.clipBounds = [[-Infinity, -Infinity, -Infinity], [Infinity, Infinity, Infinity]]
+
+ this.snapToData = false
+
+ this.opacity = 1.0
+
+ this.lightPosition = [10, 10000, 0]
+ this.ambientLight = 0.8
+ this.diffuseLight = 0.8
+ this.specularLight = 2.0
+ this.roughness = 0.5
+ this.fresnel = 1.5
+ this.vertexColor = 0;
+
+ this.dirty = true
+}
+
+var proto = SurfacePlot.prototype
+
+proto.isTransparent = function () {
+ return this.opacity < 1
+}
+
+proto.isOpaque = function () {
+ if (this.opacity >= 1) {
+ return true
+ }
+ for (var i = 0; i < 3; ++i) {
+ if (this._contourCounts[i].length > 0 || this._dynamicCounts[i] > 0) {
+ return true
+ }
+ }
+ return false
+}
+
+proto.pickSlots = 1
+
+proto.setPickBase = function (id) {
+ this.pickId = id
+}
+
+var ZERO_VEC = [0, 0, 0]
+
+var PROJECT_DATA = {
+ showSurface: false,
+ showContour: false,
+ projections: [IDENTITY.slice(), IDENTITY.slice(), IDENTITY.slice()],
+ clipBounds: [
+ [[0, 0, 0], [0, 0, 0]],
+ [[0, 0, 0], [0, 0, 0]],
+ [[0, 0, 0], [0, 0, 0]]]
+}
+
+function computeProjectionData (camera, obj) {
+ var i, j, k
+
+ // Compute cube properties
+ var cubeAxis = (obj.axes && obj.axes.lastCubeProps.axis) || ZERO_VEC
+
+ var showSurface = obj.showSurface
+ var showContour = obj.showContour
+
+ for (i = 0; i < 3; ++i) {
+ showSurface = showSurface || obj.surfaceProject[i]
+ for (j = 0; j < 3; ++j) {
+ showContour = showContour || obj.contourProject[i][j]
+ }
+ }
+
+ for (i = 0; i < 3; ++i) {
+ // Construct projection onto axis
+ var axisSquish = PROJECT_DATA.projections[i]
+ for (j = 0; j < 16; ++j) {
+ axisSquish[j] = 0
+ }
+ for (j = 0; j < 4; ++j) {
+ axisSquish[5 * j] = 1
+ }
+ axisSquish[5 * i] = 0
+ axisSquish[12 + i] = obj.axesBounds[+(cubeAxis[i] > 0)][i]
+ multiply(axisSquish, camera.model, axisSquish)
+
+ var nclipBounds = PROJECT_DATA.clipBounds[i]
+ for (k = 0; k < 2; ++k) {
+ for (j = 0; j < 3; ++j) {
+ nclipBounds[k][j] = camera.clipBounds[k][j]
+ }
+ }
+ nclipBounds[0][i] = -1e8
+ nclipBounds[1][i] = 1e8
+ }
+
+ PROJECT_DATA.showSurface = showSurface
+ PROJECT_DATA.showContour = showContour
+
+ return PROJECT_DATA
+}
+
+var UNIFORMS = {
+ model: IDENTITY,
+ view: IDENTITY,
+ projection: IDENTITY,
+ inverseModel: IDENTITY.slice(),
+ lowerBound: [0, 0, 0],
+ upperBound: [0, 0, 0],
+ colorMap: 0,
+ clipBounds: [[0, 0, 0], [0, 0, 0]],
+ height: 0.0,
+ contourTint: 0,
+ contourColor: [0, 0, 0, 1],
+ permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+ zOffset: -1e-4,
+ kambient: 1,
+ kdiffuse: 1,
+ kspecular: 1,
+ lightPosition: [1000, 1000, 1000],
+ eyePosition: [0, 0, 0],
+ roughness: 1,
+ fresnel: 1,
+ opacity: 1,
+ vertexColor: 0
+}
+
+var MATRIX_INVERSE = IDENTITY.slice()
+var DEFAULT_PERM = [1, 0, 0, 0, 1, 0, 0, 0, 1]
+
+function drawCore (params, transparent) {
+ params = params || {}
+ var gl = this.gl
+
+ gl.disable(gl.CULL_FACE)
+
+ this._colorMap.bind(0)
+
+ var uniforms = UNIFORMS
+ uniforms.model = params.model || IDENTITY
+ uniforms.view = params.view || IDENTITY
+ uniforms.projection = params.projection || IDENTITY
+ uniforms.lowerBound = [this.bounds[0][0], this.bounds[0][1], this.colorBounds[0] || this.bounds[0][2]]
+ uniforms.upperBound = [this.bounds[1][0], this.bounds[1][1], this.colorBounds[1] || this.bounds[1][2]]
+ uniforms.contourColor = this.contourColor[0]
+
+ uniforms.inverseModel = invert(uniforms.inverseModel, uniforms.model)
+
+ for (var i = 0; i < 2; ++i) {
+ var clipClamped = uniforms.clipBounds[i]
+ for (var j = 0; j < 3; ++j) {
+ clipClamped[j] = Math.min(Math.max(this.clipBounds[i][j], -1e8), 1e8)
+ }
+ }
+
+ uniforms.kambient = this.ambientLight
+ uniforms.kdiffuse = this.diffuseLight
+ uniforms.kspecular = this.specularLight
+
+ uniforms.roughness = this.roughness
+ uniforms.fresnel = this.fresnel
+ uniforms.opacity = this.opacity
+
+ uniforms.height = 0.0
+ uniforms.permutation = DEFAULT_PERM
+
+ uniforms.vertexColor = this.vertexColor
+
+ // Compute camera matrix inverse
+ var invCameraMatrix = MATRIX_INVERSE
+ multiply(invCameraMatrix, uniforms.view, uniforms.model)
+ multiply(invCameraMatrix, uniforms.projection, invCameraMatrix)
+ invert(invCameraMatrix, invCameraMatrix)
+
+ for (i = 0; i < 3; ++i) {
+ uniforms.eyePosition[i] = invCameraMatrix[12 + i] / invCameraMatrix[15]
+ }
+
+ var w = invCameraMatrix[15]
+ for (i = 0; i < 3; ++i) {
+ w += this.lightPosition[i] * invCameraMatrix[4 * i + 3]
+ }
+ for (i = 0; i < 3; ++i) {
+ var s = invCameraMatrix[12 + i]
+ for (j = 0; j < 3; ++j) {
+ s += invCameraMatrix[4 * j + i] * this.lightPosition[j]
+ }
+ uniforms.lightPosition[i] = s / w
+ }
+
+ var projectData = computeProjectionData(uniforms, this)
+
+ if (projectData.showSurface && (transparent === (this.opacity < 1))) {
+ // Set up uniforms
+ this._shader.bind()
+ this._shader.uniforms = uniforms
+
+ // Draw it
+ this._vao.bind()
+
+ if (this.showSurface && this._vertexCount) {
+ this._vao.draw(gl.TRIANGLES, this._vertexCount)
+ }
+
+ // Draw projections of surface
+ for (i = 0; i < 3; ++i) {
+ if (!this.surfaceProject[i] || !this.vertexCount) {
+ continue
+ }
+ this._shader.uniforms.model = projectData.projections[i]
+ this._shader.uniforms.clipBounds = projectData.clipBounds[i]
+ this._vao.draw(gl.TRIANGLES, this._vertexCount)
+ }
+
+ this._vao.unbind()
+ }
+
+ if (projectData.showContour && !transparent) {
+ var shader = this._contourShader
+
+ // Don't apply lighting to contours
+ uniforms.kambient = 1.0
+ uniforms.kdiffuse = 0.0
+ uniforms.kspecular = 0.0
+ uniforms.opacity = 1.0
+
+ shader.bind()
+ shader.uniforms = uniforms
+
+ // Draw contour lines
+ var vao = this._contourVAO
+ vao.bind()
+
+ // Draw contour levels
+ for (i = 0; i < 3; ++i) {
+ shader.uniforms.permutation = PERMUTATIONS[i]
+ gl.lineWidth(this.contourWidth[i])
+
+ for (j = 0; j < this.contourLevels[i].length; ++j) {
+ if (j === this.highlightLevel[i]) {
+ shader.uniforms.contourColor = this.highlightColor[i]
+ shader.uniforms.contourTint = this.highlightTint[i]
+ } else if (j === 0 || (j - 1) === this.highlightLevel[i]) {
+ shader.uniforms.contourColor = this.contourColor[i]
+ shader.uniforms.contourTint = this.contourTint[i]
+ }
+ if (!this._contourCounts[i][j]) {
+ continue
+ }
+ shader.uniforms.height = this.contourLevels[i][j]
+ vao.draw(gl.LINES, this._contourCounts[i][j], this._contourOffsets[i][j])
+ }
+ }
+
+ // Draw projections of surface
+ for (i = 0; i < 3; ++i) {
+ shader.uniforms.model = projectData.projections[i]
+ shader.uniforms.clipBounds = projectData.clipBounds[i]
+ for (j = 0; j < 3; ++j) {
+ if (!this.contourProject[i][j]) {
+ continue
+ }
+ shader.uniforms.permutation = PERMUTATIONS[j]
+ gl.lineWidth(this.contourWidth[j])
+ for (var k = 0; k < this.contourLevels[j].length; ++k) {
+ if (k === this.highlightLevel[j]) {
+ shader.uniforms.contourColor = this.highlightColor[j]
+ shader.uniforms.contourTint = this.highlightTint[j]
+ } else if (k === 0 || (k - 1) === this.highlightLevel[j]) {
+ shader.uniforms.contourColor = this.contourColor[j]
+ shader.uniforms.contourTint = this.contourTint[j]
+ }
+ shader.uniforms.height = this.contourLevels[j][k]
+ vao.draw(gl.LINES, this._contourCounts[j][k], this._contourOffsets[j][k])
+ }
+ }
+ }
+ vao.unbind()
+
+ // Draw dynamic contours
+ vao = this._dynamicVAO
+ vao.bind()
+
+ // Draw contour levels
+ for (i = 0; i < 3; ++i) {
+ if (this._dynamicCounts[i] === 0) {
+ continue
+ }
+
+ shader.uniforms.model = uniforms.model
+ shader.uniforms.clipBounds = uniforms.clipBounds
+ shader.uniforms.permutation = PERMUTATIONS[i]
+ gl.lineWidth(this.dynamicWidth[i])
+
+ shader.uniforms.contourColor = this.dynamicColor[i]
+ shader.uniforms.contourTint = this.dynamicTint[i]
+ shader.uniforms.height = this.dynamicLevel[i]
+ vao.draw(gl.LINES, this._dynamicCounts[i], this._dynamicOffsets[i])
+
+ for (j = 0; j < 3; ++j) {
+ if (!this.contourProject[j][i]) {
+ continue
+ }
+
+ shader.uniforms.model = projectData.projections[j]
+ shader.uniforms.clipBounds = projectData.clipBounds[j]
+ vao.draw(gl.LINES, this._dynamicCounts[i], this._dynamicOffsets[i])
+ }
+ }
+
+ vao.unbind()
+ }
+}
+
+proto.draw = function (params) {
+ return drawCore.call(this, params, false)
+}
+
+proto.drawTransparent = function (params) {
+ return drawCore.call(this, params, true)
+}
+
+var PICK_UNIFORMS = {
+ model: IDENTITY,
+ view: IDENTITY,
+ projection: IDENTITY,
+ inverseModel: IDENTITY,
+ clipBounds: [[0, 0, 0], [0, 0, 0]],
+ height: 0.0,
+ shape: [0, 0],
+ pickId: 0,
+ lowerBound: [0, 0, 0],
+ upperBound: [0, 0, 0],
+ zOffset: 0.0,
+ permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+ lightPosition: [0, 0, 0],
+ eyePosition: [0, 0, 0]
+}
+
+proto.drawPick = function (params) {
+ params = params || {}
+ var gl = this.gl
+ gl.disable(gl.CULL_FACE)
+
+ var uniforms = PICK_UNIFORMS
+ uniforms.model = params.model || IDENTITY
+ uniforms.view = params.view || IDENTITY
+ uniforms.projection = params.projection || IDENTITY
+ uniforms.shape = this._field[2].shape
+ uniforms.pickId = this.pickId / 255.0
+ uniforms.lowerBound = this.bounds[0]
+ uniforms.upperBound = this.bounds[1]
+ uniforms.permutation = DEFAULT_PERM
+
+ for (var i = 0; i < 2; ++i) {
+ var clipClamped = uniforms.clipBounds[i]
+ for (var j = 0; j < 3; ++j) {
+ clipClamped[j] = Math.min(Math.max(this.clipBounds[i][j], -1e8), 1e8)
+ }
+ }
+
+ var projectData = computeProjectionData(uniforms, this)
+
+ if (projectData.showSurface) {
+ // Set up uniforms
+ this._pickShader.bind()
+ this._pickShader.uniforms = uniforms
+
+ // Draw it
+ this._vao.bind()
+ this._vao.draw(gl.TRIANGLES, this._vertexCount)
+
+ // Draw projections of surface
+ for (i = 0; i < 3; ++i) {
+ if (!this.surfaceProject[i]) {
+ continue
+ }
+ this._pickShader.uniforms.model = projectData.projections[i]
+ this._pickShader.uniforms.clipBounds = projectData.clipBounds[i]
+ this._vao.draw(gl.TRIANGLES, this._vertexCount)
+ }
+
+ this._vao.unbind()
+ }
+
+ if (projectData.showContour) {
+ var shader = this._contourPickShader
+
+ shader.bind()
+ shader.uniforms = uniforms
+
+ var vao = this._contourVAO
+ vao.bind()
+
+ for (j = 0; j < 3; ++j) {
+ gl.lineWidth(this.contourWidth[j])
+ shader.uniforms.permutation = PERMUTATIONS[j]
+ for (i = 0; i < this.contourLevels[j].length; ++i) {
+ if (this._contourCounts[j][i]) {
+ shader.uniforms.height = this.contourLevels[j][i]
+ vao.draw(gl.LINES, this._contourCounts[j][i], this._contourOffsets[j][i])
+ }
+ }
+ }
+
+ // Draw projections of surface
+ for (i = 0; i < 3; ++i) {
+ shader.uniforms.model = projectData.projections[i]
+ shader.uniforms.clipBounds = projectData.clipBounds[i]
+
+ for (j = 0; j < 3; ++j) {
+ if (!this.contourProject[i][j]) {
+ continue
+ }
+
+ shader.uniforms.permutation = PERMUTATIONS[j]
+ gl.lineWidth(this.contourWidth[j])
+ for (var k = 0; k < this.contourLevels[j].length; ++k) {
+ if (this._contourCounts[j][k]) {
+ shader.uniforms.height = this.contourLevels[j][k]
+ vao.draw(gl.LINES, this._contourCounts[j][k], this._contourOffsets[j][k])
+ }
+ }
+ }
+ }
+
+ vao.unbind()
+ }
+}
+
+proto.pick = function (selection) {
+ if (!selection) {
+ return null
+ }
+
+ if (selection.id !== this.pickId) {
+ return null
+ }
+
+ var shape = this._field[2].shape
+
+ var result = this._pickResult
+
+ // Compute uv coordinate
+ var x = shape[0] * (selection.value[0] + (selection.value[2] >> 4) / 16.0) / 255.0
+ var ix = Math.floor(x)
+ var fx = x - ix
+
+ var y = shape[1] * (selection.value[1] + (selection.value[2] & 15) / 16.0) / 255.0
+ var iy = Math.floor(y)
+ var fy = y - iy
+
+ ix += 1
+ iy += 1
+
+ // Compute xyz coordinate
+ var pos = result.position
+ pos[0] = pos[1] = pos[2] = 0
+ for (var dx = 0; dx < 2; ++dx) {
+ var s = dx ? fx : 1.0 - fx
+ for (var dy = 0; dy < 2; ++dy) {
+ var t = dy ? fy : 1.0 - fy
+
+ var r = ix + dx
+ var c = iy + dy
+ var w = s * t
+
+ for (var i = 0; i < 3; ++i) {
+ pos[i] += this._field[i].get(r, c) * w
+ }
+ }
+ }
+
+ // Find closest level
+ var levelIndex = this._pickResult.level
+ for (var j = 0; j < 3; ++j) {
+ levelIndex[j] = bsearch.le(this.contourLevels[j], pos[j])
+ if (levelIndex[j] < 0) {
+ if (this.contourLevels[j].length > 0) {
+ levelIndex[j] = 0
+ }
+ } else if (levelIndex[j] < this.contourLevels[j].length - 1) {
+ var a = this.contourLevels[j][levelIndex[j]]
+ var b = this.contourLevels[j][levelIndex[j] + 1]
+ if (Math.abs(a - pos[j]) > Math.abs(b - pos[j])) {
+ levelIndex[j] += 1
+ }
+ }
+ }
+
+ result.index[0] = fx < 0.5 ? ix : (ix + 1)
+ result.index[1] = fy < 0.5 ? iy : (iy + 1)
+
+ result.uv[0] = x / shape[0]
+ result.uv[1] = y / shape[1]
+
+ for (i = 0; i < 3; ++i) {
+ result.dataCoordinate[i] = this._field[i].get(result.index[0], result.index[1])
+ }
+
+ return result
+}
+
+function padField (nfield, field) {
+ var shape = field.shape.slice()
+ var nshape = nfield.shape.slice()
+
+ // Center
+ ops.assign(nfield.lo(1, 1).hi(shape[0], shape[1]), field)
+
+ // Edges
+ ops.assign(nfield.lo(1).hi(shape[0], 1),
+ field.hi(shape[0], 1))
+ ops.assign(nfield.lo(1, nshape[1] - 1).hi(shape[0], 1),
+ field.lo(0, shape[1] - 1).hi(shape[0], 1))
+ ops.assign(nfield.lo(0, 1).hi(1, shape[1]),
+ field.hi(1))
+ ops.assign(nfield.lo(nshape[0] - 1, 1).hi(1, shape[1]),
+ field.lo(shape[0] - 1))
+ // Corners
+ nfield.set(0, 0, field.get(0, 0))
+ nfield.set(0, nshape[1] - 1, field.get(0, shape[1] - 1))
+ nfield.set(nshape[0] - 1, 0, field.get(shape[0] - 1, 0))
+ nfield.set(nshape[0] - 1, nshape[1] - 1, field.get(shape[0] - 1, shape[1] - 1))
+}
+
+function handleArray (param, ctor) {
+ if (Array.isArray(param)) {
+ return [ ctor(param[0]), ctor(param[1]), ctor(param[2]) ]
+ }
+ return [ ctor(param), ctor(param), ctor(param) ]
+}
+
+function toColor (x) {
+ if (Array.isArray(x)) {
+ if (x.length === 3) {
+ return [x[0], x[1], x[2], 1]
+ }
+ return [x[0], x[1], x[2], x[3]]
+ }
+ return [0, 0, 0, 1]
+}
+
+function handleColor (param) {
+ if (Array.isArray(param)) {
+ if (Array.isArray(param)) {
+ return [
+ toColor(param[0]),
+ toColor(param[1]),
+ toColor(param[2]) ]
+ } else {
+ var c = toColor(param)
+ return [
+ c.slice(),
+ c.slice(),
+ c.slice() ]
+ }
+ }
+}
+
+proto.update = function (params) {
+ params = params || {}
+
+ this.dirty = true
+
+ if ('contourWidth' in params) {
+ this.contourWidth = handleArray(params.contourWidth, Number)
+ }
+ if ('showContour' in params) {
+ this.showContour = handleArray(params.showContour, Boolean)
+ }
+ if ('showSurface' in params) {
+ this.showSurface = !!params.showSurface
+ }
+ if ('contourTint' in params) {
+ this.contourTint = handleArray(params.contourTint, Boolean)
+ }
+ if ('contourColor' in params) {
+ this.contourColor = handleColor(params.contourColor)
+ }
+ if ('contourProject' in params) {
+ this.contourProject = handleArray(params.contourProject, function (x) {
+ return handleArray(x, Boolean)
+ })
+ }
+ if ('surfaceProject' in params) {
+ this.surfaceProject = params.surfaceProject
+ }
+ if ('dynamicColor' in params) {
+ this.dynamicColor = handleColor(params.dynamicColor)
+ }
+ if ('dynamicTint' in params) {
+ this.dynamicTint = handleArray(params.dynamicTint, Number)
+ }
+ if ('dynamicWidth' in params) {
+ this.dynamicWidth = handleArray(params.dynamicWidth, Number)
+ }
+ if ('opacity' in params) {
+ this.opacity = params.opacity
+ }
+ if ('colorBounds' in params) {
+ this.colorBounds = params.colorBounds
+ }
+ if ('vertexColor' in params) {
+ this.vertexColor = params.vertexColor ? 1 : 0;
+ }
+
+ var field = params.field || (params.coords && params.coords[2]) || null
+ var levelsChanged = false
+
+ if (!field) {
+ if (this._field[2].shape[0] || this._field[2].shape[2]) {
+ field = this._field[2].lo(1, 1).hi(this._field[2].shape[0] - 2, this._field[2].shape[1] - 2)
+ } else {
+ field = this._field[2].hi(0, 0)
+ }
+ }
+
+ // Update field
+ if ('field' in params || 'coords' in params) {
+ var fsize = (field.shape[0] + 2) * (field.shape[1] + 2)
+
+ // Resize if necessary
+ if (fsize > this._field[2].data.length) {
+ pool.freeFloat(this._field[2].data)
+ this._field[2].data = pool.mallocFloat(bits.nextPow2(fsize))
+ }
+
+ // Pad field
+ this._field[2] = ndarray(this._field[2].data, [field.shape[0] + 2, field.shape[1] + 2])
+ padField(this._field[2], field)
+
+ // Save shape of field
+ this.shape = field.shape.slice()
+ var shape = this.shape
+
+ // Resize coordinate fields if necessary
+ for (var i = 0; i < 2; ++i) {
+ if (this._field[2].size > this._field[i].data.length) {
+ pool.freeFloat(this._field[i].data)
+ this._field[i].data = pool.mallocFloat(this._field[2].size)
+ }
+ this._field[i] = ndarray(this._field[i].data, [shape[0] + 2, shape[1] + 2])
+ }
+
+ // Generate x/y coordinates
+ if (params.coords) {
+ var coords = params.coords
+ if (!Array.isArray(coords) || coords.length !== 3) {
+ throw new Error('gl-surface: invalid coordinates for x/y')
+ }
+ for (i = 0; i < 2; ++i) {
+ var coord = coords[i]
+ for (j = 0; j < 2; ++j) {
+ if (coord.shape[j] !== shape[j]) {
+ throw new Error('gl-surface: coords have incorrect shape')
+ }
+ }
+ padField(this._field[i], coord)
+ }
+ } else if (params.ticks) {
+ var ticks = params.ticks
+ if (!Array.isArray(ticks) || ticks.length !== 2) {
+ throw new Error('gl-surface: invalid ticks')
+ }
+ for (i = 0; i < 2; ++i) {
+ var tick = ticks[i]
+ if (Array.isArray(tick) || tick.length) {
+ tick = ndarray(tick)
+ }
+ if (tick.shape[0] !== shape[i]) {
+ throw new Error('gl-surface: invalid tick length')
+ }
+ // Make a copy view of the tick array
+ var tick2 = ndarray(tick.data, shape)
+ tick2.stride[i] = tick.stride[0]
+ tick2.stride[i ^ 1] = 0
+
+ // Fill in field array
+ padField(this._field[i], tick2)
+ }
+ } else {
+ for (i = 0; i < 2; ++i) {
+ var offset = [0, 0]
+ offset[i] = 1
+ this._field[i] = ndarray(this._field[i].data, [shape[0] + 2, shape[1] + 2], offset, 0)
+ }
+ this._field[0].set(0, 0, 0)
+ for (var j = 0; j < shape[0]; ++j) {
+ this._field[0].set(j + 1, 0, j)
+ }
+ this._field[0].set(shape[0] + 1, 0, shape[0] - 1)
+ this._field[1].set(0, 0, 0)
+ for (j = 0; j < shape[1]; ++j) {
+ this._field[1].set(0, j + 1, j)
+ }
+ this._field[1].set(0, shape[1] + 1, shape[1] - 1)
+ }
+
+ // Save shape
+ var fields = this._field
+
+ // Compute surface normals
+ var dfields = ndarray(pool.mallocFloat(fields[2].size * 3 * 2), [3, shape[0] + 2, shape[1] + 2, 2])
+ for (i = 0; i < 3; ++i) {
+ gradient(dfields.pick(i), fields[i], 'mirror')
+ }
+ var normals = ndarray(pool.mallocFloat(fields[2].size * 3), [shape[0] + 2, shape[1] + 2, 3])
+ for (i = 0; i < shape[0] + 2; ++i) {
+ for (j = 0; j < shape[1] + 2; ++j) {
+ var dxdu = dfields.get(0, i, j, 0)
+ var dxdv = dfields.get(0, i, j, 1)
+ var dydu = dfields.get(1, i, j, 0)
+ var dydv = dfields.get(1, i, j, 1)
+ var dzdu = dfields.get(2, i, j, 0)
+ var dzdv = dfields.get(2, i, j, 1)
+
+ var nx = dydu * dzdv - dydv * dzdu
+ var ny = dzdu * dxdv - dzdv * dxdu
+ var nz = dxdu * dydv - dxdv * dydu
+
+ var nl = Math.sqrt(nx * nx + ny * ny + nz * nz)
+ if (nl < 1e-8) {
+ nl = Math.max(Math.abs(nx), Math.abs(ny), Math.abs(nz))
+ if (nl < 1e-8) {
+ nz = 1.0
+ ny = nx = 0.0
+ nl = 1.0
+ } else {
+ nl = 1.0 / nl
+ }
+ } else {
+ nl = 1.0 / Math.sqrt(nl)
+ }
+
+ normals.set(i, j, 0, nx * nl)
+ normals.set(i, j, 1, ny * nl)
+ normals.set(i, j, 2, nz * nl)
+ }
+ }
+ pool.free(dfields.data)
+
+ // Initialize surface
+ var lo = [ Infinity, Infinity, Infinity ]
+ var hi = [ -Infinity, -Infinity, -Infinity ]
+ var lo_intensity = Infinity
+ var hi_intensity = -Infinity
+ var count = (shape[0] - 1) * (shape[1] - 1) * 6
+ var tverts = pool.mallocFloat(bits.nextPow2(10 * count))
+ var tptr = 0
+ var vertexCount = 0
+ for (i = 0; i < shape[0] - 1; ++i) {
+ j_loop:
+ for (j = 0; j < shape[1] - 1; ++j) {
+ // Test for NaNs
+ for (var dx = 0; dx < 2; ++dx) {
+ for (var dy = 0; dy < 2; ++dy) {
+ for (var k = 0; k < 3; ++k) {
+ var f = this._field[k].get(1 + i + dx, 1 + j + dy)
+ if (isNaN(f) || !isFinite(f)) {
+ continue j_loop
+ }
+ }
+ }
+ }
+ for (k = 0; k < 6; ++k) {
+ var r = i + QUAD[k][0]
+ var c = j + QUAD[k][1]
+
+ var tx = this._field[0].get(r + 1, c + 1)
+ var ty = this._field[1].get(r + 1, c + 1)
+ f = this._field[2].get(r + 1, c + 1)
+ var vf = f
+ nx = normals.get(r + 1, c + 1, 0)
+ ny = normals.get(r + 1, c + 1, 1)
+ nz = normals.get(r + 1, c + 1, 2)
+
+ if (params.intensity) {
+ vf = params.intensity.get(r, c)
+ }
+
+ tverts[tptr++] = r
+ tverts[tptr++] = c
+ tverts[tptr++] = tx
+ tverts[tptr++] = ty
+ tverts[tptr++] = f
+ tverts[tptr++] = 0
+ tverts[tptr++] = vf
+ tverts[tptr++] = nx
+ tverts[tptr++] = ny
+ tverts[tptr++] = nz
+
+ lo[0] = Math.min(lo[0], tx)
+ lo[1] = Math.min(lo[1], ty)
+ lo[2] = Math.min(lo[2], f)
+ lo_intensity = Math.min(lo_intensity, vf)
+
+ hi[0] = Math.max(hi[0], tx)
+ hi[1] = Math.max(hi[1], ty)
+ hi[2] = Math.max(hi[2], f)
+ hi_intensity = Math.max(hi_intensity, vf)
+
+ vertexCount += 1
+ }
+ }
+ }
+
+ if (params.intensityBounds) {
+ lo_intensity = +params.intensityBounds[0]
+ hi_intensity = +params.intensityBounds[1]
+ }
+
+ // Scale all vertex intensities
+ for (i = 6; i < tptr; i += 10) {
+ tverts[i] = (tverts[i] - lo_intensity) / (hi_intensity - lo_intensity)
+ }
+
+ this._vertexCount = vertexCount
+ this._coordinateBuffer.update(tverts.subarray(0, tptr))
+ pool.freeFloat(tverts)
+ pool.free(normals.data)
+
+ // Update bounds
+ this.bounds = [lo, hi]
+
+ // Save intensity
+ this.intensity = params.intensity || this._field[2]
+
+ if(this.intensityBounds[0] !== lo_intensity || this.intensityBounds[1] !== hi_intensity) {
+ levelsChanged = true
+ }
+
+ // Save intensity bound
+ this.intensityBounds = [lo_intensity, hi_intensity]
+ }
+
+ // Update level crossings
+ if ('levels' in params) {
+ var levels = params.levels
+ if (!Array.isArray(levels[0])) {
+ levels = [ [], [], levels ]
+ } else {
+ levels = levels.slice()
+ }
+ for (i = 0; i < 3; ++i) {
+ levels[i] = levels[i].slice()
+ levels.sort(function (a, b) {
+ return a - b
+ })
+ }
+ change_test:
+ for (i = 0; i < 3; ++i) {
+ if (levels[i].length !== this.contourLevels[i].length) {
+ levelsChanged = true
+ break
+ }
+ for (j = 0; j < levels[i].length; ++j) {
+ if (levels[i][j] !== this.contourLevels[i][j]) {
+ levelsChanged = true
+ break change_test
+ }
+ }
+ }
+ this.contourLevels = levels
+ }
+
+ if (levelsChanged) {
+ fields = this._field
+ shape = this.shape
+
+ // Update contour lines
+ var contourVerts = []
+
+ for (var dim = 0; dim < 3; ++dim) {
+ levels = this.contourLevels[dim]
+ var levelOffsets = []
+ var levelCounts = []
+
+ var parts = [0, 0, 0]
+
+ for (i = 0; i < levels.length; ++i) {
+ var graph = surfaceNets(this._field[dim], levels[i])
+ levelOffsets.push((contourVerts.length / 5) | 0)
+ vertexCount = 0
+
+ edge_loop:
+ for (j = 0; j < graph.cells.length; ++j) {
+ var e = graph.cells[j]
+ for (k = 0; k < 2; ++k) {
+ var p = graph.positions[e[k]]
+
+ var x = p[0]
+ var ix = Math.floor(x) | 0
+ var fx = x - ix
+
+ var y = p[1]
+ var iy = Math.floor(y) | 0
+ var fy = y - iy
+
+ var hole = false
+ dd_loop:
+ for (var dd = 0; dd < 3; ++dd) {
+ parts[dd] = 0.0
+ var iu = (dim + dd + 1) % 3
+ for (dx = 0; dx < 2; ++dx) {
+ var s = dx ? fx : 1.0 - fx
+ r = Math.min(Math.max(ix + dx, 0), shape[0]) | 0
+ for (dy = 0; dy < 2; ++dy) {
+ var t = dy ? fy : 1.0 - fy
+ c = Math.min(Math.max(iy + dy, 0), shape[1]) | 0
+
+ if (dd < 2) {
+ f = this._field[iu].get(r, c)
+ } else {
+ f = (this.intensity.get(r, c) - this.intensityBounds[0]) / (this.intensityBounds[1] - this.intensityBounds[0])
+ }
+ if (!isFinite(f) || isNaN(f)) {
+ hole = true
+ break dd_loop
+ }
+
+ var w = s * t
+ parts[dd] += w * f
+ }
+ }
+ }
+
+ if (!hole) {
+ contourVerts.push(parts[0], parts[1], p[0], p[1], parts[2])
+ vertexCount += 1
+ } else {
+ if (k > 0) {
+ // If we already added first edge, pop off verts
+ for (var l = 0; l < 5; ++l) {
+ contourVerts.pop()
+ }
+ vertexCount -= 1
+ }
+ continue edge_loop
+ }
+ }
+ }
+ levelCounts.push(vertexCount)
+ }
+
+ // Store results
+ this._contourOffsets[dim] = levelOffsets
+ this._contourCounts[dim] = levelCounts
+ }
+
+ var floatBuffer = pool.mallocFloat(contourVerts.length)
+ for (i = 0; i < contourVerts.length; ++i) {
+ floatBuffer[i] = contourVerts[i]
+ }
+ this._contourBuffer.update(floatBuffer)
+ pool.freeFloat(floatBuffer)
+ }
+
+ if (params.colormap) {
+ this._colorMap.setPixels(genColormap(params.colormap))
+ }
+}
+
+proto.dispose = function () {
+ this._shader.dispose()
+ this._vao.dispose()
+ this._coordinateBuffer.dispose()
+ this._colorMap.dispose()
+ this._contourBuffer.dispose()
+ this._contourVAO.dispose()
+ this._contourShader.dispose()
+ this._contourPickShader.dispose()
+ this._dynamicBuffer.dispose()
+ this._dynamicVAO.dispose()
+ for (var i = 0; i < 3; ++i) {
+ pool.freeFloat(this._field[i].data)
+ }
+}
+
+proto.highlight = function (selection) {
+ if (!selection) {
+ this._dynamicCounts = [0, 0, 0]
+ this.dyanamicLevel = [NaN, NaN, NaN]
+ this.highlightLevel = [-1, -1, -1]
+ return
+ }
+
+ for (var i = 0; i < 3; ++i) {
+ if (this.enableHighlight[i]) {
+ this.highlightLevel[i] = selection.level[i]
+ } else {
+ this.highlightLevel[i] = -1
+ }
+ }
+
+ var levels
+ if (this.snapToData) {
+ levels = selection.dataCoordinate
+ } else {
+ levels = selection.position
+ }
+ if ((!this.enableDynamic[0] || levels[0] === this.dynamicLevel[0]) &&
+ (!this.enableDynamic[1] || levels[1] === this.dynamicLevel[1]) &&
+ (!this.enableDynamic[2] || levels[2] === this.dynamicLevel[2])) {
+ return
+ }
+
+ var vertexCount = 0
+ var shape = this.shape
+ var scratchBuffer = pool.mallocFloat(12 * shape[0] * shape[1])
+
+ for (var d = 0; d < 3; ++d) {
+ if (!this.enableDynamic[d]) {
+ this.dynamicLevel[d] = NaN
+ this._dynamicCounts[d] = 0
+ continue
+ }
+
+ this.dynamicLevel[d] = levels[d]
+
+ var u = (d + 1) % 3
+ var v = (d + 2) % 3
+
+ var f = this._field[d]
+ var g = this._field[u]
+ var h = this._field[v]
+ var intensity = this.intensity
+
+ var graph = surfaceNets(f, levels[d])
+ var edges = graph.cells
+ var positions = graph.positions
+
+ this._dynamicOffsets[d] = vertexCount
+
+ for (i = 0; i < edges.length; ++i) {
+ var e = edges[i]
+ for (var j = 0; j < 2; ++j) {
+ var p = positions[e[j]]
+
+ var x = +p[0]
+ var ix = x | 0
+ var jx = Math.min(ix + 1, shape[0]) | 0
+ var fx = x - ix
+ var hx = 1.0 - fx
+
+ var y = +p[1]
+ var iy = y | 0
+ var jy = Math.min(iy + 1, shape[1]) | 0
+ var fy = y - iy
+ var hy = 1.0 - fy
+
+ var w00 = hx * hy
+ var w01 = hx * fy
+ var w10 = fx * hy
+ var w11 = fx * fy
+
+ var cu = w00 * g.get(ix, iy) +
+ w01 * g.get(ix, jy) +
+ w10 * g.get(jx, iy) +
+ w11 * g.get(jx, jy)
+
+ var cv = w00 * h.get(ix, iy) +
+ w01 * h.get(ix, jy) +
+ w10 * h.get(jx, iy) +
+ w11 * h.get(jx, jy)
+
+ if (isNaN(cu) || isNaN(cv)) {
+ if (j) {
+ vertexCount -= 1
+ }
+ break
+ }
+
+ scratchBuffer[2 * vertexCount + 0] = cu
+ scratchBuffer[2 * vertexCount + 1] = cv
+
+ vertexCount += 1
+ }
+ }
+
+ this._dynamicCounts[d] = vertexCount - this._dynamicOffsets[d]
+ }
+
+ this._dynamicBuffer.update(scratchBuffer.subarray(0, 2 * vertexCount))
+ pool.freeFloat(scratchBuffer)
+}
+
+function createSurfacePlot (params) {
+ var gl = params.gl
+ var shader = createShader(gl)
+ var pickShader = createPickShader(gl)
+ var contourShader = createContourShader(gl)
+ var contourPickShader = createPickContourShader(gl)
+
+ var coordinateBuffer = createBuffer(gl)
+ var vao = createVAO(gl, [
+ { buffer: coordinateBuffer,
+ size: 4,
+ stride: SURFACE_VERTEX_SIZE,
+ offset: 0
+ },
+ { buffer: coordinateBuffer,
+ size: 3,
+ stride: SURFACE_VERTEX_SIZE,
+ offset: 16
+ },
+ {
+ buffer: coordinateBuffer,
+ size: 3,
+ stride: SURFACE_VERTEX_SIZE,
+ offset: 28
+ }
+ ])
+
+ var contourBuffer = createBuffer(gl)
+ var contourVAO = createVAO(gl, [
+ {
+ buffer: contourBuffer,
+ size: 4,
+ stride: 20,
+ offset: 0
+ },
+ {
+ buffer: contourBuffer,
+ size: 1,
+ stride: 20,
+ offset: 16
+ }
+ ])
+
+ var dynamicBuffer = createBuffer(gl)
+ var dynamicVAO = createVAO(gl, [
+ {
+ buffer: dynamicBuffer,
+ size: 2,
+ type: gl.FLOAT
+ }])
+
+ var cmap = createTexture(gl, 1, N_COLORS, gl.RGBA, gl.UNSIGNED_BYTE)
+ cmap.minFilter = gl.LINEAR
+ cmap.magFilter = gl.LINEAR
+
+ var surface = new SurfacePlot(
+ gl,
+ [0, 0],
+ [[0, 0, 0], [0, 0, 0]],
+ shader,
+ pickShader,
+ coordinateBuffer,
+ vao,
+ cmap,
+ contourShader,
+ contourPickShader,
+ contourBuffer,
+ contourVAO,
+ dynamicBuffer,
+ dynamicVAO
+ )
+
+ var nparams = {
+ levels: [[], [], []]
+ }
+ for (var id in params) {
+ nparams[id] = params[id]
+ }
+ nparams.colormap = nparams.colormap || 'jet'
+
+ surface.update(nparams)
+
+ return surface
+}
+
+},{"./lib/shaders":302,"binary-search-bounds":79,"bit-twiddle":80,"colormap":114,"gl-buffer":230,"gl-mat4/invert":254,"gl-mat4/multiply":256,"gl-texture2d":305,"gl-vao":310,"ndarray":433,"ndarray-gradient":424,"ndarray-ops":427,"ndarray-pack":428,"surface-nets":508,"typedarray-pool":522}],304:[function(_dereq_,module,exports){
+'use strict'
+
+var Font = _dereq_('css-font')
+var pick = _dereq_('pick-by-alias')
+var createRegl = _dereq_('regl')
+var createGl = _dereq_('gl-util/context')
+var WeakMap = _dereq_('es6-weak-map')
+var rgba = _dereq_('color-normalize')
+var fontAtlas = _dereq_('font-atlas')
+var pool = _dereq_('typedarray-pool')
+var parseRect = _dereq_('parse-rect')
+var isObj = _dereq_('is-plain-obj')
+var parseUnit = _dereq_('parse-unit')
+var px = _dereq_('to-px')
+var kerning = _dereq_('detect-kerning')
+var extend = _dereq_('object-assign')
+var metrics = _dereq_('font-measure')
+var flatten = _dereq_('flatten-vertex-data')
+var ref = _dereq_('bit-twiddle');
+var nextPow2 = ref.nextPow2;
+
+var shaderCache = new WeakMap
+
+
+// Safari does not support font-stretch
+var isStretchSupported = false
+if (document.body) {
+ var el = document.body.appendChild(document.createElement('div'))
+ el.style.font = 'italic small-caps bold condensed 16px/2 cursive'
+ if (getComputedStyle(el).fontStretch) {
+ isStretchSupported = true
+ }
+ document.body.removeChild(el)
+}
+
+var GlText = function GlText (o) {
+ if (isRegl(o)) {
+ o = {regl: o}
+ this.gl = o.regl._gl
+ }
+ else {
+ this.gl = createGl(o)
+ }
+
+ this.shader = shaderCache.get(this.gl)
+
+ if (!this.shader) {
+ this.regl = o.regl || createRegl({ gl: this.gl })
+ }
+ else {
+ this.regl = this.shader.regl
+ }
+
+ this.charBuffer = this.regl.buffer({ type: 'uint8', usage: 'stream' })
+ this.sizeBuffer = this.regl.buffer({ type: 'float', usage: 'stream' })
+
+ if (!this.shader) {
+ this.shader = this.createShader()
+ shaderCache.set(this.gl, this.shader)
+ }
+
+ this.batch = []
+
+ // multiple options initial state
+ this.fontSize = []
+ this.font = []
+ this.fontAtlas = []
+
+ this.draw = this.shader.draw.bind(this)
+ this.render = function () {
+ // FIXME: add Safari regl report here:
+ // charBuffer and width just do not trigger
+ this.regl._refresh()
+ this.draw(this.batch)
+ }
+ this.canvas = this.gl.canvas
+
+ this.update(isObj(o) ? o : {})
+};
+
+GlText.prototype.createShader = function createShader () {
+ var regl = this.regl
+
+ // FIXME: store 2 shader versions: with normal viewport and without
+ // draw texture method
+ var draw = regl({
+ blend: {
+ enable: true,
+ color: [0,0,0,1],
+
+ func: {
+ srcRGB: 'src alpha',
+ dstRGB: 'one minus src alpha',
+ srcAlpha: 'one minus dst alpha',
+ dstAlpha: 'one'
+ }
+ },
+ stencil: {enable: false},
+ depth: {enable: false},
+
+ count: regl.prop('count'),
+ offset: regl.prop('offset'),
+ attributes: {
+ charOffset: {
+ offset: 4,
+ stride: 8,
+ buffer: regl.this('sizeBuffer')
+ },
+ width: {
+ offset: 0,
+ stride: 8,
+ buffer: regl.this('sizeBuffer')
+ },
+ char: regl.this('charBuffer'),
+ position: regl.this('position')
+ },
+ uniforms: {
+ atlasSize: function (c, p) { return [p.atlas.width, p.atlas.height]; },
+ atlasDim: function (c, p) { return [p.atlas.cols, p.atlas.rows]; },
+ atlas: function (c, p) { return p.atlas.texture; },
+ charStep: function (c, p) { return p.atlas.step; },
+ em: function (c, p) { return p.atlas.em; },
+ color: regl.prop('color'),
+ opacity: regl.prop('opacity'),
+ viewport: regl.this('viewportArray'),
+ scale: regl.this('scale'),
+ align: regl.prop('align'),
+ baseline: regl.prop('baseline'),
+ translate: regl.this('translate'),
+ positionOffset: regl.prop('positionOffset')
+ },
+ primitive: 'points',
+ viewport: regl.this('viewport'),
+
+ vert: ("\n\t\t\tprecision highp float;\n\t\t\tattribute float width, charOffset, char;\n\t\t\tattribute vec2 position;\n\t\t\tuniform float fontSize, charStep, em, align, baseline;\n\t\t\tuniform vec4 viewport;\n\t\t\tuniform vec4 color;\n\t\t\tuniform vec2 atlasSize, atlasDim, scale, translate, positionOffset;\n\t\t\tvarying vec2 charCoord, charId;\n\t\t\tvarying float charWidth;\n\t\t\tvarying vec4 fontColor;\n\t\t\tvoid main () {\n\t\t\t\t" + (!GlText.normalViewport ? 'vec2 positionOffset = vec2(positionOffset.x,- positionOffset.y);' : '') + "\n\n\t\t\t\tvec2 offset = floor(em * (vec2(align + charOffset, baseline)\n\t\t\t\t\t+ positionOffset))\n\t\t\t\t\t/ (viewport.zw * scale.xy);\n\n\t\t\t\tvec2 position = (position + translate) * scale;\n\t\t\t\tposition += offset * scale;\n\n\t\t\t\t" + (GlText.normalViewport ? 'position.y = 1. - position.y;' : '') + "\n\n\t\t\t\tcharCoord = position * viewport.zw + viewport.xy;\n\n\t\t\t\tgl_Position = vec4(position * 2. - 1., 0, 1);\n\n\t\t\t\tgl_PointSize = charStep;\n\n\t\t\t\tcharId.x = mod(char, atlasDim.x);\n\t\t\t\tcharId.y = floor(char / atlasDim.x);\n\n\t\t\t\tcharWidth = width * em;\n\n\t\t\t\tfontColor = color / 255.;\n\t\t\t}"),
+
+ frag: "\n\t\t\tprecision highp float;\n\t\t\tuniform sampler2D atlas;\n\t\t\tuniform float fontSize, charStep, opacity;\n\t\t\tuniform vec2 atlasSize;\n\t\t\tuniform vec4 viewport;\n\t\t\tvarying vec4 fontColor;\n\t\t\tvarying vec2 charCoord, charId;\n\t\t\tvarying float charWidth;\n\n\t\t\tfloat lightness(vec4 color) {\n\t\t\t\treturn color.r * 0.299 + color.g * 0.587 + color.b * 0.114;\n\t\t\t}\n\n\t\t\tvoid main () {\n\t\t\t\tvec2 uv = gl_FragCoord.xy - charCoord + charStep * .5;\n\t\t\t\tfloat halfCharStep = floor(charStep * .5 + .5);\n\n\t\t\t\t// invert y and shift by 1px (FF expecially needs that)\n\t\t\t\tuv.y = charStep - uv.y;\n\n\t\t\t\t// ignore points outside of character bounding box\n\t\t\t\tfloat halfCharWidth = ceil(charWidth * .5);\n\t\t\t\tif (floor(uv.x) > halfCharStep + halfCharWidth ||\n\t\t\t\t\tfloor(uv.x) < halfCharStep - halfCharWidth) return;\n\n\t\t\t\tuv += charId * charStep;\n\t\t\t\tuv = uv / atlasSize;\n\n\t\t\t\tvec4 color = fontColor;\n\t\t\t\tvec4 mask = texture2D(atlas, uv);\n\n\t\t\t\tfloat maskY = lightness(mask);\n\t\t\t\t// float colorY = lightness(color);\n\t\t\t\tcolor.a *= maskY;\n\t\t\t\tcolor.a *= opacity;\n\n\t\t\t\t// color.a += .1;\n\n\t\t\t\t// antialiasing, see yiq color space y-channel formula\n\t\t\t\t// color.rgb += (1. - color.rgb) * (1. - mask.rgb);\n\n\t\t\t\tgl_FragColor = color;\n\t\t\t}"
+ })
+
+ // per font-size atlas
+ var atlas = {}
+
+ return { regl: regl, draw: draw, atlas: atlas }
+};
+
+GlText.prototype.update = function update (o) {
+ var this$1 = this;
+
+ if (typeof o === 'string') { o = { text: o } }
+ else if (!o) { return }
+
+ // FIXME: make this a static transform or more general approact
+ o = pick(o, {
+ position: 'position positions coord coords coordinates',
+ font: 'font fontFace fontface typeface cssFont css-font family fontFamily',
+ fontSize: 'fontSize fontsize size font-size',
+ text: 'text texts chars characters value values symbols',
+ align: 'align alignment textAlign textbaseline',
+ baseline: 'baseline textBaseline textbaseline',
+ direction: 'dir direction textDirection',
+ color: 'color colour fill fill-color fillColor textColor textcolor',
+ kerning: 'kerning kern',
+ range: 'range dataBox',
+ viewport: 'vp viewport viewBox viewbox viewPort',
+ opacity: 'opacity alpha transparency visible visibility opaque',
+ offset: 'offset positionOffset padding shift indent indentation'
+ }, true)
+
+
+ if (o.opacity != null) {
+ if (Array.isArray(o.opacity)) {
+ this.opacity = o.opacity.map(function (o) { return parseFloat(o); })
+ }
+ else {
+ this.opacity = parseFloat(o.opacity)
+ }
+ }
+
+ if (o.viewport != null) {
+ this.viewport = parseRect(o.viewport)
+
+ if (GlText.normalViewport) {
+ this.viewport.y = this.canvas.height - this.viewport.y - this.viewport.height
+ }
+
+ this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]
+
+ }
+ if (this.viewport == null) {
+ this.viewport = {
+ x: 0, y: 0,
+ width: this.gl.drawingBufferWidth,
+ height: this.gl.drawingBufferHeight
+ }
+ this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]
+ }
+
+ if (o.kerning != null) { this.kerning = o.kerning }
+
+ if (o.offset != null) {
+ if (typeof o.offset === 'number') { o.offset = [o.offset, 0] }
+
+ this.positionOffset = flatten(o.offset)
+ }
+
+ if (o.direction) { this.direction = o.direction }
+
+ if (o.range) {
+ this.range = o.range
+ this.scale = [1 / (o.range[2] - o.range[0]), 1 / (o.range[3] - o.range[1])]
+ this.translate = [-o.range[0], -o.range[1]]
+ }
+ if (o.scale) { this.scale = o.scale }
+ if (o.translate) { this.translate = o.translate }
+
+ // default scale corresponds to viewport
+ if (!this.scale) { this.scale = [1 / this.viewport.width, 1 / this.viewport.height] }
+
+ if (!this.translate) { this.translate = [0, 0] }
+
+ if (!this.font.length && !o.font) { o.font = GlText.baseFontSize + 'px sans-serif' }
+
+ // normalize font caching string
+ var newFont = false, newFontSize = false
+
+ // obtain new font data
+ if (o.font) {
+ (Array.isArray(o.font) ? o.font : [o.font]).forEach(function (font, i) {
+ // normalize font
+ if (typeof font === 'string') {
+ try {
+ font = Font.parse(font)
+ } catch (e) {
+ font = Font.parse(GlText.baseFontSize + 'px ' + font)
+ }
+ }
+ else { font = Font.parse(Font.stringify(font)) }
+
+ var baseString = Font.stringify({
+ size: GlText.baseFontSize,
+ family: font.family,
+ stretch: isStretchSupported ? font.stretch : undefined,
+ variant: font.variant,
+ weight: font.weight,
+ style: font.style
+ })
+
+ var unit = parseUnit(font.size)
+ var fs = Math.round(unit[0] * px(unit[1]))
+ if (fs !== this$1.fontSize[i]) {
+ newFontSize = true
+ this$1.fontSize[i] = fs
+ }
+
+ // calc new font metrics/atlas
+ if (!this$1.font[i] || baseString != this$1.font[i].baseString) {
+ newFont = true
+
+ // obtain font cache or create one
+ this$1.font[i] = GlText.fonts[baseString]
+ if (!this$1.font[i]) {
+ var family = font.family.join(', ')
+ var style = [font.style]
+ if (font.style != font.variant) { style.push(font.variant) }
+ if (font.variant != font.weight) { style.push(font.weight) }
+ if (isStretchSupported && font.weight != font.stretch) { style.push(font.stretch) }
+
+ this$1.font[i] = {
+ baseString: baseString,
+
+ // typeface
+ family: family,
+ weight: font.weight,
+ stretch: font.stretch,
+ style: font.style,
+ variant: font.variant,
+
+ // widths of characters
+ width: {},
+
+ // kernin pairs offsets
+ kerning: {},
+
+ metrics: metrics(family, {
+ origin: 'top',
+ fontSize: GlText.baseFontSize,
+ fontStyle: style.join(' ')
+ })
+ }
+
+ GlText.fonts[baseString] = this$1.font[i]
+ }
+ }
+ })
+ }
+
+ // FIXME: make independend font-size
+ // if (o.fontSize) {
+ // let unit = parseUnit(o.fontSize)
+ // let fs = Math.round(unit[0] * px(unit[1]))
+
+ // if (fs != this.fontSize) {
+ // newFontSize = true
+ // this.fontSize = fs
+ // }
+ // }
+
+ if (newFont || newFontSize) {
+ this.font.forEach(function (font, i) {
+ var fontString = Font.stringify({
+ size: this$1.fontSize[i],
+ family: font.family,
+ stretch: isStretchSupported ? font.stretch : undefined,
+ variant: font.variant,
+ weight: font.weight,
+ style: font.style
+ })
+
+ // calc new font size atlas
+ this$1.fontAtlas[i] = this$1.shader.atlas[fontString]
+
+ if (!this$1.fontAtlas[i]) {
+ var metrics = font.metrics
+
+ this$1.shader.atlas[fontString] =
+ this$1.fontAtlas[i] = {
+ fontString: fontString,
+ // even step is better for rendered characters
+ step: Math.ceil(this$1.fontSize[i] * metrics.bottom * .5) * 2,
+ em: this$1.fontSize[i],
+ cols: 0,
+ rows: 0,
+ height: 0,
+ width: 0,
+ chars: [],
+ ids: {},
+ texture: this$1.regl.texture()
+ }
+ }
+
+ // bump atlas characters
+ if (o.text == null) { o.text = this$1.text }
+ })
+ }
+
+ // if multiple positions - duplicate text arguments
+ // FIXME: this possibly can be done better to avoid array spawn
+ if (typeof o.text === 'string' && o.position && o.position.length > 2) {
+ var textArray = Array(o.position.length * .5)
+ for (var i = 0; i < textArray.length; i++) {
+ textArray[i] = o.text
+ }
+ o.text = textArray
+ }
+
+ // calculate offsets for the new font/text
+ var newAtlasChars
+ if (o.text != null || newFont) {
+ // FIXME: ignore spaces
+ // text offsets within the text buffer
+ this.textOffsets = [0]
+
+ if (Array.isArray(o.text)) {
+ this.count = o.text[0].length
+ this.counts = [this.count]
+ for (var i$1 = 1; i$1 < o.text.length; i$1++) {
+ this$1.textOffsets[i$1] = this$1.textOffsets[i$1 - 1] + o.text[i$1 - 1].length
+ this$1.count += o.text[i$1].length
+ this$1.counts.push(o.text[i$1].length)
+ }
+ this.text = o.text.join('')
+ }
+ else {
+ this.text = o.text
+ this.count = this.text.length
+ this.counts = [this.count]
+ }
+
+ newAtlasChars = []
+
+ // detect & measure new characters
+ this.font.forEach(function (font, idx) {
+ GlText.atlasContext.font = font.baseString
+
+ var atlas = this$1.fontAtlas[idx]
+
+ for (var i = 0; i < this$1.text.length; i++) {
+ var char = this$1.text.charAt(i)
+
+ if (atlas.ids[char] == null) {
+ atlas.ids[char] = atlas.chars.length
+ atlas.chars.push(char)
+ newAtlasChars.push(char)
+ }
+
+ if (font.width[char] == null) {
+ font.width[char] = GlText.atlasContext.measureText(char).width / GlText.baseFontSize
+
+ // measure kerning pairs for the new character
+ if (this$1.kerning) {
+ var pairs = []
+ for (var baseChar in font.width) {
+ pairs.push(baseChar + char, char + baseChar)
+ }
+ extend(font.kerning, kerning(font.family, {
+ pairs: pairs
+ }))
+ }
+ }
+ }
+ })
+ }
+
+ // create single position buffer (faster than batch or multiple separate instances)
+ if (o.position) {
+ if (o.position.length > 2) {
+ var flat = !o.position[0].length
+ var positionData = pool.mallocFloat(this.count * 2)
+ for (var i$2 = 0, ptr = 0; i$2 < this.counts.length; i$2++) {
+ var count = this$1.counts[i$2]
+ if (flat) {
+ for (var j = 0; j < count; j++) {
+ positionData[ptr++] = o.position[i$2 * 2]
+ positionData[ptr++] = o.position[i$2 * 2 + 1]
+ }
+ }
+ else {
+ for (var j$1 = 0; j$1 < count; j$1++) {
+ positionData[ptr++] = o.position[i$2][0]
+ positionData[ptr++] = o.position[i$2][1]
+ }
+ }
+ }
+ if (this.position.call) {
+ this.position({
+ type: 'float',
+ data: positionData
+ })
+ } else {
+ this.position = this.regl.buffer({
+ type: 'float',
+ data: positionData
+ })
+ }
+ pool.freeFloat(positionData)
+ }
+ else {
+ if (this.position.destroy) { this.position.destroy() }
+ this.position = {
+ constant: o.position
+ }
+ }
+ }
+
+ // populate text/offset buffers if font/text has changed
+ // as [charWidth, offset, charWidth, offset...]
+ // that is in em units since font-size can change often
+ if (o.text || newFont) {
+ var charIds = pool.mallocUint8(this.count)
+ var sizeData = pool.mallocFloat(this.count * 2)
+ this.textWidth = []
+
+ for (var i$3 = 0, ptr$1 = 0; i$3 < this.counts.length; i$3++) {
+ var count$1 = this$1.counts[i$3]
+ var font = this$1.font[i$3] || this$1.font[0]
+ var atlas = this$1.fontAtlas[i$3] || this$1.fontAtlas[0]
+
+ for (var j$2 = 0; j$2 < count$1; j$2++) {
+ var char = this$1.text.charAt(ptr$1)
+ var prevChar = this$1.text.charAt(ptr$1 - 1)
+
+ charIds[ptr$1] = atlas.ids[char]
+ sizeData[ptr$1 * 2] = font.width[char]
+
+ if (j$2) {
+ var prevWidth = sizeData[ptr$1 * 2 - 2]
+ var currWidth = sizeData[ptr$1 * 2]
+ var prevOffset = sizeData[ptr$1 * 2 - 1]
+ var offset = prevOffset + prevWidth * .5 + currWidth * .5;
+
+ if (this$1.kerning) {
+ var kerning$1 = font.kerning[prevChar + char]
+ if (kerning$1) {
+ offset += kerning$1 * 1e-3
+ }
+ }
+
+ sizeData[ptr$1 * 2 + 1] = offset
+ }
+ else {
+ sizeData[ptr$1 * 2 + 1] = sizeData[ptr$1 * 2] * .5
+ }
+
+ ptr$1++
+ }
+ this$1.textWidth.push(
+ !sizeData.length ? 0 :
+ // last offset + half last width
+ sizeData[ptr$1 * 2 - 2] * .5 + sizeData[ptr$1 * 2 - 1]
+ )
+ }
+
+
+ // bump recalc align offset
+ if (!o.align) { o.align = this.align }
+ this.charBuffer({data: charIds, type: 'uint8', usage: 'stream'})
+ this.sizeBuffer({data: sizeData, type: 'float', usage: 'stream'})
+ pool.freeUint8(charIds)
+ pool.freeFloat(sizeData)
+
+ // udpate font atlas and texture
+ if (newAtlasChars.length) {
+ this.font.forEach(function (font, i) {
+ var atlas = this$1.fontAtlas[i]
+
+ // FIXME: insert metrics-based ratio here
+ var step = atlas.step
+
+ var maxCols = Math.floor(GlText.maxAtlasSize / step)
+ var cols = Math.min(maxCols, atlas.chars.length)
+ var rows = Math.ceil(atlas.chars.length / cols)
+
+ var atlasWidth = nextPow2( cols * step )
+ // let atlasHeight = Math.min(rows * step + step * .5, GlText.maxAtlasSize);
+ var atlasHeight = nextPow2( rows * step );
+
+ atlas.width = atlasWidth
+ atlas.height = atlasHeight;
+ atlas.rows = rows
+ atlas.cols = cols
+
+ if (!atlas.em) { return }
+
+ atlas.texture({
+ data: fontAtlas({
+ canvas: GlText.atlasCanvas,
+ font: atlas.fontString,
+ chars: atlas.chars,
+ shape: [atlasWidth, atlasHeight],
+ step: [step, step]
+ })
+ })
+
+ })
+ }
+ }
+
+ if (o.align) {
+ this.align = o.align
+ this.alignOffset = this.textWidth.map(function (textWidth, i) {
+ var align = !Array.isArray(this$1.align) ? this$1.align : this$1.align.length > 1 ? this$1.align[i] : this$1.align[0]
+
+ if (typeof align === 'number') { return align }
+ switch (align) {
+ case 'right':
+ case 'end':
+ return -textWidth
+ case 'center':
+ case 'centre':
+ case 'middle':
+ return -textWidth * .5
+ }
+
+ return 0
+ })
+ }
+
+ if (this.baseline == null && o.baseline == null) {
+ o.baseline = 0
+ }
+ if (o.baseline != null) {
+ this.baseline = o.baseline
+ if (!Array.isArray(this.baseline)) { this.baseline = [this.baseline] }
+ this.baselineOffset = this.baseline.map(function (baseline, i) {
+ var m = (this$1.font[i] || this$1.font[0]).metrics
+ var base = 0
+
+ base += m.bottom * .5
+
+ if (typeof baseline === 'number') {
+ base += (baseline - m.baseline)
+ }
+ else {
+ base += -m[baseline]
+ }
+
+ if (!GlText.normalViewport) { base *= -1 }
+ return base
+ })
+ }
+
+ // flatten colors to a single uint8 array
+ if (o.color != null) {
+ if (!o.color) { o.color = 'transparent' }
+
+ // single color
+ if (typeof o.color === 'string' || !isNaN(o.color)) {
+ this.color = rgba(o.color, 'uint8')
+ }
+ // array
+ else {
+ var colorData
+
+ // flat array
+ if (typeof o.color[0] === 'number' && o.color.length > this.counts.length) {
+ var l = o.color.length
+ colorData = pool.mallocUint8(l)
+ var sub = (o.color.subarray || o.color.slice).bind(o.color)
+ for (var i$4 = 0; i$4 < l; i$4 += 4) {
+ colorData.set(rgba(sub(i$4, i$4 + 4), 'uint8'), i$4)
+ }
+ }
+ // nested array
+ else {
+ var l$1 = o.color.length
+ colorData = pool.mallocUint8(l$1 * 4)
+ for (var i$5 = 0; i$5 < l$1; i$5++) {
+ colorData.set(rgba(o.color[i$5] || 0, 'uint8'), i$5 * 4)
+ }
+ }
+
+ this.color = colorData
+ }
+ }
+
+ // update render batch
+ if (o.position || o.text || o.color || o.baseline || o.align || o.font || o.offset || o.opacity) {
+ var isBatch = (this.color.length > 4)
+ || (this.baselineOffset.length > 1)
+ || (this.align && this.align.length > 1)
+ || (this.fontAtlas.length > 1)
+ || (this.positionOffset.length > 2)
+ if (isBatch) {
+ var length = Math.max(
+ this.position.length * .5 || 0,
+ this.color.length * .25 || 0,
+ this.baselineOffset.length || 0,
+ this.alignOffset.length || 0,
+ this.font.length || 0,
+ this.opacity.length || 0,
+ this.positionOffset.length * .5 || 0
+ )
+ this.batch = Array(length)
+ for (var i$6 = 0; i$6 < this.batch.length; i$6++) {
+ this$1.batch[i$6] = {
+ count: this$1.counts.length > 1 ? this$1.counts[i$6] : this$1.counts[0],
+ offset: this$1.textOffsets.length > 1 ? this$1.textOffsets[i$6] : this$1.textOffsets[0],
+ color: !this$1.color ? [0,0,0,255] : this$1.color.length <= 4 ? this$1.color : this$1.color.subarray(i$6 * 4, i$6 * 4 + 4),
+ opacity: Array.isArray(this$1.opacity) ? this$1.opacity[i$6] : this$1.opacity,
+ baseline: this$1.baselineOffset[i$6] != null ? this$1.baselineOffset[i$6] : this$1.baselineOffset[0],
+ align: !this$1.align ? 0 : this$1.alignOffset[i$6] != null ? this$1.alignOffset[i$6] : this$1.alignOffset[0],
+ atlas: this$1.fontAtlas[i$6] || this$1.fontAtlas[0],
+ positionOffset: this$1.positionOffset.length > 2 ? this$1.positionOffset.subarray(i$6 * 2, i$6 * 2 + 2) : this$1.positionOffset
+ }
+ }
+ }
+ // single-color, single-baseline, single-align batch is faster to render
+ else {
+ if (this.count) {
+ this.batch = [{
+ count: this.count,
+ offset: 0,
+ color: this.color || [0,0,0,255],
+ opacity: Array.isArray(this.opacity) ? this.opacity[0] : this.opacity,
+ baseline: this.baselineOffset[0],
+ align: this.alignOffset ? this.alignOffset[0] : 0,
+ atlas: this.fontAtlas[0],
+ positionOffset: this.positionOffset
+ }]
+ }
+ else {
+ this.batch = []
+ }
+ }
+ }
+};
+
+GlText.prototype.destroy = function destroy () {
+ // TODO: count instances of atlases and destroy all on null
+};
+
+
+// defaults
+GlText.prototype.kerning = true
+GlText.prototype.position = { constant: new Float32Array(2) }
+GlText.prototype.translate = null
+GlText.prototype.scale = null
+GlText.prototype.font = null
+GlText.prototype.text = ''
+GlText.prototype.positionOffset = [0, 0]
+GlText.prototype.opacity = 1
+GlText.prototype.color = new Uint8Array([0, 0, 0, 255])
+GlText.prototype.alignOffset = [0, 0]
+
+
+// whether viewport should be top↓bottom 2d one (true) or webgl one (false)
+GlText.normalViewport = false
+
+// size of an atlas
+GlText.maxAtlasSize = 1024
+
+// font atlas canvas is singleton
+GlText.atlasCanvas = document.createElement('canvas')
+GlText.atlasContext = GlText.atlasCanvas.getContext('2d', {alpha: false})
+
+// font-size used for metrics, atlas step calculation
+GlText.baseFontSize = 64
+
+// fonts storage
+GlText.fonts = {}
+
+// max number of different font atlases/textures cached
+// FIXME: enable atlas size limitation via LRU
+// GlText.atlasCacheSize = 64
+
+function isRegl (o) {
+ return typeof o === 'function' &&
+ o._gl &&
+ o.prop &&
+ o.texture &&
+ o.buffer
+}
+
+
+module.exports = GlText
+
+
+},{"bit-twiddle":80,"color-normalize":108,"css-font":127,"detect-kerning":151,"es6-weak-map":209,"flatten-vertex-data":216,"font-atlas":217,"font-measure":218,"gl-util/context":306,"is-plain-obj":405,"object-assign":437,"parse-rect":442,"parse-unit":444,"pick-by-alias":448,"regl":478,"to-px":516,"typedarray-pool":522}],305:[function(_dereq_,module,exports){
+'use strict'
+
+var ndarray = _dereq_('ndarray')
+var ops = _dereq_('ndarray-ops')
+var pool = _dereq_('typedarray-pool')
+
+module.exports = createTexture2D
+
+var linearTypes = null
+var filterTypes = null
+var wrapTypes = null
+
+function lazyInitLinearTypes(gl) {
+ linearTypes = [
+ gl.LINEAR,
+ gl.NEAREST_MIPMAP_LINEAR,
+ gl.LINEAR_MIPMAP_NEAREST,
+ gl.LINEAR_MIPMAP_NEAREST
+ ]
+ filterTypes = [
+ gl.NEAREST,
+ gl.LINEAR,
+ gl.NEAREST_MIPMAP_NEAREST,
+ gl.NEAREST_MIPMAP_LINEAR,
+ gl.LINEAR_MIPMAP_NEAREST,
+ gl.LINEAR_MIPMAP_LINEAR
+ ]
+ wrapTypes = [
+ gl.REPEAT,
+ gl.CLAMP_TO_EDGE,
+ gl.MIRRORED_REPEAT
+ ]
+}
+
+function acceptTextureDOM (obj) {
+ return (
+ ('undefined' != typeof HTMLCanvasElement && obj instanceof HTMLCanvasElement) ||
+ ('undefined' != typeof HTMLImageElement && obj instanceof HTMLImageElement) ||
+ ('undefined' != typeof HTMLVideoElement && obj instanceof HTMLVideoElement) ||
+ ('undefined' != typeof ImageData && obj instanceof ImageData))
+}
+
+var convertFloatToUint8 = function(out, inp) {
+ ops.muls(out, inp, 255.0)
+}
+
+function reshapeTexture(tex, w, h) {
+ var gl = tex.gl
+ var maxSize = gl.getParameter(gl.MAX_TEXTURE_SIZE)
+ if(w < 0 || w > maxSize || h < 0 || h > maxSize) {
+ throw new Error('gl-texture2d: Invalid texture size')
+ }
+ tex._shape = [w, h]
+ tex.bind()
+ gl.texImage2D(gl.TEXTURE_2D, 0, tex.format, w, h, 0, tex.format, tex.type, null)
+ tex._mipLevels = [0]
+ return tex
+}
+
+function Texture2D(gl, handle, width, height, format, type) {
+ this.gl = gl
+ this.handle = handle
+ this.format = format
+ this.type = type
+ this._shape = [width, height]
+ this._mipLevels = [0]
+ this._magFilter = gl.NEAREST
+ this._minFilter = gl.NEAREST
+ this._wrapS = gl.CLAMP_TO_EDGE
+ this._wrapT = gl.CLAMP_TO_EDGE
+ this._anisoSamples = 1
+
+ var parent = this
+ var wrapVector = [this._wrapS, this._wrapT]
+ Object.defineProperties(wrapVector, [
+ {
+ get: function() {
+ return parent._wrapS
+ },
+ set: function(v) {
+ return parent.wrapS = v
+ }
+ },
+ {
+ get: function() {
+ return parent._wrapT
+ },
+ set: function(v) {
+ return parent.wrapT = v
+ }
+ }
+ ])
+ this._wrapVector = wrapVector
+
+ var shapeVector = [this._shape[0], this._shape[1]]
+ Object.defineProperties(shapeVector, [
+ {
+ get: function() {
+ return parent._shape[0]
+ },
+ set: function(v) {
+ return parent.width = v
+ }
+ },
+ {
+ get: function() {
+ return parent._shape[1]
+ },
+ set: function(v) {
+ return parent.height = v
+ }
+ }
+ ])
+ this._shapeVector = shapeVector
+}
+
+var proto = Texture2D.prototype
+
+Object.defineProperties(proto, {
+ minFilter: {
+ get: function() {
+ return this._minFilter
+ },
+ set: function(v) {
+ this.bind()
+ var gl = this.gl
+ if(this.type === gl.FLOAT && linearTypes.indexOf(v) >= 0) {
+ if(!gl.getExtension('OES_texture_float_linear')) {
+ v = gl.NEAREST
+ }
+ }
+ if(filterTypes.indexOf(v) < 0) {
+ throw new Error('gl-texture2d: Unknown filter mode ' + v)
+ }
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, v)
+ return this._minFilter = v
+ }
+ },
+ magFilter: {
+ get: function() {
+ return this._magFilter
+ },
+ set: function(v) {
+ this.bind()
+ var gl = this.gl
+ if(this.type === gl.FLOAT && linearTypes.indexOf(v) >= 0) {
+ if(!gl.getExtension('OES_texture_float_linear')) {
+ v = gl.NEAREST
+ }
+ }
+ if(filterTypes.indexOf(v) < 0) {
+ throw new Error('gl-texture2d: Unknown filter mode ' + v)
+ }
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, v)
+ return this._magFilter = v
+ }
+ },
+ mipSamples: {
+ get: function() {
+ return this._anisoSamples
+ },
+ set: function(i) {
+ var psamples = this._anisoSamples
+ this._anisoSamples = Math.max(i, 1)|0
+ if(psamples !== this._anisoSamples) {
+ var ext = this.gl.getExtension('EXT_texture_filter_anisotropic')
+ if(ext) {
+ this.gl.texParameterf(this.gl.TEXTURE_2D, ext.TEXTURE_MAX_ANISOTROPY_EXT, this._anisoSamples)
+ }
+ }
+ return this._anisoSamples
+ }
+ },
+ wrapS: {
+ get: function() {
+ return this._wrapS
+ },
+ set: function(v) {
+ this.bind()
+ if(wrapTypes.indexOf(v) < 0) {
+ throw new Error('gl-texture2d: Unknown wrap mode ' + v)
+ }
+ this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, v)
+ return this._wrapS = v
+ }
+ },
+ wrapT: {
+ get: function() {
+ return this._wrapT
+ },
+ set: function(v) {
+ this.bind()
+ if(wrapTypes.indexOf(v) < 0) {
+ throw new Error('gl-texture2d: Unknown wrap mode ' + v)
+ }
+ this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, v)
+ return this._wrapT = v
+ }
+ },
+ wrap: {
+ get: function() {
+ return this._wrapVector
+ },
+ set: function(v) {
+ if(!Array.isArray(v)) {
+ v = [v,v]
+ }
+ if(v.length !== 2) {
+ throw new Error('gl-texture2d: Must specify wrap mode for rows and columns')
+ }
+ for(var i=0; i<2; ++i) {
+ if(wrapTypes.indexOf(v[i]) < 0) {
+ throw new Error('gl-texture2d: Unknown wrap mode ' + v)
+ }
+ }
+ this._wrapS = v[0]
+ this._wrapT = v[1]
+
+ var gl = this.gl
+ this.bind()
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this._wrapS)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this._wrapT)
+
+ return v
+ }
+ },
+ shape: {
+ get: function() {
+ return this._shapeVector
+ },
+ set: function(x) {
+ if(!Array.isArray(x)) {
+ x = [x|0,x|0]
+ } else {
+ if(x.length !== 2) {
+ throw new Error('gl-texture2d: Invalid texture shape')
+ }
+ }
+ reshapeTexture(this, x[0]|0, x[1]|0)
+ return [x[0]|0, x[1]|0]
+ }
+ },
+ width: {
+ get: function() {
+ return this._shape[0]
+ },
+ set: function(w) {
+ w = w|0
+ reshapeTexture(this, w, this._shape[1])
+ return w
+ }
+ },
+ height: {
+ get: function() {
+ return this._shape[1]
+ },
+ set: function(h) {
+ h = h|0
+ reshapeTexture(this, this._shape[0], h)
+ return h
+ }
+ }
+})
+
+proto.bind = function(unit) {
+ var gl = this.gl
+ if(unit !== undefined) {
+ gl.activeTexture(gl.TEXTURE0 + (unit|0))
+ }
+ gl.bindTexture(gl.TEXTURE_2D, this.handle)
+ if(unit !== undefined) {
+ return (unit|0)
+ }
+ return gl.getParameter(gl.ACTIVE_TEXTURE) - gl.TEXTURE0
+}
+
+proto.dispose = function() {
+ this.gl.deleteTexture(this.handle)
+}
+
+proto.generateMipmap = function() {
+ this.bind()
+ this.gl.generateMipmap(this.gl.TEXTURE_2D)
+
+ //Update mip levels
+ var l = Math.min(this._shape[0], this._shape[1])
+ for(var i=0; l>0; ++i, l>>>=1) {
+ if(this._mipLevels.indexOf(i) < 0) {
+ this._mipLevels.push(i)
+ }
+ }
+}
+
+proto.setPixels = function(data, x_off, y_off, mip_level) {
+ var gl = this.gl
+ this.bind()
+ if(Array.isArray(x_off)) {
+ mip_level = y_off
+ y_off = x_off[1]|0
+ x_off = x_off[0]|0
+ } else {
+ x_off = x_off || 0
+ y_off = y_off || 0
+ }
+ mip_level = mip_level || 0
+ var directData = acceptTextureDOM(data) ? data : data.raw
+ if(directData) {
+ var needsMip = this._mipLevels.indexOf(mip_level) < 0
+ if(needsMip) {
+ gl.texImage2D(gl.TEXTURE_2D, 0, this.format, this.format, this.type, directData)
+ this._mipLevels.push(mip_level)
+ } else {
+ gl.texSubImage2D(gl.TEXTURE_2D, mip_level, x_off, y_off, this.format, this.type, directData)
+ }
+ } else if(data.shape && data.stride && data.data) {
+ if(data.shape.length < 2 ||
+ x_off + data.shape[1] > this._shape[1]>>>mip_level ||
+ y_off + data.shape[0] > this._shape[0]>>>mip_level ||
+ x_off < 0 ||
+ y_off < 0) {
+ throw new Error('gl-texture2d: Texture dimensions are out of bounds')
+ }
+ texSubImageArray(gl, x_off, y_off, mip_level, this.format, this.type, this._mipLevels, data)
+ } else {
+ throw new Error('gl-texture2d: Unsupported data type')
+ }
+}
+
+
+function isPacked(shape, stride) {
+ if(shape.length === 3) {
+ return (stride[2] === 1) &&
+ (stride[1] === shape[0]*shape[2]) &&
+ (stride[0] === shape[2])
+ }
+ return (stride[0] === 1) &&
+ (stride[1] === shape[0])
+}
+
+function texSubImageArray(gl, x_off, y_off, mip_level, cformat, ctype, mipLevels, array) {
+ var dtype = array.dtype
+ var shape = array.shape.slice()
+ if(shape.length < 2 || shape.length > 3) {
+ throw new Error('gl-texture2d: Invalid ndarray, must be 2d or 3d')
+ }
+ var type = 0, format = 0
+ var packed = isPacked(shape, array.stride.slice())
+ if(dtype === 'float32') {
+ type = gl.FLOAT
+ } else if(dtype === 'float64') {
+ type = gl.FLOAT
+ packed = false
+ dtype = 'float32'
+ } else if(dtype === 'uint8') {
+ type = gl.UNSIGNED_BYTE
+ } else {
+ type = gl.UNSIGNED_BYTE
+ packed = false
+ dtype = 'uint8'
+ }
+ var channels = 1
+ if(shape.length === 2) {
+ format = gl.LUMINANCE
+ shape = [shape[0], shape[1], 1]
+ array = ndarray(array.data, shape, [array.stride[0], array.stride[1], 1], array.offset)
+ } else if(shape.length === 3) {
+ if(shape[2] === 1) {
+ format = gl.ALPHA
+ } else if(shape[2] === 2) {
+ format = gl.LUMINANCE_ALPHA
+ } else if(shape[2] === 3) {
+ format = gl.RGB
+ } else if(shape[2] === 4) {
+ format = gl.RGBA
+ } else {
+ throw new Error('gl-texture2d: Invalid shape for pixel coords')
+ }
+ channels = shape[2]
+ } else {
+ throw new Error('gl-texture2d: Invalid shape for texture')
+ }
+ //For 1-channel textures allow conversion between formats
+ if((format === gl.LUMINANCE || format === gl.ALPHA) &&
+ (cformat === gl.LUMINANCE || cformat === gl.ALPHA)) {
+ format = cformat
+ }
+ if(format !== cformat) {
+ throw new Error('gl-texture2d: Incompatible texture format for setPixels')
+ }
+ var size = array.size
+ var needsMip = mipLevels.indexOf(mip_level) < 0
+ if(needsMip) {
+ mipLevels.push(mip_level)
+ }
+ if(type === ctype && packed) {
+ //Array data types are compatible, can directly copy into texture
+ if(array.offset === 0 && array.data.length === size) {
+ if(needsMip) {
+ gl.texImage2D(gl.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, array.data)
+ } else {
+ gl.texSubImage2D(gl.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, array.data)
+ }
+ } else {
+ if(needsMip) {
+ gl.texImage2D(gl.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, array.data.subarray(array.offset, array.offset+size))
+ } else {
+ gl.texSubImage2D(gl.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, array.data.subarray(array.offset, array.offset+size))
+ }
+ }
+ } else {
+ //Need to do type conversion to pack data into buffer
+ var pack_buffer
+ if(ctype === gl.FLOAT) {
+ pack_buffer = pool.mallocFloat32(size)
+ } else {
+ pack_buffer = pool.mallocUint8(size)
+ }
+ var pack_view = ndarray(pack_buffer, shape, [shape[2], shape[2]*shape[0], 1])
+ if(type === gl.FLOAT && ctype === gl.UNSIGNED_BYTE) {
+ convertFloatToUint8(pack_view, array)
+ } else {
+ ops.assign(pack_view, array)
+ }
+ if(needsMip) {
+ gl.texImage2D(gl.TEXTURE_2D, mip_level, cformat, shape[0], shape[1], 0, cformat, ctype, pack_buffer.subarray(0, size))
+ } else {
+ gl.texSubImage2D(gl.TEXTURE_2D, mip_level, x_off, y_off, shape[0], shape[1], cformat, ctype, pack_buffer.subarray(0, size))
+ }
+ if(ctype === gl.FLOAT) {
+ pool.freeFloat32(pack_buffer)
+ } else {
+ pool.freeUint8(pack_buffer)
+ }
+ }
+}
+
+function initTexture(gl) {
+ var tex = gl.createTexture()
+ gl.bindTexture(gl.TEXTURE_2D, tex)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
+ gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
+ return tex
+}
+
+function createTextureShape(gl, width, height, format, type) {
+ var maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE)
+ if(width < 0 || width > maxTextureSize || height < 0 || height > maxTextureSize) {
+ throw new Error('gl-texture2d: Invalid texture shape')
+ }
+ if(type === gl.FLOAT && !gl.getExtension('OES_texture_float')) {
+ throw new Error('gl-texture2d: Floating point textures not supported on this platform')
+ }
+ var tex = initTexture(gl)
+ gl.texImage2D(gl.TEXTURE_2D, 0, format, width, height, 0, format, type, null)
+ return new Texture2D(gl, tex, width, height, format, type)
+}
+
+function createTextureDOM(gl, directData, width, height, format, type) {
+ var tex = initTexture(gl)
+ gl.texImage2D(gl.TEXTURE_2D, 0, format, format, type, directData)
+ return new Texture2D(gl, tex, width, height, format, type)
+}
+
+//Creates a texture from an ndarray
+function createTextureArray(gl, array) {
+ var dtype = array.dtype
+ var shape = array.shape.slice()
+ var maxSize = gl.getParameter(gl.MAX_TEXTURE_SIZE)
+ if(shape[0] < 0 || shape[0] > maxSize || shape[1] < 0 || shape[1] > maxSize) {
+ throw new Error('gl-texture2d: Invalid texture size')
+ }
+ var packed = isPacked(shape, array.stride.slice())
+ var type = 0
+ if(dtype === 'float32') {
+ type = gl.FLOAT
+ } else if(dtype === 'float64') {
+ type = gl.FLOAT
+ packed = false
+ dtype = 'float32'
+ } else if(dtype === 'uint8') {
+ type = gl.UNSIGNED_BYTE
+ } else {
+ type = gl.UNSIGNED_BYTE
+ packed = false
+ dtype = 'uint8'
+ }
+ var format = 0
+ if(shape.length === 2) {
+ format = gl.LUMINANCE
+ shape = [shape[0], shape[1], 1]
+ array = ndarray(array.data, shape, [array.stride[0], array.stride[1], 1], array.offset)
+ } else if(shape.length === 3) {
+ if(shape[2] === 1) {
+ format = gl.ALPHA
+ } else if(shape[2] === 2) {
+ format = gl.LUMINANCE_ALPHA
+ } else if(shape[2] === 3) {
+ format = gl.RGB
+ } else if(shape[2] === 4) {
+ format = gl.RGBA
+ } else {
+ throw new Error('gl-texture2d: Invalid shape for pixel coords')
+ }
+ } else {
+ throw new Error('gl-texture2d: Invalid shape for texture')
+ }
+ if(type === gl.FLOAT && !gl.getExtension('OES_texture_float')) {
+ type = gl.UNSIGNED_BYTE
+ packed = false
+ }
+ var buffer, buf_store
+ var size = array.size
+ if(!packed) {
+ var stride = [shape[2], shape[2]*shape[0], 1]
+ buf_store = pool.malloc(size, dtype)
+ var buf_array = ndarray(buf_store, shape, stride, 0)
+ if((dtype === 'float32' || dtype === 'float64') && type === gl.UNSIGNED_BYTE) {
+ convertFloatToUint8(buf_array, array)
+ } else {
+ ops.assign(buf_array, array)
+ }
+ buffer = buf_store.subarray(0, size)
+ } else if (array.offset === 0 && array.data.length === size) {
+ buffer = array.data
+ } else {
+ buffer = array.data.subarray(array.offset, array.offset + size)
+ }
+ var tex = initTexture(gl)
+ gl.texImage2D(gl.TEXTURE_2D, 0, format, shape[0], shape[1], 0, format, type, buffer)
+ if(!packed) {
+ pool.free(buf_store)
+ }
+ return new Texture2D(gl, tex, shape[0], shape[1], format, type)
+}
+
+function createTexture2D(gl) {
+ if(arguments.length <= 1) {
+ throw new Error('gl-texture2d: Missing arguments for texture2d constructor')
+ }
+ if(!linearTypes) {
+ lazyInitLinearTypes(gl)
+ }
+ if(typeof arguments[1] === 'number') {
+ return createTextureShape(gl, arguments[1], arguments[2], arguments[3]||gl.RGBA, arguments[4]||gl.UNSIGNED_BYTE)
+ }
+ if(Array.isArray(arguments[1])) {
+ return createTextureShape(gl, arguments[1][0]|0, arguments[1][1]|0, arguments[2]||gl.RGBA, arguments[3]||gl.UNSIGNED_BYTE)
+ }
+ if(typeof arguments[1] === 'object') {
+ var obj = arguments[1]
+ var directData = acceptTextureDOM(obj) ? obj : obj.raw
+ if (directData) {
+ return createTextureDOM(gl, directData, obj.width|0, obj.height|0, arguments[2]||gl.RGBA, arguments[3]||gl.UNSIGNED_BYTE)
+ } else if(obj.shape && obj.data && obj.stride) {
+ return createTextureArray(gl, obj)
+ }
+ }
+ throw new Error('gl-texture2d: Invalid arguments for texture2d constructor')
+}
+
+},{"ndarray":433,"ndarray-ops":427,"typedarray-pool":522}],306:[function(_dereq_,module,exports){
+/** @module gl-util/context */
+'use strict'
+
+var pick = _dereq_('pick-by-alias')
+
+module.exports = function setContext (o) {
+ if (!o) o = {}
+ else if (typeof o === 'string') o = {container: o}
+
+ // HTMLCanvasElement
+ if (isCanvas(o)) {
+ o = {container: o}
+ }
+ // HTMLElement
+ else if (isElement(o)) {
+ o = {container: o}
+ }
+ // WebGLContext
+ else if (isContext(o)) {
+ o = {gl: o}
+ }
+ // options object
+ else {
+ o = pick(o, {
+ container: 'container target element el canvas holder parent parentNode wrapper use ref root node',
+ gl: 'gl context webgl glContext',
+ attrs: 'attributes attrs contextAttributes',
+ pixelRatio: 'pixelRatio pxRatio px ratio pxratio pixelratio'
+ }, true)
+ }
+
+ if (!o.pixelRatio) o.pixelRatio = window.pixelRatio || 1
+
+ // make sure there is container and canvas
+ if (o.gl) {
+ return o.gl
+ }
+ if (o.canvas) {
+ o.container = o.canvas.parentNode
+ }
+ if (o.container) {
+ if (typeof o.container === 'string') {
+ var c = document.querySelector(o.container)
+ if (!c) throw Error('Element ' + o.container + ' is not found')
+ o.container = c
+ }
+ if (isCanvas(o.container)) {
+ o.canvas = o.container
+ o.container = o.canvas.parentNode
+ }
+ else if (!o.canvas) {
+ o.canvas = document.createElement('canvas')
+ o.container.appendChild(o.canvas)
+ resize(o)
+ }
+ }
+ // blank new canvas
+ else if (!o.canvas) {
+ o.container = document.body || document.documentElement
+ o.canvas = document.createElement('canvas')
+ o.canvas.style.position = 'absolute'
+ o.canvas.style.top = 0
+ o.canvas.style.left = 0
+ o.container.appendChild(o.canvas)
+ resize(o)
+ }
+
+ // make sure there is context
+ if (!o.gl) {
+ try {
+ o.gl = o.canvas.getContext('webgl', o.attrs)
+ } catch (e) {
+ try {
+ o.gl = o.canvas.getContext('experimental-webgl', o.attrs)
+ }
+ catch (e) {
+ o.gl = o.canvas.getContext('webgl-experimental', o.attrs)
+ }
+ }
+ }
+
+ return o.gl
+}
+
+
+function resize (o) {
+ if (o.container) {
+ if (o.container == document.body) {
+ if (!document.body.style.width) o.canvas.width = o.width || (o.pixelRatio * window.innerWidth)
+ if (!document.body.style.height) o.canvas.height = o.height || (o.pixelRatio * window.innerHeight)
+ }
+ else {
+ var bounds = o.container.getBoundingClientRect()
+ o.canvas.width = o.width || (bounds.right - bounds.left)
+ o.canvas.height = o.height || (bounds.bottom - bounds.top)
+ }
+ }
+}
+
+function isCanvas (e) {
+ return typeof e.getContext === 'function'
+ && 'width' in e
+ && 'height' in e
+}
+
+function isElement (e) {
+ return typeof e.nodeName === 'string' &&
+ typeof e.appendChild === 'function' &&
+ typeof e.getBoundingClientRect === 'function'
+}
+
+function isContext (e) {
+ return typeof e.drawArrays === 'function' ||
+ typeof e.drawElements === 'function'
+}
+
+},{"pick-by-alias":448}],307:[function(_dereq_,module,exports){
+"use strict"
+
+function doBind(gl, elements, attributes) {
+ if(elements) {
+ elements.bind()
+ } else {
+ gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null)
+ }
+ var nattribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS)|0
+ if(attributes) {
+ if(attributes.length > nattribs) {
+ throw new Error("gl-vao: Too many vertex attributes")
+ }
+ for(var i=0; i 1.0){
+ return 0
+ } else {
+ return Math.acos(cosine)
+ }
+}
+
+},{"./dot":322,"./fromValues":328,"./normalize":339}],313:[function(_dereq_,module,exports){
+module.exports = ceil
+
+/**
+ * Math.ceil the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to ceil
+ * @returns {vec3} out
+ */
+function ceil(out, a) {
+ out[0] = Math.ceil(a[0])
+ out[1] = Math.ceil(a[1])
+ out[2] = Math.ceil(a[2])
+ return out
+}
+
+},{}],314:[function(_dereq_,module,exports){
+module.exports = clone;
+
+/**
+ * Creates a new vec3 initialized with values from an existing vector
+ *
+ * @param {vec3} a vector to clone
+ * @returns {vec3} a new 3D vector
+ */
+function clone(a) {
+ var out = new Float32Array(3)
+ out[0] = a[0]
+ out[1] = a[1]
+ out[2] = a[2]
+ return out
+}
+},{}],315:[function(_dereq_,module,exports){
+module.exports = copy;
+
+/**
+ * Copy the values from one vec3 to another
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the source vector
+ * @returns {vec3} out
+ */
+function copy(out, a) {
+ out[0] = a[0]
+ out[1] = a[1]
+ out[2] = a[2]
+ return out
+}
+},{}],316:[function(_dereq_,module,exports){
+module.exports = create;
+
+/**
+ * Creates a new, empty vec3
+ *
+ * @returns {vec3} a new 3D vector
+ */
+function create() {
+ var out = new Float32Array(3)
+ out[0] = 0
+ out[1] = 0
+ out[2] = 0
+ return out
+}
+},{}],317:[function(_dereq_,module,exports){
+module.exports = cross;
+
+/**
+ * Computes the cross product of two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function cross(out, a, b) {
+ var ax = a[0], ay = a[1], az = a[2],
+ bx = b[0], by = b[1], bz = b[2]
+
+ out[0] = ay * bz - az * by
+ out[1] = az * bx - ax * bz
+ out[2] = ax * by - ay * bx
+ return out
+}
+},{}],318:[function(_dereq_,module,exports){
+module.exports = _dereq_('./distance')
+
+},{"./distance":319}],319:[function(_dereq_,module,exports){
+module.exports = distance;
+
+/**
+ * Calculates the euclidian distance between two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} distance between a and b
+ */
+function distance(a, b) {
+ var x = b[0] - a[0],
+ y = b[1] - a[1],
+ z = b[2] - a[2]
+ return Math.sqrt(x*x + y*y + z*z)
+}
+},{}],320:[function(_dereq_,module,exports){
+module.exports = _dereq_('./divide')
+
+},{"./divide":321}],321:[function(_dereq_,module,exports){
+module.exports = divide;
+
+/**
+ * Divides two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function divide(out, a, b) {
+ out[0] = a[0] / b[0]
+ out[1] = a[1] / b[1]
+ out[2] = a[2] / b[2]
+ return out
+}
+},{}],322:[function(_dereq_,module,exports){
+module.exports = dot;
+
+/**
+ * Calculates the dot product of two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+function dot(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+}
+},{}],323:[function(_dereq_,module,exports){
+module.exports = 0.000001
+
+},{}],324:[function(_dereq_,module,exports){
+module.exports = equals
+
+var EPSILON = _dereq_('./epsilon')
+
+/**
+ * Returns whether or not the vectors have approximately the same elements in the same position.
+ *
+ * @param {vec3} a The first vector.
+ * @param {vec3} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+function equals(a, b) {
+ var a0 = a[0]
+ var a1 = a[1]
+ var a2 = a[2]
+ var b0 = b[0]
+ var b1 = b[1]
+ var b2 = b[2]
+ return (Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
+ Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
+ Math.abs(a2 - b2) <= EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)))
+}
+
+},{"./epsilon":323}],325:[function(_dereq_,module,exports){
+module.exports = exactEquals
+
+/**
+ * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
+ *
+ * @param {vec3} a The first vector.
+ * @param {vec3} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+function exactEquals(a, b) {
+ return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]
+}
+
+},{}],326:[function(_dereq_,module,exports){
+module.exports = floor
+
+/**
+ * Math.floor the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to floor
+ * @returns {vec3} out
+ */
+function floor(out, a) {
+ out[0] = Math.floor(a[0])
+ out[1] = Math.floor(a[1])
+ out[2] = Math.floor(a[2])
+ return out
+}
+
+},{}],327:[function(_dereq_,module,exports){
+module.exports = forEach;
+
+var vec = _dereq_('./create')()
+
+/**
+ * Perform some operation over an array of vec3s.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+function forEach(a, stride, offset, count, fn, arg) {
+ var i, l
+ if(!stride) {
+ stride = 3
+ }
+
+ if(!offset) {
+ offset = 0
+ }
+
+ if(count) {
+ l = Math.min((count * stride) + offset, a.length)
+ } else {
+ l = a.length
+ }
+
+ for(i = offset; i < l; i += stride) {
+ vec[0] = a[i]
+ vec[1] = a[i+1]
+ vec[2] = a[i+2]
+ fn(vec, vec, arg)
+ a[i] = vec[0]
+ a[i+1] = vec[1]
+ a[i+2] = vec[2]
+ }
+
+ return a
+}
+},{"./create":316}],328:[function(_dereq_,module,exports){
+module.exports = fromValues;
+
+/**
+ * Creates a new vec3 initialized with the given values
+ *
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @returns {vec3} a new 3D vector
+ */
+function fromValues(x, y, z) {
+ var out = new Float32Array(3)
+ out[0] = x
+ out[1] = y
+ out[2] = z
+ return out
+}
+},{}],329:[function(_dereq_,module,exports){
+module.exports = {
+ EPSILON: _dereq_('./epsilon')
+ , create: _dereq_('./create')
+ , clone: _dereq_('./clone')
+ , angle: _dereq_('./angle')
+ , fromValues: _dereq_('./fromValues')
+ , copy: _dereq_('./copy')
+ , set: _dereq_('./set')
+ , equals: _dereq_('./equals')
+ , exactEquals: _dereq_('./exactEquals')
+ , add: _dereq_('./add')
+ , subtract: _dereq_('./subtract')
+ , sub: _dereq_('./sub')
+ , multiply: _dereq_('./multiply')
+ , mul: _dereq_('./mul')
+ , divide: _dereq_('./divide')
+ , div: _dereq_('./div')
+ , min: _dereq_('./min')
+ , max: _dereq_('./max')
+ , floor: _dereq_('./floor')
+ , ceil: _dereq_('./ceil')
+ , round: _dereq_('./round')
+ , scale: _dereq_('./scale')
+ , scaleAndAdd: _dereq_('./scaleAndAdd')
+ , distance: _dereq_('./distance')
+ , dist: _dereq_('./dist')
+ , squaredDistance: _dereq_('./squaredDistance')
+ , sqrDist: _dereq_('./sqrDist')
+ , length: _dereq_('./length')
+ , len: _dereq_('./len')
+ , squaredLength: _dereq_('./squaredLength')
+ , sqrLen: _dereq_('./sqrLen')
+ , negate: _dereq_('./negate')
+ , inverse: _dereq_('./inverse')
+ , normalize: _dereq_('./normalize')
+ , dot: _dereq_('./dot')
+ , cross: _dereq_('./cross')
+ , lerp: _dereq_('./lerp')
+ , random: _dereq_('./random')
+ , transformMat4: _dereq_('./transformMat4')
+ , transformMat3: _dereq_('./transformMat3')
+ , transformQuat: _dereq_('./transformQuat')
+ , rotateX: _dereq_('./rotateX')
+ , rotateY: _dereq_('./rotateY')
+ , rotateZ: _dereq_('./rotateZ')
+ , forEach: _dereq_('./forEach')
+}
+
+},{"./add":311,"./angle":312,"./ceil":313,"./clone":314,"./copy":315,"./create":316,"./cross":317,"./dist":318,"./distance":319,"./div":320,"./divide":321,"./dot":322,"./epsilon":323,"./equals":324,"./exactEquals":325,"./floor":326,"./forEach":327,"./fromValues":328,"./inverse":330,"./len":331,"./length":332,"./lerp":333,"./max":334,"./min":335,"./mul":336,"./multiply":337,"./negate":338,"./normalize":339,"./random":340,"./rotateX":341,"./rotateY":342,"./rotateZ":343,"./round":344,"./scale":345,"./scaleAndAdd":346,"./set":347,"./sqrDist":348,"./sqrLen":349,"./squaredDistance":350,"./squaredLength":351,"./sub":352,"./subtract":353,"./transformMat3":354,"./transformMat4":355,"./transformQuat":356}],330:[function(_dereq_,module,exports){
+module.exports = inverse;
+
+/**
+ * Returns the inverse of the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to invert
+ * @returns {vec3} out
+ */
+function inverse(out, a) {
+ out[0] = 1.0 / a[0]
+ out[1] = 1.0 / a[1]
+ out[2] = 1.0 / a[2]
+ return out
+}
+},{}],331:[function(_dereq_,module,exports){
+module.exports = _dereq_('./length')
+
+},{"./length":332}],332:[function(_dereq_,module,exports){
+module.exports = length;
+
+/**
+ * Calculates the length of a vec3
+ *
+ * @param {vec3} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+function length(a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2]
+ return Math.sqrt(x*x + y*y + z*z)
+}
+},{}],333:[function(_dereq_,module,exports){
+module.exports = lerp;
+
+/**
+ * Performs a linear interpolation between two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @param {Number} t interpolation amount between the two inputs
+ * @returns {vec3} out
+ */
+function lerp(out, a, b, t) {
+ var ax = a[0],
+ ay = a[1],
+ az = a[2]
+ out[0] = ax + t * (b[0] - ax)
+ out[1] = ay + t * (b[1] - ay)
+ out[2] = az + t * (b[2] - az)
+ return out
+}
+},{}],334:[function(_dereq_,module,exports){
+module.exports = max;
+
+/**
+ * Returns the maximum of two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function max(out, a, b) {
+ out[0] = Math.max(a[0], b[0])
+ out[1] = Math.max(a[1], b[1])
+ out[2] = Math.max(a[2], b[2])
+ return out
+}
+},{}],335:[function(_dereq_,module,exports){
+module.exports = min;
+
+/**
+ * Returns the minimum of two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function min(out, a, b) {
+ out[0] = Math.min(a[0], b[0])
+ out[1] = Math.min(a[1], b[1])
+ out[2] = Math.min(a[2], b[2])
+ return out
+}
+},{}],336:[function(_dereq_,module,exports){
+module.exports = _dereq_('./multiply')
+
+},{"./multiply":337}],337:[function(_dereq_,module,exports){
+module.exports = multiply;
+
+/**
+ * Multiplies two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function multiply(out, a, b) {
+ out[0] = a[0] * b[0]
+ out[1] = a[1] * b[1]
+ out[2] = a[2] * b[2]
+ return out
+}
+},{}],338:[function(_dereq_,module,exports){
+module.exports = negate;
+
+/**
+ * Negates the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to negate
+ * @returns {vec3} out
+ */
+function negate(out, a) {
+ out[0] = -a[0]
+ out[1] = -a[1]
+ out[2] = -a[2]
+ return out
+}
+},{}],339:[function(_dereq_,module,exports){
+module.exports = normalize;
+
+/**
+ * Normalize a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to normalize
+ * @returns {vec3} out
+ */
+function normalize(out, a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2]
+ var len = x*x + y*y + z*z
+ if (len > 0) {
+ //TODO: evaluate use of glm_invsqrt here?
+ len = 1 / Math.sqrt(len)
+ out[0] = a[0] * len
+ out[1] = a[1] * len
+ out[2] = a[2] * len
+ }
+ return out
+}
+},{}],340:[function(_dereq_,module,exports){
+module.exports = random;
+
+/**
+ * Generates a random vector with the given scale
+ *
+ * @param {vec3} out the receiving vector
+ * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
+ * @returns {vec3} out
+ */
+function random(out, scale) {
+ scale = scale || 1.0
+
+ var r = Math.random() * 2.0 * Math.PI
+ var z = (Math.random() * 2.0) - 1.0
+ var zScale = Math.sqrt(1.0-z*z) * scale
+
+ out[0] = Math.cos(r) * zScale
+ out[1] = Math.sin(r) * zScale
+ out[2] = z * scale
+ return out
+}
+},{}],341:[function(_dereq_,module,exports){
+module.exports = rotateX;
+
+/**
+ * Rotate a 3D vector around the x-axis
+ * @param {vec3} out The receiving vec3
+ * @param {vec3} a The vec3 point to rotate
+ * @param {vec3} b The origin of the rotation
+ * @param {Number} c The angle of rotation
+ * @returns {vec3} out
+ */
+function rotateX(out, a, b, c){
+ var by = b[1]
+ var bz = b[2]
+
+ // Translate point to the origin
+ var py = a[1] - by
+ var pz = a[2] - bz
+
+ var sc = Math.sin(c)
+ var cc = Math.cos(c)
+
+ // perform rotation and translate to correct position
+ out[0] = a[0]
+ out[1] = by + py * cc - pz * sc
+ out[2] = bz + py * sc + pz * cc
+
+ return out
+}
+
+},{}],342:[function(_dereq_,module,exports){
+module.exports = rotateY;
+
+/**
+ * Rotate a 3D vector around the y-axis
+ * @param {vec3} out The receiving vec3
+ * @param {vec3} a The vec3 point to rotate
+ * @param {vec3} b The origin of the rotation
+ * @param {Number} c The angle of rotation
+ * @returns {vec3} out
+ */
+function rotateY(out, a, b, c){
+ var bx = b[0]
+ var bz = b[2]
+
+ // translate point to the origin
+ var px = a[0] - bx
+ var pz = a[2] - bz
+
+ var sc = Math.sin(c)
+ var cc = Math.cos(c)
+
+ // perform rotation and translate to correct position
+ out[0] = bx + pz * sc + px * cc
+ out[1] = a[1]
+ out[2] = bz + pz * cc - px * sc
+
+ return out
+}
+
+},{}],343:[function(_dereq_,module,exports){
+module.exports = rotateZ;
+
+/**
+ * Rotate a 3D vector around the z-axis
+ * @param {vec3} out The receiving vec3
+ * @param {vec3} a The vec3 point to rotate
+ * @param {vec3} b The origin of the rotation
+ * @param {Number} c The angle of rotation
+ * @returns {vec3} out
+ */
+function rotateZ(out, a, b, c){
+ var bx = b[0]
+ var by = b[1]
+
+ //Translate point to the origin
+ var px = a[0] - bx
+ var py = a[1] - by
+
+ var sc = Math.sin(c)
+ var cc = Math.cos(c)
+
+ // perform rotation and translate to correct position
+ out[0] = bx + px * cc - py * sc
+ out[1] = by + px * sc + py * cc
+ out[2] = a[2]
+
+ return out
+}
+
+},{}],344:[function(_dereq_,module,exports){
+module.exports = round
+
+/**
+ * Math.round the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to round
+ * @returns {vec3} out
+ */
+function round(out, a) {
+ out[0] = Math.round(a[0])
+ out[1] = Math.round(a[1])
+ out[2] = Math.round(a[2])
+ return out
+}
+
+},{}],345:[function(_dereq_,module,exports){
+module.exports = scale;
+
+/**
+ * Scales a vec3 by a scalar number
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec3} out
+ */
+function scale(out, a, b) {
+ out[0] = a[0] * b
+ out[1] = a[1] * b
+ out[2] = a[2] * b
+ return out
+}
+},{}],346:[function(_dereq_,module,exports){
+module.exports = scaleAndAdd;
+
+/**
+ * Adds two vec3's after scaling the second operand by a scalar value
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @param {Number} scale the amount to scale b by before adding
+ * @returns {vec3} out
+ */
+function scaleAndAdd(out, a, b, scale) {
+ out[0] = a[0] + (b[0] * scale)
+ out[1] = a[1] + (b[1] * scale)
+ out[2] = a[2] + (b[2] * scale)
+ return out
+}
+},{}],347:[function(_dereq_,module,exports){
+module.exports = set;
+
+/**
+ * Set the components of a vec3 to the given values
+ *
+ * @param {vec3} out the receiving vector
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @returns {vec3} out
+ */
+function set(out, x, y, z) {
+ out[0] = x
+ out[1] = y
+ out[2] = z
+ return out
+}
+},{}],348:[function(_dereq_,module,exports){
+module.exports = _dereq_('./squaredDistance')
+
+},{"./squaredDistance":350}],349:[function(_dereq_,module,exports){
+module.exports = _dereq_('./squaredLength')
+
+},{"./squaredLength":351}],350:[function(_dereq_,module,exports){
+module.exports = squaredDistance;
+
+/**
+ * Calculates the squared euclidian distance between two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} squared distance between a and b
+ */
+function squaredDistance(a, b) {
+ var x = b[0] - a[0],
+ y = b[1] - a[1],
+ z = b[2] - a[2]
+ return x*x + y*y + z*z
+}
+},{}],351:[function(_dereq_,module,exports){
+module.exports = squaredLength;
+
+/**
+ * Calculates the squared length of a vec3
+ *
+ * @param {vec3} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ */
+function squaredLength(a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2]
+ return x*x + y*y + z*z
+}
+},{}],352:[function(_dereq_,module,exports){
+module.exports = _dereq_('./subtract')
+
+},{"./subtract":353}],353:[function(_dereq_,module,exports){
+module.exports = subtract;
+
+/**
+ * Subtracts vector b from vector a
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+function subtract(out, a, b) {
+ out[0] = a[0] - b[0]
+ out[1] = a[1] - b[1]
+ out[2] = a[2] - b[2]
+ return out
+}
+},{}],354:[function(_dereq_,module,exports){
+module.exports = transformMat3;
+
+/**
+ * Transforms the vec3 with a mat3.
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {mat4} m the 3x3 matrix to transform with
+ * @returns {vec3} out
+ */
+function transformMat3(out, a, m) {
+ var x = a[0], y = a[1], z = a[2]
+ out[0] = x * m[0] + y * m[3] + z * m[6]
+ out[1] = x * m[1] + y * m[4] + z * m[7]
+ out[2] = x * m[2] + y * m[5] + z * m[8]
+ return out
+}
+},{}],355:[function(_dereq_,module,exports){
+module.exports = transformMat4;
+
+/**
+ * Transforms the vec3 with a mat4.
+ * 4th vector component is implicitly '1'
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {mat4} m matrix to transform with
+ * @returns {vec3} out
+ */
+function transformMat4(out, a, m) {
+ var x = a[0], y = a[1], z = a[2],
+ w = m[3] * x + m[7] * y + m[11] * z + m[15]
+ w = w || 1.0
+ out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w
+ out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w
+ out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w
+ return out
+}
+},{}],356:[function(_dereq_,module,exports){
+module.exports = transformQuat;
+
+/**
+ * Transforms the vec3 with a quat
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {quat} q quaternion to transform with
+ * @returns {vec3} out
+ */
+function transformQuat(out, a, q) {
+ // benchmarks: http://jsperf.com/quaternion-transform-vec3-implementations
+
+ var x = a[0], y = a[1], z = a[2],
+ qx = q[0], qy = q[1], qz = q[2], qw = q[3],
+
+ // calculate quat * vec
+ ix = qw * x + qy * z - qz * y,
+ iy = qw * y + qz * x - qx * z,
+ iz = qw * z + qx * y - qy * x,
+ iw = -qx * x - qy * y - qz * z
+
+ // calculate result * inverse quat
+ out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy
+ out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz
+ out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx
+ return out
+}
+},{}],357:[function(_dereq_,module,exports){
+module.exports = add
+
+/**
+ * Adds two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function add (out, a, b) {
+ out[0] = a[0] + b[0]
+ out[1] = a[1] + b[1]
+ out[2] = a[2] + b[2]
+ out[3] = a[3] + b[3]
+ return out
+}
+
+},{}],358:[function(_dereq_,module,exports){
+module.exports = clone
+
+/**
+ * Creates a new vec4 initialized with values from an existing vector
+ *
+ * @param {vec4} a vector to clone
+ * @returns {vec4} a new 4D vector
+ */
+function clone (a) {
+ var out = new Float32Array(4)
+ out[0] = a[0]
+ out[1] = a[1]
+ out[2] = a[2]
+ out[3] = a[3]
+ return out
+}
+
+},{}],359:[function(_dereq_,module,exports){
+module.exports = copy
+
+/**
+ * Copy the values from one vec4 to another
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the source vector
+ * @returns {vec4} out
+ */
+function copy (out, a) {
+ out[0] = a[0]
+ out[1] = a[1]
+ out[2] = a[2]
+ out[3] = a[3]
+ return out
+}
+
+},{}],360:[function(_dereq_,module,exports){
+module.exports = create
+
+/**
+ * Creates a new, empty vec4
+ *
+ * @returns {vec4} a new 4D vector
+ */
+function create () {
+ var out = new Float32Array(4)
+ out[0] = 0
+ out[1] = 0
+ out[2] = 0
+ out[3] = 0
+ return out
+}
+
+},{}],361:[function(_dereq_,module,exports){
+module.exports = distance
+
+/**
+ * Calculates the euclidian distance between two vec4's
+ *
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {Number} distance between a and b
+ */
+function distance (a, b) {
+ var x = b[0] - a[0],
+ y = b[1] - a[1],
+ z = b[2] - a[2],
+ w = b[3] - a[3]
+ return Math.sqrt(x * x + y * y + z * z + w * w)
+}
+
+},{}],362:[function(_dereq_,module,exports){
+module.exports = divide
+
+/**
+ * Divides two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function divide (out, a, b) {
+ out[0] = a[0] / b[0]
+ out[1] = a[1] / b[1]
+ out[2] = a[2] / b[2]
+ out[3] = a[3] / b[3]
+ return out
+}
+
+},{}],363:[function(_dereq_,module,exports){
+module.exports = dot
+
+/**
+ * Calculates the dot product of two vec4's
+ *
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+function dot (a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]
+}
+
+},{}],364:[function(_dereq_,module,exports){
+module.exports = fromValues
+
+/**
+ * Creates a new vec4 initialized with the given values
+ *
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {vec4} a new 4D vector
+ */
+function fromValues (x, y, z, w) {
+ var out = new Float32Array(4)
+ out[0] = x
+ out[1] = y
+ out[2] = z
+ out[3] = w
+ return out
+}
+
+},{}],365:[function(_dereq_,module,exports){
+module.exports = {
+ create: _dereq_('./create'),
+ clone: _dereq_('./clone'),
+ fromValues: _dereq_('./fromValues'),
+ copy: _dereq_('./copy'),
+ set: _dereq_('./set'),
+ add: _dereq_('./add'),
+ subtract: _dereq_('./subtract'),
+ multiply: _dereq_('./multiply'),
+ divide: _dereq_('./divide'),
+ min: _dereq_('./min'),
+ max: _dereq_('./max'),
+ scale: _dereq_('./scale'),
+ scaleAndAdd: _dereq_('./scaleAndAdd'),
+ distance: _dereq_('./distance'),
+ squaredDistance: _dereq_('./squaredDistance'),
+ length: _dereq_('./length'),
+ squaredLength: _dereq_('./squaredLength'),
+ negate: _dereq_('./negate'),
+ inverse: _dereq_('./inverse'),
+ normalize: _dereq_('./normalize'),
+ dot: _dereq_('./dot'),
+ lerp: _dereq_('./lerp'),
+ random: _dereq_('./random'),
+ transformMat4: _dereq_('./transformMat4'),
+ transformQuat: _dereq_('./transformQuat')
+}
+
+},{"./add":357,"./clone":358,"./copy":359,"./create":360,"./distance":361,"./divide":362,"./dot":363,"./fromValues":364,"./inverse":366,"./length":367,"./lerp":368,"./max":369,"./min":370,"./multiply":371,"./negate":372,"./normalize":373,"./random":374,"./scale":375,"./scaleAndAdd":376,"./set":377,"./squaredDistance":378,"./squaredLength":379,"./subtract":380,"./transformMat4":381,"./transformQuat":382}],366:[function(_dereq_,module,exports){
+module.exports = inverse
+
+/**
+ * Returns the inverse of the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to invert
+ * @returns {vec4} out
+ */
+function inverse (out, a) {
+ out[0] = 1.0 / a[0]
+ out[1] = 1.0 / a[1]
+ out[2] = 1.0 / a[2]
+ out[3] = 1.0 / a[3]
+ return out
+}
+
+},{}],367:[function(_dereq_,module,exports){
+module.exports = length
+
+/**
+ * Calculates the length of a vec4
+ *
+ * @param {vec4} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+function length (a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2],
+ w = a[3]
+ return Math.sqrt(x * x + y * y + z * z + w * w)
+}
+
+},{}],368:[function(_dereq_,module,exports){
+module.exports = lerp
+
+/**
+ * Performs a linear interpolation between two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @param {Number} t interpolation amount between the two inputs
+ * @returns {vec4} out
+ */
+function lerp (out, a, b, t) {
+ var ax = a[0],
+ ay = a[1],
+ az = a[2],
+ aw = a[3]
+ out[0] = ax + t * (b[0] - ax)
+ out[1] = ay + t * (b[1] - ay)
+ out[2] = az + t * (b[2] - az)
+ out[3] = aw + t * (b[3] - aw)
+ return out
+}
+
+},{}],369:[function(_dereq_,module,exports){
+module.exports = max
+
+/**
+ * Returns the maximum of two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function max (out, a, b) {
+ out[0] = Math.max(a[0], b[0])
+ out[1] = Math.max(a[1], b[1])
+ out[2] = Math.max(a[2], b[2])
+ out[3] = Math.max(a[3], b[3])
+ return out
+}
+
+},{}],370:[function(_dereq_,module,exports){
+module.exports = min
+
+/**
+ * Returns the minimum of two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function min (out, a, b) {
+ out[0] = Math.min(a[0], b[0])
+ out[1] = Math.min(a[1], b[1])
+ out[2] = Math.min(a[2], b[2])
+ out[3] = Math.min(a[3], b[3])
+ return out
+}
+
+},{}],371:[function(_dereq_,module,exports){
+module.exports = multiply
+
+/**
+ * Multiplies two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function multiply (out, a, b) {
+ out[0] = a[0] * b[0]
+ out[1] = a[1] * b[1]
+ out[2] = a[2] * b[2]
+ out[3] = a[3] * b[3]
+ return out
+}
+
+},{}],372:[function(_dereq_,module,exports){
+module.exports = negate
+
+/**
+ * Negates the components of a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to negate
+ * @returns {vec4} out
+ */
+function negate (out, a) {
+ out[0] = -a[0]
+ out[1] = -a[1]
+ out[2] = -a[2]
+ out[3] = -a[3]
+ return out
+}
+
+},{}],373:[function(_dereq_,module,exports){
+module.exports = normalize
+
+/**
+ * Normalize a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to normalize
+ * @returns {vec4} out
+ */
+function normalize (out, a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2],
+ w = a[3]
+ var len = x * x + y * y + z * z + w * w
+ if (len > 0) {
+ len = 1 / Math.sqrt(len)
+ out[0] = x * len
+ out[1] = y * len
+ out[2] = z * len
+ out[3] = w * len
+ }
+ return out
+}
+
+},{}],374:[function(_dereq_,module,exports){
+var vecNormalize = _dereq_('./normalize')
+var vecScale = _dereq_('./scale')
+
+module.exports = random
+
+/**
+ * Generates a random vector with the given scale
+ *
+ * @param {vec4} out the receiving vector
+ * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
+ * @returns {vec4} out
+ */
+function random (out, scale) {
+ scale = scale || 1.0
+
+ // TODO: This is a pretty awful way of doing this. Find something better.
+ out[0] = Math.random()
+ out[1] = Math.random()
+ out[2] = Math.random()
+ out[3] = Math.random()
+ vecNormalize(out, out)
+ vecScale(out, out, scale)
+ return out
+}
+
+},{"./normalize":373,"./scale":375}],375:[function(_dereq_,module,exports){
+module.exports = scale
+
+/**
+ * Scales a vec4 by a scalar number
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec4} out
+ */
+function scale (out, a, b) {
+ out[0] = a[0] * b
+ out[1] = a[1] * b
+ out[2] = a[2] * b
+ out[3] = a[3] * b
+ return out
+}
+
+},{}],376:[function(_dereq_,module,exports){
+module.exports = scaleAndAdd
+
+/**
+ * Adds two vec4's after scaling the second operand by a scalar value
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @param {Number} scale the amount to scale b by before adding
+ * @returns {vec4} out
+ */
+function scaleAndAdd (out, a, b, scale) {
+ out[0] = a[0] + (b[0] * scale)
+ out[1] = a[1] + (b[1] * scale)
+ out[2] = a[2] + (b[2] * scale)
+ out[3] = a[3] + (b[3] * scale)
+ return out
+}
+
+},{}],377:[function(_dereq_,module,exports){
+module.exports = set
+
+/**
+ * Set the components of a vec4 to the given values
+ *
+ * @param {vec4} out the receiving vector
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {vec4} out
+ */
+function set (out, x, y, z, w) {
+ out[0] = x
+ out[1] = y
+ out[2] = z
+ out[3] = w
+ return out
+}
+
+},{}],378:[function(_dereq_,module,exports){
+module.exports = squaredDistance
+
+/**
+ * Calculates the squared euclidian distance between two vec4's
+ *
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {Number} squared distance between a and b
+ */
+function squaredDistance (a, b) {
+ var x = b[0] - a[0],
+ y = b[1] - a[1],
+ z = b[2] - a[2],
+ w = b[3] - a[3]
+ return x * x + y * y + z * z + w * w
+}
+
+},{}],379:[function(_dereq_,module,exports){
+module.exports = squaredLength
+
+/**
+ * Calculates the squared length of a vec4
+ *
+ * @param {vec4} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ */
+function squaredLength (a) {
+ var x = a[0],
+ y = a[1],
+ z = a[2],
+ w = a[3]
+ return x * x + y * y + z * z + w * w
+}
+
+},{}],380:[function(_dereq_,module,exports){
+module.exports = subtract
+
+/**
+ * Subtracts vector b from vector a
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {vec4} out
+ */
+function subtract (out, a, b) {
+ out[0] = a[0] - b[0]
+ out[1] = a[1] - b[1]
+ out[2] = a[2] - b[2]
+ out[3] = a[3] - b[3]
+ return out
+}
+
+},{}],381:[function(_dereq_,module,exports){
+module.exports = transformMat4
+
+/**
+ * Transforms the vec4 with a mat4.
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the vector to transform
+ * @param {mat4} m matrix to transform with
+ * @returns {vec4} out
+ */
+function transformMat4 (out, a, m) {
+ var x = a[0], y = a[1], z = a[2], w = a[3]
+ out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w
+ out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w
+ out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w
+ out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w
+ return out
+}
+
+},{}],382:[function(_dereq_,module,exports){
+module.exports = transformQuat
+
+/**
+ * Transforms the vec4 with a quat
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the vector to transform
+ * @param {quat} q quaternion to transform with
+ * @returns {vec4} out
+ */
+function transformQuat (out, a, q) {
+ var x = a[0], y = a[1], z = a[2],
+ qx = q[0], qy = q[1], qz = q[2], qw = q[3],
+
+ // calculate quat * vec
+ ix = qw * x + qy * z - qz * y,
+ iy = qw * y + qz * x - qx * z,
+ iz = qw * z + qx * y - qy * x,
+ iw = -qx * x - qy * y - qz * z
+
+ // calculate result * inverse quat
+ out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy
+ out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz
+ out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx
+ out[3] = a[3]
+ return out
+}
+
+},{}],383:[function(_dereq_,module,exports){
+module.exports = decodeFloat
+
+var UINT8_VIEW = new Uint8Array(4)
+var FLOAT_VIEW = new Float32Array(UINT8_VIEW.buffer)
+
+function decodeFloat(x, y, z, w) {
+ UINT8_VIEW[0] = w
+ UINT8_VIEW[1] = z
+ UINT8_VIEW[2] = y
+ UINT8_VIEW[3] = x
+ return FLOAT_VIEW[0]
+}
+
+},{}],384:[function(_dereq_,module,exports){
+var tokenize = _dereq_('glsl-tokenizer')
+var atob = _dereq_('atob-lite')
+
+module.exports = getName
+
+function getName(src) {
+ var tokens = Array.isArray(src)
+ ? src
+ : tokenize(src)
+
+ for (var i = 0; i < tokens.length; i++) {
+ var token = tokens[i]
+ if (token.type !== 'preprocessor') continue
+ var match = token.data.match(/\#define\s+SHADER_NAME(_B64)?\s+(.+)$/)
+ if (!match) continue
+ if (!match[2]) continue
+
+ var b64 = match[1]
+ var name = match[2]
+
+ return (b64 ? atob(name) : name).trim()
+ }
+}
+
+},{"atob-lite":60,"glsl-tokenizer":391}],385:[function(_dereq_,module,exports){
+module.exports = tokenize
+
+var literals100 = _dereq_('./lib/literals')
+ , operators = _dereq_('./lib/operators')
+ , builtins100 = _dereq_('./lib/builtins')
+ , literals300es = _dereq_('./lib/literals-300es')
+ , builtins300es = _dereq_('./lib/builtins-300es')
+
+var NORMAL = 999 // <-- never emitted
+ , TOKEN = 9999 // <-- never emitted
+ , BLOCK_COMMENT = 0
+ , LINE_COMMENT = 1
+ , PREPROCESSOR = 2
+ , OPERATOR = 3
+ , INTEGER = 4
+ , FLOAT = 5
+ , IDENT = 6
+ , BUILTIN = 7
+ , KEYWORD = 8
+ , WHITESPACE = 9
+ , EOF = 10
+ , HEX = 11
+
+var map = [
+ 'block-comment'
+ , 'line-comment'
+ , 'preprocessor'
+ , 'operator'
+ , 'integer'
+ , 'float'
+ , 'ident'
+ , 'builtin'
+ , 'keyword'
+ , 'whitespace'
+ , 'eof'
+ , 'integer'
+]
+
+function tokenize(opt) {
+ var i = 0
+ , total = 0
+ , mode = NORMAL
+ , c
+ , last
+ , content = []
+ , tokens = []
+ , token_idx = 0
+ , token_offs = 0
+ , line = 1
+ , col = 0
+ , start = 0
+ , isnum = false
+ , isoperator = false
+ , input = ''
+ , len
+
+ opt = opt || {}
+ var allBuiltins = builtins100
+ var allLiterals = literals100
+ if (opt.version === '300 es') {
+ allBuiltins = builtins300es
+ allLiterals = literals300es
+ }
+
+ return function(data) {
+ tokens = []
+ if (data !== null) return write(data.replace ? data.replace(/\r\n/g, '\n') : data)
+ return end()
+ }
+
+ function token(data) {
+ if (data.length) {
+ tokens.push({
+ type: map[mode]
+ , data: data
+ , position: start
+ , line: line
+ , column: col
+ })
+ }
+ }
+
+ function write(chunk) {
+ i = 0
+ input += chunk
+ len = input.length
+
+ var last
+
+ while(c = input[i], i < len) {
+ last = i
+
+ switch(mode) {
+ case BLOCK_COMMENT: i = block_comment(); break
+ case LINE_COMMENT: i = line_comment(); break
+ case PREPROCESSOR: i = preprocessor(); break
+ case OPERATOR: i = operator(); break
+ case INTEGER: i = integer(); break
+ case HEX: i = hex(); break
+ case FLOAT: i = decimal(); break
+ case TOKEN: i = readtoken(); break
+ case WHITESPACE: i = whitespace(); break
+ case NORMAL: i = normal(); break
+ }
+
+ if(last !== i) {
+ switch(input[last]) {
+ case '\n': col = 0; ++line; break
+ default: ++col; break
+ }
+ }
+ }
+
+ total += i
+ input = input.slice(i)
+ return tokens
+ }
+
+ function end(chunk) {
+ if(content.length) {
+ token(content.join(''))
+ }
+
+ mode = EOF
+ token('(eof)')
+ return tokens
+ }
+
+ function normal() {
+ content = content.length ? [] : content
+
+ if(last === '/' && c === '*') {
+ start = total + i - 1
+ mode = BLOCK_COMMENT
+ last = c
+ return i + 1
+ }
+
+ if(last === '/' && c === '/') {
+ start = total + i - 1
+ mode = LINE_COMMENT
+ last = c
+ return i + 1
+ }
+
+ if(c === '#') {
+ mode = PREPROCESSOR
+ start = total + i
+ return i
+ }
+
+ if(/\s/.test(c)) {
+ mode = WHITESPACE
+ start = total + i
+ return i
+ }
+
+ isnum = /\d/.test(c)
+ isoperator = /[^\w_]/.test(c)
+
+ start = total + i
+ mode = isnum ? INTEGER : isoperator ? OPERATOR : TOKEN
+ return i
+ }
+
+ function whitespace() {
+ if(/[^\s]/g.test(c)) {
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function preprocessor() {
+ if((c === '\r' || c === '\n') && last !== '\\') {
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function line_comment() {
+ return preprocessor()
+ }
+
+ function block_comment() {
+ if(c === '/' && last === '*') {
+ content.push(c)
+ token(content.join(''))
+ mode = NORMAL
+ return i + 1
+ }
+
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function operator() {
+ if(last === '.' && /\d/.test(c)) {
+ mode = FLOAT
+ return i
+ }
+
+ if(last === '/' && c === '*') {
+ mode = BLOCK_COMMENT
+ return i
+ }
+
+ if(last === '/' && c === '/') {
+ mode = LINE_COMMENT
+ return i
+ }
+
+ if(c === '.' && content.length) {
+ while(determine_operator(content));
+
+ mode = FLOAT
+ return i
+ }
+
+ if(c === ';' || c === ')' || c === '(') {
+ if(content.length) while(determine_operator(content));
+ token(c)
+ mode = NORMAL
+ return i + 1
+ }
+
+ var is_composite_operator = content.length === 2 && c !== '='
+ if(/[\w_\d\s]/.test(c) || is_composite_operator) {
+ while(determine_operator(content));
+ mode = NORMAL
+ return i
+ }
+
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function determine_operator(buf) {
+ var j = 0
+ , idx
+ , res
+
+ do {
+ idx = operators.indexOf(buf.slice(0, buf.length + j).join(''))
+ res = operators[idx]
+
+ if(idx === -1) {
+ if(j-- + buf.length > 0) continue
+ res = buf.slice(0, 1).join('')
+ }
+
+ token(res)
+
+ start += res.length
+ content = content.slice(res.length)
+ return content.length
+ } while(1)
+ }
+
+ function hex() {
+ if(/[^a-fA-F0-9]/.test(c)) {
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function integer() {
+ if(c === '.') {
+ content.push(c)
+ mode = FLOAT
+ last = c
+ return i + 1
+ }
+
+ if(/[eE]/.test(c)) {
+ content.push(c)
+ mode = FLOAT
+ last = c
+ return i + 1
+ }
+
+ if(c === 'x' && content.length === 1 && content[0] === '0') {
+ mode = HEX
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ if(/[^\d]/.test(c)) {
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function decimal() {
+ if(c === 'f') {
+ content.push(c)
+ last = c
+ i += 1
+ }
+
+ if(/[eE]/.test(c)) {
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ if (c === '-' && /[eE]/.test(last)) {
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ if(/[^\d]/.test(c)) {
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+
+ content.push(c)
+ last = c
+ return i + 1
+ }
+
+ function readtoken() {
+ if(/[^\d\w_]/.test(c)) {
+ var contentstr = content.join('')
+ if(allLiterals.indexOf(contentstr) > -1) {
+ mode = KEYWORD
+ } else if(allBuiltins.indexOf(contentstr) > -1) {
+ mode = BUILTIN
+ } else {
+ mode = IDENT
+ }
+ token(content.join(''))
+ mode = NORMAL
+ return i
+ }
+ content.push(c)
+ last = c
+ return i + 1
+ }
+}
+
+},{"./lib/builtins":387,"./lib/builtins-300es":386,"./lib/literals":389,"./lib/literals-300es":388,"./lib/operators":390}],386:[function(_dereq_,module,exports){
+// 300es builtins/reserved words that were previously valid in v100
+var v100 = _dereq_('./builtins')
+
+// The texture2D|Cube functions have been removed
+// And the gl_ features are updated
+v100 = v100.slice().filter(function (b) {
+ return !/^(gl\_|texture)/.test(b)
+})
+
+module.exports = v100.concat([
+ // the updated gl_ constants
+ 'gl_VertexID'
+ , 'gl_InstanceID'
+ , 'gl_Position'
+ , 'gl_PointSize'
+ , 'gl_FragCoord'
+ , 'gl_FrontFacing'
+ , 'gl_FragDepth'
+ , 'gl_PointCoord'
+ , 'gl_MaxVertexAttribs'
+ , 'gl_MaxVertexUniformVectors'
+ , 'gl_MaxVertexOutputVectors'
+ , 'gl_MaxFragmentInputVectors'
+ , 'gl_MaxVertexTextureImageUnits'
+ , 'gl_MaxCombinedTextureImageUnits'
+ , 'gl_MaxTextureImageUnits'
+ , 'gl_MaxFragmentUniformVectors'
+ , 'gl_MaxDrawBuffers'
+ , 'gl_MinProgramTexelOffset'
+ , 'gl_MaxProgramTexelOffset'
+ , 'gl_DepthRangeParameters'
+ , 'gl_DepthRange'
+
+ // other builtins
+ , 'trunc'
+ , 'round'
+ , 'roundEven'
+ , 'isnan'
+ , 'isinf'
+ , 'floatBitsToInt'
+ , 'floatBitsToUint'
+ , 'intBitsToFloat'
+ , 'uintBitsToFloat'
+ , 'packSnorm2x16'
+ , 'unpackSnorm2x16'
+ , 'packUnorm2x16'
+ , 'unpackUnorm2x16'
+ , 'packHalf2x16'
+ , 'unpackHalf2x16'
+ , 'outerProduct'
+ , 'transpose'
+ , 'determinant'
+ , 'inverse'
+ , 'texture'
+ , 'textureSize'
+ , 'textureProj'
+ , 'textureLod'
+ , 'textureOffset'
+ , 'texelFetch'
+ , 'texelFetchOffset'
+ , 'textureProjOffset'
+ , 'textureLodOffset'
+ , 'textureProjLod'
+ , 'textureProjLodOffset'
+ , 'textureGrad'
+ , 'textureGradOffset'
+ , 'textureProjGrad'
+ , 'textureProjGradOffset'
+])
+
+},{"./builtins":387}],387:[function(_dereq_,module,exports){
+module.exports = [
+ // Keep this list sorted
+ 'abs'
+ , 'acos'
+ , 'all'
+ , 'any'
+ , 'asin'
+ , 'atan'
+ , 'ceil'
+ , 'clamp'
+ , 'cos'
+ , 'cross'
+ , 'dFdx'
+ , 'dFdy'
+ , 'degrees'
+ , 'distance'
+ , 'dot'
+ , 'equal'
+ , 'exp'
+ , 'exp2'
+ , 'faceforward'
+ , 'floor'
+ , 'fract'
+ , 'gl_BackColor'
+ , 'gl_BackLightModelProduct'
+ , 'gl_BackLightProduct'
+ , 'gl_BackMaterial'
+ , 'gl_BackSecondaryColor'
+ , 'gl_ClipPlane'
+ , 'gl_ClipVertex'
+ , 'gl_Color'
+ , 'gl_DepthRange'
+ , 'gl_DepthRangeParameters'
+ , 'gl_EyePlaneQ'
+ , 'gl_EyePlaneR'
+ , 'gl_EyePlaneS'
+ , 'gl_EyePlaneT'
+ , 'gl_Fog'
+ , 'gl_FogCoord'
+ , 'gl_FogFragCoord'
+ , 'gl_FogParameters'
+ , 'gl_FragColor'
+ , 'gl_FragCoord'
+ , 'gl_FragData'
+ , 'gl_FragDepth'
+ , 'gl_FragDepthEXT'
+ , 'gl_FrontColor'
+ , 'gl_FrontFacing'
+ , 'gl_FrontLightModelProduct'
+ , 'gl_FrontLightProduct'
+ , 'gl_FrontMaterial'
+ , 'gl_FrontSecondaryColor'
+ , 'gl_LightModel'
+ , 'gl_LightModelParameters'
+ , 'gl_LightModelProducts'
+ , 'gl_LightProducts'
+ , 'gl_LightSource'
+ , 'gl_LightSourceParameters'
+ , 'gl_MaterialParameters'
+ , 'gl_MaxClipPlanes'
+ , 'gl_MaxCombinedTextureImageUnits'
+ , 'gl_MaxDrawBuffers'
+ , 'gl_MaxFragmentUniformComponents'
+ , 'gl_MaxLights'
+ , 'gl_MaxTextureCoords'
+ , 'gl_MaxTextureImageUnits'
+ , 'gl_MaxTextureUnits'
+ , 'gl_MaxVaryingFloats'
+ , 'gl_MaxVertexAttribs'
+ , 'gl_MaxVertexTextureImageUnits'
+ , 'gl_MaxVertexUniformComponents'
+ , 'gl_ModelViewMatrix'
+ , 'gl_ModelViewMatrixInverse'
+ , 'gl_ModelViewMatrixInverseTranspose'
+ , 'gl_ModelViewMatrixTranspose'
+ , 'gl_ModelViewProjectionMatrix'
+ , 'gl_ModelViewProjectionMatrixInverse'
+ , 'gl_ModelViewProjectionMatrixInverseTranspose'
+ , 'gl_ModelViewProjectionMatrixTranspose'
+ , 'gl_MultiTexCoord0'
+ , 'gl_MultiTexCoord1'
+ , 'gl_MultiTexCoord2'
+ , 'gl_MultiTexCoord3'
+ , 'gl_MultiTexCoord4'
+ , 'gl_MultiTexCoord5'
+ , 'gl_MultiTexCoord6'
+ , 'gl_MultiTexCoord7'
+ , 'gl_Normal'
+ , 'gl_NormalMatrix'
+ , 'gl_NormalScale'
+ , 'gl_ObjectPlaneQ'
+ , 'gl_ObjectPlaneR'
+ , 'gl_ObjectPlaneS'
+ , 'gl_ObjectPlaneT'
+ , 'gl_Point'
+ , 'gl_PointCoord'
+ , 'gl_PointParameters'
+ , 'gl_PointSize'
+ , 'gl_Position'
+ , 'gl_ProjectionMatrix'
+ , 'gl_ProjectionMatrixInverse'
+ , 'gl_ProjectionMatrixInverseTranspose'
+ , 'gl_ProjectionMatrixTranspose'
+ , 'gl_SecondaryColor'
+ , 'gl_TexCoord'
+ , 'gl_TextureEnvColor'
+ , 'gl_TextureMatrix'
+ , 'gl_TextureMatrixInverse'
+ , 'gl_TextureMatrixInverseTranspose'
+ , 'gl_TextureMatrixTranspose'
+ , 'gl_Vertex'
+ , 'greaterThan'
+ , 'greaterThanEqual'
+ , 'inversesqrt'
+ , 'length'
+ , 'lessThan'
+ , 'lessThanEqual'
+ , 'log'
+ , 'log2'
+ , 'matrixCompMult'
+ , 'max'
+ , 'min'
+ , 'mix'
+ , 'mod'
+ , 'normalize'
+ , 'not'
+ , 'notEqual'
+ , 'pow'
+ , 'radians'
+ , 'reflect'
+ , 'refract'
+ , 'sign'
+ , 'sin'
+ , 'smoothstep'
+ , 'sqrt'
+ , 'step'
+ , 'tan'
+ , 'texture2D'
+ , 'texture2DLod'
+ , 'texture2DProj'
+ , 'texture2DProjLod'
+ , 'textureCube'
+ , 'textureCubeLod'
+ , 'texture2DLodEXT'
+ , 'texture2DProjLodEXT'
+ , 'textureCubeLodEXT'
+ , 'texture2DGradEXT'
+ , 'texture2DProjGradEXT'
+ , 'textureCubeGradEXT'
+]
+
+},{}],388:[function(_dereq_,module,exports){
+var v100 = _dereq_('./literals')
+
+module.exports = v100.slice().concat([
+ 'layout'
+ , 'centroid'
+ , 'smooth'
+ , 'case'
+ , 'mat2x2'
+ , 'mat2x3'
+ , 'mat2x4'
+ , 'mat3x2'
+ , 'mat3x3'
+ , 'mat3x4'
+ , 'mat4x2'
+ , 'mat4x3'
+ , 'mat4x4'
+ , 'uint'
+ , 'uvec2'
+ , 'uvec3'
+ , 'uvec4'
+ , 'samplerCubeShadow'
+ , 'sampler2DArray'
+ , 'sampler2DArrayShadow'
+ , 'isampler2D'
+ , 'isampler3D'
+ , 'isamplerCube'
+ , 'isampler2DArray'
+ , 'usampler2D'
+ , 'usampler3D'
+ , 'usamplerCube'
+ , 'usampler2DArray'
+ , 'coherent'
+ , 'restrict'
+ , 'readonly'
+ , 'writeonly'
+ , 'resource'
+ , 'atomic_uint'
+ , 'noperspective'
+ , 'patch'
+ , 'sample'
+ , 'subroutine'
+ , 'common'
+ , 'partition'
+ , 'active'
+ , 'filter'
+ , 'image1D'
+ , 'image2D'
+ , 'image3D'
+ , 'imageCube'
+ , 'iimage1D'
+ , 'iimage2D'
+ , 'iimage3D'
+ , 'iimageCube'
+ , 'uimage1D'
+ , 'uimage2D'
+ , 'uimage3D'
+ , 'uimageCube'
+ , 'image1DArray'
+ , 'image2DArray'
+ , 'iimage1DArray'
+ , 'iimage2DArray'
+ , 'uimage1DArray'
+ , 'uimage2DArray'
+ , 'image1DShadow'
+ , 'image2DShadow'
+ , 'image1DArrayShadow'
+ , 'image2DArrayShadow'
+ , 'imageBuffer'
+ , 'iimageBuffer'
+ , 'uimageBuffer'
+ , 'sampler1DArray'
+ , 'sampler1DArrayShadow'
+ , 'isampler1D'
+ , 'isampler1DArray'
+ , 'usampler1D'
+ , 'usampler1DArray'
+ , 'isampler2DRect'
+ , 'usampler2DRect'
+ , 'samplerBuffer'
+ , 'isamplerBuffer'
+ , 'usamplerBuffer'
+ , 'sampler2DMS'
+ , 'isampler2DMS'
+ , 'usampler2DMS'
+ , 'sampler2DMSArray'
+ , 'isampler2DMSArray'
+ , 'usampler2DMSArray'
+])
+
+},{"./literals":389}],389:[function(_dereq_,module,exports){
+module.exports = [
+ // current
+ 'precision'
+ , 'highp'
+ , 'mediump'
+ , 'lowp'
+ , 'attribute'
+ , 'const'
+ , 'uniform'
+ , 'varying'
+ , 'break'
+ , 'continue'
+ , 'do'
+ , 'for'
+ , 'while'
+ , 'if'
+ , 'else'
+ , 'in'
+ , 'out'
+ , 'inout'
+ , 'float'
+ , 'int'
+ , 'void'
+ , 'bool'
+ , 'true'
+ , 'false'
+ , 'discard'
+ , 'return'
+ , 'mat2'
+ , 'mat3'
+ , 'mat4'
+ , 'vec2'
+ , 'vec3'
+ , 'vec4'
+ , 'ivec2'
+ , 'ivec3'
+ , 'ivec4'
+ , 'bvec2'
+ , 'bvec3'
+ , 'bvec4'
+ , 'sampler1D'
+ , 'sampler2D'
+ , 'sampler3D'
+ , 'samplerCube'
+ , 'sampler1DShadow'
+ , 'sampler2DShadow'
+ , 'struct'
+
+ // future
+ , 'asm'
+ , 'class'
+ , 'union'
+ , 'enum'
+ , 'typedef'
+ , 'template'
+ , 'this'
+ , 'packed'
+ , 'goto'
+ , 'switch'
+ , 'default'
+ , 'inline'
+ , 'noinline'
+ , 'volatile'
+ , 'public'
+ , 'static'
+ , 'extern'
+ , 'external'
+ , 'interface'
+ , 'long'
+ , 'short'
+ , 'double'
+ , 'half'
+ , 'fixed'
+ , 'unsigned'
+ , 'input'
+ , 'output'
+ , 'hvec2'
+ , 'hvec3'
+ , 'hvec4'
+ , 'dvec2'
+ , 'dvec3'
+ , 'dvec4'
+ , 'fvec2'
+ , 'fvec3'
+ , 'fvec4'
+ , 'sampler2DRect'
+ , 'sampler3DRect'
+ , 'sampler2DRectShadow'
+ , 'sizeof'
+ , 'cast'
+ , 'namespace'
+ , 'using'
+]
+
+},{}],390:[function(_dereq_,module,exports){
+module.exports = [
+ '<<='
+ , '>>='
+ , '++'
+ , '--'
+ , '<<'
+ , '>>'
+ , '<='
+ , '>='
+ , '=='
+ , '!='
+ , '&&'
+ , '||'
+ , '+='
+ , '-='
+ , '*='
+ , '/='
+ , '%='
+ , '&='
+ , '^^'
+ , '^='
+ , '|='
+ , '('
+ , ')'
+ , '['
+ , ']'
+ , '.'
+ , '!'
+ , '~'
+ , '*'
+ , '/'
+ , '%'
+ , '+'
+ , '-'
+ , '<'
+ , '>'
+ , '&'
+ , '^'
+ , '|'
+ , '?'
+ , ':'
+ , '='
+ , ','
+ , ';'
+ , '{'
+ , '}'
+]
+
+},{}],391:[function(_dereq_,module,exports){
+var tokenize = _dereq_('./index')
+
+module.exports = tokenizeString
+
+function tokenizeString(str, opt) {
+ var generator = tokenize(opt)
+ var tokens = []
+
+ tokens = tokens.concat(generator(str))
+ tokens = tokens.concat(generator(null))
+
+ return tokens
+}
+
+},{"./index":385}],392:[function(_dereq_,module,exports){
+module.exports = function(strings) {
+ if (typeof strings === 'string') strings = [strings]
+ var exprs = [].slice.call(arguments,1)
+ var parts = []
+ for (var i = 0; i < strings.length-1; i++) {
+ parts.push(strings[i], exprs[i] || '')
+ }
+ parts.push(strings[i])
+ return parts.join('')
+}
+
+},{}],393:[function(_dereq_,module,exports){
+(function (global){
+'use strict'
+
+var isBrowser = _dereq_('is-browser')
+var hasHover
+
+if (typeof global.matchMedia === 'function') {
+ hasHover = !global.matchMedia('(hover: none)').matches
+}
+else {
+ hasHover = isBrowser
+}
+
+module.exports = hasHover
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"is-browser":400}],394:[function(_dereq_,module,exports){
+'use strict'
+
+var isBrowser = _dereq_('is-browser')
+
+function detect() {
+ var supported = false
+
+ try {
+ var opts = Object.defineProperty({}, 'passive', {
+ get: function() {
+ supported = true
+ }
+ })
+
+ window.addEventListener('test', null, opts)
+ window.removeEventListener('test', null, opts)
+ } catch(e) {
+ supported = false
+ }
+
+ return supported
+}
+
+module.exports = isBrowser && detect()
+
+},{"is-browser":400}],395:[function(_dereq_,module,exports){
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
+
+ i += d
+
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
+
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+ value = Math.abs(value)
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = ((value * c) - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+ buffer[offset + i - d] |= s * 128
+}
+
+},{}],396:[function(_dereq_,module,exports){
+"use strict"
+
+//High level idea:
+// 1. Use Clarkson's incremental construction to find convex hull
+// 2. Point location in triangulation by jump and walk
+
+module.exports = incrementalConvexHull
+
+var orient = _dereq_("robust-orientation")
+var compareCell = _dereq_("simplicial-complex").compareCells
+
+function compareInt(a, b) {
+ return a - b
+}
+
+function Simplex(vertices, adjacent, boundary) {
+ this.vertices = vertices
+ this.adjacent = adjacent
+ this.boundary = boundary
+ this.lastVisited = -1
+}
+
+Simplex.prototype.flip = function() {
+ var t = this.vertices[0]
+ this.vertices[0] = this.vertices[1]
+ this.vertices[1] = t
+ var u = this.adjacent[0]
+ this.adjacent[0] = this.adjacent[1]
+ this.adjacent[1] = u
+}
+
+function GlueFacet(vertices, cell, index) {
+ this.vertices = vertices
+ this.cell = cell
+ this.index = index
+}
+
+function compareGlue(a, b) {
+ return compareCell(a.vertices, b.vertices)
+}
+
+function bakeOrient(d) {
+ var code = ["function orient(){var tuple=this.tuple;return test("]
+ for(var i=0; i<=d; ++i) {
+ if(i > 0) {
+ code.push(",")
+ }
+ code.push("tuple[", i, "]")
+ }
+ code.push(")}return orient")
+ var proc = new Function("test", code.join(""))
+ var test = orient[d+1]
+ if(!test) {
+ test = orient
+ }
+ return proc(test)
+}
+
+var BAKED = []
+
+function Triangulation(dimension, vertices, simplices) {
+ this.dimension = dimension
+ this.vertices = vertices
+ this.simplices = simplices
+ this.interior = simplices.filter(function(c) {
+ return !c.boundary
+ })
+
+ this.tuple = new Array(dimension+1)
+ for(var i=0; i<=dimension; ++i) {
+ this.tuple[i] = this.vertices[i]
+ }
+
+ var o = BAKED[dimension]
+ if(!o) {
+ o = BAKED[dimension] = bakeOrient(dimension)
+ }
+ this.orient = o
+}
+
+var proto = Triangulation.prototype
+
+//Degenerate situation where we are on boundary, but coplanar to face
+proto.handleBoundaryDegeneracy = function(cell, point) {
+ var d = this.dimension
+ var n = this.vertices.length - 1
+ var tuple = this.tuple
+ var verts = this.vertices
+
+ //Dumb solution: Just do dfs from boundary cell until we find any peak, or terminate
+ var toVisit = [ cell ]
+ cell.lastVisited = -n
+ while(toVisit.length > 0) {
+ cell = toVisit.pop()
+ var cellVerts = cell.vertices
+ var cellAdj = cell.adjacent
+ for(var i=0; i<=d; ++i) {
+ var neighbor = cellAdj[i]
+ if(!neighbor.boundary || neighbor.lastVisited <= -n) {
+ continue
+ }
+ var nv = neighbor.vertices
+ for(var j=0; j<=d; ++j) {
+ var vv = nv[j]
+ if(vv < 0) {
+ tuple[j] = point
+ } else {
+ tuple[j] = verts[vv]
+ }
+ }
+ var o = this.orient()
+ if(o > 0) {
+ return neighbor
+ }
+ neighbor.lastVisited = -n
+ if(o === 0) {
+ toVisit.push(neighbor)
+ }
+ }
+ }
+ return null
+}
+
+proto.walk = function(point, random) {
+ //Alias local properties
+ var n = this.vertices.length - 1
+ var d = this.dimension
+ var verts = this.vertices
+ var tuple = this.tuple
+
+ //Compute initial jump cell
+ var initIndex = random ? (this.interior.length * Math.random())|0 : (this.interior.length-1)
+ var cell = this.interior[ initIndex ]
+
+ //Start walking
+outerLoop:
+ while(!cell.boundary) {
+ var cellVerts = cell.vertices
+ var cellAdj = cell.adjacent
+
+ for(var i=0; i<=d; ++i) {
+ tuple[i] = verts[cellVerts[i]]
+ }
+ cell.lastVisited = n
+
+ //Find farthest adjacent cell
+ for(var i=0; i<=d; ++i) {
+ var neighbor = cellAdj[i]
+ if(neighbor.lastVisited >= n) {
+ continue
+ }
+ var prev = tuple[i]
+ tuple[i] = point
+ var o = this.orient()
+ tuple[i] = prev
+ if(o < 0) {
+ cell = neighbor
+ continue outerLoop
+ } else {
+ if(!neighbor.boundary) {
+ neighbor.lastVisited = n
+ } else {
+ neighbor.lastVisited = -n
+ }
+ }
+ }
+ return
+ }
+
+ return cell
+}
+
+proto.addPeaks = function(point, cell) {
+ var n = this.vertices.length - 1
+ var d = this.dimension
+ var verts = this.vertices
+ var tuple = this.tuple
+ var interior = this.interior
+ var simplices = this.simplices
+
+ //Walking finished at boundary, time to add peaks
+ var tovisit = [ cell ]
+
+ //Stretch initial boundary cell into a peak
+ cell.lastVisited = n
+ cell.vertices[cell.vertices.indexOf(-1)] = n
+ cell.boundary = false
+ interior.push(cell)
+
+ //Record a list of all new boundaries created by added peaks so we can glue them together when we are all done
+ var glueFacets = []
+
+ //Do a traversal of the boundary walking outward from starting peak
+ while(tovisit.length > 0) {
+ //Pop off peak and walk over adjacent cells
+ var cell = tovisit.pop()
+ var cellVerts = cell.vertices
+ var cellAdj = cell.adjacent
+ var indexOfN = cellVerts.indexOf(n)
+ if(indexOfN < 0) {
+ continue
+ }
+
+ for(var i=0; i<=d; ++i) {
+ if(i === indexOfN) {
+ continue
+ }
+
+ //For each boundary neighbor of the cell
+ var neighbor = cellAdj[i]
+ if(!neighbor.boundary || neighbor.lastVisited >= n) {
+ continue
+ }
+
+ var nv = neighbor.vertices
+
+ //Test if neighbor is a peak
+ if(neighbor.lastVisited !== -n) {
+ //Compute orientation of p relative to each boundary peak
+ var indexOfNeg1 = 0
+ for(var j=0; j<=d; ++j) {
+ if(nv[j] < 0) {
+ indexOfNeg1 = j
+ tuple[j] = point
+ } else {
+ tuple[j] = verts[nv[j]]
+ }
+ }
+ var o = this.orient()
+
+ //Test if neighbor cell is also a peak
+ if(o > 0) {
+ nv[indexOfNeg1] = n
+ neighbor.boundary = false
+ interior.push(neighbor)
+ tovisit.push(neighbor)
+ neighbor.lastVisited = n
+ continue
+ } else {
+ neighbor.lastVisited = -n
+ }
+ }
+
+ var na = neighbor.adjacent
+
+ //Otherwise, replace neighbor with new face
+ var vverts = cellVerts.slice()
+ var vadj = cellAdj.slice()
+ var ncell = new Simplex(vverts, vadj, true)
+ simplices.push(ncell)
+
+ //Connect to neighbor
+ var opposite = na.indexOf(cell)
+ if(opposite < 0) {
+ continue
+ }
+ na[opposite] = ncell
+ vadj[indexOfN] = neighbor
+
+ //Connect to cell
+ vverts[i] = -1
+ vadj[i] = cell
+ cellAdj[i] = ncell
+
+ //Flip facet
+ ncell.flip()
+
+ //Add to glue list
+ for(var j=0; j<=d; ++j) {
+ var uu = vverts[j]
+ if(uu < 0 || uu === n) {
+ continue
+ }
+ var nface = new Array(d-1)
+ var nptr = 0
+ for(var k=0; k<=d; ++k) {
+ var vv = vverts[k]
+ if(vv < 0 || k === j) {
+ continue
+ }
+ nface[nptr++] = vv
+ }
+ glueFacets.push(new GlueFacet(nface, ncell, j))
+ }
+ }
+ }
+
+ //Glue boundary facets together
+ glueFacets.sort(compareGlue)
+
+ for(var i=0; i+1= 0) {
+ bcell[ptr++] = cv[j]
+ } else {
+ parity = j&1
+ }
+ }
+ if(parity === (d&1)) {
+ var t = bcell[0]
+ bcell[0] = bcell[1]
+ bcell[1] = t
+ }
+ boundary.push(bcell)
+ }
+ }
+ return boundary
+}
+
+function incrementalConvexHull(points, randomSearch) {
+ var n = points.length
+ if(n === 0) {
+ throw new Error("Must have at least d+1 points")
+ }
+ var d = points[0].length
+ if(n <= d) {
+ throw new Error("Must input at least d+1 points")
+ }
+
+ //FIXME: This could be degenerate, but need to select d+1 non-coplanar points to bootstrap process
+ var initialSimplex = points.slice(0, d+1)
+
+ //Make sure initial simplex is positively oriented
+ var o = orient.apply(void 0, initialSimplex)
+ if(o === 0) {
+ throw new Error("Input not in general position")
+ }
+ var initialCoords = new Array(d+1)
+ for(var i=0; i<=d; ++i) {
+ initialCoords[i] = i
+ }
+ if(o < 0) {
+ initialCoords[0] = 1
+ initialCoords[1] = 0
+ }
+
+ //Create initial topological index, glue pointers together (kind of messy)
+ var initialCell = new Simplex(initialCoords, new Array(d+1), false)
+ var boundary = initialCell.adjacent
+ var list = new Array(d+2)
+ for(var i=0; i<=d; ++i) {
+ var verts = initialCoords.slice()
+ for(var j=0; j<=d; ++j) {
+ if(j === i) {
+ verts[j] = -1
+ }
+ }
+ var t = verts[0]
+ verts[0] = verts[1]
+ verts[1] = t
+ var cell = new Simplex(verts, new Array(d+1), true)
+ boundary[i] = cell
+ list[i] = cell
+ }
+ list[d+1] = initialCell
+ for(var i=0; i<=d; ++i) {
+ var verts = boundary[i].vertices
+ var adj = boundary[i].adjacent
+ for(var j=0; j<=d; ++j) {
+ var v = verts[j]
+ if(v < 0) {
+ adj[j] = initialCell
+ continue
+ }
+ for(var k=0; k<=d; ++k) {
+ if(boundary[k].vertices.indexOf(v) < 0) {
+ adj[j] = boundary[k]
+ }
+ }
+ }
+ }
+
+ //Initialize triangles
+ var triangles = new Triangulation(d, initialSimplex, list)
+
+ //Insert remaining points
+ var useRandom = !!randomSearch
+ for(var i=d+1; i 3*(weight+1)) {
+ rebuildWithInterval(this, interval)
+ } else {
+ this.left.insert(interval)
+ }
+ } else {
+ this.left = createIntervalTree([interval])
+ }
+ } else if(interval[0] > this.mid) {
+ if(this.right) {
+ if(4*(this.right.count+1) > 3*(weight+1)) {
+ rebuildWithInterval(this, interval)
+ } else {
+ this.right.insert(interval)
+ }
+ } else {
+ this.right = createIntervalTree([interval])
+ }
+ } else {
+ var l = bounds.ge(this.leftPoints, interval, compareBegin)
+ var r = bounds.ge(this.rightPoints, interval, compareEnd)
+ this.leftPoints.splice(l, 0, interval)
+ this.rightPoints.splice(r, 0, interval)
+ }
+}
+
+proto.remove = function(interval) {
+ var weight = this.count - this.leftPoints
+ if(interval[1] < this.mid) {
+ if(!this.left) {
+ return NOT_FOUND
+ }
+ var rw = this.right ? this.right.count : 0
+ if(4 * rw > 3 * (weight-1)) {
+ return rebuildWithoutInterval(this, interval)
+ }
+ var r = this.left.remove(interval)
+ if(r === EMPTY) {
+ this.left = null
+ this.count -= 1
+ return SUCCESS
+ } else if(r === SUCCESS) {
+ this.count -= 1
+ }
+ return r
+ } else if(interval[0] > this.mid) {
+ if(!this.right) {
+ return NOT_FOUND
+ }
+ var lw = this.left ? this.left.count : 0
+ if(4 * lw > 3 * (weight-1)) {
+ return rebuildWithoutInterval(this, interval)
+ }
+ var r = this.right.remove(interval)
+ if(r === EMPTY) {
+ this.right = null
+ this.count -= 1
+ return SUCCESS
+ } else if(r === SUCCESS) {
+ this.count -= 1
+ }
+ return r
+ } else {
+ if(this.count === 1) {
+ if(this.leftPoints[0] === interval) {
+ return EMPTY
+ } else {
+ return NOT_FOUND
+ }
+ }
+ if(this.leftPoints.length === 1 && this.leftPoints[0] === interval) {
+ if(this.left && this.right) {
+ var p = this
+ var n = this.left
+ while(n.right) {
+ p = n
+ n = n.right
+ }
+ if(p === this) {
+ n.right = this.right
+ } else {
+ var l = this.left
+ var r = this.right
+ p.count -= n.count
+ p.right = n.left
+ n.left = l
+ n.right = r
+ }
+ copy(this, n)
+ this.count = (this.left?this.left.count:0) + (this.right?this.right.count:0) + this.leftPoints.length
+ } else if(this.left) {
+ copy(this, this.left)
+ } else {
+ copy(this, this.right)
+ }
+ return SUCCESS
+ }
+ for(var l = bounds.ge(this.leftPoints, interval, compareBegin); l=0 && arr[i][1] >= lo; --i) {
+ var r = cb(arr[i])
+ if(r) { return r }
+ }
+}
+
+function reportRange(arr, cb) {
+ for(var i=0; i this.mid) {
+ if(this.right) {
+ var r = this.right.queryPoint(x, cb)
+ if(r) { return r }
+ }
+ return reportRightRange(this.rightPoints, x, cb)
+ } else {
+ return reportRange(this.leftPoints, cb)
+ }
+}
+
+proto.queryInterval = function(lo, hi, cb) {
+ if(lo < this.mid && this.left) {
+ var r = this.left.queryInterval(lo, hi, cb)
+ if(r) { return r }
+ }
+ if(hi > this.mid && this.right) {
+ var r = this.right.queryInterval(lo, hi, cb)
+ if(r) { return r }
+ }
+ if(hi < this.mid) {
+ return reportLeftRange(this.leftPoints, hi, cb)
+ } else if(lo > this.mid) {
+ return reportRightRange(this.rightPoints, lo, cb)
+ } else {
+ return reportRange(this.leftPoints, cb)
+ }
+}
+
+function compareNumbers(a, b) {
+ return a - b
+}
+
+function compareBegin(a, b) {
+ var d = a[0] - b[0]
+ if(d) { return d }
+ return a[1] - b[1]
+}
+
+function compareEnd(a, b) {
+ var d = a[1] - b[1]
+ if(d) { return d }
+ return a[0] - b[0]
+}
+
+function createIntervalTree(intervals) {
+ if(intervals.length === 0) {
+ return null
+ }
+ var pts = []
+ for(var i=0; i>1]
+
+ var leftIntervals = []
+ var rightIntervals = []
+ var centerIntervals = []
+ for(var i=0; i
+ * @license MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+ return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+}
+
+function isBuffer (obj) {
+ return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+}
+
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+ return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
+
+},{}],402:[function(_dereq_,module,exports){
+'use strict';
+module.exports = typeof navigator !== 'undefined' &&
+ (/MSIE/.test(navigator.userAgent) || /Trident\//.test(navigator.appVersion));
+
+},{}],403:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = isMobile;
+module.exports.isMobile = isMobile;
+
+var mobileRE = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+
+var tabletRE = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino|android|ipad|playbook|silk/i;
+
+function isMobile (opts) {
+ if (!opts) opts = {}
+ var ua = opts.ua
+ if (!ua && typeof navigator !== 'undefined') ua = navigator.userAgent;
+ if (ua && ua.headers && typeof ua.headers['user-agent'] === 'string') {
+ ua = ua.headers['user-agent'];
+ }
+ if (typeof ua !== 'string') return false;
+
+ return opts.tablet
+ ? tabletRE.test(ua)
+ : mobileRE.test(ua);
+}
+
+},{}],404:[function(_dereq_,module,exports){
+'use strict';
+module.exports = function (x) {
+ var type = typeof x;
+ return x !== null && (type === 'object' || type === 'function');
+};
+
+},{}],405:[function(_dereq_,module,exports){
+'use strict';
+var toString = Object.prototype.toString;
+
+module.exports = function (x) {
+ var prototype;
+ return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
+};
+
+},{}],406:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * Is this string all whitespace?
+ * This solution kind of makes my brain hurt, but it's significantly faster
+ * than !str.trim() or any other solution I could find.
+ *
+ * whitespace codes from: http://en.wikipedia.org/wiki/Whitespace_character
+ * and verified with:
+ *
+ * for(var i = 0; i < 65536; i++) {
+ * var s = String.fromCharCode(i);
+ * if(+s===0 && !s.trim()) console.log(i, s);
+ * }
+ *
+ * which counts a couple of these as *not* whitespace, but finds nothing else
+ * that *is* whitespace. Note that charCodeAt stops at 16 bits, but it appears
+ * that there are no whitespace characters above this, and code points above
+ * this do not map onto white space characters.
+ */
+
+module.exports = function(str){
+ var l = str.length,
+ a;
+ for(var i = 0; i < l; i++) {
+ a = str.charCodeAt(i);
+ if((a < 9 || a > 13) && (a !== 32) && (a !== 133) && (a !== 160) &&
+ (a !== 5760) && (a !== 6158) && (a < 8192 || a > 8205) &&
+ (a !== 8232) && (a !== 8233) && (a !== 8239) && (a !== 8287) &&
+ (a !== 8288) && (a !== 12288) && (a !== 65279)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+},{}],407:[function(_dereq_,module,exports){
+'use strict'
+
+module.exports = function isPath(str) {
+ if (typeof str !== 'string') return false
+
+ str = str.trim()
+
+ // https://www.w3.org/TR/SVG/paths.html#PathDataBNF
+ if (/^[mzlhvcsqta]\s*[-+.0-9][^mlhvzcsqta]+/i.test(str) && /[\dz]$/i.test(str) && str.length > 4) return true
+
+ return false
+}
+
+},{}],408:[function(_dereq_,module,exports){
+function lerp(v0, v1, t) {
+ return v0*(1-t)+v1*t
+}
+module.exports = lerp
+},{}],409:[function(_dereq_,module,exports){
+(function (global){
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+ typeof define === 'function' && define.amd ? define(factory) :
+ (global.mapboxgl = factory());
+}(this, (function () { 'use strict';
+
+/* eslint-disable */
+
+var shared, worker, mapboxgl;
+// define gets called three times: one for each chunk. we rely on the order
+// they're imported to know which is which
+function define(_, chunk) {
+if (!shared) {
+ shared = chunk;
+} else if (!worker) {
+ worker = chunk;
+} else {
+ var workerBundleString = 'var sharedChunk = {}; (' + shared + ')(sharedChunk); (' + worker + ')(sharedChunk);'
+
+ var sharedChunk = {};
+ shared(sharedChunk);
+ mapboxgl = chunk(sharedChunk);
+ mapboxgl.workerUrl = window.URL.createObjectURL(new Blob([workerBundleString], { type: 'text/javascript' }));
+}
+}
+
+
+define(["exports"],function(t){"use strict";var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function r(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}function n(t,e){return t(e={exports:{}},e.exports),e.exports}var i=o;function o(t,e,r,n){this.cx=3*t,this.bx=3*(r-t)-this.cx,this.ax=1-this.cx-this.bx,this.cy=3*e,this.by=3*(n-e)-this.cy,this.ay=1-this.cy-this.by,this.p1x=t,this.p1y=n,this.p2x=r,this.p2y=n;}o.prototype.sampleCurveX=function(t){return((this.ax*t+this.bx)*t+this.cx)*t},o.prototype.sampleCurveY=function(t){return((this.ay*t+this.by)*t+this.cy)*t},o.prototype.sampleCurveDerivativeX=function(t){return(3*this.ax*t+2*this.bx)*t+this.cx},o.prototype.solveCurveX=function(t,e){var r,n,i,o,a;for(void 0===e&&(e=1e-6),i=t,a=0;a<8;a++){if(o=this.sampleCurveX(i)-t,Math.abs(o)(n=1))return n;for(;ro?r=i:n=i,i=.5*(n-r)+r;}return i},o.prototype.solve=function(t,e){return this.sampleCurveY(this.solveCurveX(t,e))};var a=function(t,e,r){this.column=t,this.row=e,this.zoom=r;};a.prototype.clone=function(){return new a(this.column,this.row,this.zoom)},a.prototype.zoomTo=function(t){return this.clone()._zoomTo(t)},a.prototype.sub=function(t){return this.clone()._sub(t)},a.prototype._zoomTo=function(t){var e=Math.pow(2,t-this.zoom);return this.column*=e,this.row*=e,this.zoom=t,this},a.prototype._sub=function(t){return t=t.zoomTo(this.zoom),this.column-=t.column,this.row-=t.row,this};var s=u;function u(t,e){this.x=t,this.y=e;}function l(t,e,r,n){var o=new i(t,e,r,n);return function(t){return o.solve(t)}}u.prototype={clone:function(){return new u(this.x,this.y)},add:function(t){return this.clone()._add(t)},sub:function(t){return this.clone()._sub(t)},multByPoint:function(t){return this.clone()._multByPoint(t)},divByPoint:function(t){return this.clone()._divByPoint(t)},mult:function(t){return this.clone()._mult(t)},div:function(t){return this.clone()._div(t)},rotate:function(t){return this.clone()._rotate(t)},rotateAround:function(t,e){return this.clone()._rotateAround(t,e)},matMult:function(t){return this.clone()._matMult(t)},unit:function(){return this.clone()._unit()},perp:function(){return this.clone()._perp()},round:function(){return this.clone()._round()},mag:function(){return Math.sqrt(this.x*this.x+this.y*this.y)},equals:function(t){return this.x===t.x&&this.y===t.y},dist:function(t){return Math.sqrt(this.distSqr(t))},distSqr:function(t){var e=t.x-this.x,r=t.y-this.y;return e*e+r*r},angle:function(){return Math.atan2(this.y,this.x)},angleTo:function(t){return Math.atan2(this.y-t.y,this.x-t.x)},angleWith:function(t){return this.angleWithSep(t.x,t.y)},angleWithSep:function(t,e){return Math.atan2(this.x*e-this.y*t,this.x*t+this.y*e)},_matMult:function(t){var e=t[0]*this.x+t[1]*this.y,r=t[2]*this.x+t[3]*this.y;return this.x=e,this.y=r,this},_add:function(t){return this.x+=t.x,this.y+=t.y,this},_sub:function(t){return this.x-=t.x,this.y-=t.y,this},_mult:function(t){return this.x*=t,this.y*=t,this},_div:function(t){return this.x/=t,this.y/=t,this},_multByPoint:function(t){return this.x*=t.x,this.y*=t.y,this},_divByPoint:function(t){return this.x/=t.x,this.y/=t.y,this},_unit:function(){return this._div(this.mag()),this},_perp:function(){var t=this.y;return this.y=this.x,this.x=-t,this},_rotate:function(t){var e=Math.cos(t),r=Math.sin(t),n=e*this.x-r*this.y,i=r*this.x+e*this.y;return this.x=n,this.y=i,this},_rotateAround:function(t,e){var r=Math.cos(t),n=Math.sin(t),i=e.x+r*(this.x-e.x)-n*(this.y-e.y),o=e.y+n*(this.x-e.x)+r*(this.y-e.y);return this.x=i,this.y=o,this},_round:function(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this}},u.convert=function(t){return t instanceof u?t:Array.isArray(t)?new u(t[0],t[1]):t};var p=l(.25,.1,.25,1);function c(t,e,r){return Math.min(r,Math.max(e,t))}function h(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];for(var n=0,i=e;n(e.y-t.y)*(r.x-t.x)}function _(t){for(var e=0,r=0,n=t.length,i=n-1,o=void 0,a=void 0;r=200&&r.status<300&&r.response?e(null,{data:n,cacheControl:r.getResponseHeader("Cache-Control"),expires:r.getResponseHeader("Expires")}):e(new k(r.statusText,r.status,t.url));},r.send(),r};function M(t,e,r){r[t]=r[t]||[],r[t].push(e);}function V(t,e,r){if(r&&r[t]){var n=r[t].indexOf(e);-1!==n&&r[t].splice(n,1);}}var B=function(t,e){void 0===e&&(e={}),h(this,e),this.type=t;},C=function(t){function e(e,r){void 0===r&&(r={}),t.call(this,"error",h({error:e},r));}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(B),I=function(){};I.prototype.on=function(t,e){return this._listeners=this._listeners||{},M(t,e,this._listeners),this},I.prototype.off=function(t,e){return V(t,e,this._listeners),V(t,e,this._oneTimeListeners),this},I.prototype.once=function(t,e){return this._oneTimeListeners=this._oneTimeListeners||{},M(t,e,this._oneTimeListeners),this},I.prototype.fire=function(t){"string"==typeof t&&(t=new B(t,arguments[1]||{}));var e=t.type;if(this.listens(e)){t.target=this;for(var r=0,n=this._listeners&&this._listeners[e]?this._listeners[e].slice():[];r0||this._oneTimeListeners&&this._oneTimeListeners[t]&&this._oneTimeListeners[t].length>0||this._eventedParent&&this._eventedParent.listens(t)},I.prototype.setEventedParent=function(t,e){return this._eventedParent=t,this._eventedParentData=e,this};var E={$version:8,$root:{version:{required:!0,type:"enum",values:[8]},name:{type:"string"},metadata:{type:"*"},center:{type:"array",value:"number"},zoom:{type:"number"},bearing:{type:"number",default:0,period:360,units:"degrees"},pitch:{type:"number",default:0,units:"degrees"},light:{type:"light"},sources:{required:!0,type:"sources"},sprite:{type:"string"},glyphs:{type:"string"},transition:{type:"transition"},layers:{required:!0,type:"array",value:"layer"}},sources:{"*":{type:"source"}},source:["source_vector","source_raster","source_raster_dem","source_geojson","source_video","source_image"],source_vector:{type:{required:!0,type:"enum",values:{vector:{}}},url:{type:"string"},tiles:{type:"array",value:"string"},bounds:{type:"array",value:"number",length:4,default:[-180,-85.0511,180,85.0511]},minzoom:{type:"number",default:0},maxzoom:{type:"number",default:22},attribution:{type:"string"},"*":{type:"*"}},source_raster:{type:{required:!0,type:"enum",values:{raster:{}}},url:{type:"string"},tiles:{type:"array",value:"string"},bounds:{type:"array",value:"number",length:4,default:[-180,-85.0511,180,85.0511]},minzoom:{type:"number",default:0},maxzoom:{type:"number",default:22},tileSize:{type:"number",default:512,units:"pixels"},scheme:{type:"enum",values:{xyz:{},tms:{}},default:"xyz"},attribution:{type:"string"},"*":{type:"*"}},source_raster_dem:{type:{required:!0,type:"enum",values:{"raster-dem":{}}},url:{type:"string"},tiles:{type:"array",value:"string"},bounds:{type:"array",value:"number",length:4,default:[-180,-85.0511,180,85.0511]},minzoom:{type:"number",default:0},maxzoom:{type:"number",default:22},tileSize:{type:"number",default:512,units:"pixels"},attribution:{type:"string"},encoding:{type:"enum",values:{terrarium:{},mapbox:{}},default:"mapbox"},"*":{type:"*"}},source_geojson:{type:{required:!0,type:"enum",values:{geojson:{}}},data:{type:"*"},maxzoom:{type:"number",default:18},buffer:{type:"number",default:128,maximum:512,minimum:0},tolerance:{type:"number",default:.375},cluster:{type:"boolean",default:!1},clusterRadius:{type:"number",default:50,minimum:0},clusterMaxZoom:{type:"number"},lineMetrics:{type:"boolean",default:!1}},source_video:{type:{required:!0,type:"enum",values:{video:{}}},urls:{required:!0,type:"array",value:"string"},coordinates:{required:!0,type:"array",length:4,value:{type:"array",length:2,value:"number"}}},source_image:{type:{required:!0,type:"enum",values:{image:{}}},url:{required:!0,type:"string"},coordinates:{required:!0,type:"array",length:4,value:{type:"array",length:2,value:"number"}}},layer:{id:{type:"string",required:!0},type:{type:"enum",values:{fill:{},line:{},symbol:{},circle:{},heatmap:{},"fill-extrusion":{},raster:{},hillshade:{},background:{}},required:!0},metadata:{type:"*"},source:{type:"string"},"source-layer":{type:"string"},minzoom:{type:"number",minimum:0,maximum:24},maxzoom:{type:"number",minimum:0,maximum:24},filter:{type:"filter"},layout:{type:"layout"},paint:{type:"paint"}},layout:["layout_fill","layout_line","layout_circle","layout_heatmap","layout_fill-extrusion","layout_symbol","layout_raster","layout_hillshade","layout_background"],layout_background:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_fill:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_circle:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_heatmap:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_line:{"line-cap":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{butt:{},round:{},square:{}},default:"butt"},"line-join":{type:"enum",function:"piecewise-constant","zoom-function":!0,"property-function":!0,values:{bevel:{},round:{},miter:{}},default:"miter"},"line-miter-limit":{type:"number",default:2,function:"interpolated","zoom-function":!0,requires:[{"line-join":"miter"}]},"line-round-limit":{type:"number",default:1.05,function:"interpolated","zoom-function":!0,requires:[{"line-join":"round"}]},visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_symbol:{"symbol-placement":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{point:{},line:{}},default:"point"},"symbol-spacing":{type:"number",default:250,minimum:1,function:"interpolated","zoom-function":!0,units:"pixels",requires:[{"symbol-placement":"line"}]},"symbol-avoid-edges":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1},"icon-allow-overlap":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["icon-image"]},"icon-ignore-placement":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["icon-image"]},"icon-optional":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["icon-image","text-field"]},"icon-rotation-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{},auto:{}},default:"auto",requires:["icon-image"]},"icon-size":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,units:"factor of the original icon size",requires:["icon-image"]},"icon-text-fit":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{none:{},width:{},height:{},both:{}},default:"none",requires:["icon-image","text-field"]},"icon-text-fit-padding":{type:"array",value:"number",length:4,default:[0,0,0,0],units:"pixels",function:"interpolated","zoom-function":!0,requires:["icon-image","text-field",{"icon-text-fit":["both","width","height"]}]},"icon-image":{type:"string",function:"piecewise-constant","zoom-function":!0,"property-function":!0,tokens:!0},"icon-rotate":{type:"number",default:0,period:360,function:"interpolated","zoom-function":!0,"property-function":!0,units:"degrees",requires:["icon-image"]},"icon-padding":{type:"number",default:2,minimum:0,function:"interpolated","zoom-function":!0,units:"pixels",requires:["icon-image"]},"icon-keep-upright":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["icon-image",{"icon-rotation-alignment":"map"},{"symbol-placement":"line"}]},"icon-offset":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,"property-function":!0,requires:["icon-image"]},"icon-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,"property-function":!0,values:{center:{},left:{},right:{},top:{},bottom:{},"top-left":{},"top-right":{},"bottom-left":{},"bottom-right":{}},default:"center",requires:["icon-image"]},"icon-pitch-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{},auto:{}},default:"auto",requires:["icon-image"]},"text-pitch-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{},auto:{}},default:"auto",requires:["text-field"]},"text-rotation-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{},auto:{}},default:"auto",requires:["text-field"]},"text-field":{type:"string",function:"piecewise-constant","zoom-function":!0,"property-function":!0,default:"",tokens:!0},"text-font":{type:"array",value:"string",function:"piecewise-constant","zoom-function":!0,"property-function":!0,default:["Open Sans Regular","Arial Unicode MS Regular"],requires:["text-field"]},"text-size":{type:"number",default:16,minimum:0,units:"pixels",function:"interpolated","zoom-function":!0,"property-function":!0,requires:["text-field"]},"text-max-width":{type:"number",default:10,minimum:0,units:"ems",function:"interpolated","zoom-function":!0,"property-function":!0,requires:["text-field"]},"text-line-height":{type:"number",default:1.2,units:"ems",function:"interpolated","zoom-function":!0,requires:["text-field"]},"text-letter-spacing":{type:"number",default:0,units:"ems",function:"interpolated","zoom-function":!0,"property-function":!0,requires:["text-field"]},"text-justify":{type:"enum",function:"piecewise-constant","zoom-function":!0,"property-function":!0,values:{left:{},center:{},right:{}},default:"center",requires:["text-field"]},"text-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,"property-function":!0,values:{center:{},left:{},right:{},top:{},bottom:{},"top-left":{},"top-right":{},"bottom-left":{},"bottom-right":{}},default:"center",requires:["text-field"]},"text-max-angle":{type:"number",default:45,units:"degrees",function:"interpolated","zoom-function":!0,requires:["text-field",{"symbol-placement":"line"}]},"text-rotate":{type:"number",default:0,period:360,units:"degrees",function:"interpolated","zoom-function":!0,"property-function":!0,requires:["text-field"]},"text-padding":{type:"number",default:2,minimum:0,units:"pixels",function:"interpolated","zoom-function":!0,requires:["text-field"]},"text-keep-upright":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!0,requires:["text-field",{"text-rotation-alignment":"map"},{"symbol-placement":"line"}]},"text-transform":{type:"enum",function:"piecewise-constant","zoom-function":!0,"property-function":!0,values:{none:{},uppercase:{},lowercase:{}},default:"none",requires:["text-field"]},"text-offset":{type:"array",value:"number",units:"ems",function:"interpolated","zoom-function":!0,"property-function":!0,length:2,default:[0,0],requires:["text-field"]},"text-allow-overlap":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["text-field"]},"text-ignore-placement":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["text-field"]},"text-optional":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!1,requires:["text-field","icon-image"]},visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_raster:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},layout_hillshade:{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},filter:{type:"array",value:"*"},filter_operator:{type:"enum",values:{"==":{},"!=":{},">":{},">=":{},"<":{},"<=":{},in:{},"!in":{},all:{},any:{},none:{},has:{},"!has":{}}},geometry_type:{type:"enum",values:{Point:{},LineString:{},Polygon:{}}},function_stop:{type:"array",minimum:0,maximum:22,value:["number","color"],length:2},expression:{type:"array",value:"*",minimum:1},expression_name:{type:"enum",values:{let:{group:"Variable binding"},var:{group:"Variable binding"},literal:{group:"Types"},array:{group:"Types"},at:{group:"Lookup"},case:{group:"Decision"},match:{group:"Decision"},coalesce:{group:"Decision"},step:{group:"Ramps, scales, curves"},interpolate:{group:"Ramps, scales, curves"},ln2:{group:"Math"},pi:{group:"Math"},e:{group:"Math"},typeof:{group:"Types"},string:{group:"Types"},number:{group:"Types"},boolean:{group:"Types"},object:{group:"Types"},collator:{group:"Types"},"to-string":{group:"Types"},"to-number":{group:"Types"},"to-boolean":{group:"Types"},"to-rgba":{group:"Color"},"to-color":{group:"Types"},rgb:{group:"Color"},rgba:{group:"Color"},get:{group:"Lookup"},has:{group:"Lookup"},length:{group:"Lookup"},properties:{group:"Feature data"},"geometry-type":{group:"Feature data"},id:{group:"Feature data"},zoom:{group:"Zoom"},"heatmap-density":{group:"Heatmap"},"line-progress":{group:"Heatmap"},"+":{group:"Math"},"*":{group:"Math"},"-":{group:"Math"},"/":{group:"Math"},"%":{group:"Math"},"^":{group:"Math"},sqrt:{group:"Math"},log10:{group:"Math"},ln:{group:"Math"},log2:{group:"Math"},sin:{group:"Math"},cos:{group:"Math"},tan:{group:"Math"},asin:{group:"Math"},acos:{group:"Math"},atan:{group:"Math"},min:{group:"Math"},max:{group:"Math"},round:{group:"Math"},abs:{group:"Math"},ceil:{group:"Math"},floor:{group:"Math"},"==":{group:"Decision"},"!=":{group:"Decision"},">":{group:"Decision"},"<":{group:"Decision"},">=":{group:"Decision"},"<=":{group:"Decision"},all:{group:"Decision"},any:{group:"Decision"},"!":{group:"Decision"},"is-supported-script":{group:"String"},upcase:{group:"String"},downcase:{group:"String"},concat:{group:"String"},"resolved-locale":{group:"String"}}},light:{anchor:{type:"enum",default:"viewport",values:{map:{},viewport:{}},transition:!1,"zoom-function":!0,"property-function":!1,function:"piecewise-constant"},position:{type:"array",default:[1.15,210,30],length:3,value:"number",transition:!0,function:"interpolated","zoom-function":!0,"property-function":!1},color:{type:"color",default:"#ffffff",function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},intensity:{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint:["paint_fill","paint_line","paint_circle","paint_heatmap","paint_fill-extrusion","paint_symbol","paint_raster","paint_hillshade","paint_background"],paint_fill:{"fill-antialias":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!0},"fill-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"fill-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"}]},"fill-outline-color":{type:"color",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"},{"fill-antialias":!0}]},"fill-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-translate"]},"fill-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0}},paint_line:{"line-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"line-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"line-pattern"}]},"line-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"line-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["line-translate"]},"line-width":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-gap-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-offset":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-dasharray":{type:"array",value:"number",function:"piecewise-constant","zoom-function":!0,minimum:0,transition:!0,units:"line widths",requires:[{"!":"line-pattern"}]},"line-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"line-gradient":{type:"color",function:"interpolated","zoom-function":!1,"property-function":!1,transition:!1,requires:[{"!":"line-dasharray"},{"!":"line-pattern"},{source:"geojson",has:{lineMetrics:!0}}]}},paint_circle:{"circle-radius":{type:"number",default:5,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-blur":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"circle-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["circle-translate"]},"circle-pitch-scale":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map"},"circle-pitch-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"circle-stroke-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-stroke-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-stroke-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0}},paint_heatmap:{"heatmap-radius":{type:"number",default:30,minimum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"heatmap-weight":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!1},"heatmap-intensity":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},"heatmap-color":{type:"color",default:["interpolate",["linear"],["heatmap-density"],0,"rgba(0, 0, 255, 0)",.1,"royalblue",.3,"cyan",.5,"lime",.7,"yellow",1,"red"],function:"interpolated","zoom-function":!1,"property-function":!1,transition:!1},"heatmap-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint_symbol:{"icon-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["icon-image","icon-translate"]},"text-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["text-field","text-translate"]}},paint_raster:{"raster-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-hue-rotate":{type:"number",default:0,period:360,function:"interpolated","zoom-function":!0,transition:!0,units:"degrees"},"raster-brightness-min":{type:"number",function:"interpolated","zoom-function":!0,default:0,minimum:0,maximum:1,transition:!0},"raster-brightness-max":{type:"number",function:"interpolated","zoom-function":!0,default:1,minimum:0,maximum:1,transition:!0},"raster-saturation":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-contrast":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-fade-duration":{type:"number",default:300,minimum:0,function:"interpolated","zoom-function":!0,transition:!1,units:"milliseconds"}},paint_hillshade:{"hillshade-illumination-direction":{type:"number",default:335,minimum:0,maximum:359,function:"interpolated","zoom-function":!0,transition:!1},"hillshade-illumination-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"hillshade-exaggeration":{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"hillshade-shadow-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-highlight-color":{type:"color",default:"#FFFFFF",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-accent-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0}},paint_background:{"background-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0,requires:[{"!":"background-pattern"}]},"background-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"background-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0}},transition:{duration:{type:"number",default:300,minimum:0,units:"milliseconds"},delay:{type:"number",default:0,minimum:0,units:"milliseconds"}},"layout_fill-extrusion":{visibility:{type:"enum",values:{visible:{},none:{}},default:"visible"}},function:{expression:{type:"expression"},stops:{type:"array",value:"function_stop"},base:{type:"number",default:1,minimum:0},property:{type:"string",default:"$zoom"},type:{type:"enum",values:{identity:{},exponential:{},interval:{},categorical:{}},default:"exponential"},colorSpace:{type:"enum",values:{rgb:{},lab:{},hcl:{}},default:"rgb"},default:{type:"*",required:!1}},"paint_fill-extrusion":{"fill-extrusion-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!1,default:1,minimum:0,maximum:1,transition:!0},"fill-extrusion-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-extrusion-pattern"}]},"fill-extrusion-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-extrusion-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-extrusion-translate"]},"fill-extrusion-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"fill-extrusion-height":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0},"fill-extrusion-base":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0,requires:["fill-extrusion-height"]}}},F=function(t,e,r,n){this.message=(t?t+": ":"")+r,n&&(this.identifier=n),null!=e&&e.__line__&&(this.line=e.__line__);};function P(t){var e=t.key,r=t.value;return r?[new F(e,r,"constants have been deprecated as of v8")]:[]}function T(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];for(var n=0,i=e;n":"value"===t.itemType.kind?"array":"array<"+e+">"}return t.kind}var G=[R,U,D,N,Z,K,H(J)];function Y(t,e){if("error"===e.kind)return null;if("array"===t.kind){if("array"===e.kind&&!Y(t.itemType,e.itemType)&&("number"!=typeof t.N||t.N===e.N))return null}else{if(t.kind===e.kind)return null;if("value"===t.kind)for(var r=0,n=G;r255?255:t}function i(t){return t<0?0:t>1?1:t}function o(t){return"%"===t[t.length-1]?n(parseFloat(t)/100*255):n(parseInt(t))}function a(t){return"%"===t[t.length-1]?i(parseFloat(t)/100):i(parseFloat(t))}function s(t,e,r){return r<0?r+=1:r>1&&(r-=1),6*r<1?t+(e-t)*r*6:2*r<1?e:3*r<2?t+(e-t)*(2/3-r)*6:t}try{e.parseCSSColor=function(t){var e,i=t.replace(/ /g,"").toLowerCase();if(i in r)return r[i].slice();if("#"===i[0])return 4===i.length?(e=parseInt(i.substr(1),16))>=0&&e<=4095?[(3840&e)>>4|(3840&e)>>8,240&e|(240&e)>>4,15&e|(15&e)<<4,1]:null:7===i.length&&(e=parseInt(i.substr(1),16))>=0&&e<=16777215?[(16711680&e)>>16,(65280&e)>>8,255&e,1]:null;var u=i.indexOf("("),l=i.indexOf(")");if(-1!==u&&l+1===i.length){var p=i.substr(0,u),c=i.substr(u+1,l-(u+1)).split(","),h=1;switch(p){case"rgba":if(4!==c.length)return null;h=a(c.pop());case"rgb":return 3!==c.length?null:[o(c[0]),o(c[1]),o(c[2]),h];case"hsla":if(4!==c.length)return null;h=a(c.pop());case"hsl":if(3!==c.length)return null;var f=(parseFloat(c[0])%360+360)%360/360,y=a(c[1]),d=a(c[2]),v=d<=.5?d*(y+1):d+y-d*y,m=2*d-v;return[n(255*s(m,v,f+1/3)),n(255*s(m,v,f)),n(255*s(m,v,f-1/3)),h];default:return null}}return null};}catch(t){}}).parseCSSColor,Q=function(t,e,r,n){void 0===n&&(n=1),this.r=t,this.g=e,this.b=r,this.a=n;};Q.parse=function(t){if(t){if(t instanceof Q)return t;if("string"==typeof t){var e=W(t);if(e)return new Q(e[0]/255*e[3],e[1]/255*e[3],e[2]/255*e[3],e[3])}}},Q.prototype.toString=function(){var t=this.toArray(),e=t[0],r=t[1],n=t[2],i=t[3];return"rgba("+Math.round(e)+","+Math.round(r)+","+Math.round(n)+","+i+")"},Q.prototype.toArray=function(){var t=this.r,e=this.g,r=this.b,n=this.a;return 0===n?[0,0,0,0]:[255*t/n,255*e/n,255*r/n,n]},Q.black=new Q(0,0,0,1),Q.white=new Q(1,1,1,1),Q.transparent=new Q(0,0,0,0);var tt=function(t,e,r){this.sensitivity=t?e?"variant":"case":e?"accent":"base",this.locale=r,this.collator=new Intl.Collator(this.locale?this.locale:[],{sensitivity:this.sensitivity,usage:"search"});};tt.prototype.compare=function(t,e){return this.collator.compare(t,e)},tt.prototype.resolvedLocale=function(){return new Intl.Collator(this.locale?this.locale:[]).resolvedOptions().locale};var et=function(t,e,r){this.type=$,this.locale=r,this.caseSensitive=t,this.diacriticSensitive=e;};function rt(t,e,r,n){return"number"==typeof t&&t>=0&&t<=255&&"number"==typeof e&&e>=0&&e<=255&&"number"==typeof r&&r>=0&&r<=255?void 0===n||"number"==typeof n&&n>=0&&n<=1?null:"Invalid rgba value ["+[t,e,r,n].join(", ")+"]: 'a' must be between 0 and 1.":"Invalid rgba value ["+("number"==typeof n?[t,e,r,n]:[t,e,r]).join(", ")+"]: 'r', 'g', and 'b' must be between 0 and 255."}function nt(t){if(null===t)return R;if("string"==typeof t)return D;if("boolean"==typeof t)return N;if("number"==typeof t)return U;if(t instanceof Q)return Z;if(t instanceof tt)return $;if(Array.isArray(t)){for(var e,r=t.length,n=0,i=t;n4)return e.error("Expected 1, 2, or 3 arguments, but found "+(t.length-1)+" instead.");var r,n;if(t.length>2){var i=t[1];if("string"!=typeof i||!(i in ut))return e.error('The item type argument of "array" must be one of string, number, boolean',1);r=ut[i];}else r=J;if(t.length>3){if("number"!=typeof t[2]||t[2]<0||t[2]!==Math.floor(t[2]))return e.error('The length argument to "array" must be a positive integer literal',2);n=t[2];}var o=H(r,n),a=e.parse(t[t.length-1],t.length-1,J);return a?new lt(o,a):null},lt.prototype.evaluate=function(t){var e=this.input.evaluate(t);if(Y(this.type,nt(e)))throw new ot("Expected value to be of type "+X(this.type)+", but found "+X(nt(e))+" instead.");return e},lt.prototype.eachChild=function(t){t(this.input);},lt.prototype.possibleOutputs=function(){return this.input.possibleOutputs()},lt.prototype.serialize=function(){var t=["array"],e=this.type.itemType;if("string"===e.kind||"number"===e.kind||"boolean"===e.kind){t.push(e.kind);var r=this.type.N;"number"==typeof r&&t.push(r);}return t.push(this.input.serialize()),t};var pt={"to-number":U,"to-color":Z},ct=function(t,e){this.type=t,this.args=e;};ct.parse=function(t,e){if(t.length<2)return e.error("Expected at least one argument.");for(var r=t[0],n=pt[r],i=[],o=1;o4?"Invalid rbga value "+JSON.stringify(e)+": expected an array containing either three or four numeric values.":rt(e[0],e[1],e[2],e[3])))return new Q(e[0]/255,e[1]/255,e[2]/255,e[3])}throw new ot(r||"Could not parse color from value '"+("string"==typeof e?e:JSON.stringify(e))+"'")}for(var a=null,s=0,u=this.args;s=0)return!1;var r=!0;return t.eachChild(function(t){r&&!vt(t,e)&&(r=!1);}),r}yt.prototype.evaluate=function(t){return this._evaluate(t,this.args)},yt.prototype.eachChild=function(t){this.args.forEach(t);},yt.prototype.possibleOutputs=function(){return[void 0]},yt.prototype.serialize=function(){return[this.name].concat(this.args.map(function(t){return t.serialize()}))},yt.parse=function(t,e){var r=t[0],n=yt.definitions[r];if(!n)return e.error('Unknown expression "'+r+'". If you wanted a literal array, use ["literal", [...]].',0);for(var i=Array.isArray(n)?n[0]:n.type,o=Array.isArray(n)?[[n[1],n[2]]]:n.overloads,a=o.filter(function(e){var r=e[0];return!Array.isArray(r)||r.length===t.length-1}),s=[],u=1;ur&&ee))throw new ot("Input is not a number.");o=a-1;}}return Math.max(a-1,0)}gt.prototype.parse=function(t,e,r,n,i){return void 0===i&&(i={}),e?this.concat(e,r,n)._parse(t,i):this._parse(t,i)},gt.prototype._parse=function(t,e){if(null!==t&&"string"!=typeof t&&"boolean"!=typeof t&&"number"!=typeof t||(t=["literal",t]),Array.isArray(t)){if(0===t.length)return this.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');var r=t[0];if("string"!=typeof r)return this.error("Expression name must be a string, but found "+typeof r+' instead. If you wanted a literal array, use ["literal", [...]].',0),null;var n=this.registry[r];if(n){var i=n.parse(t,this);if(!i)return null;if(this.expectedType){var o=this.expectedType,a=i.type;if("string"!==o.kind&&"number"!==o.kind&&"boolean"!==o.kind&&"object"!==o.kind||"value"!==a.kind)if("array"===o.kind&&"value"===a.kind)e.omitTypeAnnotations||(i=new lt(o,i));else if("color"!==o.kind||"value"!==a.kind&&"string"!==a.kind){if(this.checkSubtype(this.expectedType,i.type))return null}else e.omitTypeAnnotations||(i=new ct(o,[i]));else e.omitTypeAnnotations||(i=new st(o,[i]));}if(!(i instanceof it)&&function t(e){if(e instanceof mt)return t(e.boundExpression);if(e instanceof yt&&"error"===e.name)return!1;if(e instanceof et)return!1;var r=e instanceof ct||e instanceof st||e instanceof lt;var n=!0;e.eachChild(function(e){n=r?n&&t(e):n&&e instanceof it;});if(!n)return!1;return dt(e)&&vt(e,["zoom","heatmap-density","line-progress","is-supported-script"])}(i)){var s=new ft;try{i=new it(i.type,i.evaluate(s));}catch(t){return this.error(t.message),null}}return i}return this.error('Unknown expression "'+r+'". If you wanted a literal array, use ["literal", [...]].',0)}return void 0===t?this.error("'undefined' value invalid. Use null instead."):"object"==typeof t?this.error('Bare objects invalid. Use ["literal", {...}] instead.'):this.error("Expected an array, but found "+typeof t+" instead.")},gt.prototype.concat=function(t,e,r){var n="number"==typeof t?this.path.concat(t):this.path,i=r?this.scope.concat(r):this.scope;return new gt(this.registry,n,e||null,i,this.errors)},gt.prototype.error=function(t){for(var e=[],r=arguments.length-1;r-- >0;)e[r]=arguments[r+1];var n=""+this.key+e.map(function(t){return"["+t+"]"}).join("");this.errors.push(new j(n,t));},gt.prototype.checkSubtype=function(t,e){var r=Y(t,e);return r&&this.error(r),r};var bt=function(t,e,r){this.type=t,this.input=e,this.labels=[],this.outputs=[];for(var n=0,i=r;n=s)return e.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.',l);var c=e.parse(u,p,o);if(!c)return null;o=o||c.type,i.push([s,c]);}return new bt(o,r,i)},bt.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var i=e.length;return n>=e[i-1]?r[i-1].evaluate(t):r[xt(e,n)].evaluate(t)},bt.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;e0&&t.push(this.labels[e]),t.push(this.outputs[e].serialize());return t};var _t=Object.freeze({number:wt,color:function(t,e,r){return new Q(wt(t.r,e.r,r),wt(t.g,e.g,r),wt(t.b,e.b,r),wt(t.a,e.a,r))},array:function(t,e,r){return t.map(function(t,n){return wt(t,e[n],r)})}}),At=function(t,e,r,n){this.type=t,this.interpolation=e,this.input=r,this.labels=[],this.outputs=[];for(var i=0,o=n;i1}))return e.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.",1);r={name:"cubic-bezier",controlPoints:a};}if(t.length-1<4)return e.error("Expected at least 4 arguments, but found only "+(t.length-1)+".");if((t.length-1)%2!=0)return e.error("Expected an even number of arguments.");if(!(n=e.parse(n,2,U)))return null;var s=[],u=null;e.expectedType&&"value"!==e.expectedType.kind&&(u=e.expectedType);for(var l=0;l=p)return e.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.',h);var y=e.parse(c,f,u);if(!y)return null;u=u||y.type,s.push([p,y]);}return"number"===u.kind||"color"===u.kind||"array"===u.kind&&"number"===u.itemType.kind&&"number"==typeof u.N?new At(u,r,n,s):e.error("Type "+X(u)+" is not interpolatable.")},At.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var i=e.length;if(n>=e[i-1])return r[i-1].evaluate(t);var o=xt(e,n),a=e[o],s=e[o+1],u=At.interpolationFactor(this.interpolation,n,a,s),l=r[o].evaluate(t),p=r[o+1].evaluate(t);return _t[this.type.kind.toLowerCase()](l,p,u)},At.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;e=r.length)throw new ot("Array index out of bounds: "+e+" > "+(r.length-1)+".");if(e!==Math.floor(e))throw new ot("Array index must be an integer, but found "+e+" instead.");return r[e]},Mt.prototype.eachChild=function(t){t(this.index),t(this.input);},Mt.prototype.possibleOutputs=function(){return[void 0]},Mt.prototype.serialize=function(){return["at",this.index.serialize(),this.input.serialize()]};var Vt=function(t,e,r,n,i,o){this.inputType=t,this.type=e,this.input=r,this.cases=n,this.outputs=i,this.otherwise=o;};Vt.parse=function(t,e){if(t.length<5)return e.error("Expected at least 4 arguments, but found only "+(t.length-1)+".");if(t.length%2!=1)return e.error("Expected an even number of arguments.");var r,n;e.expectedType&&"value"!==e.expectedType.kind&&(n=e.expectedType);for(var i={},o=[],a=2;aNumber.MAX_SAFE_INTEGER)return l.error("Branch labels must be integers no larger than "+Number.MAX_SAFE_INTEGER+".");if("number"==typeof h&&Math.floor(h)!==h)return l.error("Numeric branch labels must be integer values.");if(r){if(l.checkSubtype(r,nt(h)))return null}else r=nt(h);if(void 0!==i[String(h)])return l.error("Branch labels must be unique.");i[String(h)]=o.length;}var f=e.parse(u,a,n);if(!f)return null;n=n||f.type,o.push(f);}var y=e.parse(t[1],1,r);if(!y)return null;var d=e.parse(t[t.length-1],t.length-1,n);return d?new Vt(r,n,y,i,o,d):null},Vt.prototype.evaluate=function(t){var e=this.input.evaluate(t);return(this.outputs[this.cases[e]]||this.otherwise).evaluate(t)},Vt.prototype.eachChild=function(t){t(this.input),this.outputs.forEach(t),t(this.otherwise);},Vt.prototype.possibleOutputs=function(){return(t=[]).concat.apply(t,this.outputs.map(function(t){return t.possibleOutputs()})).concat(this.otherwise.possibleOutputs());var t;},Vt.prototype.serialize=function(){for(var t=this,e=["match",this.input.serialize()],r=[],n={},i=0,o=Object.keys(this.cases).sort();in.evaluate(t)}function Ut(t,e){var r=e[0],n=e[1];return r.evaluate(t)<=n.evaluate(t)}function Dt(t,e){var r=e[0],n=e[1];return r.evaluate(t)>=n.evaluate(t)}function Nt(t){return{type:t}}function Zt(t){return{result:"success",value:t}}function Kt(t){return{result:"error",value:t}}yt.register(Tt,{error:[{kind:"error"},[D],function(t,e){var r=e[0];throw new ot(r.evaluate(t))}],typeof:[D,[J],function(t,e){return X(nt(e[0].evaluate(t)))}],"to-string":[D,[J],function(t,e){var r=e[0],n=typeof(r=r.evaluate(t));return null===r?"":"string"===n||"number"===n||"boolean"===n?String(r):r instanceof Q?r.toString():JSON.stringify(r)}],"to-boolean":[N,[J],function(t,e){var r=e[0];return Boolean(r.evaluate(t))}],"to-rgba":[H(U,4),[Z],function(t,e){return e[0].evaluate(t).toArray()}],rgb:[Z,[U,U,U],Ot],rgba:[Z,[U,U,U,U],Ot],has:{type:N,overloads:[[[D],function(t,e){return Lt(e[0].evaluate(t),t.properties())}],[[D,K],function(t,e){var r=e[0],n=e[1];return Lt(r.evaluate(t),n.evaluate(t))}]]},get:{type:J,overloads:[[[D],function(t,e){return jt(e[0].evaluate(t),t.properties())}],[[D,K],function(t,e){var r=e[0],n=e[1];return jt(r.evaluate(t),n.evaluate(t))}]]},properties:[K,[],function(t){return t.properties()}],"geometry-type":[D,[],function(t){return t.geometryType()}],id:[J,[],function(t){return t.id()}],zoom:[U,[],function(t){return t.globals.zoom}],"heatmap-density":[U,[],function(t){return t.globals.heatmapDensity||0}],"line-progress":[U,[],function(t){return t.globals.lineProgress||0}],"+":[U,Nt(U),function(t,e){for(var r=0,n=0,i=e;n":[N,[D,J],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],o=n.value;return typeof i==typeof o&&i>o}],"filter-id->":[N,[J],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>i}],"filter-<=":[N,[D,J],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],o=n.value;return typeof i==typeof o&&i<=o}],"filter-id-<=":[N,[J],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n<=i}],"filter->=":[N,[D,J],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],o=n.value;return typeof i==typeof o&&i>=o}],"filter-id->=":[N,[J],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>=i}],"filter-has":[N,[J],function(t,e){return e[0].value in t.properties()}],"filter-has-id":[N,[],function(t){return null!==t.id()}],"filter-type-in":[N,[H(D)],function(t,e){return e[0].value.indexOf(t.geometryType())>=0}],"filter-id-in":[N,[H(J)],function(t,e){return e[0].value.indexOf(t.id())>=0}],"filter-in-small":[N,[D,H(J)],function(t,e){var r=e[0];return e[1].value.indexOf(t.properties()[r.value])>=0}],"filter-in-large":[N,[D,H(J)],function(t,e){var r=e[0],n=e[1];return function(t,e,r,n){for(;r<=n;){var i=r+n>>1;if(e[i]===t)return!0;e[i]>t?n=i-1:r=i+1;}return!1}(t.properties()[r.value],n.value,0,n.value.length-1)}],">":{type:N,overloads:[[[U,U],Rt],[[D,D],Rt],[[D,D,$],function(t,e){var r=e[0],n=e[1];return e[2].evaluate(t).compare(r.evaluate(t),n.evaluate(t))>0}]]},"<":{type:N,overloads:[[[U,U],qt],[[D,D],qt],[[D,D,$],function(t,e){var r=e[0],n=e[1];return e[2].evaluate(t).compare(r.evaluate(t),n.evaluate(t))<0}]]},">=":{type:N,overloads:[[[U,U],Dt],[[D,D],Dt],[[D,D,$],function(t,e){var r=e[0],n=e[1];return e[2].evaluate(t).compare(r.evaluate(t),n.evaluate(t))>=0}]]},"<=":{type:N,overloads:[[[U,U],Ut],[[D,D],Ut],[[D,D,$],function(t,e){var r=e[0],n=e[1];return e[2].evaluate(t).compare(r.evaluate(t),n.evaluate(t))<=0}]]},all:{type:N,overloads:[[[N,N],function(t,e){var r=e[0],n=e[1];return r.evaluate(t)&&n.evaluate(t)}],[Nt(N),function(t,e){for(var r=0,n=e;rWt?Math.pow(t,1/3):t/Yt+Xt}function re(t){return t>Gt?t*t*t:Yt*(t-Xt)}function ne(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function ie(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function oe(t){var e=ie(t.r),r=ie(t.g),n=ie(t.b),i=ee((.4124564*e+.3575761*r+.1804375*n)/Jt),o=ee((.2126729*e+.7151522*r+.072175*n)/$t);return{l:116*o-16,a:500*(i-o),b:200*(o-ee((.0193339*e+.119192*r+.9503041*n)/Ht)),alpha:t.a}}function ae(t){var e=(t.l+16)/116,r=isNaN(t.a)?e:e+t.a/500,n=isNaN(t.b)?e:e-t.b/200;return e=$t*re(e),r=Jt*re(r),n=Ht*re(n),new Q(ne(3.2404542*r-1.5371385*e-.4985314*n),ne(-.969266*r+1.8760108*e+.041556*n),ne(.0556434*r-.2040259*e+1.0572252*n),t.alpha)}var se={forward:oe,reverse:ae,interpolate:function(t,e,r){return{l:wt(t.l,e.l,r),a:wt(t.a,e.a,r),b:wt(t.b,e.b,r),alpha:wt(t.alpha,e.alpha,r)}}},ue={forward:function(t){var e=oe(t),r=e.l,n=e.a,i=e.b,o=Math.atan2(i,n)*te;return{h:o<0?o+360:o,c:Math.sqrt(n*n+i*i),l:r,alpha:t.a}},reverse:function(t){var e=t.h*Qt,r=t.c;return ae({l:t.l,a:Math.cos(e)*r,b:Math.sin(e)*r,alpha:t.alpha})},interpolate:function(t,e,r){return{h:function(t,e,r){var n=e-t;return t+r*(n>180||n<-180?n-360*Math.round(n/360):n)}(t.h,e.h,r),c:wt(t.c,e.c,r),l:wt(t.l,e.l,r),alpha:wt(t.alpha,e.alpha,r)}}},le=Object.freeze({lab:se,hcl:ue});function pe(t){return t instanceof Number?"number":t instanceof String?"string":t instanceof Boolean?"boolean":Array.isArray(t)?"array":null===t?"null":typeof t}function ce(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}function he(t){return t}function fe(t,e,r){return void 0!==t?t:void 0!==e?e:void 0!==r?r:void 0}function ye(t,e,r,n,i){return fe(typeof r===i?n[r]:void 0,t.default,e.default)}function de(t,e,r){if("number"!==pe(r))return fe(t.default,e.default);var n=t.stops.length;if(1===n)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[n-1][0])return t.stops[n-1][1];var i=ge(t.stops,r);return t.stops[i][1]}function ve(t,e,r){var n=void 0!==t.base?t.base:1;if("number"!==pe(r))return fe(t.default,e.default);var i=t.stops.length;if(1===i)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[i-1][0])return t.stops[i-1][1];var o=ge(t.stops,r),a=function(t,e,r,n){var i=n-r,o=t-r;return 0===i?0:1===e?o/i:(Math.pow(e,o)-1)/(Math.pow(e,i)-1)}(r,n,t.stops[o][0],t.stops[o+1][0]),s=t.stops[o][1],u=t.stops[o+1][1],l=_t[e.type]||he;if(t.colorSpace&&"rgb"!==t.colorSpace){var p=le[t.colorSpace];l=function(t,e){return p.reverse(p.interpolate(p.forward(t),p.forward(e),a))};}return"function"==typeof s.evaluate?{evaluate:function(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];var r=s.evaluate.apply(void 0,t),n=u.evaluate.apply(void 0,t);if(void 0!==r&&void 0!==n)return l(r,n,a)}}:l(s,u,a)}function me(t,e,r){return"color"===e.type?r=Q.parse(r):pe(r)===e.type||"enum"===e.type&&e.values[r]||(r=void 0),fe(r,t.default,e.default)}function ge(t,e){for(var r,n,i=0,o=t.length-1,a=0;i<=o;){if(r=t[a=Math.floor((i+o)/2)][0],n=t[a+1][0],e===r||e>r&&ee&&(o=a-1);}return Math.max(a-1,0)}var xe=function(t,e){var r;this.expression=t,this._warningHistory={},this._defaultValue="color"===(r=e).type&&ce(r.default)?new Q(0,0,0,0):"color"===r.type?Q.parse(r.default)||null:void 0===r.default?null:r.default,"enum"===e.type&&(this._enumValues=e.values);};function be(t){return Array.isArray(t)&&t.length>0&&"string"==typeof t[0]&&t[0]in Tt}function we(t,e){var r=new gt(Tt,[],function(t){var e={color:Z,string:D,number:U,enum:D,boolean:N};if("array"===t.type)return H(e[t.value]||J,t.length);return e[t.type]||null}(e)),n=r.parse(t);return n?Zt(new xe(n,e)):Kt(r.errors)}xe.prototype.evaluateWithoutErrorHandling=function(t,e){return this._evaluator||(this._evaluator=new ft),this._evaluator.globals=t,this._evaluator.feature=e,this.expression.evaluate(this._evaluator)},xe.prototype.evaluate=function(t,e){this._evaluator||(this._evaluator=new ft),this._evaluator.globals=t,this._evaluator.feature=e;try{var r=this.expression.evaluate(this._evaluator);if(null==r)return this._defaultValue;if(this._enumValues&&!(r in this._enumValues))throw new ot("Expected value to be one of "+Object.keys(this._enumValues).map(function(t){return JSON.stringify(t)}).join(", ")+", but found "+JSON.stringify(r)+" instead.");return r}catch(t){return this._warningHistory[t.message]||(this._warningHistory[t.message]=!0,"undefined"!=typeof console&&console.warn(t.message)),this._defaultValue}};var _e=function(t,e){this.kind=t,this._styleExpression=e;};_e.prototype.evaluateWithoutErrorHandling=function(t,e){return this._styleExpression.evaluateWithoutErrorHandling(t,e)},_e.prototype.evaluate=function(t,e){return this._styleExpression.evaluate(t,e)};var Ae=function(t,e,r){this.kind=t,this.zoomStops=r.labels,this._styleExpression=e,r instanceof At&&(this._interpolationType=r.interpolation);};function ke(t,e){if("error"===(t=we(t,e)).result)return t;var r=t.value.expression,n=dt(r);if(!n&&!e["property-function"])return Kt([new j("","property expressions not supported")]);var i=vt(r,["zoom"]);if(!i&&!1===e["zoom-function"])return Kt([new j("","zoom expressions not supported")]);var o=function t(e){var r=null;if(e instanceof St)r=t(e.result);else if(e instanceof zt)for(var n=0,i=e.args;nn.maximum?[new F(e,r,r+" is greater than the maximum value "+n.maximum)]:[]}function Ce(t){var e,r,n,i=t.valueSpec,o=O(t.value.type),a={},s="categorical"!==o&&void 0===t.value.property,u=!s,l="array"===pe(t.value.stops)&&"array"===pe(t.value.stops[0])&&"object"===pe(t.value.stops[0][0]),p=Me({key:t.key,value:t.value,valueSpec:t.styleSpec.function,style:t.style,styleSpec:t.styleSpec,objectElementValidators:{stops:function(t){if("identity"===o)return[new F(t.key,t.value,'identity function may not have a "stops" property')];var e=[],r=t.value;e=e.concat(Ve({key:t.key,value:r,valueSpec:t.valueSpec,style:t.style,styleSpec:t.styleSpec,arrayElementValidator:c})),"array"===pe(r)&&0===r.length&&e.push(new F(t.key,r,"array must have at least one stop"));return e},default:function(t){return Ye({key:t.key,value:t.value,valueSpec:i,style:t.style,styleSpec:t.styleSpec})}}});return"identity"===o&&s&&p.push(new F(t.key,t.value,'missing required property "property"')),"identity"===o||t.value.stops||p.push(new F(t.key,t.value,'missing required property "stops"')),"exponential"===o&&"piecewise-constant"===t.valueSpec.function&&p.push(new F(t.key,t.value,"exponential functions not supported")),t.styleSpec.$version>=8&&(u&&!t.valueSpec["property-function"]?p.push(new F(t.key,t.value,"property functions not supported")):s&&!t.valueSpec["zoom-function"]&&"heatmap-color"!==t.objectKey&&"line-gradient"!==t.objectKey&&p.push(new F(t.key,t.value,"zoom functions not supported"))),"categorical"!==o&&!l||void 0!==t.value.property||p.push(new F(t.key,t.value,'"property" property is required')),p;function c(t){var e=[],o=t.value,s=t.key;if("array"!==pe(o))return[new F(s,o,"array expected, "+pe(o)+" found")];if(2!==o.length)return[new F(s,o,"array length 2 expected, length "+o.length+" found")];if(l){if("object"!==pe(o[0]))return[new F(s,o,"object expected, "+pe(o[0])+" found")];if(void 0===o[0].zoom)return[new F(s,o,"object stop key must have zoom")];if(void 0===o[0].value)return[new F(s,o,"object stop key must have value")];if(n&&n>O(o[0].zoom))return[new F(s,o[0].zoom,"stop zoom values must appear in ascending order")];O(o[0].zoom)!==n&&(n=O(o[0].zoom),r=void 0,a={}),e=e.concat(Me({key:s+"[0]",value:o[0],valueSpec:{zoom:{}},style:t.style,styleSpec:t.styleSpec,objectElementValidators:{zoom:Be,value:h}}));}else e=e.concat(h({key:s+"[0]",value:o[0],valueSpec:{},style:t.style,styleSpec:t.styleSpec},o));return e.concat(Ye({key:s+"[1]",value:o[1],valueSpec:i,style:t.style,styleSpec:t.styleSpec}))}function h(t,n){var s=pe(t.value),u=O(t.value),l=null!==t.value?t.value:n;if(e){if(s!==e)return[new F(t.key,l,s+" stop domain type must match previous stop domain type "+e)]}else e=s;if("number"!==s&&"string"!==s&&"boolean"!==s)return[new F(t.key,l,"stop domain value must be a number, string, or boolean")];if("number"!==s&&"categorical"!==o){var p="number expected, "+s+" found";return i["property-function"]&&void 0===o&&(p+='\nIf you intended to use a categorical function, specify `"type": "categorical"`.'),[new F(t.key,l,p)]}return"categorical"!==o||"number"!==s||isFinite(u)&&Math.floor(u)===u?"categorical"!==o&&"number"===s&&void 0!==r&&u=2&&"$id"!==t[1]&&"$type"!==t[1];case"in":case"!in":case"!has":case"none":return!1;case"==":case"!=":case">":case">=":case"<":case"<=":return 3===t.length&&(Array.isArray(t[1])||Array.isArray(t[2]));case"any":case"all":for(var e=0,r=t.slice(1);ee?1:0}function Le(t){if(!t)return!0;var e,r=t[0];return t.length<=1?"any"!==r:"=="===r?je(t[1],t[2],"=="):"!="===r?Ue(je(t[1],t[2],"==")):"<"===r||">"===r||"<="===r||">="===r?je(t[1],t[2],r):"any"===r?(e=t.slice(1),["any"].concat(e.map(Le))):"all"===r?["all"].concat(t.slice(1).map(Le)):"none"===r?["all"].concat(t.slice(1).map(Le).map(Ue)):"in"===r?qe(t[1],t.slice(2)):"!in"===r?Ue(qe(t[1],t.slice(2))):"has"===r?Re(t[1]):"!has"!==r||Ue(Re(t[1]))}function je(t,e,r){switch(t){case"$type":return["filter-type-"+r,e];case"$id":return["filter-id-"+r,e];default:return["filter-"+r,t,e]}}function qe(t,e){if(0===e.length)return!1;switch(t){case"$type":return["filter-type-in",["literal",e]];case"$id":return["filter-id-in",["literal",e]];default:return e.length>200&&!e.some(function(t){return typeof t!=typeof e[0]})?["filter-in-large",t,["literal",e.sort(Oe)]]:["filter-in-small",t,["literal",e]]}}function Re(t){switch(t){case"$type":return!0;case"$id":return["filter-has-id"];default:return["filter-has",t]}}function Ue(t){return["!",t]}function De(t){return Fe(L(t.value))?Ie(T({},t,{expressionContext:"filter",valueSpec:{value:"boolean"}})):function t(e){var r=e.value;var n=e.key;if("array"!==pe(r))return[new F(n,r,"array expected, "+pe(r)+" found")];var i=e.styleSpec;var o;var a=[];if(r.length<1)return[new F(n,r,"filter array must have at least 1 element")];a=a.concat(Ee({key:n+"[0]",value:r[0],valueSpec:i.filter_operator,style:e.style,styleSpec:e.styleSpec}));switch(O(r[0])){case"<":case"<=":case">":case">=":r.length>=2&&"$type"===O(r[1])&&a.push(new F(n,r,'"$type" cannot be use with operator "'+r[0]+'"'));case"==":case"!=":3!==r.length&&a.push(new F(n,r,'filter array for operator "'+r[0]+'" must have 3 elements'));case"in":case"!in":r.length>=2&&"string"!==(o=pe(r[1]))&&a.push(new F(n+"[1]",r[1],"string expected, "+o+" found"));for(var s=2;s=l[h+0]&&n>=l[h+1]?(a[c]=!0,o.push(u[c])):a[c]=!1;}}},lr.prototype._forEachCell=function(t,e,r,n,i,o,a){for(var s=this._convertToCellCoord(t),u=this._convertToCellCoord(e),l=this._convertToCellCoord(r),p=this._convertToCellCoord(n),c=s;c<=l;c++)for(var h=u;h<=p;h++){var f=this.d*h+c;if(i.call(this,t,e,r,n,f,o,a))return}},lr.prototype._convertToCellCoord=function(t){return Math.max(0,Math.min(this.d-1,Math.floor(t*this.scale)+this.padding))},lr.prototype.toArrayBuffer=function(){if(this.arrayBuffer)return this.arrayBuffer;for(var t=this.cells,e=ur+this.cells.length+1+1,r=0,n=0;n=0)){var c=t[p];l[p]=cr[u].shallow.indexOf(p)>=0?c:yr(c,e);}t instanceof Error&&(l.message=t.message);}return{name:u,properties:l}}throw new Error("can't serialize object of type "+typeof t)}function dr(t){if(null==t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||t instanceof Boolean||t instanceof Number||t instanceof String||t instanceof Date||t instanceof RegExp||t instanceof ArrayBuffer||ArrayBuffer.isView(t)||t instanceof pr)return t;if(Array.isArray(t))return t.map(function(t){return dr(t)});if("object"==typeof t){var e=t,r=e.name,n=e.properties;if(!r)throw new Error("can't deserialize object of anonymous class");var i=cr[r].klass;if(!i)throw new Error("can't deserialize unregistered class "+r);if(i.deserialize)return i.deserialize(n._serialized);for(var o=Object.create(i.prototype),a=0,s=Object.keys(n);a=0?n[u]:dr(n[u]);}return o}throw new Error("can't deserialize object of type "+typeof t)}var vr=function(){this.first=!0;};vr.prototype.update=function(t,e){var r=Math.floor(t);return this.first?(this.first=!1,this.lastIntegerZoom=r,this.lastIntegerZoomTime=0,this.lastZoom=t,this.lastFloorZoom=r,!0):(this.lastFloorZoom>r?(this.lastIntegerZoom=r+1,this.lastIntegerZoomTime=e):this.lastFloorZoom=128&&t<=255},Arabic:function(t){return t>=1536&&t<=1791},"Arabic Supplement":function(t){return t>=1872&&t<=1919},"Arabic Extended-A":function(t){return t>=2208&&t<=2303},"Hangul Jamo":function(t){return t>=4352&&t<=4607},"Unified Canadian Aboriginal Syllabics":function(t){return t>=5120&&t<=5759},Khmer:function(t){return t>=6016&&t<=6143},"Unified Canadian Aboriginal Syllabics Extended":function(t){return t>=6320&&t<=6399},"General Punctuation":function(t){return t>=8192&&t<=8303},"Letterlike Symbols":function(t){return t>=8448&&t<=8527},"Number Forms":function(t){return t>=8528&&t<=8591},"Miscellaneous Technical":function(t){return t>=8960&&t<=9215},"Control Pictures":function(t){return t>=9216&&t<=9279},"Optical Character Recognition":function(t){return t>=9280&&t<=9311},"Enclosed Alphanumerics":function(t){return t>=9312&&t<=9471},"Geometric Shapes":function(t){return t>=9632&&t<=9727},"Miscellaneous Symbols":function(t){return t>=9728&&t<=9983},"Miscellaneous Symbols and Arrows":function(t){return t>=11008&&t<=11263},"CJK Radicals Supplement":function(t){return t>=11904&&t<=12031},"Kangxi Radicals":function(t){return t>=12032&&t<=12255},"Ideographic Description Characters":function(t){return t>=12272&&t<=12287},"CJK Symbols and Punctuation":function(t){return t>=12288&&t<=12351},Hiragana:function(t){return t>=12352&&t<=12447},Katakana:function(t){return t>=12448&&t<=12543},Bopomofo:function(t){return t>=12544&&t<=12591},"Hangul Compatibility Jamo":function(t){return t>=12592&&t<=12687},Kanbun:function(t){return t>=12688&&t<=12703},"Bopomofo Extended":function(t){return t>=12704&&t<=12735},"CJK Strokes":function(t){return t>=12736&&t<=12783},"Katakana Phonetic Extensions":function(t){return t>=12784&&t<=12799},"Enclosed CJK Letters and Months":function(t){return t>=12800&&t<=13055},"CJK Compatibility":function(t){return t>=13056&&t<=13311},"CJK Unified Ideographs Extension A":function(t){return t>=13312&&t<=19903},"Yijing Hexagram Symbols":function(t){return t>=19904&&t<=19967},"CJK Unified Ideographs":function(t){return t>=19968&&t<=40959},"Yi Syllables":function(t){return t>=40960&&t<=42127},"Yi Radicals":function(t){return t>=42128&&t<=42191},"Hangul Jamo Extended-A":function(t){return t>=43360&&t<=43391},"Hangul Syllables":function(t){return t>=44032&&t<=55215},"Hangul Jamo Extended-B":function(t){return t>=55216&&t<=55295},"Private Use Area":function(t){return t>=57344&&t<=63743},"CJK Compatibility Ideographs":function(t){return t>=63744&&t<=64255},"Arabic Presentation Forms-A":function(t){return t>=64336&&t<=65023},"Vertical Forms":function(t){return t>=65040&&t<=65055},"CJK Compatibility Forms":function(t){return t>=65072&&t<=65103},"Small Form Variants":function(t){return t>=65104&&t<=65135},"Arabic Presentation Forms-B":function(t){return t>=65136&&t<=65279},"Halfwidth and Fullwidth Forms":function(t){return t>=65280&&t<=65519}};function gr(t){for(var e=0,r=t;e=65097&&t<=65103)||(!!mr["CJK Compatibility Ideographs"](t)||(!!mr["CJK Compatibility"](t)||(!!mr["CJK Radicals Supplement"](t)||(!!mr["CJK Strokes"](t)||(!(!mr["CJK Symbols and Punctuation"](t)||t>=12296&&t<=12305||t>=12308&&t<=12319||12336===t)||(!!mr["CJK Unified Ideographs Extension A"](t)||(!!mr["CJK Unified Ideographs"](t)||(!!mr["Enclosed CJK Letters and Months"](t)||(!!mr["Hangul Compatibility Jamo"](t)||(!!mr["Hangul Jamo Extended-A"](t)||(!!mr["Hangul Jamo Extended-B"](t)||(!!mr["Hangul Jamo"](t)||(!!mr["Hangul Syllables"](t)||(!!mr.Hiragana(t)||(!!mr["Ideographic Description Characters"](t)||(!!mr.Kanbun(t)||(!!mr["Kangxi Radicals"](t)||(!!mr["Katakana Phonetic Extensions"](t)||(!(!mr.Katakana(t)||12540===t)||(!(!mr["Halfwidth and Fullwidth Forms"](t)||65288===t||65289===t||65293===t||t>=65306&&t<=65310||65339===t||65341===t||65343===t||t>=65371&&t<=65503||65507===t||t>=65512&&t<=65519)||(!(!mr["Small Form Variants"](t)||t>=65112&&t<=65118||t>=65123&&t<=65126)||(!!mr["Unified Canadian Aboriginal Syllabics"](t)||(!!mr["Unified Canadian Aboriginal Syllabics Extended"](t)||(!!mr["Vertical Forms"](t)||(!!mr["Yijing Hexagram Symbols"](t)||(!!mr["Yi Syllables"](t)||!!mr["Yi Radicals"](t))))))))))))))))))))))))))))))}function wr(t){return!(br(t)||function(t){return!!(mr["Latin-1 Supplement"](t)&&(167===t||169===t||174===t||177===t||188===t||189===t||190===t||215===t||247===t)||mr["General Punctuation"](t)&&(8214===t||8224===t||8225===t||8240===t||8241===t||8251===t||8252===t||8258===t||8263===t||8264===t||8265===t||8273===t)||mr["Letterlike Symbols"](t)||mr["Number Forms"](t)||mr["Miscellaneous Technical"](t)&&(t>=8960&&t<=8967||t>=8972&&t<=8991||t>=8996&&t<=9e3||9003===t||t>=9085&&t<=9114||t>=9150&&t<=9165||9167===t||t>=9169&&t<=9179||t>=9186&&t<=9215)||mr["Control Pictures"](t)&&9251!==t||mr["Optical Character Recognition"](t)||mr["Enclosed Alphanumerics"](t)||mr["Geometric Shapes"](t)||mr["Miscellaneous Symbols"](t)&&!(t>=9754&&t<=9759)||mr["Miscellaneous Symbols and Arrows"](t)&&(t>=11026&&t<=11055||t>=11088&&t<=11097||t>=11192&&t<=11243)||mr["CJK Symbols and Punctuation"](t)||mr.Katakana(t)||mr["Private Use Area"](t)||mr["CJK Compatibility Forms"](t)||mr["Small Form Variants"](t)||mr["Halfwidth and Fullwidth Forms"](t)||8734===t||8756===t||8757===t||t>=9984&&t<=10087||t>=10102&&t<=10131||65532===t||65533===t)}(t))}function _r(t,e){return!(!e&&(t>=1424&&t<=2303||mr["Arabic Presentation Forms-A"](t)||mr["Arabic Presentation Forms-B"](t)))&&!(t>=2304&&t<=3583||t>=3840&&t<=4255||mr.Khmer(t))}var Ar,kr=!1,zr=null,Sr=!1,Mr=new I,Vr={applyArabicShaping:null,processBidirectionalText:null,isLoaded:function(){return Sr||null!=Vr.applyArabicShaping}},Br=function(t,e){this.zoom=t,e?(this.now=e.now,this.fadeDuration=e.fadeDuration,this.zoomHistory=e.zoomHistory,this.transition=e.transition):(this.now=0,this.fadeDuration=0,this.zoomHistory=new vr,this.transition={});};Br.prototype.isSupportedScript=function(t){return function(t,e){for(var r=0,n=t;rthis.end)return this.prior=null,r;if(this.value.isDataDriven())return this.prior=null,r;if(e=1)return 1;var e=t*t,r=e*t;return 4*(t<.5?r:3*(t-e)+r-.75)}(i))}return r};var Pr=function(t){this._properties=t,this._values=Object.create(t.defaultTransitioningPropertyValues);};Pr.prototype.possiblyEvaluate=function(t){for(var e=new Lr(this._properties),r=0,n=Object.keys(this._values);rn.zoomHistory.lastIntegerZoom?{from:t,to:e,fromScale:2,toScale:1,t:o+(1-o)*a}:{from:r,to:e,fromScale:.5,toScale:1,t:1-(1-a)*o}},Rr.prototype.interpolate=function(t){return t};var Ur=function(t){this.specification=t;};Ur.prototype.possiblyEvaluate=function(t,e){return!!t.expression.evaluate(e)},Ur.prototype.interpolate=function(){return!1};var Dr=function(t){for(var e in this.properties=t,this.defaultPropertyValues={},this.defaultTransitionablePropertyValues={},this.defaultTransitioningPropertyValues={},this.defaultPossiblyEvaluatedValues={},t){var r=t[e],n=this.defaultPropertyValues[e]=new Cr(r,void 0),i=this.defaultTransitionablePropertyValues[e]=new Ir(r);this.defaultTransitioningPropertyValues[e]=i.untransitioned(),this.defaultPossiblyEvaluatedValues[e]=n.possiblyEvaluate({});}};hr("DataDrivenProperty",qr),hr("DataConstantProperty",jr),hr("CrossFadedProperty",Rr),hr("ColorRampProperty",Ur);var Nr=function(t){function e(e,r){for(var n in t.call(this),this.id=e.id,this.metadata=e.metadata,this.type=e.type,this.minzoom=e.minzoom,this.maxzoom=e.maxzoom,this.visibility="visible","background"!==e.type&&(this.source=e.source,this.sourceLayer=e["source-layer"],this.filter=e.filter),this._featureFilter=function(){return!0},r.layout&&(this._unevaluatedLayout=new Tr(r.layout)),this._transitionablePaint=new Er(r.paint),e.paint)this.setPaintProperty(n,e.paint[n],{validate:!1});for(var i in e.layout)this.setLayoutProperty(i,e.layout[i],{validate:!1});this._transitioningPaint=this._transitionablePaint.untransitioned();}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getLayoutProperty=function(t){return"visibility"===t?this.visibility:this._unevaluatedLayout.getValue(t)},e.prototype.setLayoutProperty=function(t,e,r){if(null!=e){var n="layers."+this.id+".layout."+t;if(this._validate(or,n,t,e,r))return}"visibility"!==t?this._unevaluatedLayout.setValue(t,e):this.visibility="none"===e?e:"visible";},e.prototype.getPaintProperty=function(t){return d(t,"-transition")?this._transitionablePaint.getTransition(t.slice(0,-"-transition".length)):this._transitionablePaint.getValue(t)},e.prototype.setPaintProperty=function(t,e,r){if(null!=e){var n="layers."+this.id+".paint."+t;if(this._validate(ir,n,t,e,r))return}d(t,"-transition")?this._transitionablePaint.setTransition(t.slice(0,-"-transition".length),e||void 0):this._transitionablePaint.setValue(t,e);},e.prototype.isHidden=function(t){return!!(this.minzoom&&t=this.maxzoom)||"none"===this.visibility)},e.prototype.updateTransitions=function(t){this._transitioningPaint=this._transitionablePaint.transitioned(t,this._transitioningPaint);},e.prototype.hasTransition=function(){return this._transitioningPaint.hasTransition()},e.prototype.recalculate=function(t){this._unevaluatedLayout&&(this.layout=this._unevaluatedLayout.possiblyEvaluate(t)),this.paint=this._transitioningPaint.possiblyEvaluate(t);},e.prototype.serialize=function(){var t={id:this.id,type:this.type,source:this.source,"source-layer":this.sourceLayer,metadata:this.metadata,minzoom:this.minzoom,maxzoom:this.maxzoom,filter:this.filter,layout:this._unevaluatedLayout&&this._unevaluatedLayout.serialize(),paint:this._transitionablePaint&&this._transitionablePaint.serialize()};return"none"===this.visibility&&(t.layout=t.layout||{},t.layout.visibility="none"),m(t,function(t,e){return!(void 0===t||"layout"===e&&!Object.keys(t).length||"paint"===e&&!Object.keys(t).length)})},e.prototype._validate=function(t,e,r,n,i){return(!i||!1!==i.validate)&&ar(this,t.call(rr,{key:e,layerType:this.type,objectKey:r,value:n,styleSpec:E,style:{glyphs:!0,sprite:!0}}))},e.prototype.hasOffscreenPass=function(){return!1},e.prototype.resize=function(){},e}(I),Zr={Int8:Int8Array,Uint8:Uint8Array,Int16:Int16Array,Uint16:Uint16Array,Int32:Int32Array,Uint32:Uint32Array,Float32:Float32Array},Kr=function(t,e){this._structArray=t,this._pos1=e*this.size,this._pos2=this._pos1/2,this._pos4=this._pos1/4,this._pos8=this._pos1/8;},Jr=function(){this.isTransferred=!1,this.capacity=-1,this.resize(0);};function $r(t,e){void 0===e&&(e=1);var r=0,n=0;return{members:t.map(function(t){var i,o=(i=t.type,Zr[i].BYTES_PER_ELEMENT),a=r=Hr(r,Math.max(e,o)),s=t.components||1;return n=Math.max(n,o),r+=o*s,{name:t.name,type:t.type,components:s,offset:a}}),size:Hr(r,Math.max(n,e)),alignment:e}}function Hr(t,e){return Math.ceil(t/e)*e}Jr.serialize=function(t,e){return t._trim(),e&&(t.isTransferred=!0,e.push(t.arrayBuffer)),{length:t.length,arrayBuffer:t.arrayBuffer}},Jr.deserialize=function(t){var e=Object.create(this.prototype);return e.arrayBuffer=t.arrayBuffer,e.length=t.length,e.capacity=t.arrayBuffer.byteLength/e.bytesPerElement,e._refreshViews(),e},Jr.prototype._trim=function(){this.length!==this.capacity&&(this.capacity=this.length,this.arrayBuffer=this.arrayBuffer.slice(0,this.length*this.bytesPerElement),this._refreshViews());},Jr.prototype.clear=function(){this.length=0;},Jr.prototype.resize=function(t){this.reserve(t),this.length=t;},Jr.prototype.reserve=function(t){if(t>this.capacity){this.capacity=Math.max(t,Math.floor(5*this.capacity),128),this.arrayBuffer=new ArrayBuffer(this.capacity*this.bytesPerElement);var e=this.uint8;this._refreshViews(),e&&this.uint8.set(e);}},Jr.prototype._refreshViews=function(){throw new Error("_refreshViews() must be implemented by each concrete StructArray layout")};var Xr=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e){var r=this.length;this.resize(r+1);var n=2*r;return this.int16[n+0]=t,this.int16[n+1]=e,r},e}(Jr);Xr.prototype.bytesPerElement=4,hr("StructArrayLayout2i4",Xr);var Gr=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n){var i=this.length;this.resize(i+1);var o=4*i;return this.int16[o+0]=t,this.int16[o+1]=e,this.int16[o+2]=r,this.int16[o+3]=n,i},e}(Jr);Gr.prototype.bytesPerElement=8,hr("StructArrayLayout4i8",Gr);var Yr=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o){var a=this.length;this.resize(a+1);var s=6*a;return this.int16[s+0]=t,this.int16[s+1]=e,this.int16[s+2]=r,this.int16[s+3]=n,this.int16[s+4]=i,this.int16[s+5]=o,a},e}(Jr);Yr.prototype.bytesPerElement=12,hr("StructArrayLayout2i4i12",Yr);var Wr=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o,a,s){var u=this.length;this.resize(u+1);var l=6*u,p=12*u;return this.int16[l+0]=t,this.int16[l+1]=e,this.int16[l+2]=r,this.int16[l+3]=n,this.uint8[p+8]=i,this.uint8[p+9]=o,this.uint8[p+10]=a,this.uint8[p+11]=s,u},e}(Jr);Wr.prototype.bytesPerElement=12,hr("StructArrayLayout4i4ub12",Wr);var Qr=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o,a,s){var u=this.length;this.resize(u+1);var l=8*u;return this.int16[l+0]=t,this.int16[l+1]=e,this.int16[l+2]=r,this.int16[l+3]=n,this.uint16[l+4]=i,this.uint16[l+5]=o,this.uint16[l+6]=a,this.uint16[l+7]=s,u},e}(Jr);Qr.prototype.bytesPerElement=16,hr("StructArrayLayout4i4ui16",Qr);var tn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.float32=new Float32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r){var n=this.length;this.resize(n+1);var i=3*n;return this.float32[i+0]=t,this.float32[i+1]=e,this.float32[i+2]=r,n},e}(Jr);tn.prototype.bytesPerElement=12,hr("StructArrayLayout3f12",tn);var en=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.uint32=new Uint32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t){var e=this.length;this.resize(e+1);var r=1*e;return this.uint32[r+0]=t,e},e}(Jr);en.prototype.bytesPerElement=4,hr("StructArrayLayout1ul4",en);var rn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer),this.uint32=new Uint32Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o,a,s,u,l,p){var c=this.length;this.resize(c+1);var h=12*c,f=6*c;return this.int16[h+0]=t,this.int16[h+1]=e,this.int16[h+2]=r,this.int16[h+3]=n,this.int16[h+4]=i,this.int16[h+5]=o,this.uint32[f+3]=a,this.uint16[h+8]=s,this.uint16[h+9]=u,this.int16[h+10]=l,this.int16[h+11]=p,c},e}(Jr);rn.prototype.bytesPerElement=24,hr("StructArrayLayout6i1ul2ui2i24",rn);var nn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o){var a=this.length;this.resize(a+1);var s=6*a;return this.int16[s+0]=t,this.int16[s+1]=e,this.int16[s+2]=r,this.int16[s+3]=n,this.int16[s+4]=i,this.int16[s+5]=o,a},e}(Jr);nn.prototype.bytesPerElement=12,hr("StructArrayLayout2i2i2i12",nn);var on=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e){var r=this.length;this.resize(r+1);var n=4*r;return this.uint8[n+0]=t,this.uint8[n+1]=e,r},e}(Jr);on.prototype.bytesPerElement=4,hr("StructArrayLayout2ub4",on);var an=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer),this.uint32=new Uint32Array(this.arrayBuffer),this.float32=new Float32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n,i,o,a,s,u,l,p,c,h,f){var y=this.length;this.resize(y+1);var d=20*y,v=10*y,m=40*y;return this.int16[d+0]=t,this.int16[d+1]=e,this.uint16[d+2]=r,this.uint16[d+3]=n,this.uint32[v+2]=i,this.uint32[v+3]=o,this.uint32[v+4]=a,this.uint16[d+10]=s,this.uint16[d+11]=u,this.uint16[d+12]=l,this.float32[v+7]=p,this.float32[v+8]=c,this.uint8[m+36]=h,this.uint8[m+37]=f,y},e}(Jr);an.prototype.bytesPerElement=40,hr("StructArrayLayout2i2ui3ul3ui2f2ub40",an);var sn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.float32=new Float32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t){var e=this.length;this.resize(e+1);var r=1*e;return this.float32[r+0]=t,e},e}(Jr);sn.prototype.bytesPerElement=4,hr("StructArrayLayout1f4",sn);var un=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.int16=new Int16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r){var n=this.length;this.resize(n+1);var i=3*n;return this.int16[i+0]=t,this.int16[i+1]=e,this.int16[i+2]=r,n},e}(Jr);un.prototype.bytesPerElement=6,hr("StructArrayLayout3i6",un);var ln=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.uint32=new Uint32Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r){var n=this.length;this.resize(n+1);var i=2*n,o=4*n;return this.uint32[i+0]=t,this.uint16[o+2]=e,this.uint16[o+3]=r,n},e}(Jr);ln.prototype.bytesPerElement=8,hr("StructArrayLayout1ul2ui8",ln);var pn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r){var n=this.length;this.resize(n+1);var i=3*n;return this.uint16[i+0]=t,this.uint16[i+1]=e,this.uint16[i+2]=r,n},e}(Jr);pn.prototype.bytesPerElement=6,hr("StructArrayLayout3ui6",pn);var cn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.uint16=new Uint16Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e){var r=this.length;this.resize(r+1);var n=2*r;return this.uint16[n+0]=t,this.uint16[n+1]=e,r},e}(Jr);cn.prototype.bytesPerElement=4,hr("StructArrayLayout2ui4",cn);var hn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.float32=new Float32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e){var r=this.length;this.resize(r+1);var n=2*r;return this.float32[n+0]=t,this.float32[n+1]=e,r},e}(Jr);hn.prototype.bytesPerElement=8,hr("StructArrayLayout2f8",hn);var fn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype._refreshViews=function(){this.uint8=new Uint8Array(this.arrayBuffer),this.float32=new Float32Array(this.arrayBuffer);},e.prototype.emplaceBack=function(t,e,r,n){var i=this.length;this.resize(i+1);var o=4*i;return this.float32[o+0]=t,this.float32[o+1]=e,this.float32[o+2]=r,this.float32[o+3]=n,i},e}(Jr);fn.prototype.bytesPerElement=16,hr("StructArrayLayout4f16",fn);var yn=function(t){function e(){t.apply(this,arguments);}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={anchorPointX:{configurable:!0},anchorPointY:{configurable:!0},x1:{configurable:!0},y1:{configurable:!0},x2:{configurable:!0},y2:{configurable:!0},featureIndex:{configurable:!0},sourceLayerIndex:{configurable:!0},bucketIndex:{configurable:!0},radius:{configurable:!0},signedDistanceFromAnchor:{configurable:!0},anchorPoint:{configurable:!0}};return r.anchorPointX.get=function(){return this._structArray.int16[this._pos2+0]},r.anchorPointX.set=function(t){this._structArray.int16[this._pos2+0]=t;},r.anchorPointY.get=function(){return this._structArray.int16[this._pos2+1]},r.anchorPointY.set=function(t){this._structArray.int16[this._pos2+1]=t;},r.x1.get=function(){return this._structArray.int16[this._pos2+2]},r.x1.set=function(t){this._structArray.int16[this._pos2+2]=t;},r.y1.get=function(){return this._structArray.int16[this._pos2+3]},r.y1.set=function(t){this._structArray.int16[this._pos2+3]=t;},r.x2.get=function(){return this._structArray.int16[this._pos2+4]},r.x2.set=function(t){this._structArray.int16[this._pos2+4]=t;},r.y2.get=function(){return this._structArray.int16[this._pos2+5]},r.y2.set=function(t){this._structArray.int16[this._pos2+5]=t;},r.featureIndex.get=function(){return this._structArray.uint32[this._pos4+3]},r.featureIndex.set=function(t){this._structArray.uint32[this._pos4+3]=t;},r.sourceLayerIndex.get=function(){return this._structArray.uint16[this._pos2+8]},r.sourceLayerIndex.set=function(t){this._structArray.uint16[this._pos2+8]=t;},r.bucketIndex.get=function(){return this._structArray.uint16[this._pos2+9]},r.bucketIndex.set=function(t){this._structArray.uint16[this._pos2+9]=t;},r.radius.get=function(){return this._structArray.int16[this._pos2+10]},r.radius.set=function(t){this._structArray.int16[this._pos2+10]=t;},r.signedDistanceFromAnchor.get=function(){return this._structArray.int16[this._pos2+11]},r.signedDistanceFromAnchor.set=function(t){this._structArray.int16[this._pos2+11]=t;},r.anchorPoint.get=function(){return new s(this.anchorPointX,this.anchorPointY)},Object.defineProperties(e.prototype,r),e}(Kr);yn.prototype.size=24;var dn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.get=function(t){return new yn(this,t)},e}(rn);hr("CollisionBoxArray",dn);var vn=function(t){function e(){t.apply(this,arguments);}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={anchorX:{configurable:!0},anchorY:{configurable:!0},glyphStartIndex:{configurable:!0},numGlyphs:{configurable:!0},vertexStartIndex:{configurable:!0},lineStartIndex:{configurable:!0},lineLength:{configurable:!0},segment:{configurable:!0},lowerSize:{configurable:!0},upperSize:{configurable:!0},lineOffsetX:{configurable:!0},lineOffsetY:{configurable:!0},writingMode:{configurable:!0},hidden:{configurable:!0}};return r.anchorX.get=function(){return this._structArray.int16[this._pos2+0]},r.anchorX.set=function(t){this._structArray.int16[this._pos2+0]=t;},r.anchorY.get=function(){return this._structArray.int16[this._pos2+1]},r.anchorY.set=function(t){this._structArray.int16[this._pos2+1]=t;},r.glyphStartIndex.get=function(){return this._structArray.uint16[this._pos2+2]},r.glyphStartIndex.set=function(t){this._structArray.uint16[this._pos2+2]=t;},r.numGlyphs.get=function(){return this._structArray.uint16[this._pos2+3]},r.numGlyphs.set=function(t){this._structArray.uint16[this._pos2+3]=t;},r.vertexStartIndex.get=function(){return this._structArray.uint32[this._pos4+2]},r.vertexStartIndex.set=function(t){this._structArray.uint32[this._pos4+2]=t;},r.lineStartIndex.get=function(){return this._structArray.uint32[this._pos4+3]},r.lineStartIndex.set=function(t){this._structArray.uint32[this._pos4+3]=t;},r.lineLength.get=function(){return this._structArray.uint32[this._pos4+4]},r.lineLength.set=function(t){this._structArray.uint32[this._pos4+4]=t;},r.segment.get=function(){return this._structArray.uint16[this._pos2+10]},r.segment.set=function(t){this._structArray.uint16[this._pos2+10]=t;},r.lowerSize.get=function(){return this._structArray.uint16[this._pos2+11]},r.lowerSize.set=function(t){this._structArray.uint16[this._pos2+11]=t;},r.upperSize.get=function(){return this._structArray.uint16[this._pos2+12]},r.upperSize.set=function(t){this._structArray.uint16[this._pos2+12]=t;},r.lineOffsetX.get=function(){return this._structArray.float32[this._pos4+7]},r.lineOffsetX.set=function(t){this._structArray.float32[this._pos4+7]=t;},r.lineOffsetY.get=function(){return this._structArray.float32[this._pos4+8]},r.lineOffsetY.set=function(t){this._structArray.float32[this._pos4+8]=t;},r.writingMode.get=function(){return this._structArray.uint8[this._pos1+36]},r.writingMode.set=function(t){this._structArray.uint8[this._pos1+36]=t;},r.hidden.get=function(){return this._structArray.uint8[this._pos1+37]},r.hidden.set=function(t){this._structArray.uint8[this._pos1+37]=t;},Object.defineProperties(e.prototype,r),e}(Kr);vn.prototype.size=40;var mn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.get=function(t){return new vn(this,t)},e}(an);hr("PlacedSymbolArray",mn);var gn=function(t){function e(){t.apply(this,arguments);}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={offsetX:{configurable:!0}};return r.offsetX.get=function(){return this._structArray.float32[this._pos4+0]},r.offsetX.set=function(t){this._structArray.float32[this._pos4+0]=t;},Object.defineProperties(e.prototype,r),e}(Kr);gn.prototype.size=4;var xn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getoffsetX=function(t){return this.float32[1*t+0]},e.prototype.get=function(t){return new gn(this,t)},e}(sn);hr("GlyphOffsetArray",xn);var bn=function(t){function e(){t.apply(this,arguments);}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={x:{configurable:!0},y:{configurable:!0},tileUnitDistanceFromAnchor:{configurable:!0}};return r.x.get=function(){return this._structArray.int16[this._pos2+0]},r.x.set=function(t){this._structArray.int16[this._pos2+0]=t;},r.y.get=function(){return this._structArray.int16[this._pos2+1]},r.y.set=function(t){this._structArray.int16[this._pos2+1]=t;},r.tileUnitDistanceFromAnchor.get=function(){return this._structArray.int16[this._pos2+2]},r.tileUnitDistanceFromAnchor.set=function(t){this._structArray.int16[this._pos2+2]=t;},Object.defineProperties(e.prototype,r),e}(Kr);bn.prototype.size=6;var wn=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getx=function(t){return this.int16[3*t+0]},e.prototype.gety=function(t){return this.int16[3*t+1]},e.prototype.gettileUnitDistanceFromAnchor=function(t){return this.int16[3*t+2]},e.prototype.get=function(t){return new bn(this,t)},e}(un);hr("SymbolLineVertexArray",wn);var _n=function(t){function e(){t.apply(this,arguments);}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={featureIndex:{configurable:!0},sourceLayerIndex:{configurable:!0},bucketIndex:{configurable:!0}};return r.featureIndex.get=function(){return this._structArray.uint32[this._pos4+0]},r.featureIndex.set=function(t){this._structArray.uint32[this._pos4+0]=t;},r.sourceLayerIndex.get=function(){return this._structArray.uint16[this._pos2+2]},r.sourceLayerIndex.set=function(t){this._structArray.uint16[this._pos2+2]=t;},r.bucketIndex.get=function(){return this._structArray.uint16[this._pos2+3]},r.bucketIndex.set=function(t){this._structArray.uint16[this._pos2+3]=t;},Object.defineProperties(e.prototype,r),e}(Kr);_n.prototype.size=8;var An=function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.get=function(t){return new _n(this,t)},e}(ln);hr("FeatureIndexArray",An);var kn=$r([{name:"a_pos",components:2,type:"Int16"}],4).members,zn=function(t){void 0===t&&(t=[]),this.segments=t;};zn.prototype.prepareSegment=function(t,e,r){var n=this.segments[this.segments.length-1];return t>zn.MAX_VERTEX_ARRAY_LENGTH&&b("Max vertices per segment is "+zn.MAX_VERTEX_ARRAY_LENGTH+": bucket requested "+t),(!n||n.vertexLength+t>zn.MAX_VERTEX_ARRAY_LENGTH)&&(n={vertexOffset:e.length,primitiveOffset:r.length,vertexLength:0,primitiveLength:0},this.segments.push(n)),n},zn.prototype.get=function(){return this.segments},zn.prototype.destroy=function(){for(var t=0,e=this.segments;tOn.max||a.yOn.max)&&b("Geometry exceeds allowed extent, reduce your vector tile buffer size");}return r}function jn(t,e,r,n,i){t.emplaceBack(2*e+(n+1)/2,2*r+(i+1)/2);}var qn=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new Xr,this.indexArray=new pn,this.segments=new zn,this.programConfigurations=new En(kn,t.layers,t.zoom);};function Rn(t,e,r){for(var n=0;n=3)for(var s=0;s1){if(Zn(t,e))return!0;for(var n=0;n1?t.distSqr(r):t.distSqr(r.sub(e)._mult(i)._add(e))}function Hn(t,e){for(var r,n,i,o=!1,a=0;ae.y!=i.y>e.y&&e.x<(i.x-n.x)*(e.y-n.y)/(i.y-n.y)+n.x&&(o=!o);return o}function Xn(t,e){for(var r=!1,n=0,i=t.length-1;ne.y!=a.y>e.y&&e.x<(a.x-o.x)*(e.y-o.y)/(a.y-o.y)+o.x&&(r=!r);}return r}function Gn(t,e,r){var n=e.paint.get(t).value;return"constant"===n.kind?n.value:r.programConfigurations.get(e.id).binders[t].statistics.max}function Yn(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1])}function Wn(t,e,r,n,i){if(!e[0]&&!e[1])return t;var o=s.convert(e);"viewport"===r&&o._rotate(-n);for(var a=[],u=0;u=Pn||u<0||u>=Pn)){var l=this.segments.prepareSegment(4,this.layoutVertexArray,this.indexArray),p=l.vertexLength;jn(this.layoutVertexArray,s,u,-1,-1),jn(this.layoutVertexArray,s,u,1,-1),jn(this.layoutVertexArray,s,u,1,1),jn(this.layoutVertexArray,s,u,-1,1),this.indexArray.emplaceBack(p,p+1,p+2),this.indexArray.emplaceBack(p,p+3,p+2),l.vertexLength+=4,l.primitiveLength+=2;}}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,t);},hr("CircleBucket",qn,{omit:["layers"]});var Qn={paint:new Dr({"circle-radius":new qr(E.paint_circle["circle-radius"]),"circle-color":new qr(E.paint_circle["circle-color"]),"circle-blur":new qr(E.paint_circle["circle-blur"]),"circle-opacity":new qr(E.paint_circle["circle-opacity"]),"circle-translate":new jr(E.paint_circle["circle-translate"]),"circle-translate-anchor":new jr(E.paint_circle["circle-translate-anchor"]),"circle-pitch-scale":new jr(E.paint_circle["circle-pitch-scale"]),"circle-pitch-alignment":new jr(E.paint_circle["circle-pitch-alignment"]),"circle-stroke-width":new qr(E.paint_circle["circle-stroke-width"]),"circle-stroke-color":new qr(E.paint_circle["circle-stroke-color"]),"circle-stroke-opacity":new qr(E.paint_circle["circle-stroke-opacity"])})},ti=n(function(t,e){var r;t.exports=((r=new Float32Array(3))[0]=0,r[1]=0,r[2]=0,function(){var t=new Float32Array(4);t[0]=0,t[1]=0,t[2]=0,t[3]=0;}(),{vec3:{transformMat3:function(t,e,r){var n=e[0],i=e[1],o=e[2];return t[0]=n*r[0]+i*r[3]+o*r[6],t[1]=n*r[1]+i*r[4]+o*r[7],t[2]=n*r[2]+i*r[5]+o*r[8],t}},vec4:{transformMat4:function(t,e,r){var n=e[0],i=e[1],o=e[2],a=e[3];return t[0]=r[0]*n+r[4]*i+r[8]*o+r[12]*a,t[1]=r[1]*n+r[5]*i+r[9]*o+r[13]*a,t[2]=r[2]*n+r[6]*i+r[10]*o+r[14]*a,t[3]=r[3]*n+r[7]*i+r[11]*o+r[15]*a,t}},mat2:{create:function(){var t=new Float32Array(4);return t[0]=1,t[1]=0,t[2]=0,t[3]=1,t},rotate:function(t,e,r){var n=e[0],i=e[1],o=e[2],a=e[3],s=Math.sin(r),u=Math.cos(r);return t[0]=n*u+o*s,t[1]=i*u+a*s,t[2]=n*-s+o*u,t[3]=i*-s+a*u,t},scale:function(t,e,r){var n=e[0],i=e[1],o=e[2],a=e[3],s=r[0],u=r[1];return t[0]=n*s,t[1]=i*s,t[2]=o*u,t[3]=a*u,t}},mat3:{create:function(){var t=new Float32Array(9);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=1,t[5]=0,t[6]=0,t[7]=0,t[8]=1,t},fromRotation:function(t,e){var r=Math.sin(e),n=Math.cos(e);return t[0]=n,t[1]=r,t[2]=0,t[3]=-r,t[4]=n,t[5]=0,t[6]=0,t[7]=0,t[8]=1,t}},mat4:{create:function(){var t=new Float32Array(16);return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t},identity:function(t){return t[0]=1,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=1,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=1,t[11]=0,t[12]=0,t[13]=0,t[14]=0,t[15]=1,t},translate:function(t,e,r){var n,i,o,a,s,u,l,p,c,h,f,y,d=r[0],v=r[1],m=r[2];return e===t?(t[12]=e[0]*d+e[4]*v+e[8]*m+e[12],t[13]=e[1]*d+e[5]*v+e[9]*m+e[13],t[14]=e[2]*d+e[6]*v+e[10]*m+e[14],t[15]=e[3]*d+e[7]*v+e[11]*m+e[15]):(n=e[0],i=e[1],o=e[2],a=e[3],s=e[4],u=e[5],l=e[6],p=e[7],c=e[8],h=e[9],f=e[10],y=e[11],t[0]=n,t[1]=i,t[2]=o,t[3]=a,t[4]=s,t[5]=u,t[6]=l,t[7]=p,t[8]=c,t[9]=h,t[10]=f,t[11]=y,t[12]=n*d+s*v+c*m+e[12],t[13]=i*d+u*v+h*m+e[13],t[14]=o*d+l*v+f*m+e[14],t[15]=a*d+p*v+y*m+e[15]),t},scale:function(t,e,r){var n=r[0],i=r[1],o=r[2];return t[0]=e[0]*n,t[1]=e[1]*n,t[2]=e[2]*n,t[3]=e[3]*n,t[4]=e[4]*i,t[5]=e[5]*i,t[6]=e[6]*i,t[7]=e[7]*i,t[8]=e[8]*o,t[9]=e[9]*o,t[10]=e[10]*o,t[11]=e[11]*o,t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15],t},multiply:function(t,e,r){var n=e[0],i=e[1],o=e[2],a=e[3],s=e[4],u=e[5],l=e[6],p=e[7],c=e[8],h=e[9],f=e[10],y=e[11],d=e[12],v=e[13],m=e[14],g=e[15],x=r[0],b=r[1],w=r[2],_=r[3];return t[0]=x*n+b*s+w*c+_*d,t[1]=x*i+b*u+w*h+_*v,t[2]=x*o+b*l+w*f+_*m,t[3]=x*a+b*p+w*y+_*g,x=r[4],b=r[5],w=r[6],_=r[7],t[4]=x*n+b*s+w*c+_*d,t[5]=x*i+b*u+w*h+_*v,t[6]=x*o+b*l+w*f+_*m,t[7]=x*a+b*p+w*y+_*g,x=r[8],b=r[9],w=r[10],_=r[11],t[8]=x*n+b*s+w*c+_*d,t[9]=x*i+b*u+w*h+_*v,t[10]=x*o+b*l+w*f+_*m,t[11]=x*a+b*p+w*y+_*g,x=r[12],b=r[13],w=r[14],_=r[15],t[12]=x*n+b*s+w*c+_*d,t[13]=x*i+b*u+w*h+_*v,t[14]=x*o+b*l+w*f+_*m,t[15]=x*a+b*p+w*y+_*g,t},perspective:function(t,e,r,n,i){var o=1/Math.tan(e/2),a=1/(n-i);return t[0]=o/r,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=o,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=(i+n)*a,t[11]=-1,t[12]=0,t[13]=0,t[14]=2*i*n*a,t[15]=0,t},rotateX:function(t,e,r){var n=Math.sin(r),i=Math.cos(r),o=e[4],a=e[5],s=e[6],u=e[7],l=e[8],p=e[9],c=e[10],h=e[11];return e!==t&&(t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t[4]=o*i+l*n,t[5]=a*i+p*n,t[6]=s*i+c*n,t[7]=u*i+h*n,t[8]=l*i-o*n,t[9]=p*i-a*n,t[10]=c*i-s*n,t[11]=h*i-u*n,t},rotateZ:function(t,e,r){var n=Math.sin(r),i=Math.cos(r),o=e[0],a=e[1],s=e[2],u=e[3],l=e[4],p=e[5],c=e[6],h=e[7];return e!==t&&(t[8]=e[8],t[9]=e[9],t[10]=e[10],t[11]=e[11],t[12]=e[12],t[13]=e[13],t[14]=e[14],t[15]=e[15]),t[0]=o*i+l*n,t[1]=a*i+p*n,t[2]=s*i+c*n,t[3]=u*i+h*n,t[4]=l*i-o*n,t[5]=p*i-a*n,t[6]=c*i-s*n,t[7]=h*i-u*n,t},invert:function(t,e){var r=e[0],n=e[1],i=e[2],o=e[3],a=e[4],s=e[5],u=e[6],l=e[7],p=e[8],c=e[9],h=e[10],f=e[11],y=e[12],d=e[13],v=e[14],m=e[15],g=r*s-n*a,x=r*u-i*a,b=r*l-o*a,w=n*u-i*s,_=n*l-o*s,A=i*l-o*u,k=p*d-c*y,z=p*v-h*y,S=p*m-f*y,M=c*v-h*d,V=c*m-f*d,B=h*m-f*v,C=g*B-x*V+b*M+w*S-_*z+A*k;return C?(C=1/C,t[0]=(s*B-u*V+l*M)*C,t[1]=(i*V-n*B-o*M)*C,t[2]=(d*A-v*_+m*w)*C,t[3]=(h*_-c*A-f*w)*C,t[4]=(u*S-a*B-l*z)*C,t[5]=(r*B-i*S+o*z)*C,t[6]=(v*b-y*A-m*x)*C,t[7]=(p*A-h*b+f*x)*C,t[8]=(a*V-s*S+l*k)*C,t[9]=(n*S-r*V-o*k)*C,t[10]=(y*_-d*b+m*g)*C,t[11]=(c*b-p*_-f*g)*C,t[12]=(s*z-a*M-u*k)*C,t[13]=(r*M-n*z+i*k)*C,t[14]=(d*x-y*w-v*g)*C,t[15]=(p*w-c*x+h*g)*C,t):null},ortho:function(t,e,r,n,i,o,a){var s=1/(e-r),u=1/(n-i),l=1/(o-a);return t[0]=-2*s,t[1]=0,t[2]=0,t[3]=0,t[4]=0,t[5]=-2*u,t[6]=0,t[7]=0,t[8]=0,t[9]=0,t[10]=2*l,t[11]=0,t[12]=(e+r)*s,t[13]=(i+n)*u,t[14]=(a+o)*l,t[15]=1,t}}});}),ei=(ti.vec3,ti.vec4),ri=(ti.mat2,ti.mat3,ti.mat4),ni=function(t){function e(e){t.call(this,e,Qn);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new qn(t)},e.prototype.queryRadius=function(t){var e=t;return Gn("circle-radius",this,e)+Gn("circle-stroke-width",this,e)+Yn(this.paint.get("circle-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o,a){for(var s=Wn(t,this.paint.get("circle-translate"),this.paint.get("circle-translate-anchor"),i.angle,o),u=this.paint.get("circle-radius").evaluate(e)+this.paint.get("circle-stroke-width").evaluate(e),l="map"===this.paint.get("circle-pitch-alignment"),p=l?s:function(t,e,r){return t.map(function(t){return t.map(function(t){return ii(t,e,r)})})}(s,a,i),c=l?u*o:u,h=0,f=r;ht.width||i.height>t.height||r.x>t.width-i.width||r.y>t.height-i.height)throw new RangeError("out of range source coordinates for image copy");if(i.width>e.width||i.height>e.height||n.x>e.width-i.width||n.y>e.height-i.height)throw new RangeError("out of range destination coordinates for image copy");for(var a=t.data,s=e.data,u=0;u80*r){n=o=t[0],i=a=t[1];for(var y=r;yo&&(o=s),u>a&&(a=u);l=0!==(l=Math.max(o-n,a-i))?1/l:0;}return _i(h,f,r,n,i,l),f}function bi(t,e,r,n,i){var o,a;if(i===Ui(t,e,r,n)>0)for(o=e;o=e;o-=n)a=ji(o,t[o],t[o+1],a);return a&&Pi(a,a.next)&&(qi(a),a=a.next),a}function wi(t,e){if(!t)return t;e||(e=t);var r,n=t;do{if(r=!1,n.steiner||!Pi(n,n.next)&&0!==Fi(n.prev,n,n.next))n=n.next;else{if(qi(n),(n=e=n.prev)===n.next)break;r=!0;}}while(r||n!==e);return e}function _i(t,e,r,n,i,o,a){if(t){!a&&o&&function(t,e,r,n){var i=t;do{null===i.z&&(i.z=Bi(i.x,i.y,e,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next;}while(i!==t);i.prevZ.nextZ=null,i.prevZ=null,function(t){var e,r,n,i,o,a,s,u,l=1;do{for(r=t,t=null,o=null,a=0;r;){for(a++,n=r,s=0,e=0;e0||u>0&&n;)0!==s&&(0===u||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,u--),o?o.nextZ=i:t=i,i.prevZ=o,o=i;r=n;}o.nextZ=null,l*=2;}while(a>1)}(i);}(t,n,i,o);for(var s,u,l=t;t.prev!==t.next;)if(s=t.prev,u=t.next,o?ki(t,n,i,o):Ai(t))e.push(s.i/r),e.push(t.i/r),e.push(u.i/r),qi(t),t=u.next,l=u.next;else if((t=u)===l){a?1===a?_i(t=zi(t,e,r),e,r,n,i,o,2):2===a&&Si(t,e,r,n,i,o):_i(wi(t),e,r,n,i,o,1);break}}}function Ai(t){var e=t.prev,r=t,n=t.next;if(Fi(e,r,n)>=0)return!1;for(var i=t.next.next;i!==t.prev;){if(Ii(e.x,e.y,r.x,r.y,n.x,n.y,i.x,i.y)&&Fi(i.prev,i,i.next)>=0)return!1;i=i.next;}return!0}function ki(t,e,r,n){var i=t.prev,o=t,a=t.next;if(Fi(i,o,a)>=0)return!1;for(var s=i.xo.x?i.x>a.x?i.x:a.x:o.x>a.x?o.x:a.x,p=i.y>o.y?i.y>a.y?i.y:a.y:o.y>a.y?o.y:a.y,c=Bi(s,u,e,r,n),h=Bi(l,p,e,r,n),f=t.prevZ,y=t.nextZ;f&&f.z>=c&&y&&y.z<=h;){if(f!==t.prev&&f!==t.next&&Ii(i.x,i.y,o.x,o.y,a.x,a.y,f.x,f.y)&&Fi(f.prev,f,f.next)>=0)return!1;if(f=f.prevZ,y!==t.prev&&y!==t.next&&Ii(i.x,i.y,o.x,o.y,a.x,a.y,y.x,y.y)&&Fi(y.prev,y,y.next)>=0)return!1;y=y.nextZ;}for(;f&&f.z>=c;){if(f!==t.prev&&f!==t.next&&Ii(i.x,i.y,o.x,o.y,a.x,a.y,f.x,f.y)&&Fi(f.prev,f,f.next)>=0)return!1;f=f.prevZ;}for(;y&&y.z<=h;){if(y!==t.prev&&y!==t.next&&Ii(i.x,i.y,o.x,o.y,a.x,a.y,y.x,y.y)&&Fi(y.prev,y,y.next)>=0)return!1;y=y.nextZ;}return!0}function zi(t,e,r){var n=t;do{var i=n.prev,o=n.next.next;!Pi(i,o)&&Ti(i,n,n.next,o)&&Oi(i,o)&&Oi(o,i)&&(e.push(i.i/r),e.push(n.i/r),e.push(o.i/r),qi(n),qi(n.next),n=t=o),n=n.next;}while(n!==t);return n}function Si(t,e,r,n,i,o){var a=t;do{for(var s=a.next.next;s!==a.prev;){if(a.i!==s.i&&Ei(a,s)){var u=Li(a,s);return a=wi(a,a.next),u=wi(u,u.next),_i(a,e,r,n,i,o),void _i(u,e,r,n,i,o)}s=s.next;}a=a.next;}while(a!==t)}function Mi(t,e){return t.x-e.x}function Vi(t,e){if(e=function(t,e){var r,n=e,i=t.x,o=t.y,a=-1/0;do{if(o<=n.y&&o>=n.next.y&&n.next.y!==n.y){var s=n.x+(o-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(s<=i&&s>a){if(a=s,s===i){if(o===n.y)return n;if(o===n.next.y)return n.next}r=n.x=n.x&&n.x>=p&&i!==n.x&&Ii(or.x)&&Oi(n,t)&&(r=n,h=u),n=n.next;return r}(t,e)){var r=Li(e,t);wi(r,r.next);}}function Bi(t,e,r,n,i){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-r)*i)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-n)*i)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function Ci(t){var e=t,r=t;do{e.x=0&&(t-a)*(n-s)-(r-a)*(e-s)>=0&&(r-a)*(o-s)-(i-a)*(n-s)>=0}function Ei(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){var r=t;do{if(r.i!==t.i&&r.next.i!==t.i&&r.i!==e.i&&r.next.i!==e.i&&Ti(r,r.next,t,e))return!0;r=r.next;}while(r!==t);return!1}(t,e)&&Oi(t,e)&&Oi(e,t)&&function(t,e){var r=t,n=!1,i=(t.x+e.x)/2,o=(t.y+e.y)/2;do{r.y>o!=r.next.y>o&&r.next.y!==r.y&&i<(r.next.x-r.x)*(o-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next;}while(r!==t);return n}(t,e)}function Fi(t,e,r){return(e.y-t.y)*(r.x-e.x)-(e.x-t.x)*(r.y-e.y)}function Pi(t,e){return t.x===e.x&&t.y===e.y}function Ti(t,e,r,n){return!!(Pi(t,e)&&Pi(r,n)||Pi(t,n)&&Pi(r,e))||Fi(t,e,r)>0!=Fi(t,e,n)>0&&Fi(r,n,t)>0!=Fi(r,n,e)>0}function Oi(t,e){return Fi(t.prev,t,t.next)<0?Fi(t,e,t.next)>=0&&Fi(t,t.prev,e)>=0:Fi(t,e,t.prev)<0||Fi(t,t.next,e)<0}function Li(t,e){var r=new Ri(t.i,t.x,t.y),n=new Ri(e.i,e.x,e.y),i=t.next,o=e.prev;return t.next=e,e.prev=t,r.next=i,i.prev=r,n.next=r,r.prev=n,o.next=n,n.prev=o,n}function ji(t,e,r,n){var i=new Ri(t,e,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function qi(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ);}function Ri(t,e,r){this.i=t,this.x=e,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1;}function Ui(t,e,r,n){for(var i=0,o=e,a=r-n;o0&&(n+=t[i-1].length,r.holes.push(n));}return r},mi.default=gi;var Di=Zi,Ni=Zi;function Zi(t,e,r,n,i){!function t(e,r,n,i,o){for(;i>n;){if(i-n>600){var a=i-n+1,s=r-n+1,u=Math.log(a),l=.5*Math.exp(2*u/3),p=.5*Math.sqrt(u*l*(a-l)/a)*(s-a/2<0?-1:1),c=Math.max(n,Math.floor(r-s*l/a+p)),h=Math.min(i,Math.floor(r+(a-s)*l/a+p));t(e,r,c,h,o);}var f=e[r],y=n,d=i;for(Ki(e,n,r),o(e[i],f)>0&&Ki(e,n,i);y0;)d--;}0===o(e[n],f)?Ki(e,n,d):Ki(e,++d,i),d<=r&&(n=d+1),r<=d&&(i=d-1);}}(t,e,r||0,n||t.length-1,i||Ji);}function Ki(t,e,r){var n=t[e];t[e]=t[r],t[r]=n;}function Ji(t,e){return te?1:0}function $i(t,e){var r=t.length;if(r<=1)return[t];for(var n,i,o=[],a=0;a1)for(var u=0;uPn)||t.y===e.y&&(t.y<0||t.y>Pn)}function no(t){return t.every(function(t){return t.x<0})||t.every(function(t){return t.x>Pn})||t.every(function(t){return t.y<0})||t.every(function(t){return t.y>Pn})}eo.prototype.populate=function(t,e){for(var r=0,n=t;r=1){var d=c[f-1];if(!ro(y,d)){u.vertexLength+4>zn.MAX_VERTEX_ARRAY_LENGTH&&(u=this.segments.prepareSegment(4,this.layoutVertexArray,this.indexArray));var v=y.sub(d)._perp()._unit(),m=d.dist(y);h+m>32768&&(h=0),to(this.layoutVertexArray,y.x,y.y,v.x,v.y,0,0,h),to(this.layoutVertexArray,y.x,y.y,v.x,v.y,0,1,h),h+=m,to(this.layoutVertexArray,d.x,d.y,v.x,v.y,0,0,h),to(this.layoutVertexArray,d.x,d.y,v.x,v.y,0,1,h);var g=u.vertexLength;this.indexArray.emplaceBack(g,g+1,g+2),this.indexArray.emplaceBack(g+1,g+2,g+3),u.vertexLength+=4,u.primitiveLength+=2;}}}}u.vertexLength+o>zn.MAX_VERTEX_ARRAY_LENGTH&&(u=this.segments.prepareSegment(o,this.layoutVertexArray,this.indexArray));for(var x=[],b=[],w=u.vertexLength,_=0,A=i;_>3;}if(i--,1===n||2===n)o+=t.readSVarint(),a+=t.readSVarint(),1===n&&(e&&u.push(e),e=[]),e.push(new s(o,a));else{if(7!==n)throw new Error("unknown command "+n);e&&e.push(e[0].clone());}}return e&&u.push(e),u},uo.prototype.bbox=function(){var t=this._pbf;t.pos=this._geometry;for(var e=t.readVarint()+t.pos,r=1,n=0,i=0,o=0,a=1/0,s=-1/0,u=1/0,l=-1/0;t.pos>3;}if(n--,1===r||2===r)(i+=t.readSVarint())s&&(s=i),(o+=t.readSVarint())l&&(l=o);else if(7!==r)throw new Error("unknown command "+r)}return[a,u,s,l]},uo.prototype.toGeoJSON=function(t,e,r){var n,i,o=this.extent*Math.pow(2,r),a=this.extent*t,s=this.extent*e,u=this.loadGeometry(),l=uo.types[this.type];function p(t){for(var e=0;e>3;e=1===n?t.readString():2===n?t.readFloat():3===n?t.readDouble():4===n?t.readVarint64():5===n?t.readVarint():6===n?t.readSVarint():7===n?t.readBoolean():null;}return e}(r));}function yo(t,e,r){if(3===t){var n=new co(r,r.readVarint()+r.pos);n.length&&(e[n.name]=n);}}ho.prototype.feature=function(t){if(t<0||t>=this._features.length)throw new Error("feature index out of bounds");this._pbf.pos=this._features[t];var e=this._pbf.readVarint()+this._pbf.pos;return new so(this._pbf,e,this.extent,this._keys,this._values)};var vo={VectorTile:function(t,e){this.layers=t.readFields(yo,{},e);},VectorTileFeature:so,VectorTileLayer:co},mo=vo.VectorTileFeature.types,go=63,xo=Math.cos(Math.PI/180*37.5),bo=.5,wo=Math.pow(2,14)/bo;function _o(t,e,r,n,i,o,a){t.emplaceBack(e.x,e.y,n?1:0,i?1:-1,Math.round(go*r.x)+128,Math.round(go*r.y)+128,1+(0===o?0:o<0?-1:1)|(a*bo&63)<<2,a*bo>>6);}var Ao=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new Wr,this.indexArray=new pn,this.programConfigurations=new En(ao,t.layers,t.zoom),this.segments=new zn;};function ko(t,e){return(t/e.tileTotal*(e.end-e.start)+e.start)*(wo-1)}Ao.prototype.populate=function(t,e){for(var r=0,n=t;r=2&&t[u-1].equals(t[u-2]);)u--;for(var l=0;ll){var V=f.dist(x);if(V>2*p){var B=f.sub(f.sub(x)._mult(p/V)._round());this.distance+=B.dist(x),this.addCurrentVertex(B,this.distance,w.mult(1),0,0,!1,h,a),x=B;}}var C=x&&b,I=C?r:b?v:m;if(C&&"round"===I&&(Si&&(I="bevel"),"bevel"===I&&(S>2&&(I="flipbevel"),S100)k=_.clone().mult(-1);else{var E=w.x*_.y-w.y*_.x>0?-1:1,F=S*w.add(_).mag()/w.sub(_).mag();k._perp()._mult(F*E);}this.addCurrentVertex(f,this.distance,k,0,0,!1,h,a),this.addCurrentVertex(f,this.distance,k.mult(-1),0,0,!1,h,a);}else if("bevel"===I||"fakeround"===I){var P=w.x*_.y-w.y*_.x>0,T=-Math.sqrt(S*S-1);if(P?(d=0,y=T):(y=0,d=T),g||this.addCurrentVertex(f,this.distance,w,y,d,!1,h,a),"fakeround"===I){for(var O=Math.floor(8*(.5-(z-.5))),L=void 0,j=0;j=0;q--)L=w.mult((q+1)/(O+1))._add(_)._unit(),this.addPieSliceVertex(f,this.distance,L,P,h,a);}b&&this.addCurrentVertex(f,this.distance,_,-y,-d,!1,h,a);}else"butt"===I?(g||this.addCurrentVertex(f,this.distance,w,0,0,!1,h,a),b&&this.addCurrentVertex(f,this.distance,_,0,0,!1,h,a)):"square"===I?(g||(this.addCurrentVertex(f,this.distance,w,1,1,!1,h,a),this.e1=this.e2=-1),b&&this.addCurrentVertex(f,this.distance,_,-1,-1,!1,h,a)):"round"===I&&(g||(this.addCurrentVertex(f,this.distance,w,0,0,!1,h,a),this.addCurrentVertex(f,this.distance,w,1,1,!0,h,a),this.e1=this.e2=-1),b&&(this.addCurrentVertex(f,this.distance,_,-1,-1,!0,h,a),this.addCurrentVertex(f,this.distance,_,0,0,!1,h,a)));if(M&&A2*p){var U=f.add(b.sub(f)._mult(p/R)._round());this.distance+=U.dist(f),this.addCurrentVertex(U,this.distance,_.mult(1),0,0,!1,h,a),f=U;}}g=!1;}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,e);}},Ao.prototype.addCurrentVertex=function(t,e,r,n,i,o,a,s){var u,l=this.layoutVertexArray,p=this.indexArray;s&&(e=ko(e,s)),u=r.clone(),n&&u._sub(r.perp()._mult(n)),_o(l,t,u,o,!1,n,e),this.e3=a.vertexLength++,this.e1>=0&&this.e2>=0&&(p.emplaceBack(this.e1,this.e2,this.e3),a.primitiveLength++),this.e1=this.e2,this.e2=this.e3,u=r.mult(-1),i&&u._sub(r.perp()._mult(i)),_o(l,t,u,o,!0,-i,e),this.e3=a.vertexLength++,this.e1>=0&&this.e2>=0&&(p.emplaceBack(this.e1,this.e2,this.e3),a.primitiveLength++),this.e1=this.e2,this.e2=this.e3,e>wo/2&&!s&&(this.distance=0,this.addCurrentVertex(t,this.distance,r,n,i,o,a));},Ao.prototype.addPieSliceVertex=function(t,e,r,n,i,o){r=r.mult(n?-1:1);var a=this.layoutVertexArray,s=this.indexArray;o&&(e=ko(e,o)),_o(a,t,r,!1,n,0,e),this.e3=i.vertexLength++,this.e1>=0&&this.e2>=0&&(s.emplaceBack(this.e1,this.e2,this.e3),i.primitiveLength++),n?this.e2=this.e3:this.e1=this.e3;},hr("LineBucket",Ao,{omit:["layers"]});var zo=new Dr({"line-cap":new jr(E.layout_line["line-cap"]),"line-join":new qr(E.layout_line["line-join"]),"line-miter-limit":new jr(E.layout_line["line-miter-limit"]),"line-round-limit":new jr(E.layout_line["line-round-limit"])}),So={paint:new Dr({"line-opacity":new qr(E.paint_line["line-opacity"]),"line-color":new qr(E.paint_line["line-color"]),"line-translate":new jr(E.paint_line["line-translate"]),"line-translate-anchor":new jr(E.paint_line["line-translate-anchor"]),"line-width":new qr(E.paint_line["line-width"]),"line-gap-width":new qr(E.paint_line["line-gap-width"]),"line-offset":new qr(E.paint_line["line-offset"]),"line-blur":new qr(E.paint_line["line-blur"]),"line-dasharray":new Rr(E.paint_line["line-dasharray"]),"line-pattern":new Rr(E.paint_line["line-pattern"]),"line-gradient":new Ur(E.paint_line["line-gradient"])}),layout:zo},Mo=new(function(t){function e(){t.apply(this,arguments);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.possiblyEvaluate=function(e,r){return r=new Br(Math.floor(r.zoom),{now:r.now,fadeDuration:r.fadeDuration,zoomHistory:r.zoomHistory,transition:r.transition}),t.prototype.possiblyEvaluate.call(this,e,r)},e.prototype.evaluate=function(e,r,n){return r=h({},r,{zoom:Math.floor(r.zoom)}),t.prototype.evaluate.call(this,e,r,n)},e}(qr))(So.paint.properties["line-width"].specification);Mo.useIntegerZoom=!0;var Vo=function(t){function e(e){t.call(this,e,So);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.setPaintProperty=function(e,r,n){t.prototype.setPaintProperty.call(this,e,r,n),"line-gradient"===e&&this._updateGradient();},e.prototype._updateGradient=function(){var t=this._transitionablePaint._values["line-gradient"].value.expression;this.gradient=hi(t,"lineProgress"),this.gradientTexture=null;},e.prototype.recalculate=function(e){t.prototype.recalculate.call(this,e),this.paint._values["line-floorwidth"]=Mo.possiblyEvaluate(this._transitioningPaint._values["line-width"].value,e);},e.prototype.createBucket=function(t){return new Ao(t)},e.prototype.queryRadius=function(t){var e=t,r=Bo(Gn("line-width",this,e),Gn("line-gap-width",this,e)),n=Gn("line-offset",this,e);return r/2+Math.abs(n)+Yn(this.paint.get("line-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var a=Wn(t,this.paint.get("line-translate"),this.paint.get("line-translate-anchor"),i.angle,o),u=o/2*Bo(this.paint.get("line-width").evaluate(e),this.paint.get("line-gap-width").evaluate(e)),l=this.paint.get("line-offset").evaluate(e);return l&&(r=function(t,e){for(var r=[],n=new s(0,0),i=0;i0?e+2*t:t}var Co=$r([{name:"a_pos_offset",components:4,type:"Int16"},{name:"a_data",components:4,type:"Uint16"}]),Io=$r([{name:"a_projected_pos",components:3,type:"Float32"}],4),Eo=($r([{name:"a_fade_opacity",components:1,type:"Uint32"}],4),$r([{name:"a_placed",components:2,type:"Uint8"}],4)),Fo=($r([{type:"Int16",name:"anchorPointX"},{type:"Int16",name:"anchorPointY"},{type:"Int16",name:"x1"},{type:"Int16",name:"y1"},{type:"Int16",name:"x2"},{type:"Int16",name:"y2"},{type:"Uint32",name:"featureIndex"},{type:"Uint16",name:"sourceLayerIndex"},{type:"Uint16",name:"bucketIndex"},{type:"Int16",name:"radius"},{type:"Int16",name:"signedDistanceFromAnchor"}]),$r([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4)),Po=$r([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4);$r([{type:"Int16",name:"anchorX"},{type:"Int16",name:"anchorY"},{type:"Uint16",name:"glyphStartIndex"},{type:"Uint16",name:"numGlyphs"},{type:"Uint32",name:"vertexStartIndex"},{type:"Uint32",name:"lineStartIndex"},{type:"Uint32",name:"lineLength"},{type:"Uint16",name:"segment"},{type:"Uint16",name:"lowerSize"},{type:"Uint16",name:"upperSize"},{type:"Float32",name:"lineOffsetX"},{type:"Float32",name:"lineOffsetY"},{type:"Uint8",name:"writingMode"},{type:"Uint8",name:"hidden"}]),$r([{type:"Float32",name:"offsetX"}]),$r([{type:"Int16",name:"x"},{type:"Int16",name:"y"},{type:"Int16",name:"tileUnitDistanceFromAnchor"}]);function To(t,e,r){var n=e.layout.get("text-transform").evaluate(r);return"uppercase"===n?t=t.toLocaleUpperCase():"lowercase"===n&&(t=t.toLocaleLowerCase()),Vr.applyArabicShaping&&(t=Vr.applyArabicShaping(t)),t}var Oo={"!":"︕","#":"＃",$:"＄","%":"％","&":"＆","(":"︵",")":"︶","*":"＊","+":"＋",",":"︐","-":"︲",".":"・","/":"／",":":"︓",";":"︔","<":"︿","=":"＝",">":"﹀","?":"︖","@":"＠","[":"﹇","\\":"＼","]":"﹈","^":"＾",_:"︳","`":"｀","{":"︷","|":"―","}":"︸","~":"～","¢":"￠","£":"￡","¥":"￥","¦":"￤","¬":"￢","¯":"￣","–":"︲","—":"︱","‘":"﹃","’":"﹄","“":"﹁","”":"﹂","…":"︙","‧":"・","₩":"￦","、":"︑","。":"︒","〈":"︿","〉":"﹀","《":"︽","》":"︾","「":"﹁","」":"﹂","『":"﹃","』":"﹄","【":"︻","】":"︼","〔":"︹","〕":"︺","〖":"︗","〗":"︘","！":"︕","（":"︵","）":"︶","，":"︐","－":"︲","．":"・","：":"︓","；":"︔","＜":"︿","＞":"﹀","？":"︖","［":"﹇","］":"﹈","＿":"︳","｛":"︷","｜":"―","｝":"︸","｟":"︵","｠":"︶","｡":"︒","｢":"﹁","｣":"﹂"};var Lo=function(t){function e(e,r,n,i){t.call(this,e,r),this.angle=n,void 0!==i&&(this.segment=i);}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.clone=function(){return new e(this.x,this.y,this.angle,this.segment)},e}(s);function jo(t,e){var r=e.expression;if("constant"===r.kind)return{functionType:"constant",layoutSize:r.evaluate(new Br(t+1))};if("source"===r.kind)return{functionType:"source"};for(var n=r.zoomStops,i=0;i0)&&("constant"!==i.value.kind||i.value.value.length>0),u="constant"!==a.value.kind||a.value.value&&a.value.value.length>0;if(this.features=[],s||u){for(var l=e.iconDependencies,p=e.glyphDependencies,c=new Br(this.zoom),h=0,f=t;h=0;s--)o[s]={x:e[s].x,y:e[s].y,tileUnitDistanceFromAnchor:i},s>0&&(i+=e[s-1].dist(e[s]));for(var u=0;u0;this.addCollisionDebugVertices(s,u,l,p,c?this.collisionCircle:this.collisionBox,a.anchorPoint,r,c);}}}},Ko.prototype.deserializeCollisionBoxes=function(t,e,r,n,i){for(var o={},a=e;a0},Ko.prototype.hasIconData=function(){return this.icon.segments.get().length>0},Ko.prototype.hasCollisionBoxData=function(){return this.collisionBox.segments.get().length>0},Ko.prototype.hasCollisionCircleData=function(){return this.collisionCircle.segments.get().length>0},Ko.prototype.sortFeatures=function(t){var e=this;if(this.sortFeaturesByY&&this.sortedAngle!==t&&(this.sortedAngle=t,!(this.text.segments.get().length>1||this.icon.segments.get().length>1))){for(var r=[],n=0;ni.maxh||t>i.maxw||r<=i.maxh&&t<=i.maxw&&(a=i.maxw*i.maxh-t*r)o.free)){if(r===o.h)return this.allocShelf(s,t,r,n);r>o.h||rp)&&(c=2*Math.max(t,p)),(uu)&&(l=2*Math.max(r,u)),this.resize(c,l),this.packOne(t,r,n)):null},t.prototype.allocFreebin=function(t,e,r,n){var i=this.freebins.splice(t,1)[0];return i.id=n,i.w=e,i.h=r,i.refcount=0,this.bins[n]=i,this.ref(i),i},t.prototype.allocShelf=function(t,e,r,n){var i=this.shelves[t].alloc(e,r,n);return this.bins[n]=i,this.ref(i),i},t.prototype.shrink=function(){if(this.shelves.length>0){for(var t=0,e=0,r=0;rthis.free||e>this.h)return null;var n=this.x;return this.x+=t,this.free-=t,new function(t,e,r,n,i,o,a){this.id=t,this.x=e,this.y=r,this.w=n,this.h=i,this.maxw=o||n,this.maxh=a||i,this.refcount=0;}(r,n,this.y,t,e,t,this.h)},e.prototype.resize=function(t){return this.free+=t-this.w,this.w=t,!0},t}();}),ta=function(t,e){var r=e.pixelRatio;this.paddedRect=t,this.pixelRatio=r;},ea={tl:{configurable:!0},br:{configurable:!0},displaySize:{configurable:!0}};ea.tl.get=function(){return[this.paddedRect.x+1,this.paddedRect.y+1]},ea.br.get=function(){return[this.paddedRect.x+this.paddedRect.w-1,this.paddedRect.y+this.paddedRect.h-1]},ea.displaySize.get=function(){return[(this.paddedRect.w-2)/this.pixelRatio,(this.paddedRect.h-2)/this.pixelRatio]},Object.defineProperties(ta.prototype,ea);var ra=function(t){var e=new pi({width:0,height:0}),r={},n=new Qo(0,0,{autoResize:!0});for(var i in t){var o=t[i],a=n.packOne(o.data.width+2,o.data.height+2);e.resize({width:n.w,height:n.h}),pi.copy(o.data,e,{x:0,y:0},{x:a.x+1,y:a.y+1},o.data),r[i]=new ta(a,o);}n.shrink(),e.resize({width:n.w,height:n.h}),this.image=e,this.positions=r;};hr("ImagePosition",ta),hr("ImageAtlas",ra);var na=function(t,e,r,n,i){var o,a,s=8*i-n-1,u=(1<>1,p=-7,c=r?i-1:0,h=r?-1:1,f=t[e+c];for(c+=h,o=f&(1<<-p)-1,f>>=-p,p+=s;p>0;o=256*o+t[e+c],c+=h,p-=8);for(a=o&(1<<-p)-1,o>>=-p,p+=n;p>0;a=256*a+t[e+c],c+=h,p-=8);if(0===o)o=1-l;else{if(o===u)return a?NaN:1/0*(f?-1:1);a+=Math.pow(2,n),o-=l;}return(f?-1:1)*a*Math.pow(2,o-n)},ia=function(t,e,r,n,i,o){var a,s,u,l=8*o-i-1,p=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,f=n?0:o-1,y=n?1:-1,d=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,a=p):(a=Math.floor(Math.log(e)/Math.LN2),e*(u=Math.pow(2,-a))<1&&(a--,u*=2),(e+=a+c>=1?h/u:h*Math.pow(2,1-c))*u>=2&&(a++,u/=2),a+c>=p?(s=0,a=p):a+c>=1?(s=(e*u-1)*Math.pow(2,i),a+=c):(s=e*Math.pow(2,c-1)*Math.pow(2,i),a=0));i>=8;t[r+f]=255&s,f+=y,s/=256,i-=8);for(a=a<0;t[r+f]=255&a,f+=y,a/=256,l-=8);t[r+f-y]|=128*d;},oa=aa;function aa(t){this.buf=ArrayBuffer.isView&&ArrayBuffer.isView(t)?t:new Uint8Array(t||0),this.pos=0,this.type=0,this.length=this.buf.length;}aa.Varint=0,aa.Fixed64=1,aa.Bytes=2,aa.Fixed32=5;function sa(t){return t.type===aa.Bytes?t.readVarint()+t.pos:t.pos+1}function ua(t,e,r){return r?4294967296*e+(t>>>0):4294967296*(e>>>0)+(t>>>0)}function la(t,e,r){var n=e<=16383?1:e<=2097151?2:e<=268435455?3:Math.ceil(Math.log(e)/(7*Math.LN2));r.realloc(n);for(var i=r.pos-1;i>=t;i--)r.buf[i+n]=r.buf[i];}function pa(t,e){for(var r=0;r>>8,t[r+2]=e>>>16,t[r+3]=e>>>24;}function wa(t,e){return(t[e]|t[e+1]<<8|t[e+2]<<16)+(t[e+3]<<24)}aa.prototype={destroy:function(){this.buf=null;},readFields:function(t,e,r){for(r=r||this.length;this.pos>3,o=this.pos;this.type=7&n,t(i,e,this),this.pos===o&&this.skip(n);}return e},readMessage:function(t,e){return this.readFields(t,e,this.readVarint()+this.pos)},readFixed32:function(){var t=xa(this.buf,this.pos);return this.pos+=4,t},readSFixed32:function(){var t=wa(this.buf,this.pos);return this.pos+=4,t},readFixed64:function(){var t=xa(this.buf,this.pos)+4294967296*xa(this.buf,this.pos+4);return this.pos+=8,t},readSFixed64:function(){var t=xa(this.buf,this.pos)+4294967296*wa(this.buf,this.pos+4);return this.pos+=8,t},readFloat:function(){var t=na(this.buf,this.pos,!0,23,4);return this.pos+=4,t},readDouble:function(){var t=na(this.buf,this.pos,!0,52,8);return this.pos+=8,t},readVarint:function(t){var e,r,n=this.buf;return e=127&(r=n[this.pos++]),r<128?e:(e|=(127&(r=n[this.pos++]))<<7,r<128?e:(e|=(127&(r=n[this.pos++]))<<14,r<128?e:(e|=(127&(r=n[this.pos++]))<<21,r<128?e:function(t,e,r){var n,i,o=r.buf;if(i=o[r.pos++],n=(112&i)>>4,i<128)return ua(t,n,e);if(i=o[r.pos++],n|=(127&i)<<3,i<128)return ua(t,n,e);if(i=o[r.pos++],n|=(127&i)<<10,i<128)return ua(t,n,e);if(i=o[r.pos++],n|=(127&i)<<17,i<128)return ua(t,n,e);if(i=o[r.pos++],n|=(127&i)<<24,i<128)return ua(t,n,e);if(i=o[r.pos++],n|=(1&i)<<31,i<128)return ua(t,n,e);throw new Error("Expected varint not more than 10 bytes")}(e|=(15&(r=n[this.pos]))<<28,t,this))))},readVarint64:function(){return this.readVarint(!0)},readSVarint:function(){var t=this.readVarint();return t%2==1?(t+1)/-2:t/2},readBoolean:function(){return Boolean(this.readVarint())},readString:function(){var t=this.readVarint()+this.pos,e=function(t,e,r){var n="",i=e;for(;i239?4:u>223?3:u>191?2:1;if(i+p>r)break;1===p?u<128&&(l=u):2===p?128==(192&(o=t[i+1]))&&(l=(31&u)<<6|63&o)<=127&&(l=null):3===p?(o=t[i+1],a=t[i+2],128==(192&o)&&128==(192&a)&&((l=(15&u)<<12|(63&o)<<6|63&a)<=2047||l>=55296&&l<=57343)&&(l=null)):4===p&&(o=t[i+1],a=t[i+2],s=t[i+3],128==(192&o)&&128==(192&a)&&128==(192&s)&&((l=(15&u)<<18|(63&o)<<12|(63&a)<<6|63&s)<=65535||l>=1114112)&&(l=null)),null===l?(l=65533,p=1):l>65535&&(l-=65536,n+=String.fromCharCode(l>>>10&1023|55296),l=56320|1023&l),n+=String.fromCharCode(l),i+=p;}return n}(this.buf,this.pos,t);return this.pos=t,e},readBytes:function(){var t=this.readVarint()+this.pos,e=this.buf.subarray(this.pos,t);return this.pos=t,e},readPackedVarint:function(t,e){var r=sa(this);for(t=t||[];this.pos127;);else if(e===aa.Bytes)this.pos=this.readVarint()+this.pos;else if(e===aa.Fixed32)this.pos+=4;else{if(e!==aa.Fixed64)throw new Error("Unimplemented type: "+e);this.pos+=8;}},writeTag:function(t,e){this.writeVarint(t<<3|e);},realloc:function(t){for(var e=this.length||16;e268435455||t<0?function(t,e){var r,n;t>=0?(r=t%4294967296|0,n=t/4294967296|0):(n=~(-t/4294967296),4294967295^(r=~(-t%4294967296))?r=r+1|0:(r=0,n=n+1|0));if(t>=0x10000000000000000||t<-0x10000000000000000)throw new Error("Given varint doesn't fit into 10 bytes");e.realloc(10),function(t,e,r){r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos]=127&t;}(r,0,e),function(t,e){var r=(7&t)<<4;if(e.buf[e.pos++]|=r|((t>>>=3)?128:0),!t)return;if(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),!t)return;if(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),!t)return;if(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),!t)return;if(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),!t)return;e.buf[e.pos++]=127&t;}(n,e);}(t,this):(this.realloc(4),this.buf[this.pos++]=127&t|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=t>>>7&127))));},writeSVarint:function(t){this.writeVarint(t<0?2*-t-1:2*t);},writeBoolean:function(t){this.writeVarint(Boolean(t));},writeString:function(t){t=String(t),this.realloc(4*t.length),this.pos++;var e=this.pos;this.pos=function(t,e,r){for(var n,i,o=0;o55295&&n<57344){if(!i){n>56319||o+1===e.length?(t[r++]=239,t[r++]=191,t[r++]=189):i=n;continue}if(n<56320){t[r++]=239,t[r++]=191,t[r++]=189,i=n;continue}n=i-55296<<10|n-56320|65536,i=null;}else i&&(t[r++]=239,t[r++]=191,t[r++]=189,i=null);n<128?t[r++]=n:(n<2048?t[r++]=n>>6|192:(n<65536?t[r++]=n>>12|224:(t[r++]=n>>18|240,t[r++]=n>>12&63|128),t[r++]=n>>6&63|128),t[r++]=63&n|128);}return r}(this.buf,t,this.pos);var r=this.pos-e;r>=128&&la(e,r,this),this.pos=e-1,this.writeVarint(r),this.pos+=r;},writeFloat:function(t){this.realloc(4),ia(this.buf,t,this.pos,!0,23,4),this.pos+=4;},writeDouble:function(t){this.realloc(8),ia(this.buf,t,this.pos,!0,52,8),this.pos+=8;},writeBytes:function(t){var e=t.length;this.writeVarint(e),this.realloc(e);for(var r=0;r=128&&la(r,n,this),this.pos=r-1,this.writeVarint(n),this.pos+=n;},writeMessage:function(t,e,r){this.writeTag(t,aa.Bytes),this.writeRawMessage(e,r);},writePackedVarint:function(t,e){this.writeMessage(t,pa,e);},writePackedSVarint:function(t,e){this.writeMessage(t,ca,e);},writePackedBoolean:function(t,e){this.writeMessage(t,ya,e);},writePackedFloat:function(t,e){this.writeMessage(t,ha,e);},writePackedDouble:function(t,e){this.writeMessage(t,fa,e);},writePackedFixed32:function(t,e){this.writeMessage(t,da,e);},writePackedSFixed32:function(t,e){this.writeMessage(t,va,e);},writePackedFixed64:function(t,e){this.writeMessage(t,ma,e);},writePackedSFixed64:function(t,e){this.writeMessage(t,ga,e);},writeBytesField:function(t,e){this.writeTag(t,aa.Bytes),this.writeBytes(e);},writeFixed32Field:function(t,e){this.writeTag(t,aa.Fixed32),this.writeFixed32(e);},writeSFixed32Field:function(t,e){this.writeTag(t,aa.Fixed32),this.writeSFixed32(e);},writeFixed64Field:function(t,e){this.writeTag(t,aa.Fixed64),this.writeFixed64(e);},writeSFixed64Field:function(t,e){this.writeTag(t,aa.Fixed64),this.writeSFixed64(e);},writeVarintField:function(t,e){this.writeTag(t,aa.Varint),this.writeVarint(e);},writeSVarintField:function(t,e){this.writeTag(t,aa.Varint),this.writeSVarint(e);},writeStringField:function(t,e){this.writeTag(t,aa.Bytes),this.writeString(e);},writeFloatField:function(t,e){this.writeTag(t,aa.Fixed32),this.writeFloat(e);},writeDoubleField:function(t,e){this.writeTag(t,aa.Fixed64),this.writeDouble(e);},writeBooleanField:function(t,e){this.writeVarintField(t,Boolean(e));}};var _a=3;function Aa(t,e,r){1===t&&r.readMessage(ka,e);}function ka(t,e,r){if(3===t){var n=r.readMessage(za,{}),i=n.id,o=n.bitmap,a=n.width,s=n.height,u=n.left,l=n.top,p=n.advance;e.push({id:i,bitmap:new li({width:a+2*_a,height:s+2*_a},o),metrics:{width:a,height:s,left:u,top:l,advance:p}});}}function za(t,e,r){1===t?e.id=r.readVarint():2===t?e.bitmap=r.readBytes():3===t?e.width=r.readVarint():4===t?e.height=r.readVarint():5===t?e.left=r.readSVarint():6===t?e.top=r.readSVarint():7===t&&(e.advance=r.readVarint());}var Sa=_a,Ma=function(t,e,r){this.target=t,this.parent=e,this.mapId=r,this.callbacks={},this.callbackID=0,y(["receive"],this),this.target.addEventListener("message",this.receive,!1);};Ma.prototype.send=function(t,e,r,n){var i=r?this.mapId+":"+this.callbackID++:null;r&&(this.callbacks[i]=r);var o=[];this.target.postMessage({targetMapId:n,sourceMapId:this.mapId,type:t,id:String(i),data:yr(e,o)},o);},Ma.prototype.receive=function(t){var e,r=this,n=t.data,i=n.id;if(!n.targetMapId||this.mapId===n.targetMapId){var o=function(t,e){var n=[];r.target.postMessage({sourceMapId:r.mapId,type:"",id:String(i),error:t?yr(t):null,data:yr(e,n)},n);};if(""===n.type)e=this.callbacks[n.id],delete this.callbacks[n.id],e&&n.error?e(dr(n.error)):e&&e(null,dr(n.data));else if(void 0!==n.id&&this.parent[n.type])this.parent[n.type](n.sourceMapId,dr(n.data),o);else if(void 0!==n.id&&this.parent.getWorkerSource){var a=n.type.split(".");this.parent.getWorkerSource(n.sourceMapId,a[0],a[1])[a[2]](dr(n.data),o);}else this.parent[n.type](dr(n.data));}},Ma.prototype.remove=function(){this.target.removeEventListener("message",this.receive,!1);};var Va=r(n(function(t,e){!function(t){function e(t,e,n){e=Math.pow(2,n)-e-1;var i=r(256*t,256*e,n),o=r(256*(t+1),256*(e+1),n);return i[0]+","+i[1]+","+o[0]+","+o[1]}function r(t,e,r){var n=2*Math.PI*6378137/256/Math.pow(2,r),i=t*n-2*Math.PI*6378137/2,o=e*n-2*Math.PI*6378137/2;return[i,o]}t.getURL=function(t,r,n,i,o,a){return a=a||{},t+"?"+["bbox="+e(n,i,o),"format="+(a.format||"image/png"),"service="+(a.service||"WMS"),"version="+(a.version||"1.1.1"),"request="+(a.request||"GetMap"),"srs="+(a.srs||"EPSG:3857"),"width="+(a.width||256),"height="+(a.height||256),"layers="+r].join("&")},t.getTileBBox=e,t.getMercCoords=r,Object.defineProperty(t,"__esModule",{value:!0});}(e);})),Ba=function(t,e,r){this.z=t,this.x=e,this.y=r,this.key=Ea(0,t,e,r);};Ba.prototype.equals=function(t){return this.z===t.z&&this.x===t.x&&this.y===t.y},Ba.prototype.url=function(t,e){var r=Va.getTileBBox(this.x,this.y,this.z),n=function(t,e,r){for(var n,i="",o=t;o>0;o--)i+=(e&(n=1<this.canonical.z?new Ia(t,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y):new Ia(t,this.wrap,t,this.canonical.x>>e,this.canonical.y>>e)},Ia.prototype.isChildOf=function(t){var e=this.canonical.z-t.canonical.z;return 0===t.overscaledZ||t.overscaledZ>e&&t.canonical.y===this.canonical.y>>e},Ia.prototype.children=function(t){if(this.overscaledZ>=t)return[new Ia(this.overscaledZ+1,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y)];var e=this.canonical.z+1,r=2*this.canonical.x,n=2*this.canonical.y;return[new Ia(e,this.wrap,e,r,n),new Ia(e,this.wrap,e,r+1,n),new Ia(e,this.wrap,e,r,n+1),new Ia(e,this.wrap,e,r+1,n+1)]},Ia.prototype.isLessThan=function(t){return this.wrapt.wrap)&&(this.overscaledZt.overscaledZ)&&(this.canonical.xt.canonical.x)&&this.canonical.y=this.dim+this.border||e<-this.border||e>=this.dim+this.border)throw new RangeError("out of range source coordinates for DEM data");return(e+this.border)*this.stride+(t+this.border)},hr("Level",Fa);var Pa=function(t,e,r){this.uid=t,this.scale=e||1,this.level=r||new Fa(256,512),this.loaded=!!r;};Pa.prototype.loadFromImage=function(t,e){if(t.height!==t.width)throw new RangeError("DEM tiles must be square");if(e&&"mapbox"!==e&&"terrarium"!==e)return b('"'+e+'" is not a valid encoding type. Valid types include "mapbox" and "terrarium".');var r=this.level=new Fa(t.width,t.width/2),n=t.data;this._unpackData(r,n,e||"mapbox");for(var i=0;i=0&&u[3]>=0&&this.grid.insert(o,u[0],u[1],u[2],u[3]);}},ja.prototype.loadVTLayers=function(){return this.vtLayers||(this.vtLayers=new vo.VectorTile(new oa(this.rawTileData)).layers,this.sourceLayerCoder=new Ta(this.vtLayers?Object.keys(this.vtLayers).sort():["_geojsonTileLayer"])),this.vtLayers},ja.prototype.query=function(t,e){var r=this;this.loadVTLayers();for(var n=t.params||{},i=Pn/t.tileSize/t.scale,o=Te(n.filter),a=t.queryGeometry,s=t.queryPadding*i,u=1/0,l=1/0,p=-1/0,c=-1/0,h=0;h=0)return!0;return!1}(o,u)){var l=this.sourceLayerCoder.decode(r),p=this.vtLayers[l].feature(n);if(i(new Br(this.tileID.overscaledZ),p))for(var c=0;c=200&&r.status<300&&r.response){var n;try{n=JSON.parse(r.response);}catch(t){return e(t)}e(null,n);}else 401===r.status&&t.url.match(/mapbox.com/)?e(new k(r.statusText+": you may have provided an invalid Mapbox access token. See https://www.mapbox.com/api-documentation/#access-tokens",r.status,t.url)):e(new k(r.statusText,r.status,t.url));},r.send(),r},t.getImage=function(t,e){return S(t,function(t,r){if(t)e(t);else if(r){var n=new self.Image,i=self.URL||self.webkitURL;n.onload=function(){e(null,n),i.revokeObjectURL(n.src);};var o=new self.Blob([new Uint8Array(r.data)],{type:"image/png"});n.cacheControl=r.cacheControl,n.expires=r.expires,n.src=r.data.byteLength?i.createObjectURL(o):"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";}})},t.ResourceType=A,t.RGBAImage=pi,t.default$2=Qo,t.ImagePosition=ta,t.getArrayBuffer=S,t.default$3=function(t){return new oa(t).readFields(Aa,[])},t.default$4=mr,t.asyncAll=function(t,e,r){if(!t.length)return r(null,[]);var n=t.length,i=new Array(t.length),o=null;t.forEach(function(t,a){e(t,function(t,e){t&&(o=t),i[a]=e,0==--n&&r(o,i);});});},t.AlphaImage=li,t.default$5=E,t.endsWith=d,t.extend=h,t.sphericalToCartesian=function(t){var e=t[0],r=t[1],n=t[2];return r+=90,r*=Math.PI/180,n*=Math.PI/180,{x:e*Math.cos(r)*Math.sin(n),y:e*Math.sin(r)*Math.sin(n),z:e*Math.cos(n)}},t.Evented=I,t.validateStyle=rr,t.validateLight=nr,t.emitValidationErrors=ar,t.default$6=Q,t.number=wt,t.Properties=Dr,t.Transitionable=Er,t.Transitioning=Pr,t.PossiblyEvaluated=Lr,t.DataConstantProperty=jr,t.warnOnce=b,t.uniqueId=function(){return f++},t.default$7=Ma,t.pick=function(t,e){for(var r={},n=0;n@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g,function(t,r,n,i){var o=n||i;return e[r]=!o||o.toLowerCase(),""}),e["max-age"]){var r=parseInt(e["max-age"],10);isNaN(r)?delete e["max-age"]:e["max-age"]=r;}return e},t.default$11=ja,t.default$12=Oa,t.default$13=Te,t.default$14=Ko,t.CollisionBoxArray=dn,t.default$15=zn,t.TriangleIndexArray=pn,t.default$16=Br,t.default$17=a,t.keysDifference=function(t,e){var r=[];for(var n in t)n in e||r.push(n);return r},t.default$18=["type","source","source-layer","minzoom","maxzoom","filter","layout"],t.mat4=ri,t.vec4=ei,t.getSizeData=jo,t.evaluateSizeForFeature=function(t,e,r){var n=e;return"source"===t.functionType?r.lowerSize/10:"composite"===t.functionType?wt(r.lowerSize/10,r.upperSize/10,n.uSizeT):n.uSize},t.evaluateSizeForZoom=function(t,e,r){if("constant"===t.functionType)return{uSizeT:0,uSize:t.layoutSize};if("source"===t.functionType)return{uSizeT:0,uSize:0};if("camera"===t.functionType){var n=t.propertyValue,i=t.zoomRange,o=t.sizeRange,a=c(Se(n,r.specification).interpolationFactor(e,i.min,i.max),0,1);return{uSizeT:0,uSize:o.min+a*(o.max-o.min)}}var s=t.propertyValue,u=t.zoomRange;return{uSizeT:c(Se(s,r.specification).interpolationFactor(e,u.min,u.max),0,1),uSize:0}},t.addDynamicAttributes=Do,t.default$19=$o,t.WritingMode=Ra,t.multiPolygonIntersectsBufferedPoint=Rn,t.multiPolygonIntersectsMultiPolygon=Un,t.multiPolygonIntersectsBufferedMultiLine=Dn,t.polygonIntersectsPolygon=function(t,e){for(var r=0;r-i/2;){if(--a<0)return!1;s-=e[a].dist(o),o=e[a];}s+=e[a].dist(e[a+1]),a++;for(var l=[],u=0;sr;)u-=l.shift().angleDelta;if(u>n)return!1;a++,s+=c.dist(f);}return!0}function o(t,i,r,o,a,s,l,u,h){var c=o?.6*s*l:0,f=Math.max(o?o.right-o.left:0,a?a.right-a.left:0),p=0===t[0].x||t[0].x===h||0===t[0].y||t[0].y===h;return i-f*l=0&&_=0&&I=0&&v+f<=p){var z=new e.default$25(_,I,M,m);z._round(),a&&!n(i,z,l,a,s)||y.push(z);}}g+=S;}h||y.length||u||(y=t(i,g/2,o,a,s,l,u,!0,c));return y}(t,p?i/2*u%i:(f/2+2*s)*l*u%i,i,c,r,f*l,p,!1,h)}r.prototype.replace=function(e){this._layerConfigs={},this._layers={},this.update(e,[]);},r.prototype.update=function(t,r){for(var n=this,o=0,a=t;o0&&(g=Math.max(10*s,g),this._addLineCollisionCircles(e,t,i,i.segment,v,g,r,n,o,h));}else e.emplaceBack(i.x,i.y,p,c,d,f,r,n,o,0,0);this.boxEndIndex=e.length;};s.prototype._addLineCollisionCircles=function(e,t,i,r,n,o,a,s,l,u){var h=o/2,c=Math.floor(n/h),f=1+.4*Math.log(u)/Math.LN2,p=Math.floor(c*f/2),d=-o/2,g=i,v=r+1,y=d,m=-n/2,x=m-n/4;do{if(--v<0){if(y>m)return;v=0;break}y-=t[v].dist(g),g=t[v];}while(y>x);for(var w=t[v].dist(t[v+1]),S=-p;Sn&&(b+=M-n),!(b=t.length)return;w=t[v].dist(t[v+1]);}var _=b-y,I=t[v],z=t[v+1].sub(I)._unit()._mult(_)._add(I)._round(),T=Math.abs(b-d)0)for(var i=(this.length>>1)-1;i>=0;i--)this._down(i);}function c(e,t){return et?1:0}function f(t,i,r){void 0===i&&(i=1),void 0===r&&(r=!1);for(var n=1/0,o=1/0,a=-1/0,s=-1/0,u=t[0],h=0;ha)&&(a=c.x),(!h||c.y>s)&&(s=c.y);}var f=a-n,g=s-o,v=Math.min(f,g),y=v/2,m=new l(null,p);if(0===v)return new e.default$1(n,o);for(var x=n;xS.d||!S.d)&&(S=b,r&&console.log("found best %d after %d probes",Math.round(1e4*b.d)/1e4,M)),b.max-S.d<=i||(y=b.h/2,m.push(new d(b.p.x-y,b.p.y-y,y,t)),m.push(new d(b.p.x+y,b.p.y-y,y,t)),m.push(new d(b.p.x-y,b.p.y+y,y,t)),m.push(new d(b.p.x+y,b.p.y+y,y,t)),M+=4);}return r&&(console.log("num probes: "+M),console.log("best distance: "+S.d)),S.p}function p(e,t){return t.max-e.max}function d(t,i,r,n){this.p=new e.default$1(t,i),this.h=r,this.d=function(t,i){for(var r=!1,n=1/0,o=0;ot.y!=c.y>t.y&&t.x<(c.x-h.x)*(t.y-h.y)/(c.y-h.y)+h.x&&(r=!r),n=Math.min(n,e.distToSegmentSquared(t,h,c));}return(r?1:-1)*Math.sqrt(n)}(this.p,n),this.max=this.d+this.h*Math.SQRT2;}function g(t,i,r,n,o,a){t.createArrays(),t.symbolInstances=[];var s=512*t.overscaling;t.tilePixelRatio=e.default$8/s,t.compareText={},t.iconsNeedLinear=!1;var l=t.layers[0].layout,u=t.layers[0]._unevaluatedLayout._values,h={};if("composite"===t.textSizeData.functionType){var c=t.textSizeData.zoomRange,f=c.min,p=c.max;h.compositeTextSizes=[u["text-size"].possiblyEvaluate(new e.default$16(f)),u["text-size"].possiblyEvaluate(new e.default$16(p))];}if("composite"===t.iconSizeData.functionType){var d=t.iconSizeData.zoomRange,g=d.min,y=d.max;h.compositeIconSizes=[u["icon-size"].possiblyEvaluate(new e.default$16(g)),u["icon-size"].possiblyEvaluate(new e.default$16(y))];}h.layoutTextSize=u["text-size"].possiblyEvaluate(new e.default$16(t.zoom+1)),h.layoutIconSize=u["icon-size"].possiblyEvaluate(new e.default$16(t.zoom+1)),h.textMaxSize=u["text-size"].possiblyEvaluate(new e.default$16(18));for(var m=24*l.get("text-line-height"),x="map"===l.get("text-rotation-alignment")&&"line"===l.get("symbol-placement"),w=l.get("text-keep-upright"),S=0,M=t.features;S=e.default$8||h.y<0||h.y>=e.default$8||t.symbolInstances.push(function(t,i,r,n,o,l,u,h,c,f,p,d,g,v,m,x,w,S,M,b,_){var I,z,T=t.addToLineVertexArray(i,r),P=0,k=0,L=0,$=n.horizontal?n.horizontal.text:"",D=[];n.horizontal&&(I=new s(u,r,i,h,c,f,n.horizontal,p,d,g,t.overscaling),k+=y(t,i,n.horizontal,l,g,M,v,T,n.vertical?e.WritingMode.horizontal:e.WritingMode.horizontalOnly,D,b,_),n.vertical&&(L+=y(t,i,n.vertical,l,g,M,v,T,e.WritingMode.vertical,D,b,_)));var O=I?I.boxStartIndex:t.collisionBoxArray.length,C=I?I.boxEndIndex:t.collisionBoxArray.length;if(o){var A=function(t,i,r,n,o,a){var s,l,u,h,c=i.image,f=r.layout,p=i.top-1/c.pixelRatio,d=i.left-1/c.pixelRatio,g=i.bottom+1/c.pixelRatio,v=i.right+1/c.pixelRatio;if("none"!==f.get("icon-text-fit")&&o){var y=v-d,m=g-p,x=f.get("text-size").evaluate(a)/24,w=o.left*x,S=o.right*x,M=o.top*x,b=S-w,_=o.bottom*x-M,I=f.get("icon-text-fit-padding")[0],z=f.get("icon-text-fit-padding")[1],T=f.get("icon-text-fit-padding")[2],P=f.get("icon-text-fit-padding")[3],k="width"===f.get("icon-text-fit")?.5*(_-m):0,L="height"===f.get("icon-text-fit")?.5*(b-y):0,$="width"===f.get("icon-text-fit")||"both"===f.get("icon-text-fit")?b:y,D="height"===f.get("icon-text-fit")||"both"===f.get("icon-text-fit")?_:m;s=new e.default$1(w+L-P,M+k-I),l=new e.default$1(w+L+z+$,M+k-I),u=new e.default$1(w+L+z+$,M+k+T+D),h=new e.default$1(w+L-P,M+k+T+D);}else s=new e.default$1(d,p),l=new e.default$1(v,p),u=new e.default$1(v,g),h=new e.default$1(d,g);var O=r.layout.get("icon-rotate").evaluate(a)*Math.PI/180;if(O){var C=Math.sin(O),A=Math.cos(O),E=[A,-C,C,A];s._matMult(E),l._matMult(E),h._matMult(E),u._matMult(E);}return[{tl:s,tr:l,bl:h,br:u,tex:c.paddedRect,writingMode:void 0,glyphOffset:[0,0]}]}(0,o,l,0,n.horizontal,M);z=new s(u,r,i,h,c,f,o,m,x,!1,t.overscaling),P=4*A.length;var E=t.iconSizeData,N=null;"source"===E.functionType?N=[10*l.layout.get("icon-size").evaluate(M)]:"composite"===E.functionType&&(N=[10*_.compositeIconSizes[0].evaluate(M),10*_.compositeIconSizes[1].evaluate(M)]),t.addSymbols(t.icon,A,N,S,w,M,!1,i,T.lineStartIndex,T.lineLength);}var R=z?z.boxStartIndex:t.collisionBoxArray.length,B=z?z.boxEndIndex:t.collisionBoxArray.length;t.glyphOffsetArray.length>=e.default$14.MAX_GLYPHS&&e.warnOnce("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907");var F=new a,G=new a;return{key:$,textBoxStartIndex:O,textBoxEndIndex:C,iconBoxStartIndex:R,iconBoxEndIndex:B,textOffset:v,iconOffset:S,anchor:i,line:r,featureIndex:h,feature:M,numGlyphVertices:k,numVerticalGlyphVertices:L,numIconVertices:P,textOpacityState:F,iconOpacityState:G,isDuplicate:!1,placedTextSymbolIndices:D,crossTileID:0}}(t,h,o,r,n,t.layers[0],t.collisionBoxArray,i.index,i.sourceLayerIndex,t.index,w,_,T,g,M,I,P,v,i,l,u));};if("line"===d.get("symbol-placement"))for(var $=0,D=function(t,i,r,n,o){for(var a=[],s=0;s=n&&f.x>=n||(c.x>=n?c=new e.default$1(n,c.y+(f.y-c.y)*((n-c.x)/(f.x-c.x)))._round():f.x>=n&&(f=new e.default$1(n,c.y+(f.y-c.y)*((n-c.x)/(f.x-c.x)))._round()),c.y>=o&&f.y>=o||(c.y>=o?c=new e.default$1(c.x+(f.x-c.x)*((o-c.y)/(f.y-c.y)),o)._round():f.y>=o&&(f=new e.default$1(c.x+(f.x-c.x)*((o-c.y)/(f.y-c.y)),o)._round()),u&&c.equals(u[u.length-1])||(u=[c],a.push(u)),u.push(f)))));}return a}(i.geometry,0,0,e.default$8,e.default$8);$=0;a--)if(r.dist(o[a])0&&(this.data[0]=this.data[this.length],this._down(0)),this.data.pop(),e}},peek:function(){return this.data[0]},_up:function(e){for(var t=this.data,i=this.compare,r=t[e];e>0;){var n=e-1>>1,o=t[n];if(i(r,o)>=0)break;t[e]=o,e=n;}t[e]=r;},_down:function(e){for(var t=this.data,i=this.compare,r=this.length>>1,n=t[e];e=0)break;t[e]=s,e=o;}t[e]=n;}},l.default=u;var x=function(t){var i=new e.AlphaImage({width:0,height:0}),r={},n=new e.default$2(0,0,{autoResize:!0});for(var o in t){var a=t[o],s=r[o]={};for(var l in a){var u=a[+l];if(u&&0!==u.bitmap.width&&0!==u.bitmap.height){var h=n.packOne(u.bitmap.width+2,u.bitmap.height+2);i.resize({width:n.w,height:n.h}),e.AlphaImage.copy(u.bitmap,i,{x:0,y:0},{x:h.x+1,y:h.y+1},u.bitmap),s[l]={rect:h,metrics:u.metrics};}}}n.shrink(),i.resize({width:n.w,height:n.h}),this.image=i,this.positions=r;};e.register("GlyphAtlas",x);var w=function(t){this.tileID=new e.OverscaledTileID(t.tileID.overscaledZ,t.tileID.wrap,t.tileID.canonical.z,t.tileID.canonical.x,t.tileID.canonical.y),this.uid=t.uid,this.zoom=t.zoom,this.pixelRatio=t.pixelRatio,this.tileSize=t.tileSize,this.source=t.source,this.overscaling=this.tileID.overscaleFactor(),this.showCollisionBoxes=t.showCollisionBoxes,this.collectResourceTiming=!!t.collectResourceTiming;};function S(t,i){for(var r=new e.default$16(i),n=0,o=t;n=z.maxzoom))if("none"!==z.visibility)S(I,o.zoom),(c[z.id]=z.createBucket({index:s.bucketLayerIDs.length,layers:I,zoom:o.zoom,pixelRatio:o.pixelRatio,overscaling:o.overscaling,collisionBoxArray:o.collisionBoxArray,sourceLayerIndex:y})).populate(m,f),s.bucketLayerIDs.push(I.map(function(e){return e.id}));}}}var T=e.mapObject(f.glyphDependencies,function(e){return Object.keys(e).map(Number)});Object.keys(T).length?r.send("getGlyphs",{uid:this.uid,stacks:T},function(e,t){l||(l=e,u=t,k.call(o));}):u={};var P=Object.keys(f.iconDependencies);function k(){if(l)return n(l);if(u&&h){var t=new x(u),i=new e.default$28(h);for(var r in c){var o=c[r];o instanceof e.default$14&&(S(o.layers,this.zoom),g(o,u,t.positions,h,i.positions,this.showCollisionBoxes));}this.status="done",n(null,{buckets:e.values(c).filter(function(e){return!e.isEmpty()}),featureIndex:s,collisionBoxArray:this.collisionBoxArray,glyphAtlasImage:t.image,iconAtlasImage:i.image});}}P.length?r.send("getImages",{icons:P},function(e,t){l||(l=e,h=t,k.call(o));}):h={},k.call(this);};var M=function(e){return!(!performance||!performance.getEntriesByName)&&performance.getEntriesByName(e)};function b(t,i){var r=e.getArrayBuffer(t.request,function(t,r){t?i(t):r&&i(null,{vectorTile:new e.default$29.VectorTile(new e.default$30(r.data)),rawData:r.data,cacheControl:r.cacheControl,expires:r.expires});});return function(){r.abort(),i();}}var _=function(e,t,i){this.actor=e,this.layerIndex=t,this.loadVectorData=i||b,this.loading={},this.loaded={};};_.prototype.loadTile=function(t,i){var r=this,n=t.uid;this.loading||(this.loading={});var o=this.loading[n]=new w(t);o.abort=this.loadVectorData(t,function(a,s){if(delete r.loading[n],a||!s)return i(a);var l=s.rawData,u={};s.expires&&(u.expires=s.expires),s.cacheControl&&(u.cacheControl=s.cacheControl);var h={};if(t.request&&t.request.collectResourceTiming){var c=M(t.request.url);c&&(h.resourceTiming=JSON.parse(JSON.stringify(c)));}o.vectorTile=s.vectorTile,o.parse(s.vectorTile,r.layerIndex,r.actor,function(t,r){if(t||!r)return i(t);i(null,e.extend({rawTileData:l.slice(0)},r,u,h));}),r.loaded=r.loaded||{},r.loaded[n]=o;});},_.prototype.reloadTile=function(e,t){var i=this.loaded,r=e.uid,n=this;if(i&&i[r]){var o=i[r];o.showCollisionBoxes=e.showCollisionBoxes;var a=function(e,i){var r=o.reloadCallback;r&&(delete o.reloadCallback,o.parse(o.vectorTile,n.layerIndex,n.actor,r)),t(e,i);};"parsing"===o.status?o.reloadCallback=a:"done"===o.status&&o.parse(o.vectorTile,this.layerIndex,this.actor,a);}},_.prototype.abortTile=function(e,t){var i=this.loading,r=e.uid;i&&i[r]&&i[r].abort&&(i[r].abort(),delete i[r]),t();},_.prototype.removeTile=function(e,t){var i=this.loaded,r=e.uid;i&&i[r]&&delete i[r],t();};var I=function(){this.loading={},this.loaded={};};I.prototype.loadTile=function(t,i){var r=t.uid,n=t.encoding,o=new e.default$31(r);this.loading[r]=o,o.loadFromImage(t.rawImageData,n),delete this.loading[r],this.loaded=this.loaded||{},this.loaded[r]=o,i(null,o);},I.prototype.removeTile=function(e){var t=this.loaded,i=e.uid;t&&t[i]&&delete t[i];};var z={RADIUS:6378137,FLATTENING:1/298.257223563,POLAR_RADIUS:6356752.3142};function T(e){var t=0;if(e&&e.length>0){t+=Math.abs(P(e[0]));for(var i=1;i2){for(a=0;a=0}(e)===t?e:e.reverse()}var A=e.default$29.VectorTileFeature.prototype.toGeoJSON,E=function(t){this._feature=t,this.extent=e.default$8,this.type=t.type,this.properties=t.tags,"id"in t&&!isNaN(t.id)&&(this.id=parseInt(t.id,10));};E.prototype.loadGeometry=function(){if(1===this._feature.type){for(var t=[],i=0,r=this._feature.geometry;i>31}function Q(e,t){for(var i=e.loadGeometry(),r=e.type,n=0,o=0,a=i.length,s=0;sn;){if(o-n>600){var s=o-n+1,l=r-n+1,u=Math.log(s),h=.5*Math.exp(2*u/3),c=.5*Math.sqrt(u*h*(s-h)/s)*(l-s/2<0?-1:1),f=Math.max(n,Math.floor(r-l*h/s+c)),p=Math.min(o,Math.floor(r+(s-l)*h/s+c));e(t,i,r,f,p,a);}var d=i[2*r+a],g=n,v=o;for(te(t,i,n,r),i[2*o+a]>d&&te(t,i,n,o);gd;)v--;}i[2*n+a]===d?te(t,i,n,v):te(t,i,++v,o),v<=r&&(n=v+1),r<=v&&(o=v-1);}}(t,i,s,n,o,a%2);e(t,i,r,n,s-1,a+1);e(t,i,r,s+1,o,a+1);};function te(e,t,i,r){ie(e,i,r),ie(t,2*i,2*r),ie(t,2*i+1,2*r+1);}function ie(e,t,i){var r=e[t];e[t]=e[i],e[i]=r;}var re=function(e,t,i,r,n,o,a){var s,l,u=[0,e.length-1,0],h=[];for(;u.length;){var c=u.pop(),f=u.pop(),p=u.pop();if(f-p<=a)for(var d=p;d<=f;d++)s=t[2*d],l=t[2*d+1],s>=i&&s<=n&&l>=r&&l<=o&&h.push(e[d]);else{var g=Math.floor((p+f)/2);s=t[2*g],l=t[2*g+1],s>=i&&s<=n&&l>=r&&l<=o&&h.push(e[g]);var v=(c+1)%2;(0===c?i<=s:r<=l)&&(u.push(p),u.push(g-1),u.push(v)),(0===c?n>=s:o>=l)&&(u.push(g+1),u.push(f),u.push(v));}}return h};var ne=function(e,t,i,r,n,o){var a=[0,e.length-1,0],s=[],l=n*n;for(;a.length;){var u=a.pop(),h=a.pop(),c=a.pop();if(h-c<=o)for(var f=c;f<=h;f++)oe(t[2*f],t[2*f+1],i,r)<=l&&s.push(e[f]);else{var p=Math.floor((c+h)/2),d=t[2*p],g=t[2*p+1];oe(d,g,i,r)<=l&&s.push(e[p]);var v=(u+1)%2;(0===u?i-n<=d:r-n<=g)&&(a.push(c),a.push(p-1),a.push(v)),(0===u?i+n>=d:r+n>=g)&&(a.push(p+1),a.push(h),a.push(v));}}return s};function oe(e,t,i,r){var n=e-i,o=t-r;return n*n+o*o}var ae=function(e,t,i,r,n){return new se(e,t,i,r,n)};function se(e,t,i,r,n){t=t||le,i=i||ue,n=n||Array,this.nodeSize=r||64,this.points=e,this.ids=new n(e.length),this.coords=new n(2*e.length);for(var o=0;o=1e4?Math.round(t/1e3)+"k":t>=1e3?Math.round(t/100)/10+"k":t;return me(me({},e.properties),{cluster:!0,cluster_id:e.id,point_count:t,point_count_abbreviated:i})}function ve(e){return e/360+.5}function ye(e){var t=Math.sin(e*Math.PI/180),i=.5-.25*Math.log((1+t)/(1-t))/Math.PI;return i<0?0:i>1?1:i}function me(e,t){for(var i in t)e[i]=t[i];return e}function xe(e){return e.x}function we(e){return e.y}function Se(e,t,i,r,n,o){var a=n-i,s=o-r;if(0!==a||0!==s){var l=((e-i)*a+(t-r)*s)/(a*a+s*s);l>1?(i=n,r=o):l>0&&(i+=a*l,r+=s*l);}return(a=e-i)*a+(s=t-r)*s}function Me(e,t,i,r){var n={id:e||null,type:t,geometry:i,tags:r,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0};return function(e){var t=e.geometry,i=e.type;if("Point"===i||"MultiPoint"===i||"LineString"===i)be(e,t);else if("Polygon"===i||"MultiLineString"===i)for(var r=0;r0&&(a+=r?(n*u-l*o)/2:Math.sqrt(Math.pow(l-n,2)+Math.pow(u-o,2))),n=l,o=u;}var h=t.length-3;t[2]=1,function e(t,i,r,n){for(var o,a=n,s=t[i],l=t[i+1],u=t[r],h=t[r+1],c=i+3;ca&&(o=c,a=f);}a>n&&(o-i>3&&e(t,i,o,n),t[o+2]=a,r-o>3&&e(t,o,r,n));}(t,0,h,i),t[h+2]=1,t.size=Math.abs(a),t.start=0,t.end=t.size;}function Te(e,t,i,r){for(var n=0;n1?1:i}function Le(e,t,i,r,n,o,a,s){if(r/=t,o>=(i/=t)&&a<=r)return e;if(o>r||a=i&&d<=r)l.push(h);else if(!(p>r||d=i&&a<=r&&(t.push(e[o]),t.push(e[o+1]),t.push(e[o+2]));}}function De(e,t,i,r,n,o,a){for(var s,l,u=Oe(e),h=0===n?Ee:Ne,c=e.start,f=0;f=i&&(l=h(u,p,d,v,y,i),a&&(u.start=c+s*l)):m>r?x<=r&&(l=h(u,p,d,v,y,r),a&&(u.start=c+s*l)):Ae(u,p,d,g),x=i&&(l=h(u,p,d,v,y,i),w=!0),x>r&&m<=r&&(l=h(u,p,d,v,y,r),w=!0),!o&&w&&(a&&(u.end=c+s*l),t.push(u),u=Oe(e)),a&&(c+=s);}var S=e.length-3;p=e[S],d=e[S+1],g=e[S+2],(m=0===n?p:d)>=i&&m<=r&&Ae(u,p,d,g),S=u.length-3,o&&S>=3&&(u[S]!==u[0]||u[S+1]!==u[1])&&Ae(u,u[0],u[1],u[2]),u.length&&t.push(u);}function Oe(e){var t=[];return t.size=e.size,t.start=e.start,t.end=e.end,t}function Ce(e,t,i,r,n,o){for(var a=0;aa.maxX&&(a.maxX=h),c>a.maxY&&(a.maxY=c);}return a}function Je(e,t,i,r){var n=t.geometry,o=t.type,a=[];if("Point"===o||"MultiPoint"===o)for(var s=0;s0&&t.size<(n?a:r))i.numPoints+=t.length/3;else{for(var s=[],l=0;la)&&(i.numSimplified++,s.push(t[l]),s.push(t[l+1])),i.numPoints++;n&&function(e,t){for(var i=0,r=0,n=e.length,o=n-2;r0===t)for(r=0,n=e.length;r24)throw new Error("maxZoom should be in the 0-24 range");var r=function(e,t){var i=[];if("FeatureCollection"===e.type)for(var r=0;r=this.options.minZoom;n--){var o=+Date.now();this.trees[n+1]=ae(r,xe,we,this.options.nodeSize,Float32Array),r=this._cluster(r,n),t&&console.log("z%d: %d clusters in %dms",n,r.length,+Date.now()-o);}return this.trees[this.options.minZoom]=ae(r,xe,we,this.options.nodeSize,Float32Array),t&&console.timeEnd("total time"),this},getClusters:function(e,t){for(var i=this.trees[this._limitZoom(t)],r=i.range(ve(e[0]),ye(e[3]),ve(e[2]),ye(e[1])),n=[],o=0;o1&&console.time("creation"),f=this.tiles[c]=Ve(e,t,i,r,l),this.tileCoords.push({z:t,x:i,y:r}),u)){u>1&&(console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",t,i,r,f.numFeatures,f.numPoints,f.numSimplified),console.timeEnd("creation"));var p="z"+t;this.stats[p]=(this.stats[p]||0)+1,this.total++;}if(f.source=e,n){if(t===l.maxZoom||t===n)continue;var d=1<1&&console.time("clipping");var g,v,y,m,x,w,S=.5*l.buffer/l.extent,M=.5-S,b=.5+S,_=1+S;g=v=y=m=null,x=Le(e,h,i-S,i+b,0,f.minX,f.maxX,l),w=Le(e,h,i+M,i+_,0,f.minX,f.maxX,l),e=null,x&&(g=Le(x,h,r-S,r+b,1,f.minY,f.maxY,l),v=Le(x,h,r+M,r+_,1,f.minY,f.maxY,l),x=null),w&&(y=Le(w,h,r-S,r+b,1,f.minY,f.maxY,l),m=Le(w,h,r+M,r+_,1,f.minY,f.maxY,l),w=null),u>1&&console.timeEnd("clipping"),s.push(g||[],t+1,2*i,2*r),s.push(v||[],t+1,2*i,2*r+1),s.push(y||[],t+1,2*i+1,2*r),s.push(m||[],t+1,2*i+1,2*r+1);}}},Ye.prototype.getTile=function(e,t,i){var r=this.options,n=r.extent,o=r.debug;if(e<0||e>24)return null;var a=1<1&&console.log("drilling down to z%d-%d-%d",e,t,i);for(var l,u=e,h=t,c=i;!l&&u>0;)u--,h=Math.floor(h/2),c=Math.floor(c/2),l=this.tiles[Ze(u,h,c)];return l&&l.source?(o>1&&console.log("found parent tile z%d-%d-%d",u,h,c),o>1&&console.time("drilling down"),this.splitTile(l.source,u,h,c,e,t,i),o>1&&console.timeEnd("drilling down"),this.tiles[s]?Fe(this.tiles[s],n):null):null};var Xe=function(t){function i(e,i,r){t.call(this,e,i,je),r&&(this.loadGeoJSON=r);}return t&&(i.__proto__=t),i.prototype=Object.create(t&&t.prototype),i.prototype.constructor=i,i.prototype.loadData=function(e,t){this._pendingCallback&&this._pendingCallback(null,{abandoned:!0}),this._pendingCallback=t,this._pendingLoadDataParams=e,this._state&&"Idle"!==this._state?this._state="NeedsLoadData":(this._state="Coalescing",this._loadData());},i.prototype._loadData=function(){var e=this;if(this._pendingCallback&&this._pendingLoadDataParams){var t=this._pendingCallback,i=this._pendingLoadDataParams;delete this._pendingCallback,delete this._pendingLoadDataParams,this.loadGeoJSON(i,function(r,n){if(r||!n)return t(r);if("object"!=typeof n)return t(new Error("Input data is not a valid GeoJSON object."));$(n,!0);try{e._geoJSONIndex=i.cluster?he(i.superclusterOptions).load(n.features):function(e,t){return new Ye(e,t)}(n,i.geojsonVtOptions);}catch(r){return t(r)}e.loaded={};var o={};if(i.request&&i.request.collectResourceTiming){var a=M(i.request.url);a&&(o.resourceTiming={},o.resourceTiming[i.source]=JSON.parse(JSON.stringify(a)));}t(null,o);});}},i.prototype.coalesce=function(){"Coalescing"===this._state?this._state="Idle":"NeedsLoadData"===this._state&&(this._state="Coalescing",this._loadData());},i.prototype.reloadTile=function(e,i){var r=this.loaded,n=e.uid;return r&&r[n]?t.prototype.reloadTile.call(this,e,i):this.loadTile(e,i)},i.prototype.loadGeoJSON=function(t,i){if(t.request)e.getJSON(t.request,i);else{if("string"!=typeof t.data)return i(new Error("Input data is not a valid GeoJSON object."));try{return i(null,JSON.parse(t.data))}catch(e){return i(new Error("Input data is not a valid GeoJSON object."))}}},i.prototype.removeSource=function(e,t){this._pendingCallback&&this._pendingCallback(null,{abandoned:!0}),t();},i}(_),qe=function(t){var i=this;this.self=t,this.actor=new e.default$7(t,this),this.layerIndexes={},this.workerSourceTypes={vector:_,geojson:Xe},this.workerSources={},this.demWorkerSources={},this.self.registerWorkerSource=function(e,t){if(i.workerSourceTypes[e])throw new Error('Worker source with name "'+e+'" already registered.');i.workerSourceTypes[e]=t;},this.self.registerRTLTextPlugin=function(t){if(e.plugin.isLoaded())throw new Error("RTL text plugin already registered.");e.plugin.applyArabicShaping=t.applyArabicShaping,e.plugin.processBidirectionalText=t.processBidirectionalText;};};return qe.prototype.setLayers=function(e,t,i){this.getLayerIndex(e).replace(t),i();},qe.prototype.updateLayers=function(e,t,i){this.getLayerIndex(e).update(t.layers,t.removedIds),i();},qe.prototype.loadTile=function(e,t,i){this.getWorkerSource(e,t.type,t.source).loadTile(t,i);},qe.prototype.loadDEMTile=function(e,t,i){this.getDEMWorkerSource(e,t.source).loadTile(t,i);},qe.prototype.reloadTile=function(e,t,i){this.getWorkerSource(e,t.type,t.source).reloadTile(t,i);},qe.prototype.abortTile=function(e,t,i){this.getWorkerSource(e,t.type,t.source).abortTile(t,i);},qe.prototype.removeTile=function(e,t,i){this.getWorkerSource(e,t.type,t.source).removeTile(t,i);},qe.prototype.removeDEMTile=function(e,t){this.getDEMWorkerSource(e,t.source).removeTile(t);},qe.prototype.removeSource=function(e,t,i){if(this.workerSources[e]&&this.workerSources[e][t.type]&&this.workerSources[e][t.type][t.source]){var r=this.workerSources[e][t.type][t.source];delete this.workerSources[e][t.type][t.source],void 0!==r.removeSource?r.removeSource(t,i):i();}},qe.prototype.loadWorkerSource=function(e,t,i){try{this.self.importScripts(t.url),i();}catch(e){i(e.toString());}},qe.prototype.loadRTLTextPlugin=function(t,i,r){try{e.plugin.isLoaded()||(this.self.importScripts(i),r(e.plugin.isLoaded()?null:new Error("RTL Text Plugin failed to import scripts from "+i)));}catch(e){r(e.toString());}},qe.prototype.getLayerIndex=function(e){var t=this.layerIndexes[e];return t||(t=this.layerIndexes[e]=new r),t},qe.prototype.getWorkerSource=function(e,t,i){var r=this;if(this.workerSources[e]||(this.workerSources[e]={}),this.workerSources[e][t]||(this.workerSources[e][t]={}),!this.workerSources[e][t][i]){var n={send:function(t,i,n){r.actor.send(t,i,n,e);}};this.workerSources[e][t][i]=new this.workerSourceTypes[t](n,this.getLayerIndex(e));}return this.workerSources[e][t][i]},qe.prototype.getDEMWorkerSource=function(e,t){return this.demWorkerSources[e]||(this.demWorkerSources[e]={}),this.demWorkerSources[e][t]||(this.demWorkerSources[e][t]=new I),this.demWorkerSources[e][t]},"undefined"!=typeof WorkerGlobalScope&&"undefined"!=typeof self&&self instanceof WorkerGlobalScope&&new qe(self),qe});
+
+define(["./chunk1.js"],function(t){"use strict";var e=t.createCommonjsModule(function(t){function e(t){return!!("undefined"!=typeof window&&"undefined"!=typeof document&&Array.prototype&&Array.prototype.every&&Array.prototype.filter&&Array.prototype.forEach&&Array.prototype.indexOf&&Array.prototype.lastIndexOf&&Array.prototype.map&&Array.prototype.some&&Array.prototype.reduce&&Array.prototype.reduceRight&&Array.isArray&&Function.prototype&&Function.prototype.bind&&Object.keys&&Object.create&&Object.getPrototypeOf&&Object.getOwnPropertyNames&&Object.isSealed&&Object.isFrozen&&Object.isExtensible&&Object.getOwnPropertyDescriptor&&Object.defineProperty&&Object.defineProperties&&Object.seal&&Object.freeze&&Object.preventExtensions&&"JSON"in window&&"parse"in JSON&&"stringify"in JSON&&function(){if(!("Worker"in window&&"Blob"in window&&"URL"in window))return!1;var t,e,i=new Blob([""],{type:"text/javascript"}),n=URL.createObjectURL(i);try{e=new Worker(n),t=!0;}catch(e){t=!1;}e&&e.terminate();return URL.revokeObjectURL(n),t}()&&"Uint8ClampedArray"in window&&function(t){void 0===i[t]&&(i[t]=function(t){var i=document.createElement("canvas"),n=Object.create(e.webGLContextAttributes);return n.failIfMajorPerformanceCaveat=t,i.probablySupportsContext?i.probablySupportsContext("webgl",n)||i.probablySupportsContext("experimental-webgl",n):i.supportsContext?i.supportsContext("webgl",n)||i.supportsContext("experimental-webgl",n):i.getContext("webgl",n)||i.getContext("experimental-webgl",n)}(t));return i[t]}(t&&t.failIfMajorPerformanceCaveat))}t.exports?t.exports=e:window&&(window.mapboxgl=window.mapboxgl||{},window.mapboxgl.supported=e);var i={};e.webGLContextAttributes={antialias:!1,alpha:!0,stencil:!0,depth:!0};}),i=t.default.performance&&t.default.performance.now?t.default.performance.now.bind(t.default.performance):Date.now.bind(Date),n=t.default.requestAnimationFrame||t.default.mozRequestAnimationFrame||t.default.webkitRequestAnimationFrame||t.default.msRequestAnimationFrame,o=t.default.cancelAnimationFrame||t.default.mozCancelAnimationFrame||t.default.webkitCancelAnimationFrame||t.default.msCancelAnimationFrame,r={now:i,frame:function(t){return n(t)},cancelFrame:function(t){return o(t)},getImageData:function(e){var i=t.default.document.createElement("canvas"),n=i.getContext("2d");if(!n)throw new Error("failed to create canvas 2d context");return i.width=e.width,i.height=e.height,n.drawImage(e,0,0,e.width,e.height),n.getImageData(0,0,e.width,e.height)},hardwareConcurrency:t.default.navigator.hardwareConcurrency||4,get devicePixelRatio(){return t.default.devicePixelRatio},supportsWebp:!1};if(t.default.document){var a=t.default.document.createElement("img");a.onload=function(){r.supportsWebp=!0;},a.src="data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA=";}var s={create:function(e,i,n){var o=t.default.document.createElement(e);return i&&(o.className=i),n&&n.appendChild(o),o},createNS:function(e,i){return t.default.document.createElementNS(e,i)}},l=t.default.document?t.default.document.documentElement.style:null;function c(t){if(!l)return null;for(var e=0;e=0?0:e.button},s.remove=function(t){t.parentNode&&t.parentNode.removeChild(t);};var _={API_URL:"https://api.mapbox.com",REQUIRE_ACCESS_TOKEN:!0,ACCESS_TOKEN:null},g="See https://www.mapbox.com/api-documentation/#access-tokens";function v(t,e){var i=C(_.API_URL);if(t.protocol=i.protocol,t.authority=i.authority,"/"!==i.path&&(t.path=""+i.path+t.path),!_.REQUIRE_ACCESS_TOKEN)return S(t);if(!(e=e||_.ACCESS_TOKEN))throw new Error("An API access token is required to use Mapbox GL. "+g);if("s"===e[0])throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). "+g);return t.params.push("access_token="+e),S(t)}function y(t){return 0===t.indexOf("mapbox:")}var x=function(t,e){if(!y(t))return t;var i=C(t);return i.path="/fonts/v1"+i.path,v(i,e)},b=function(t,e){if(!y(t))return t;var i=C(t);return i.path="/v4/"+i.authority+".json",i.params.push("secure"),v(i,e)},w=function(t,e,i,n){var o=C(t);return y(t)?(o.path="/styles/v1"+o.path+"/sprite"+e+i,v(o,n)):(o.path+=""+e+i,S(o))},E=/(\.(png|jpg)\d*)(?=$)/,T=function(t,e,i){if(!e||!y(e))return t;var n=C(t),o=r.devicePixelRatio>=2||512===i?"@2x":"",a=r.supportsWebp?".webp":"$1";return n.path=n.path.replace(E,""+o+a),function(t){for(var e=0;e