react-globe.gl 2.29.3 → 2.29.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/react-globe.gl.js +1400 -327
  2. package/dist/react-globe.gl.js.map +1 -1
  3. package/dist/react-globe.gl.min.js +3 -3
  4. package/package.json +3 -3
package/dist/react-globe.gl.js CHANGED
@@ -1,11 +1,11 @@
1
- // Version 2.29.3 react-globe.gl - https://github.com/vasturiano/react-globe.gl
1
+ // Version 2.29.5 react-globe.gl - https://github.com/vasturiano/react-globe.gl
2
2
  (function (global, factory) {
3
3
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react')) :
4
4
  typeof define === 'function' && define.amd ? define(['react'], factory) :
5
5
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Globe = factory(global.React));
6
6
  })(this, (function (React) { 'use strict';
7
7
 
8
- function _iterableToArrayLimit$9(arr, i) {
8
+ function _iterableToArrayLimit$a(arr, i) {
9
9
  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
10
10
  if (null != _i) {
11
11
  var _s,
@@ -46,30 +46,30 @@
46
46
  }
47
47
  return obj;
48
48
  }
49
- function _slicedToArray$9(arr, i) {
50
- return _arrayWithHoles$9(arr) || _iterableToArrayLimit$9(arr, i) || _unsupportedIterableToArray$a(arr, i) || _nonIterableRest$9();
49
+ function _slicedToArray$a(arr, i) {
50
+ return _arrayWithHoles$a(arr) || _iterableToArrayLimit$a(arr, i) || _unsupportedIterableToArray$b(arr, i) || _nonIterableRest$a();
51
51
  }
52
52
  function _toConsumableArray$9(arr) {
53
- return _arrayWithoutHoles$9(arr) || _iterableToArray$9(arr) || _unsupportedIterableToArray$a(arr) || _nonIterableSpread$9();
53
+ return _arrayWithoutHoles$9(arr) || _iterableToArray$9(arr) || _unsupportedIterableToArray$b(arr) || _nonIterableSpread$9();
54
54
  }
55
55
  function _arrayWithoutHoles$9(arr) {
56
- if (Array.isArray(arr)) return _arrayLikeToArray$a(arr);
56
+ if (Array.isArray(arr)) return _arrayLikeToArray$b(arr);
57
57
  }
58
- function _arrayWithHoles$9(arr) {
58
+ function _arrayWithHoles$a(arr) {
59
59
  if (Array.isArray(arr)) return arr;
60
60
  }
61
61
  function _iterableToArray$9(iter) {
62
62
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
63
63
  }
64
- function _unsupportedIterableToArray$a(o, minLen) {
64
+ function _unsupportedIterableToArray$b(o, minLen) {
65
65
  if (!o) return;
66
- if (typeof o === "string") return _arrayLikeToArray$a(o, minLen);
66
+ if (typeof o === "string") return _arrayLikeToArray$b(o, minLen);
67
67
  var n = Object.prototype.toString.call(o).slice(8, -1);
68
68
  if (n === "Object" && o.constructor) n = o.constructor.name;
69
69
  if (n === "Map" || n === "Set") return Array.from(o);
70
- if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$a(o, minLen);
70
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$b(o, minLen);
71
71
  }
72
- function _arrayLikeToArray$a(arr, len) {
72
+ function _arrayLikeToArray$b(arr, len) {
73
73
  if (len == null || len > arr.length) len = arr.length;
74
74
  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
75
75
  return arr2;
@@ -77,7 +77,7 @@
77
77
  function _nonIterableSpread$9() {
78
78
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
79
79
  }
80
- function _nonIterableRest$9() {
80
+ function _nonIterableRest$a() {
81
81
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
82
82
  }
83
83
  function _toPrimitive$6(input, hint) {
@@ -97,32 +97,32 @@
97
97
  var omit = function omit(obj, keys) {
98
98
  var keySet = new Set(keys);
99
99
  return Object.assign.apply(Object, [{}].concat(_toConsumableArray$9(Object.entries(obj).filter(function (_ref2) {
100
- var _ref3 = _slicedToArray$9(_ref2, 1),
100
+ var _ref3 = _slicedToArray$a(_ref2, 1),
101
101
  key = _ref3[0];
102
102
  return !keySet.has(key);
103
103
  }).map(function (_ref4) {
104
- var _ref5 = _slicedToArray$9(_ref4, 2),
104
+ var _ref5 = _slicedToArray$a(_ref4, 2),
105
105
  key = _ref5[0],
106
106
  val = _ref5[1];
107
107
  return _defineProperty$4({}, key, val);
108
108
  }))));
109
109
  };
110
110
 
111
- function _arrayLikeToArray$9(r, a) {
111
+ function _arrayLikeToArray$a(r, a) {
112
112
  (null == a || a > r.length) && (a = r.length);
113
113
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
114
114
  return n;
115
115
  }
116
- function _arrayWithHoles$8(r) {
116
+ function _arrayWithHoles$9(r) {
117
117
  if (Array.isArray(r)) return r;
118
118
  }
119
119
  function _arrayWithoutHoles$8(r) {
120
- if (Array.isArray(r)) return _arrayLikeToArray$9(r);
120
+ if (Array.isArray(r)) return _arrayLikeToArray$a(r);
121
121
  }
122
122
  function _iterableToArray$8(r) {
123
123
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
124
124
  }
125
- function _iterableToArrayLimit$8(r, l) {
125
+ function _iterableToArrayLimit$9(r, l) {
126
126
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
127
127
  if (null != t) {
128
128
  var e,
@@ -146,27 +146,27 @@
146
146
  return a;
147
147
  }
148
148
  }
149
- function _nonIterableRest$8() {
149
+ function _nonIterableRest$9() {
150
150
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
151
151
  }
152
152
  function _nonIterableSpread$8() {
153
153
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
154
154
  }
155
- function _slicedToArray$8(r, e) {
156
- return _arrayWithHoles$8(r) || _iterableToArrayLimit$8(r, e) || _unsupportedIterableToArray$9(r, e) || _nonIterableRest$8();
155
+ function _slicedToArray$9(r, e) {
156
+ return _arrayWithHoles$9(r) || _iterableToArrayLimit$9(r, e) || _unsupportedIterableToArray$a(r, e) || _nonIterableRest$9();
157
157
  }
158
158
  function _toConsumableArray$8(r) {
159
- return _arrayWithoutHoles$8(r) || _iterableToArray$8(r) || _unsupportedIterableToArray$9(r) || _nonIterableSpread$8();
159
+ return _arrayWithoutHoles$8(r) || _iterableToArray$8(r) || _unsupportedIterableToArray$a(r) || _nonIterableSpread$8();
160
160
  }
161
- function _unsupportedIterableToArray$9(r, a) {
161
+ function _unsupportedIterableToArray$a(r, a) {
162
162
  if (r) {
163
- if ("string" == typeof r) return _arrayLikeToArray$9(r, a);
163
+ if ("string" == typeof r) return _arrayLikeToArray$a(r, a);
164
164
  var t = {}.toString.call(r).slice(8, -1);
165
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$9(r, a) : undefined;
165
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$a(r, a) : undefined;
166
166
  }
167
167
  }
168
168
 
169
- function index$3 (kapsuleComponent) {
169
+ function index$4 (kapsuleComponent) {
170
170
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
171
171
  _ref$wrapperElementTy = _ref.wrapperElementType,
172
172
  wrapperElementType = _ref$wrapperElementTy === undefined ? 'div' : _ref$wrapperElementTy,
@@ -243,7 +243,7 @@
243
243
  var effectCalled = React.useRef(false);
244
244
  var renderAfterCalled = React.useRef(false);
245
245
  var _useState = React.useState(0),
246
- _useState2 = _slicedToArray$8(_useState, 2);
246
+ _useState2 = _slicedToArray$9(_useState, 2);
247
247
  _useState2[0];
248
248
  var setVal = _useState2[1];
249
249
  if (effectCalled.current) {
@@ -40730,7 +40730,7 @@ void main() {
40730
40730
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
40731
40731
 
40732
40732
  /** Used as a reference to the global object. */
40733
- var root = freeGlobal || freeSelf || Function('return this')();
40733
+ var root$1 = freeGlobal || freeSelf || Function('return this')();
40734
40734
 
40735
40735
  /**
40736
40736
  * Gets the timestamp of the number of milliseconds that have elapsed since
@@ -40749,7 +40749,7 @@ void main() {
40749
40749
  * // => Logs the number of milliseconds it took for the deferred invocation.
40750
40750
  */
40751
40751
  var now$1 = function() {
40752
- return root.Date.now();
40752
+ return root$1.Date.now();
40753
40753
  };
40754
40754
 
40755
40755
  /** Used to match a single whitespace character. */
@@ -40787,7 +40787,7 @@ void main() {
40787
40787
  }
40788
40788
 
40789
40789
  /** Built-in value references. */
40790
- var Symbol$1 = root.Symbol;
40790
+ var Symbol$1 = root$1.Symbol;
40791
40791
 
40792
40792
  /** Used for built-in method references. */
40793
40793
  var objectProto$1 = Object.prototype;
@@ -41174,12 +41174,12 @@ void main() {
41174
41174
  return debounced;
41175
41175
  }
41176
41176
 
41177
- function _arrayLikeToArray$8(r, a) {
41177
+ function _arrayLikeToArray$9(r, a) {
41178
41178
  (null == a || a > r.length) && (a = r.length);
41179
41179
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
41180
41180
  return n;
41181
41181
  }
41182
- function _arrayWithHoles$7(r) {
41182
+ function _arrayWithHoles$8(r) {
41183
41183
  if (Array.isArray(r)) return r;
41184
41184
  }
41185
41185
  function _classCallCheck$5(a, n) {
@@ -41190,7 +41190,7 @@ void main() {
41190
41190
  writable: false
41191
41191
  }), e;
41192
41192
  }
41193
- function _iterableToArrayLimit$7(r, l) {
41193
+ function _iterableToArrayLimit$8(r, l) {
41194
41194
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
41195
41195
  if (null != t) {
41196
41196
  var e,
@@ -41214,17 +41214,17 @@ void main() {
41214
41214
  return a;
41215
41215
  }
41216
41216
  }
41217
- function _nonIterableRest$7() {
41217
+ function _nonIterableRest$8() {
41218
41218
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
41219
41219
  }
41220
- function _slicedToArray$7(r, e) {
41221
- return _arrayWithHoles$7(r) || _iterableToArrayLimit$7(r, e) || _unsupportedIterableToArray$8(r, e) || _nonIterableRest$7();
41220
+ function _slicedToArray$8(r, e) {
41221
+ return _arrayWithHoles$8(r) || _iterableToArrayLimit$8(r, e) || _unsupportedIterableToArray$9(r, e) || _nonIterableRest$8();
41222
41222
  }
41223
- function _unsupportedIterableToArray$8(r, a) {
41223
+ function _unsupportedIterableToArray$9(r, a) {
41224
41224
  if (r) {
41225
- if ("string" == typeof r) return _arrayLikeToArray$8(r, a);
41225
+ if ("string" == typeof r) return _arrayLikeToArray$9(r, a);
41226
41226
  var t = {}.toString.call(r).slice(8, -1);
41227
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$8(r, a) : undefined;
41227
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$9(r, a) : undefined;
41228
41228
  }
41229
41229
  }
41230
41230
 
@@ -41241,7 +41241,7 @@ void main() {
41241
41241
  this.triggerUpdate = triggerUpdate;
41242
41242
  this.onChange = onChange;
41243
41243
  });
41244
- function index$2 (_ref2) {
41244
+ function index$3 (_ref2) {
41245
41245
  var _ref2$stateInit = _ref2.stateInit,
41246
41246
  stateInit = _ref2$stateInit === undefined ? function () {
41247
41247
  return {};
@@ -41341,7 +41341,7 @@ void main() {
41341
41341
 
41342
41342
  // Link aliases
41343
41343
  Object.entries(aliases).forEach(function (_ref4) {
41344
- var _ref5 = _slicedToArray$7(_ref4, 2),
41344
+ var _ref5 = _slicedToArray$8(_ref4, 2),
41345
41345
  alias = _ref5[0],
41346
41346
  target = _ref5[1];
41347
41347
  return comp[alias] = comp[target];
@@ -42986,7 +42986,7 @@ void main() {
42986
42986
  treeProto.y = tree_y;
42987
42987
  treeProto.z = tree_z;
42988
42988
 
42989
- function ascending(a, b) {
42989
+ function ascending$1(a, b) {
42990
42990
  return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
42991
42991
  }
42992
42992
 
@@ -43007,11 +43007,11 @@ void main() {
43007
43007
  // tell if the comparator is symmetric, and an asymmetric comparator can’t be
43008
43008
  // used to test whether a single value is comparable.
43009
43009
  if (f.length !== 2) {
43010
- compare1 = ascending;
43011
- compare2 = (d, x) => ascending(f(d), x);
43010
+ compare1 = ascending$1;
43011
+ compare2 = (d, x) => ascending$1(f(d), x);
43012
43012
  delta = (d, x) => f(d) - x;
43013
43013
  } else {
43014
- compare1 = f === ascending || f === descending ? f : zero$1;
43014
+ compare1 = f === ascending$1 || f === descending ? f : zero$1;
43015
43015
  compare2 = f;
43016
43016
  delta = f;
43017
43017
  }
@@ -43056,7 +43056,7 @@ void main() {
43056
43056
  return x === null ? NaN : +x;
43057
43057
  }
43058
43058
 
43059
- const ascendingBisect = bisector(ascending);
43059
+ const ascendingBisect = bisector(ascending$1);
43060
43060
  const bisectRight = ascendingBisect.right;
43061
43061
  bisector(number$1).center;
43062
43062
 
@@ -43672,7 +43672,7 @@ void main() {
43672
43672
  : m1) * 255;
43673
43673
  }
43674
43674
 
43675
- var constant = x => () => x;
43675
+ var constant$1 = x => () => x;
43676
43676
 
43677
43677
  function linear$1(a, d) {
43678
43678
  return function(t) {
@@ -43688,13 +43688,13 @@ void main() {
43688
43688
 
43689
43689
  function gamma(y) {
43690
43690
  return (y = +y) === 1 ? nogamma : function(a, b) {
43691
- return b - a ? exponential(a, b, y) : constant(isNaN(a) ? b : a);
43691
+ return b - a ? exponential(a, b, y) : constant$1(isNaN(a) ? b : a);
43692
43692
  };
43693
43693
  }
43694
43694
 
43695
43695
  function nogamma(a, b) {
43696
43696
  var d = b - a;
43697
- return d ? linear$1(a, d) : constant(isNaN(a) ? b : a);
43697
+ return d ? linear$1(a, d) : constant$1(isNaN(a) ? b : a);
43698
43698
  }
43699
43699
 
43700
43700
  var rgb$1 = (function rgbGamma(y) {
@@ -43854,7 +43854,7 @@ void main() {
43854
43854
 
43855
43855
  function interpolate(a, b) {
43856
43856
  var t = typeof b, c;
43857
- return b == null || t === "boolean" ? constant(b)
43857
+ return b == null || t === "boolean" ? constant$1(b)
43858
43858
  : (t === "number" ? interpolateNumber
43859
43859
  : t === "string" ? ((c = color$1(b)) ? (b = c, rgb$1) : string)
43860
43860
  : b instanceof color$1 ? rgb$1
@@ -46606,16 +46606,16 @@ void main() {
46606
46606
  .clipAngle(142);
46607
46607
  }
46608
46608
 
46609
- function _arrayLikeToArray$7(r, a) {
46609
+ function _arrayLikeToArray$8(r, a) {
46610
46610
  (null == a || a > r.length) && (a = r.length);
46611
46611
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
46612
46612
  return n;
46613
46613
  }
46614
- function _arrayWithHoles$6(r) {
46614
+ function _arrayWithHoles$7(r) {
46615
46615
  if (Array.isArray(r)) return r;
46616
46616
  }
46617
46617
  function _arrayWithoutHoles$7(r) {
46618
- if (Array.isArray(r)) return _arrayLikeToArray$7(r);
46618
+ if (Array.isArray(r)) return _arrayLikeToArray$8(r);
46619
46619
  }
46620
46620
  function _assertClassBrand$2(e, t, n) {
46621
46621
  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
@@ -46693,7 +46693,7 @@ void main() {
46693
46693
  function _iterableToArray$7(r) {
46694
46694
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
46695
46695
  }
46696
- function _iterableToArrayLimit$6(r, l) {
46696
+ function _iterableToArrayLimit$7(r, l) {
46697
46697
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
46698
46698
  if (null != t) {
46699
46699
  var e,
@@ -46717,7 +46717,7 @@ void main() {
46717
46717
  return a;
46718
46718
  }
46719
46719
  }
46720
- function _nonIterableRest$6() {
46720
+ function _nonIterableRest$7() {
46721
46721
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
46722
46722
  }
46723
46723
  function _nonIterableSpread$7() {
@@ -46733,11 +46733,11 @@ void main() {
46733
46733
  return t.__proto__ = e, t;
46734
46734
  }, _setPrototypeOf$4(t, e);
46735
46735
  }
46736
- function _slicedToArray$6(r, e) {
46737
- return _arrayWithHoles$6(r) || _iterableToArrayLimit$6(r, e) || _unsupportedIterableToArray$7(r, e) || _nonIterableRest$6();
46736
+ function _slicedToArray$7(r, e) {
46737
+ return _arrayWithHoles$7(r) || _iterableToArrayLimit$7(r, e) || _unsupportedIterableToArray$8(r, e) || _nonIterableRest$7();
46738
46738
  }
46739
46739
  function _toConsumableArray$7(r) {
46740
- return _arrayWithoutHoles$7(r) || _iterableToArray$7(r) || _unsupportedIterableToArray$7(r) || _nonIterableSpread$7();
46740
+ return _arrayWithoutHoles$7(r) || _iterableToArray$7(r) || _unsupportedIterableToArray$8(r) || _nonIterableSpread$7();
46741
46741
  }
46742
46742
  function _toPrimitive$5(t, r) {
46743
46743
  if ("object" != typeof t || !t) return t;
@@ -46753,11 +46753,11 @@ void main() {
46753
46753
  var i = _toPrimitive$5(t, "string");
46754
46754
  return "symbol" == typeof i ? i : i + "";
46755
46755
  }
46756
- function _unsupportedIterableToArray$7(r, a) {
46756
+ function _unsupportedIterableToArray$8(r, a) {
46757
46757
  if (r) {
46758
- if ("string" == typeof r) return _arrayLikeToArray$7(r, a);
46758
+ if ("string" == typeof r) return _arrayLikeToArray$8(r, a);
46759
46759
  var t = {}.toString.call(r).slice(8, -1);
46760
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$7(r, a) : undefined;
46760
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$8(r, a) : undefined;
46761
46761
  }
46762
46762
  }
46763
46763
 
@@ -47038,7 +47038,7 @@ void main() {
47038
47038
  var lat0 = lat - latLen / 2;
47039
47039
  var lat1 = lat + latLen / 2;
47040
47040
  d.hullPnts = [[lat, lng], [lat0, lng0], [lat1, lng0], [lat0, lng1], [lat1, lng1]].map(function (_ref2) {
47041
- var _ref3 = _slicedToArray$6(_ref2, 2),
47041
+ var _ref3 = _slicedToArray$7(_ref2, 2),
47042
47042
  lat = _ref3[0],
47043
47043
  lng = _ref3[1];
47044
47044
  return polar2Cartesian$3(lat, lng, _classPrivateFieldGet2$2(_radius, _this3));
@@ -47118,11 +47118,11 @@ void main() {
47118
47118
  var lngRange = [povCoords.lng - searchRadiusLng, povCoords.lng + searchRadiusLng];
47119
47119
  var latRange = [povCoords.lat + searchRadiusLat, povCoords.lat - searchRadiusLat];
47120
47120
  var _findTileXY = findTileXY(this.level, _classPrivateFieldGet2$2(_isMercator, this), lngRange[0], latRange[0]),
47121
- _findTileXY2 = _slicedToArray$6(_findTileXY, 2),
47121
+ _findTileXY2 = _slicedToArray$7(_findTileXY, 2),
47122
47122
  x0 = _findTileXY2[0],
47123
47123
  y0 = _findTileXY2[1];
47124
47124
  var _findTileXY3 = findTileXY(this.level, _classPrivateFieldGet2$2(_isMercator, this), lngRange[1], latRange[1]),
47125
- _findTileXY4 = _slicedToArray$6(_findTileXY3, 2),
47125
+ _findTileXY4 = _slicedToArray$7(_findTileXY3, 2),
47126
47126
  x1 = _findTileXY4[0],
47127
47127
  y1 = _findTileXY4[1];
47128
47128
  !tiles.record && (tiles.record = {}); // Index gen tiles by XY
@@ -47187,7 +47187,7 @@ void main() {
47187
47187
  var _map = [lat + latLen / 2, lat - latLen / 2].map(function (lat) {
47188
47188
  return 0.5 - lat / 180;
47189
47189
  }),
47190
- _map2 = _slicedToArray$6(_map, 2),
47190
+ _map2 = _slicedToArray$7(_map, 2),
47191
47191
  _y = _map2[0],
47192
47192
  _y2 = _map2[1];
47193
47193
  convertMercatorUV(tile.geometry.attributes.uv, _y, _y2);
@@ -47866,16 +47866,16 @@ void main() {
47866
47866
  return {vertices, holes, dimensions};
47867
47867
  }
47868
47868
 
47869
- function _arrayLikeToArray$6(r, a) {
47869
+ function _arrayLikeToArray$7(r, a) {
47870
47870
  (null == a || a > r.length) && (a = r.length);
47871
47871
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
47872
47872
  return n;
47873
47873
  }
47874
- function _arrayWithHoles$5(r) {
47874
+ function _arrayWithHoles$6(r) {
47875
47875
  if (Array.isArray(r)) return r;
47876
47876
  }
47877
47877
  function _arrayWithoutHoles$6(r) {
47878
- if (Array.isArray(r)) return _arrayLikeToArray$6(r);
47878
+ if (Array.isArray(r)) return _arrayLikeToArray$7(r);
47879
47879
  }
47880
47880
  function _assertThisInitialized$3(e) {
47881
47881
  if (undefined === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -47895,7 +47895,7 @@ void main() {
47895
47895
  function _createForOfIteratorHelper(r, e) {
47896
47896
  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
47897
47897
  if (!t) {
47898
- if (Array.isArray(r) || (t = _unsupportedIterableToArray$6(r)) || e) {
47898
+ if (Array.isArray(r) || (t = _unsupportedIterableToArray$7(r)) || e) {
47899
47899
  t && (r = t);
47900
47900
  var n = 0,
47901
47901
  F = function () {};
@@ -47968,7 +47968,7 @@ void main() {
47968
47968
  function _iterableToArray$6(r) {
47969
47969
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
47970
47970
  }
47971
- function _iterableToArrayLimit$5(r, l) {
47971
+ function _iterableToArrayLimit$6(r, l) {
47972
47972
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
47973
47973
  if (null != t) {
47974
47974
  var e,
@@ -47995,7 +47995,7 @@ void main() {
47995
47995
  return a;
47996
47996
  }
47997
47997
  }
47998
- function _nonIterableRest$5() {
47998
+ function _nonIterableRest$6() {
47999
47999
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
48000
48000
  }
48001
48001
  function _nonIterableSpread$6() {
@@ -48011,17 +48011,17 @@ void main() {
48011
48011
  return t.__proto__ = e, t;
48012
48012
  }, _setPrototypeOf$3(t, e);
48013
48013
  }
48014
- function _slicedToArray$5(r, e) {
48015
- return _arrayWithHoles$5(r) || _iterableToArrayLimit$5(r, e) || _unsupportedIterableToArray$6(r, e) || _nonIterableRest$5();
48014
+ function _slicedToArray$6(r, e) {
48015
+ return _arrayWithHoles$6(r) || _iterableToArrayLimit$6(r, e) || _unsupportedIterableToArray$7(r, e) || _nonIterableRest$6();
48016
48016
  }
48017
48017
  function _toConsumableArray$6(r) {
48018
- return _arrayWithoutHoles$6(r) || _iterableToArray$6(r) || _unsupportedIterableToArray$6(r) || _nonIterableSpread$6();
48018
+ return _arrayWithoutHoles$6(r) || _iterableToArray$6(r) || _unsupportedIterableToArray$7(r) || _nonIterableSpread$6();
48019
48019
  }
48020
- function _unsupportedIterableToArray$6(r, a) {
48020
+ function _unsupportedIterableToArray$7(r, a) {
48021
48021
  if (r) {
48022
- if ("string" == typeof r) return _arrayLikeToArray$6(r, a);
48022
+ if ("string" == typeof r) return _arrayLikeToArray$7(r, a);
48023
48023
  var t = {}.toString.call(r).slice(8, -1);
48024
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$6(r, a) : undefined;
48024
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$7(r, a) : undefined;
48025
48025
  }
48026
48026
  }
48027
48027
 
@@ -48121,7 +48121,7 @@ void main() {
48121
48121
  coords.map(function (c) {
48122
48122
  return genPoint(c, r);
48123
48123
  }).forEach(function (_ref) {
48124
- var _ref2 = _slicedToArray$5(_ref, 1),
48124
+ var _ref2 = _slicedToArray$6(_ref, 1),
48125
48125
  newPnt = _ref2[0];
48126
48126
  concatGroup(result, newPnt);
48127
48127
  });
@@ -48129,7 +48129,7 @@ void main() {
48129
48129
  }
48130
48130
  function genLineString(coords, r) {
48131
48131
  var coords3d = interpolateLine(coords, resolution).map(function (_ref3) {
48132
- var _ref4 = _slicedToArray$5(_ref3, 3),
48132
+ var _ref4 = _slicedToArray$6(_ref3, 3),
48133
48133
  lng = _ref4[0],
48134
48134
  lat = _ref4[1],
48135
48135
  _ref4$ = _ref4[2],
@@ -48156,7 +48156,7 @@ void main() {
48156
48156
  coords.map(function (c) {
48157
48157
  return genLineString(c, r);
48158
48158
  }).forEach(function (_ref5) {
48159
- var _ref6 = _slicedToArray$5(_ref5, 1),
48159
+ var _ref6 = _slicedToArray$6(_ref5, 1),
48160
48160
  newLine = _ref6[0];
48161
48161
  concatGroup(result, newLine);
48162
48162
  });
@@ -48165,7 +48165,7 @@ void main() {
48165
48165
  function genPolygon(coords, r) {
48166
48166
  var coords3d = coords.map(function (coordsSegment) {
48167
48167
  return interpolateLine(coordsSegment, resolution).map(function (_ref7) {
48168
- var _ref8 = _slicedToArray$5(_ref7, 3),
48168
+ var _ref8 = _slicedToArray$6(_ref7, 3),
48169
48169
  lng = _ref8[0],
48170
48170
  lat = _ref8[1],
48171
48171
  _ref8$ = _ref8[2],
@@ -48218,7 +48218,7 @@ void main() {
48218
48218
  coords.map(function (c) {
48219
48219
  return genPolygon(c, r);
48220
48220
  }).forEach(function (_ref9) {
48221
- var _ref10 = _slicedToArray$5(_ref9, 2),
48221
+ var _ref10 = _slicedToArray$6(_ref9, 2),
48222
48222
  newOuter = _ref10[0],
48223
48223
  newHoles = _ref10[1];
48224
48224
  concatGroup(outer, newOuter);
@@ -49631,7 +49631,7 @@ void main() {
49631
49631
  toTrianglesDrawMode: toTrianglesDrawMode
49632
49632
  });
49633
49633
 
49634
- var index$1 = (function (p) {
49634
+ var index$2 = (function (p) {
49635
49635
  return typeof p === 'function' ? p // fn
49636
49636
  : typeof p === 'string' ? function (obj) {
49637
49637
  return obj[p];
@@ -49642,14 +49642,14 @@ void main() {
49642
49642
  }); // constant
49643
49643
 
49644
49644
  // This file is autogenerated. It's used to publish ESM to npm.
49645
- function _typeof(obj) {
49645
+ function _typeof$1(obj) {
49646
49646
  "@babel/helpers - typeof";
49647
49647
 
49648
- return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
49648
+ return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
49649
49649
  return typeof obj;
49650
49650
  } : function (obj) {
49651
49651
  return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
49652
- }, _typeof(obj);
49652
+ }, _typeof$1(obj);
49653
49653
  }
49654
49654
 
49655
49655
  // https://github.com/bgrins/TinyColor
@@ -49913,7 +49913,7 @@ void main() {
49913
49913
  // If input is an object, force 1 into "1.0" to handle ratios properly
49914
49914
  // String input requires "1.0" as input, so 1 will be treated as 1
49915
49915
  tinycolor.fromRatio = function (color, opts) {
49916
- if (_typeof(color) == "object") {
49916
+ if (_typeof$1(color) == "object") {
49917
49917
  var newColor = {};
49918
49918
  for (var i in color) {
49919
49919
  if (color.hasOwnProperty(i)) {
@@ -49959,7 +49959,7 @@ void main() {
49959
49959
  if (typeof color == "string") {
49960
49960
  color = stringInputToObject(color);
49961
49961
  }
49962
- if (_typeof(color) == "object") {
49962
+ if (_typeof$1(color) == "object") {
49963
49963
  if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
49964
49964
  rgb = rgbToRgb(color.r, color.g, color.b);
49965
49965
  ok = true;
@@ -50820,16 +50820,16 @@ void main() {
50820
50820
  };
50821
50821
  }
50822
50822
 
50823
- function _arrayLikeToArray$5(r, a) {
50823
+ function _arrayLikeToArray$6(r, a) {
50824
50824
  (null == a || a > r.length) && (a = r.length);
50825
50825
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
50826
50826
  return n;
50827
50827
  }
50828
- function _arrayWithHoles$4(r) {
50828
+ function _arrayWithHoles$5(r) {
50829
50829
  if (Array.isArray(r)) return r;
50830
50830
  }
50831
50831
  function _arrayWithoutHoles$5(r) {
50832
- if (Array.isArray(r)) return _arrayLikeToArray$5(r);
50832
+ if (Array.isArray(r)) return _arrayLikeToArray$6(r);
50833
50833
  }
50834
50834
  function _assertClassBrand$1(e, t, n) {
50835
50835
  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
@@ -50864,7 +50864,7 @@ void main() {
50864
50864
  function _iterableToArray$5(r) {
50865
50865
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
50866
50866
  }
50867
- function _iterableToArrayLimit$4(r, l) {
50867
+ function _iterableToArrayLimit$5(r, l) {
50868
50868
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
50869
50869
  if (null != t) {
50870
50870
  var e,
@@ -50888,17 +50888,17 @@ void main() {
50888
50888
  return a;
50889
50889
  }
50890
50890
  }
50891
- function _nonIterableRest$4() {
50891
+ function _nonIterableRest$5() {
50892
50892
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
50893
50893
  }
50894
50894
  function _nonIterableSpread$5() {
50895
50895
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
50896
50896
  }
50897
- function _slicedToArray$4(r, e) {
50898
- return _arrayWithHoles$4(r) || _iterableToArrayLimit$4(r, e) || _unsupportedIterableToArray$5(r, e) || _nonIterableRest$4();
50897
+ function _slicedToArray$5(r, e) {
50898
+ return _arrayWithHoles$5(r) || _iterableToArrayLimit$5(r, e) || _unsupportedIterableToArray$6(r, e) || _nonIterableRest$5();
50899
50899
  }
50900
50900
  function _toConsumableArray$5(r) {
50901
- return _arrayWithoutHoles$5(r) || _iterableToArray$5(r) || _unsupportedIterableToArray$5(r) || _nonIterableSpread$5();
50901
+ return _arrayWithoutHoles$5(r) || _iterableToArray$5(r) || _unsupportedIterableToArray$6(r) || _nonIterableSpread$5();
50902
50902
  }
50903
50903
  function _toPrimitive$4(t, r) {
50904
50904
  if ("object" != typeof t || !t) return t;
@@ -50914,11 +50914,11 @@ void main() {
50914
50914
  var i = _toPrimitive$4(t, "string");
50915
50915
  return "symbol" == typeof i ? i : i + "";
50916
50916
  }
50917
- function _unsupportedIterableToArray$5(r, a) {
50917
+ function _unsupportedIterableToArray$6(r, a) {
50918
50918
  if (r) {
50919
- if ("string" == typeof r) return _arrayLikeToArray$5(r, a);
50919
+ if ("string" == typeof r) return _arrayLikeToArray$6(r, a);
50920
50920
  var t = {}.toString.call(r).slice(8, -1);
50921
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$5(r, a) : undefined;
50921
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$6(r, a) : undefined;
50922
50922
  }
50923
50923
  }
50924
50924
 
@@ -50956,7 +50956,7 @@ void main() {
50956
50956
  key: "entries",
50957
50957
  value: function entries() {
50958
50958
  return _toConsumableArray$5(_classPrivateFieldGet2$1(_objMap, this).entries()).map(function (_ref) {
50959
- var _ref2 = _slicedToArray$4(_ref, 2),
50959
+ var _ref2 = _slicedToArray$5(_ref, 2),
50960
50960
  o = _ref2[0],
50961
50961
  d = _ref2[1];
50962
50962
  return [d, o];
@@ -50965,7 +50965,7 @@ void main() {
50965
50965
  }, {
50966
50966
  key: "id",
50967
50967
  value: function id(p) {
50968
- _classPrivateFieldSet2$1(_id$a, this, index$1(p));
50968
+ _classPrivateFieldSet2$1(_id$a, this, index$2(p));
50969
50969
  return this;
50970
50970
  }
50971
50971
  }, {
@@ -53152,16 +53152,16 @@ void main() {
53152
53152
  return v(data) ;
53153
53153
  }
53154
53154
 
53155
- function _arrayLikeToArray$4(r, a) {
53155
+ function _arrayLikeToArray$5(r, a) {
53156
53156
  (null == a || a > r.length) && (a = r.length);
53157
53157
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
53158
53158
  return n;
53159
53159
  }
53160
- function _arrayWithHoles$3(r) {
53160
+ function _arrayWithHoles$4(r) {
53161
53161
  if (Array.isArray(r)) return r;
53162
53162
  }
53163
53163
  function _arrayWithoutHoles$4(r) {
53164
- if (Array.isArray(r)) return _arrayLikeToArray$4(r);
53164
+ if (Array.isArray(r)) return _arrayLikeToArray$5(r);
53165
53165
  }
53166
53166
  function _assertThisInitialized$2(e) {
53167
53167
  if (undefined === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
@@ -53206,7 +53206,7 @@ void main() {
53206
53206
  function _iterableToArray$4(r) {
53207
53207
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
53208
53208
  }
53209
- function _iterableToArrayLimit$3(r, l) {
53209
+ function _iterableToArrayLimit$4(r, l) {
53210
53210
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
53211
53211
  if (null != t) {
53212
53212
  var e,
@@ -53230,7 +53230,7 @@ void main() {
53230
53230
  return a;
53231
53231
  }
53232
53232
  }
53233
- function _nonIterableRest$3() {
53233
+ function _nonIterableRest$4() {
53234
53234
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
53235
53235
  }
53236
53236
  function _nonIterableSpread$4() {
@@ -53246,17 +53246,17 @@ void main() {
53246
53246
  return t.__proto__ = e, t;
53247
53247
  }, _setPrototypeOf$2(t, e);
53248
53248
  }
53249
- function _slicedToArray$3(r, e) {
53250
- return _arrayWithHoles$3(r) || _iterableToArrayLimit$3(r, e) || _unsupportedIterableToArray$4(r, e) || _nonIterableRest$3();
53249
+ function _slicedToArray$4(r, e) {
53250
+ return _arrayWithHoles$4(r) || _iterableToArrayLimit$4(r, e) || _unsupportedIterableToArray$5(r, e) || _nonIterableRest$4();
53251
53251
  }
53252
53252
  function _toConsumableArray$4(r) {
53253
- return _arrayWithoutHoles$4(r) || _iterableToArray$4(r) || _unsupportedIterableToArray$4(r) || _nonIterableSpread$4();
53253
+ return _arrayWithoutHoles$4(r) || _iterableToArray$4(r) || _unsupportedIterableToArray$5(r) || _nonIterableSpread$4();
53254
53254
  }
53255
- function _unsupportedIterableToArray$4(r, a) {
53255
+ function _unsupportedIterableToArray$5(r, a) {
53256
53256
  if (r) {
53257
- if ("string" == typeof r) return _arrayLikeToArray$4(r, a);
53257
+ if ("string" == typeof r) return _arrayLikeToArray$5(r, a);
53258
53258
  var t = {}.toString.call(r).slice(8, -1);
53259
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$4(r, a) : undefined;
53259
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$5(r, a) : undefined;
53260
53260
  }
53261
53261
  }
53262
53262
 
@@ -53273,11 +53273,11 @@ void main() {
53273
53273
  coordinates: polygon
53274
53274
  };
53275
53275
  var _geoBounds = geoBounds(boundariesGeojson),
53276
- _geoBounds2 = _slicedToArray$3(_geoBounds, 2),
53277
- _geoBounds2$ = _slicedToArray$3(_geoBounds2[0], 2),
53276
+ _geoBounds2 = _slicedToArray$4(_geoBounds, 2),
53277
+ _geoBounds2$ = _slicedToArray$4(_geoBounds2[0], 2),
53278
53278
  minLng = _geoBounds2$[0],
53279
53279
  minLat = _geoBounds2$[1],
53280
- _geoBounds2$2 = _slicedToArray$3(_geoBounds2[1], 2),
53280
+ _geoBounds2$2 = _slicedToArray$4(_geoBounds2[1], 2),
53281
53281
  maxLng = _geoBounds2$2[0],
53282
53282
  maxLat = _geoBounds2$2[1];
53283
53283
  var crossesPoleOrAntimeridian = minLng > maxLng // crosses antimeridian
@@ -53289,7 +53289,7 @@ void main() {
53289
53289
  // Use d3-geo-voronoi. Slowest, but most accurate for polygons that cross poles or anti-meridian
53290
53290
  var vt = geoVoronoi(points).triangles(); // geoDelaunay generates more triangles than needed
53291
53291
  var pntMap = new Map(points.map(function (_ref2, idx) {
53292
- var _ref3 = _slicedToArray$3(_ref2, 2),
53292
+ var _ref3 = _slicedToArray$4(_ref2, 2),
53293
53293
  lng = _ref3[0],
53294
53294
  lat = _ref3[1];
53295
53295
  return ["".concat(lng, "-").concat(lat), idx];
@@ -53300,7 +53300,7 @@ void main() {
53300
53300
 
53301
53301
  var inds = [];
53302
53302
  triangle.forEach(function (_ref4) {
53303
- var _ref5 = _slicedToArray$3(_ref4, 2),
53303
+ var _ref5 = _slicedToArray$4(_ref4, 2),
53304
53304
  lng = _ref5[0],
53305
53305
  lat = _ref5[1];
53306
53306
  var k = "".concat(lng, "-").concat(lat);
@@ -53362,7 +53362,7 @@ void main() {
53362
53362
  return d[1];
53363
53363
  }), [0, 1]);
53364
53364
  var uvs = points.map(function (_ref6) {
53365
- var _ref7 = _slicedToArray$3(_ref6, 2),
53365
+ var _ref7 = _slicedToArray$4(_ref6, 2),
53366
53366
  lng = _ref7[0],
53367
53367
  lat = _ref7[1];
53368
53368
  return [lngUvScale(lng), latUvScale(lat)];
@@ -53406,11 +53406,11 @@ void main() {
53406
53406
  coordinates: polygon
53407
53407
  };
53408
53408
  var _geoBounds3 = geoBounds(boundariesGeojson),
53409
- _geoBounds4 = _slicedToArray$3(_geoBounds3, 2),
53410
- _geoBounds4$ = _slicedToArray$3(_geoBounds4[0], 2),
53409
+ _geoBounds4 = _slicedToArray$4(_geoBounds3, 2),
53410
+ _geoBounds4$ = _slicedToArray$4(_geoBounds4[0], 2),
53411
53411
  minLng = _geoBounds4$[0],
53412
53412
  minLat = _geoBounds4$[1],
53413
- _geoBounds4$2 = _slicedToArray$3(_geoBounds4[1], 2),
53413
+ _geoBounds4$2 = _slicedToArray$4(_geoBounds4[1], 2),
53414
53414
  maxLng = _geoBounds4$2[0],
53415
53415
  maxLat = _geoBounds4$2[1];
53416
53416
 
@@ -53481,15 +53481,15 @@ void main() {
53481
53481
  // support both modes for backwards threejs compatibility
53482
53482
  var setAttributeFn = new THREE$j.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
53483
53483
  var ConicPolygonGeometry = /*#__PURE__*/function (_THREE$BufferGeometry) {
53484
- function ConicPolygonGeometry(polygonGeoJson, startHeight, endHeight, closedBottom, closedTop, includeSides, curvatureResolution) {
53484
+ function ConicPolygonGeometry(polygonGeoJson, bottomHeight, topHeight, closedBottom, closedTop, includeSides, curvatureResolution) {
53485
53485
  var _this;
53486
53486
  _classCallCheck$1(this, ConicPolygonGeometry);
53487
53487
  _this = _callSuper$1(this, ConicPolygonGeometry);
53488
53488
  _this.type = 'ConicPolygonGeometry';
53489
53489
  _this.parameters = {
53490
53490
  polygonGeoJson: polygonGeoJson,
53491
- startHeight: startHeight,
53492
- endHeight: endHeight,
53491
+ bottomHeight: bottomHeight,
53492
+ topHeight: topHeight,
53493
53493
  closedBottom: closedBottom,
53494
53494
  closedTop: closedTop,
53495
53495
  includeSides: includeSides,
@@ -53497,8 +53497,8 @@ void main() {
53497
53497
  };
53498
53498
 
53499
53499
  // defaults
53500
- startHeight = startHeight || 0;
53501
- endHeight = endHeight || 1;
53500
+ bottomHeight = bottomHeight || 0;
53501
+ topHeight = topHeight || 1;
53502
53502
  closedBottom = closedBottom !== undefined ? closedBottom : true;
53503
53503
  closedTop = closedTop !== undefined ? closedTop : true;
53504
53504
  includeSides = includeSides !== undefined ? includeSides : true;
@@ -53527,8 +53527,8 @@ void main() {
53527
53527
  _this.addGroup(prevIndCnt, indices.length - prevIndCnt, groupCnt++);
53528
53528
  };
53529
53529
  includeSides && addGroup(generateTorso());
53530
- closedBottom && addGroup(generateCap(startHeight, false));
53531
- closedTop && addGroup(generateCap(endHeight, true));
53530
+ closedBottom && addGroup(generateCap(bottomHeight, false));
53531
+ closedTop && addGroup(generateCap(topHeight, true));
53532
53532
 
53533
53533
  // build geometry
53534
53534
  _this.setIndex(indices);
@@ -53541,22 +53541,25 @@ void main() {
53541
53541
  //
53542
53542
 
53543
53543
  function generateVertices(polygon, altitude) {
53544
+ var altFn = typeof altitude === 'function' ? altitude : function () {
53545
+ return altitude;
53546
+ };
53544
53547
  var coords3d = polygon.map(function (coords) {
53545
53548
  return coords.map(function (_ref) {
53546
- var _ref2 = _slicedToArray$3(_ref, 2),
53549
+ var _ref2 = _slicedToArray$4(_ref, 2),
53547
53550
  lng = _ref2[0],
53548
53551
  lat = _ref2[1];
53549
- return polar2Cartesian$1(lat, lng, altitude);
53552
+ return polar2Cartesian$1(lat, lng, altFn(lng, lat));
53550
53553
  });
53551
53554
  });
53552
53555
  // returns { vertices, holes, coordinates }. Each point generates 3 vertice items (x,y,z).
53553
53556
  return flatten(coords3d);
53554
53557
  }
53555
53558
  function generateTorso() {
53556
- var _generateVertices = generateVertices(contour, startHeight),
53559
+ var _generateVertices = generateVertices(contour, bottomHeight),
53557
53560
  bottomVerts = _generateVertices.vertices,
53558
53561
  holes = _generateVertices.holes;
53559
- var _generateVertices2 = generateVertices(contour, endHeight),
53562
+ var _generateVertices2 = generateVertices(contour, topHeight),
53560
53563
  topVerts = _generateVertices2.vertices;
53561
53564
  var vertices = merge([topVerts, bottomVerts]);
53562
53565
  var numPoints = Math.round(topVerts.length / 3);
@@ -53611,21 +53614,21 @@ void main() {
53611
53614
  ];
53612
53615
  }
53613
53616
 
53614
- function _arrayLikeToArray$3(r, a) {
53617
+ function _arrayLikeToArray$4(r, a) {
53615
53618
  (null == a || a > r.length) && (a = r.length);
53616
53619
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
53617
53620
  return n;
53618
53621
  }
53619
- function _arrayWithHoles$2(r) {
53622
+ function _arrayWithHoles$3(r) {
53620
53623
  if (Array.isArray(r)) return r;
53621
53624
  }
53622
53625
  function _arrayWithoutHoles$3(r) {
53623
- if (Array.isArray(r)) return _arrayLikeToArray$3(r);
53626
+ if (Array.isArray(r)) return _arrayLikeToArray$4(r);
53624
53627
  }
53625
53628
  function _iterableToArray$3(r) {
53626
53629
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
53627
53630
  }
53628
- function _iterableToArrayLimit$2(r, l) {
53631
+ function _iterableToArrayLimit$3(r, l) {
53629
53632
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
53630
53633
  if (null != t) {
53631
53634
  var e,
@@ -53649,7 +53652,7 @@ void main() {
53649
53652
  return a;
53650
53653
  }
53651
53654
  }
53652
- function _nonIterableRest$2() {
53655
+ function _nonIterableRest$3() {
53653
53656
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
53654
53657
  }
53655
53658
  function _nonIterableSpread$3() {
@@ -53675,11 +53678,11 @@ void main() {
53675
53678
  }
53676
53679
  return t;
53677
53680
  }
53678
- function _slicedToArray$2(r, e) {
53679
- return _arrayWithHoles$2(r) || _iterableToArrayLimit$2(r, e) || _unsupportedIterableToArray$3(r, e) || _nonIterableRest$2();
53681
+ function _slicedToArray$3(r, e) {
53682
+ return _arrayWithHoles$3(r) || _iterableToArrayLimit$3(r, e) || _unsupportedIterableToArray$4(r, e) || _nonIterableRest$3();
53680
53683
  }
53681
53684
  function _toConsumableArray$3(r) {
53682
- return _arrayWithoutHoles$3(r) || _iterableToArray$3(r) || _unsupportedIterableToArray$3(r) || _nonIterableSpread$3();
53685
+ return _arrayWithoutHoles$3(r) || _iterableToArray$3(r) || _unsupportedIterableToArray$4(r) || _nonIterableSpread$3();
53683
53686
  }
53684
53687
  function _toPrimitive$3(t, r) {
53685
53688
  if ("object" != typeof t || !t) return t;
@@ -53695,15 +53698,15 @@ void main() {
53695
53698
  var i = _toPrimitive$3(t, "string");
53696
53699
  return "symbol" == typeof i ? i : i + "";
53697
53700
  }
53698
- function _unsupportedIterableToArray$3(r, a) {
53701
+ function _unsupportedIterableToArray$4(r, a) {
53699
53702
  if (r) {
53700
- if ("string" == typeof r) return _arrayLikeToArray$3(r, a);
53703
+ if ("string" == typeof r) return _arrayLikeToArray$4(r, a);
53701
53704
  var t = {}.toString.call(r).slice(8, -1);
53702
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : undefined;
53705
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$4(r, a) : undefined;
53703
53706
  }
53704
53707
  }
53705
53708
 
53706
- var index = (function () {
53709
+ var index$1 = (function () {
53707
53710
  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
53708
53711
  var keyAccessors = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
53709
53712
  var multiItem = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
@@ -53777,7 +53780,7 @@ void main() {
53777
53780
  });
53778
53781
  } else {
53779
53782
  Object.entries(node).forEach(function (_ref2) {
53780
- var _ref3 = _slicedToArray$2(_ref2, 2),
53783
+ var _ref3 = _slicedToArray$3(_ref2, 2),
53781
53784
  key = _ref3[0],
53782
53785
  val = _ref3[1];
53783
53786
  return flatten(val, [].concat(_toConsumableArray$3(accKeys), [key]));
@@ -70716,16 +70719,16 @@ void main() {
70716
70719
 
70717
70720
  }
70718
70721
 
70719
- function _arrayLikeToArray$2(r, a) {
70722
+ function _arrayLikeToArray$3(r, a) {
70720
70723
  (null == a || a > r.length) && (a = r.length);
70721
70724
  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
70722
70725
  return n;
70723
70726
  }
70724
- function _arrayWithHoles$1(r) {
70727
+ function _arrayWithHoles$2(r) {
70725
70728
  if (Array.isArray(r)) return r;
70726
70729
  }
70727
70730
  function _arrayWithoutHoles$2(r) {
70728
- if (Array.isArray(r)) return _arrayLikeToArray$2(r);
70731
+ if (Array.isArray(r)) return _arrayLikeToArray$3(r);
70729
70732
  }
70730
70733
  function _assertClassBrand(e, t, n) {
70731
70734
  if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
@@ -70819,7 +70822,7 @@ void main() {
70819
70822
  function _iterableToArray$2(r) {
70820
70823
  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
70821
70824
  }
70822
- function _iterableToArrayLimit$1(r, l) {
70825
+ function _iterableToArrayLimit$2(r, l) {
70823
70826
  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
70824
70827
  if (null != t) {
70825
70828
  var e,
@@ -70846,7 +70849,7 @@ void main() {
70846
70849
  return a;
70847
70850
  }
70848
70851
  }
70849
- function _nonIterableRest$1() {
70852
+ function _nonIterableRest$2() {
70850
70853
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
70851
70854
  }
70852
70855
  function _nonIterableSpread$2() {
@@ -70903,8 +70906,8 @@ void main() {
70903
70906
  return t.__proto__ = e, t;
70904
70907
  }, _setPrototypeOf$1(t, e);
70905
70908
  }
70906
- function _slicedToArray$1(r, e) {
70907
- return _arrayWithHoles$1(r) || _iterableToArrayLimit$1(r, e) || _unsupportedIterableToArray$2(r, e) || _nonIterableRest$1();
70909
+ function _slicedToArray$2(r, e) {
70910
+ return _arrayWithHoles$2(r) || _iterableToArrayLimit$2(r, e) || _unsupportedIterableToArray$3(r, e) || _nonIterableRest$2();
70908
70911
  }
70909
70912
  function _superPropBase(t, o) {
70910
70913
  for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf$1(t)););
@@ -70917,7 +70920,7 @@ void main() {
70917
70920
  } : p;
70918
70921
  }
70919
70922
  function _toConsumableArray$2(r) {
70920
- return _arrayWithoutHoles$2(r) || _iterableToArray$2(r) || _unsupportedIterableToArray$2(r) || _nonIterableSpread$2();
70923
+ return _arrayWithoutHoles$2(r) || _iterableToArray$2(r) || _unsupportedIterableToArray$3(r) || _nonIterableSpread$2();
70921
70924
  }
70922
70925
  function _toPrimitive$2(t, r) {
70923
70926
  if ("object" != typeof t || !t) return t;
@@ -70933,11 +70936,11 @@ void main() {
70933
70936
  var i = _toPrimitive$2(t, "string");
70934
70937
  return "symbol" == typeof i ? i : i + "";
70935
70938
  }
70936
- function _unsupportedIterableToArray$2(r, a) {
70939
+ function _unsupportedIterableToArray$3(r, a) {
70937
70940
  if (r) {
70938
- if ("string" == typeof r) return _arrayLikeToArray$2(r, a);
70941
+ if ("string" == typeof r) return _arrayLikeToArray$3(r, a);
70939
70942
  var t = {}.toString.call(r).slice(8, -1);
70940
- return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : undefined;
70943
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : undefined;
70941
70944
  }
70942
70945
  }
70943
70946
 
@@ -71127,7 +71130,7 @@ void main() {
71127
71130
 
71128
71131
  //
71129
71132
 
71130
- var GlobeLayerKapsule = index$2({
71133
+ var GlobeLayerKapsule = index$3({
71131
71134
  props: {
71132
71135
  globeImageUrl: {},
71133
71136
  bumpImageUrl: {},
@@ -71311,7 +71314,7 @@ void main() {
71311
71314
  var rgbaMatch = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.eE+-]+)\s*\)$/.exec(str.trim().toLowerCase());
71312
71315
  if (rgbaMatch) {
71313
71316
  var _rgbaMatch$slice = rgbaMatch.slice(1),
71314
- _rgbaMatch$slice2 = _slicedToArray$1(_rgbaMatch$slice, 4),
71317
+ _rgbaMatch$slice2 = _slicedToArray$2(_rgbaMatch$slice, 4),
71315
71318
  r = _rgbaMatch$slice2[0],
71316
71319
  g = _rgbaMatch$slice2[1],
71317
71320
  b = _rgbaMatch$slice2[2],
@@ -71435,7 +71438,7 @@ void main() {
71435
71438
 
71436
71439
  //
71437
71440
 
71438
- var PointsLayerKapsule = index$2({
71441
+ var PointsLayerKapsule = index$3({
71439
71442
  props: {
71440
71443
  pointsData: {
71441
71444
  "default": []
@@ -71487,11 +71490,11 @@ void main() {
71487
71490
  },
71488
71491
  update: function update(state, changedProps) {
71489
71492
  // Data accessors
71490
- var latAccessor = index$1(state.pointLat);
71491
- var lngAccessor = index$1(state.pointLng);
71492
- var altitudeAccessor = index$1(state.pointAltitude);
71493
- var radiusAccessor = index$1(state.pointRadius);
71494
- var colorAccessor = index$1(state.pointColor);
71493
+ var latAccessor = index$2(state.pointLat);
71494
+ var lngAccessor = index$2(state.pointLng);
71495
+ var altitudeAccessor = index$2(state.pointAltitude);
71496
+ var radiusAccessor = index$2(state.pointRadius);
71497
+ var colorAccessor = index$2(state.pointColor);
71495
71498
 
71496
71499
  // shared geometry
71497
71500
  var pointGeometry = new THREE$e.CylinderGeometry(1, 1, 1, state.pointResolution);
@@ -71678,7 +71681,7 @@ void main() {
71678
71681
 
71679
71682
  //
71680
71683
 
71681
- var ArcsLayerKapsule = index$2({
71684
+ var ArcsLayerKapsule = index$3({
71682
71685
  props: {
71683
71686
  arcsData: {
71684
71687
  "default": []
@@ -71782,7 +71785,7 @@ void main() {
71782
71785
  // Kick-off dash animations
71783
71786
  state.ticker.onTick.add(function (_, timeDelta) {
71784
71787
  state.dataMapper.entries().map(function (_ref2) {
71785
- var _ref3 = _slicedToArray$1(_ref2, 2),
71788
+ var _ref3 = _slicedToArray$2(_ref2, 2),
71786
71789
  obj = _ref3[1];
71787
71790
  return obj;
71788
71791
  }).filter(function (o) {
@@ -71797,18 +71800,18 @@ void main() {
71797
71800
  },
71798
71801
  update: function update(state) {
71799
71802
  // Data accessors
71800
- var startLatAccessor = index$1(state.arcStartLat);
71801
- var startLngAccessor = index$1(state.arcStartLng);
71802
- var endLatAccessor = index$1(state.arcEndLat);
71803
- var endLngAccessor = index$1(state.arcEndLng);
71804
- var altitudeAccessor = index$1(state.arcAltitude);
71805
- var altitudeAutoScaleAccessor = index$1(state.arcAltitudeAutoScale);
71806
- var strokeAccessor = index$1(state.arcStroke);
71807
- var colorAccessor = index$1(state.arcColor);
71808
- var dashLengthAccessor = index$1(state.arcDashLength);
71809
- var dashGapAccessor = index$1(state.arcDashGap);
71810
- var dashInitialGapAccessor = index$1(state.arcDashInitialGap);
71811
- var dashAnimateTimeAccessor = index$1(state.arcDashAnimateTime);
71803
+ var startLatAccessor = index$2(state.arcStartLat);
71804
+ var startLngAccessor = index$2(state.arcStartLng);
71805
+ var endLatAccessor = index$2(state.arcEndLat);
71806
+ var endLngAccessor = index$2(state.arcEndLng);
71807
+ var altitudeAccessor = index$2(state.arcAltitude);
71808
+ var altitudeAutoScaleAccessor = index$2(state.arcAltitudeAutoScale);
71809
+ var strokeAccessor = index$2(state.arcStroke);
71810
+ var colorAccessor = index$2(state.arcColor);
71811
+ var dashLengthAccessor = index$2(state.arcDashLength);
71812
+ var dashGapAccessor = index$2(state.arcDashGap);
71813
+ var dashInitialGapAccessor = index$2(state.arcDashInitialGap);
71814
+ var dashAnimateTimeAccessor = index$2(state.arcDashAnimateTime);
71812
71815
  state.dataMapper.onUpdateObj(function (group, arc) {
71813
71816
  var stroke = strokeAccessor(arc);
71814
71817
  var useTube = stroke !== null && stroke !== undefined;
@@ -71905,7 +71908,7 @@ void main() {
71905
71908
  endLat = _ref4.endLat,
71906
71909
  endLng = _ref4.endLng;
71907
71910
  var getVec = function getVec(_ref5) {
71908
- var _ref6 = _slicedToArray$1(_ref5, 3),
71911
+ var _ref6 = _slicedToArray$2(_ref5, 3),
71909
71912
  lng = _ref6[0],
71910
71913
  lat = _ref6[1],
71911
71914
  alt = _ref6[2];
@@ -71928,7 +71931,7 @@ void main() {
71928
71931
  var _map = [0.25, 0.75].map(function (t) {
71929
71932
  return [].concat(_toConsumableArray$2(interpolate(t)), [altitude * 1.5]);
71930
71933
  }),
71931
- _map2 = _slicedToArray$1(_map, 2),
71934
+ _map2 = _slicedToArray$2(_map, 2),
71932
71935
  m1Pnt = _map2[0],
71933
71936
  m2Pnt = _map2[1];
71934
71937
  var curve = _construct$1(THREE$d.CubicBezierCurve3, _toConsumableArray$2([startPnt, m1Pnt, m2Pnt, endPnt].map(getVec)));
@@ -72021,7 +72024,7 @@ void main() {
72021
72024
 
72022
72025
  //
72023
72026
 
72024
- var HexBinLayerKapsule = index$2({
72027
+ var HexBinLayerKapsule = index$3({
72025
72028
  props: {
72026
72029
  hexBinPointsData: {
72027
72030
  "default": []
@@ -72087,20 +72090,20 @@ void main() {
72087
72090
  },
72088
72091
  update: function update(state, changedProps) {
72089
72092
  // Accessors
72090
- var latAccessor = index$1(state.hexBinPointLat);
72091
- var lngAccessor = index$1(state.hexBinPointLng);
72092
- var weightAccessor = index$1(state.hexBinPointWeight);
72093
- var altitudeAccessor = index$1(state.hexAltitude);
72094
- var topColorAccessor = index$1(state.hexTopColor);
72095
- var sideColorAccessor = index$1(state.hexSideColor);
72096
- var marginAccessor = index$1(state.hexMargin);
72097
- var byH3Idx = index(state.hexBinPointsData.map(function (d) {
72093
+ var latAccessor = index$2(state.hexBinPointLat);
72094
+ var lngAccessor = index$2(state.hexBinPointLng);
72095
+ var weightAccessor = index$2(state.hexBinPointWeight);
72096
+ var altitudeAccessor = index$2(state.hexAltitude);
72097
+ var topColorAccessor = index$2(state.hexTopColor);
72098
+ var sideColorAccessor = index$2(state.hexSideColor);
72099
+ var marginAccessor = index$2(state.hexMargin);
72100
+ var byH3Idx = index$1(state.hexBinPointsData.map(function (d) {
72098
72101
  return _objectSpread2$1(_objectSpread2$1({}, d), {}, {
72099
72102
  h3Idx: latLngToCell(latAccessor(d), lngAccessor(d), state.hexBinResolution)
72100
72103
  });
72101
72104
  }), 'h3Idx');
72102
72105
  var hexBins = Object.entries(byH3Idx).map(function (_ref3) {
72103
- var _ref4 = _slicedToArray$1(_ref3, 2),
72106
+ var _ref4 = _slicedToArray$2(_ref3, 2),
72104
72107
  h3Idx = _ref4[0],
72105
72108
  points = _ref4[1];
72106
72109
  return {
@@ -72186,15 +72189,15 @@ void main() {
72186
72189
  return st - (st - end) * rat;
72187
72190
  };
72188
72191
  var margin = Math.max(0, Math.min(1, +marginAccessor(d)));
72189
- var _obj$__hexCenter = _slicedToArray$1(obj.__hexCenter, 2),
72192
+ var _obj$__hexCenter = _slicedToArray$2(obj.__hexCenter, 2),
72190
72193
  clat = _obj$__hexCenter[0],
72191
72194
  clng = _obj$__hexCenter[1];
72192
72195
  var geoJson = margin === 0 ? obj.__hexGeoJson : obj.__hexGeoJson.map(function (_ref5) {
72193
- var _ref6 = _slicedToArray$1(_ref5, 2),
72196
+ var _ref6 = _slicedToArray$2(_ref5, 2),
72194
72197
  elng = _ref6[0],
72195
72198
  elat = _ref6[1];
72196
72199
  return [[elng, clng], [elat, clat]].map(function (_ref7) {
72197
- var _ref8 = _slicedToArray$1(_ref7, 2),
72200
+ var _ref8 = _slicedToArray$2(_ref7, 2),
72198
72201
  st = _ref8[0],
72199
72202
  end = _ref8[1];
72200
72203
  return relNum(st, end, margin);
@@ -72278,7 +72281,7 @@ void main() {
72278
72281
  return Math.exp(-sq(x / bw) / 2) / (bw * sqrt2PI);
72279
72282
  }
72280
72283
  var getGeoKDE = function getGeoKDE(_ref) {
72281
- var _ref2 = _slicedToArray$1(_ref, 2),
72284
+ var _ref2 = _slicedToArray$2(_ref, 2),
72282
72285
  lng = _ref2[0],
72283
72286
  lat = _ref2[1];
72284
72287
  var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
@@ -72355,7 +72358,7 @@ void main() {
72355
72358
  c.opacity = Math.cbrt(t);
72356
72359
  return c.formatRgb();
72357
72360
  };
72358
- var HeatmapsLayerKapsule = index$2({
72361
+ var HeatmapsLayerKapsule = index$3({
72359
72362
  props: {
72360
72363
  heatmapsData: {
72361
72364
  "default": []
@@ -72423,15 +72426,15 @@ void main() {
72423
72426
  },
72424
72427
  update: function update(state) {
72425
72428
  // Accessors
72426
- var pointsAccessor = index$1(state.heatmapPoints);
72427
- var latPntAccessor = index$1(state.heatmapPointLat);
72428
- var lngPntAccessor = index$1(state.heatmapPointLng);
72429
- var weightPntAccessor = index$1(state.heatmapPointWeight);
72430
- var bandwidthAccessor = index$1(state.heatmapBandwidth);
72431
- var colorFnAccessor = index$1(state.heatmapColorFn);
72432
- var saturationAccessor = index$1(state.heatmapColorSaturation);
72433
- var baseAltitudeAccessor = index$1(state.heatmapBaseAltitude);
72434
- var topAltitudeAccessor = index$1(state.heatmapTopAltitude);
72429
+ var pointsAccessor = index$2(state.heatmapPoints);
72430
+ var latPntAccessor = index$2(state.heatmapPointLat);
72431
+ var lngPntAccessor = index$2(state.heatmapPointLng);
72432
+ var weightPntAccessor = index$2(state.heatmapPointWeight);
72433
+ var bandwidthAccessor = index$2(state.heatmapBandwidth);
72434
+ var colorFnAccessor = index$2(state.heatmapColorFn);
72435
+ var saturationAccessor = index$2(state.heatmapColorSaturation);
72436
+ var baseAltitudeAccessor = index$2(state.heatmapBaseAltitude);
72437
+ var topAltitudeAccessor = index$2(state.heatmapTopAltitude);
72435
72438
  state.dataMapper.onUpdateObj(function (obj, d) {
72436
72439
  // Accessors
72437
72440
  var bandwidth = bandwidthAccessor(d);
@@ -72467,7 +72470,7 @@ void main() {
72467
72470
  // Get vertex polar coordinates
72468
72471
  var vertexCoords = bufferAttr2Array(obj.geometry.getAttribute('position'));
72469
72472
  var vertexGeoCoords = vertexCoords.map(function (_ref2) {
72470
- var _ref3 = _slicedToArray$1(_ref2, 3),
72473
+ var _ref3 = _slicedToArray$2(_ref2, 3),
72471
72474
  x = _ref3[0],
72472
72475
  y = _ref3[1],
72473
72476
  z = _ref3[2];
@@ -72484,7 +72487,7 @@ void main() {
72484
72487
  // Compute KDE
72485
72488
  var pntsOctree = new PointsOctree(pnts, bandwidth * BW_RADIUS_INFLUENCE);
72486
72489
  var kdeVals = vertexGeoCoords.map(function (vxCoords, idx) {
72487
- var _vertexCoords$idx = _slicedToArray$1(vertexCoords[idx], 3),
72490
+ var _vertexCoords$idx = _slicedToArray$2(vertexCoords[idx], 3),
72488
72491
  x = _vertexCoords$idx[0],
72489
72492
  y = _vertexCoords$idx[1],
72490
72493
  z = _vertexCoords$idx[2];
@@ -72564,7 +72567,7 @@ void main() {
72564
72567
 
72565
72568
  //
72566
72569
 
72567
- var PolygonsLayerKapsule = index$2({
72570
+ var PolygonsLayerKapsule = index$3({
72568
72571
  props: {
72569
72572
  polygonsData: {
72570
72573
  "default": []
@@ -72636,14 +72639,14 @@ void main() {
72636
72639
  },
72637
72640
  update: function update(state) {
72638
72641
  // Data accessors
72639
- var geoJsonAccessor = index$1(state.polygonGeoJsonGeometry);
72640
- var altitudeAccessor = index$1(state.polygonAltitude);
72641
- var capCurvatureResolutionAccessor = index$1(state.polygonCapCurvatureResolution);
72642
- var capColorAccessor = index$1(state.polygonCapColor);
72643
- var capMaterialAccessor = index$1(state.polygonCapMaterial);
72644
- var sideColorAccessor = index$1(state.polygonSideColor);
72645
- var sideMaterialAccessor = index$1(state.polygonSideMaterial);
72646
- var strokeColorAccessor = index$1(state.polygonStrokeColor);
72642
+ var geoJsonAccessor = index$2(state.polygonGeoJsonGeometry);
72643
+ var altitudeAccessor = index$2(state.polygonAltitude);
72644
+ var capCurvatureResolutionAccessor = index$2(state.polygonCapCurvatureResolution);
72645
+ var capColorAccessor = index$2(state.polygonCapColor);
72646
+ var capMaterialAccessor = index$2(state.polygonCapMaterial);
72647
+ var sideColorAccessor = index$2(state.polygonSideColor);
72648
+ var sideMaterialAccessor = index$2(state.polygonSideMaterial);
72649
+ var strokeColorAccessor = index$2(state.polygonStrokeColor);
72647
72650
  var singlePolygons = [];
72648
72651
  state.polygonsData.forEach(function (polygon) {
72649
72652
  var objAttrs = {
@@ -72684,7 +72687,7 @@ void main() {
72684
72687
  strokeColor = _ref2.strokeColor,
72685
72688
  altitude = _ref2.altitude,
72686
72689
  capCurvatureResolution = _ref2.capCurvatureResolution;
72687
- var _obj$children = _slicedToArray$1(obj.children, 2),
72690
+ var _obj$children = _slicedToArray$2(obj.children, 2),
72688
72691
  conicObj = _obj$children[0],
72689
72692
  strokeObj = _obj$children[1];
72690
72693
 
@@ -72767,7 +72770,7 @@ void main() {
72767
72770
  };
72768
72771
  };
72769
72772
  return Object.entries(attrs).every(function (_ref3) {
72770
- var _ref4 = _slicedToArray$1(_ref3, 2),
72773
+ var _ref4 = _slicedToArray$2(_ref3, 2),
72771
72774
  k = _ref4[0],
72772
72775
  v = _ref4[1];
72773
72776
  return obj.hasOwnProperty(k) && compFn(k)(obj[k], v);
@@ -72788,7 +72791,7 @@ void main() {
72788
72791
 
72789
72792
  //
72790
72793
 
72791
- var HexedPolygonsLayerKapsule = index$2({
72794
+ var HexedPolygonsLayerKapsule = index$3({
72792
72795
  props: {
72793
72796
  hexPolygonsData: {
72794
72797
  "default": []
@@ -72851,14 +72854,14 @@ void main() {
72851
72854
  },
72852
72855
  update: function update(state) {
72853
72856
  // Accessors
72854
- var geoJsonAccessor = index$1(state.hexPolygonGeoJsonGeometry);
72855
- var colorAccessor = index$1(state.hexPolygonColor);
72856
- var altitudeAccessor = index$1(state.hexPolygonAltitude);
72857
- var resolutionAccessor = index$1(state.hexPolygonResolution);
72858
- var marginAccessor = index$1(state.hexPolygonMargin);
72859
- var useDotsAccessor = index$1(state.hexPolygonUseDots);
72860
- var curvatureResolutionAccessor = index$1(state.hexPolygonCurvatureResolution);
72861
- var dotResolutionAccessor = index$1(state.hexPolygonDotResolution);
72857
+ var geoJsonAccessor = index$2(state.hexPolygonGeoJsonGeometry);
72858
+ var colorAccessor = index$2(state.hexPolygonColor);
72859
+ var altitudeAccessor = index$2(state.hexPolygonAltitude);
72860
+ var resolutionAccessor = index$2(state.hexPolygonResolution);
72861
+ var marginAccessor = index$2(state.hexPolygonMargin);
72862
+ var useDotsAccessor = index$2(state.hexPolygonUseDots);
72863
+ var curvatureResolutionAccessor = index$2(state.hexPolygonCurvatureResolution);
72864
+ var dotResolutionAccessor = index$2(state.hexPolygonDotResolution);
72862
72865
  state.dataMapper.onUpdateObj(function (obj, d) {
72863
72866
  var geoJson = geoJsonAccessor(d);
72864
72867
  var h3Res = resolutionAccessor(d);
@@ -72933,7 +72936,7 @@ void main() {
72933
72936
  curvatureResolution = _obj$__currentTargetD.curvatureResolution;
72934
72937
  obj.geometry && obj.geometry.dispose();
72935
72938
  obj.geometry = !hexBins.length ? new THREE$9.BufferGeometry() : (BufferGeometryUtils.mergeGeometries || BufferGeometryUtils.mergeBufferGeometries)(hexBins.map(function (h) {
72936
- var _h$hexCenter = _slicedToArray$1(h.hexCenter, 2),
72939
+ var _h$hexCenter = _slicedToArray$2(h.hexCenter, 2),
72937
72940
  clat = _h$hexCenter[0],
72938
72941
  clng = _h$hexCenter[1];
72939
72942
  if (useDots) {
@@ -72952,11 +72955,11 @@ void main() {
72952
72955
 
72953
72956
  // compute new geojson with relative margin
72954
72957
  var _geoJson = margin === 0 ? h.hexGeoJson : h.hexGeoJson.map(function (_ref2) {
72955
- var _ref3 = _slicedToArray$1(_ref2, 2),
72958
+ var _ref3 = _slicedToArray$2(_ref2, 2),
72956
72959
  elng = _ref3[0],
72957
72960
  elat = _ref3[1];
72958
72961
  return [[elng, clng], [elat, clat]].map(function (_ref4) {
72959
- var _ref5 = _slicedToArray$1(_ref4, 2),
72962
+ var _ref5 = _slicedToArray$2(_ref4, 2),
72960
72963
  st = _ref5[0],
72961
72964
  end = _ref5[1];
72962
72965
  return relNum(st, end, margin);
@@ -73000,7 +73003,7 @@ void main() {
73000
73003
  })));
73001
73004
  return function (k) {
73002
73005
  return k === 0 ? fromPnts : k === 1 ? toPnts : interpolator(k).map(function (_ref2) {
73003
- var _ref3 = _slicedToArray$1(_ref2, 3),
73006
+ var _ref3 = _slicedToArray$2(_ref2, 3),
73004
73007
  x = _ref3[0],
73005
73008
  y = _ref3[1],
73006
73009
  z = _ref3[2];
@@ -73023,7 +73026,7 @@ void main() {
73023
73026
 
73024
73027
  //
73025
73028
 
73026
- var PathsLayerKapsule = index$2({
73029
+ var PathsLayerKapsule = index$3({
73027
73030
  props: {
73028
73031
  pathsData: {
73029
73032
  "default": []
@@ -73122,7 +73125,7 @@ void main() {
73122
73125
  // Kick-off dash animations
73123
73126
  state.ticker.onTick.add(function (_, timeDelta) {
73124
73127
  state.dataMapper.entries().map(function (_ref2) {
73125
- var _ref3 = _slicedToArray$1(_ref2, 2),
73128
+ var _ref3 = _slicedToArray$2(_ref2, 2),
73126
73129
  obj = _ref3[1];
73127
73130
  return obj;
73128
73131
  }).filter(function (o) {
@@ -73145,16 +73148,16 @@ void main() {
73145
73148
  },
73146
73149
  update: function update(state) {
73147
73150
  // Data accessors
73148
- var pointsAccessor = index$1(state.pathPoints);
73149
- var pointLatAccessor = index$1(state.pathPointLat);
73150
- var pointLngAccessor = index$1(state.pathPointLng);
73151
- var pointAltAccessor = index$1(state.pathPointAlt);
73152
- var strokeAccessor = index$1(state.pathStroke);
73153
- var colorAccessor = index$1(state.pathColor);
73154
- var dashLengthAccessor = index$1(state.pathDashLength);
73155
- var dashGapAccessor = index$1(state.pathDashGap);
73156
- var dashInitialGapAccessor = index$1(state.pathDashInitialGap);
73157
- var dashAnimateTimeAccessor = index$1(state.pathDashAnimateTime);
73151
+ var pointsAccessor = index$2(state.pathPoints);
73152
+ var pointLatAccessor = index$2(state.pathPointLat);
73153
+ var pointLngAccessor = index$2(state.pathPointLng);
73154
+ var pointAltAccessor = index$2(state.pathPointAlt);
73155
+ var strokeAccessor = index$2(state.pathStroke);
73156
+ var colorAccessor = index$2(state.pathColor);
73157
+ var dashLengthAccessor = index$2(state.pathDashLength);
73158
+ var dashGapAccessor = index$2(state.pathDashGap);
73159
+ var dashInitialGapAccessor = index$2(state.pathDashInitialGap);
73160
+ var dashAnimateTimeAccessor = index$2(state.pathDashAnimateTime);
73158
73161
  state.dataMapper.onUpdateObj(function (group, path) {
73159
73162
  var stroke = strokeAccessor(path);
73160
73163
  var useFatLine = stroke !== null && stroke !== undefined;
@@ -73336,7 +73339,7 @@ void main() {
73336
73339
  return result;
73337
73340
  };
73338
73341
  var getVec = function getVec(_ref6) {
73339
- var _ref7 = _slicedToArray$1(_ref6, 3),
73342
+ var _ref7 = _slicedToArray$2(_ref6, 3),
73340
73343
  lat = _ref7[0],
73341
73344
  lng = _ref7[1],
73342
73345
  alt = _ref7[2];
@@ -73410,7 +73413,7 @@ void main() {
73410
73413
 
73411
73414
  //
73412
73415
 
73413
- var TilesLayerKapsule = index$2({
73416
+ var TilesLayerKapsule = index$3({
73414
73417
  props: {
73415
73418
  tilesData: {
73416
73419
  "default": []
@@ -73475,14 +73478,14 @@ void main() {
73475
73478
  },
73476
73479
  update: function update(state) {
73477
73480
  // Data accessors
73478
- var latAccessor = index$1(state.tileLat);
73479
- var lngAccessor = index$1(state.tileLng);
73480
- var altitudeAccessor = index$1(state.tileAltitude);
73481
- var widthAccessor = index$1(state.tileWidth);
73482
- var heightAccessor = index$1(state.tileHeight);
73483
- var useGlobeProjectionAccessor = index$1(state.tileUseGlobeProjection);
73484
- var materialAccessor = index$1(state.tileMaterial);
73485
- var curvatureResolutionAccessor = index$1(state.tileCurvatureResolution);
73481
+ var latAccessor = index$2(state.tileLat);
73482
+ var lngAccessor = index$2(state.tileLng);
73483
+ var altitudeAccessor = index$2(state.tileAltitude);
73484
+ var widthAccessor = index$2(state.tileWidth);
73485
+ var heightAccessor = index$2(state.tileHeight);
73486
+ var useGlobeProjectionAccessor = index$2(state.tileUseGlobeProjection);
73487
+ var materialAccessor = index$2(state.tileMaterial);
73488
+ var curvatureResolutionAccessor = index$2(state.tileCurvatureResolution);
73486
73489
  state.dataMapper.onUpdateObj(function (obj, d) {
73487
73490
  obj.material = materialAccessor(d); // set material
73488
73491
 
@@ -73554,7 +73557,7 @@ void main() {
73554
73557
 
73555
73558
  //
73556
73559
 
73557
- var LabelsLayerKapsule = index$2({
73560
+ var LabelsLayerKapsule = index$3({
73558
73561
  props: {
73559
73562
  labelsData: {
73560
73563
  "default": []
@@ -73644,23 +73647,23 @@ void main() {
73644
73647
  },
73645
73648
  update: function update(state) {
73646
73649
  // Data accessors
73647
- var latAccessor = index$1(state.labelLat);
73648
- var lngAccessor = index$1(state.labelLng);
73649
- var altitudeAccessor = index$1(state.labelAltitude);
73650
- var textAccessor = index$1(state.labelText);
73651
- var sizeAccessor = index$1(state.labelSize);
73652
- var rotationAccessor = index$1(state.labelRotation);
73653
- var colorAccessor = index$1(state.labelColor);
73654
- var includeDotAccessor = index$1(state.labelIncludeDot);
73655
- var dotRadiusAccessor = index$1(state.labelDotRadius);
73656
- var dotOrientationAccessor = index$1(state.labelDotOrientation);
73650
+ var latAccessor = index$2(state.labelLat);
73651
+ var lngAccessor = index$2(state.labelLng);
73652
+ var altitudeAccessor = index$2(state.labelAltitude);
73653
+ var textAccessor = index$2(state.labelText);
73654
+ var sizeAccessor = index$2(state.labelSize);
73655
+ var rotationAccessor = index$2(state.labelRotation);
73656
+ var colorAccessor = index$2(state.labelColor);
73657
+ var includeDotAccessor = index$2(state.labelIncludeDot);
73658
+ var dotRadiusAccessor = index$2(state.labelDotRadius);
73659
+ var dotOrientationAccessor = index$2(state.labelDotOrientation);
73657
73660
  var orientations = new Set(['right', 'top', 'bottom']);
73658
73661
  var pxPerDeg = 2 * Math.PI * GLOBE_RADIUS / 360;
73659
73662
  state.dataMapper.onUpdateObj(function (obj, d) {
73660
- var _obj$children = _slicedToArray$1(obj.children, 2),
73663
+ var _obj$children = _slicedToArray$2(obj.children, 2),
73661
73664
  dotObj = _obj$children[0],
73662
73665
  textObj = _obj$children[1];
73663
- var _textObj$children = _slicedToArray$1(textObj.children, 1),
73666
+ var _textObj$children = _slicedToArray$2(textObj.children, 1),
73664
73667
  bbObj = _textObj$children[0];
73665
73668
 
73666
73669
  // update color
@@ -73797,7 +73800,7 @@ void main() {
73797
73800
  Vector3: Vector3
73798
73801
  };
73799
73802
  var FrameTicker = _FrameTicker["default"] || _FrameTicker;
73800
- var RingsLayerKapsule = index$2({
73803
+ var RingsLayerKapsule = index$3({
73801
73804
  props: {
73802
73805
  ringsData: {
73803
73806
  "default": []
@@ -73873,17 +73876,17 @@ void main() {
73873
73876
  if (!state.ringsData.length) return;
73874
73877
 
73875
73878
  // Data accessors
73876
- var colorAccessor = index$1(state.ringColor);
73877
- var altitudeAccessor = index$1(state.ringAltitude);
73878
- var maxRadiusAccessor = index$1(state.ringMaxRadius);
73879
- var propagationSpeedAccessor = index$1(state.ringPropagationSpeed);
73880
- var repeatPeriodAccessor = index$1(state.ringRepeatPeriod);
73879
+ var colorAccessor = index$2(state.ringColor);
73880
+ var altitudeAccessor = index$2(state.ringAltitude);
73881
+ var maxRadiusAccessor = index$2(state.ringMaxRadius);
73882
+ var propagationSpeedAccessor = index$2(state.ringPropagationSpeed);
73883
+ var repeatPeriodAccessor = index$2(state.ringRepeatPeriod);
73881
73884
  state.dataMapper.entries().filter(function (_ref2) {
73882
- var _ref3 = _slicedToArray$1(_ref2, 2),
73885
+ var _ref3 = _slicedToArray$2(_ref2, 2),
73883
73886
  o = _ref3[1];
73884
73887
  return o;
73885
73888
  }).forEach(function (_ref4) {
73886
- var _ref5 = _slicedToArray$1(_ref4, 2),
73889
+ var _ref5 = _slicedToArray$2(_ref4, 2),
73887
73890
  d = _ref5[0],
73888
73891
  obj = _ref5[1];
73889
73892
  if ((obj.__nextRingTime || 0) <= time) {
@@ -73952,9 +73955,9 @@ void main() {
73952
73955
  },
73953
73956
  update: function update(state) {
73954
73957
  // Data accessors
73955
- var latAccessor = index$1(state.ringLat);
73956
- var lngAccessor = index$1(state.ringLng);
73957
- var altitudeAccessor = index$1(state.ringAltitude);
73958
+ var latAccessor = index$2(state.ringLat);
73959
+ var lngAccessor = index$2(state.ringLng);
73960
+ var altitudeAccessor = index$2(state.ringAltitude);
73958
73961
  var globeCenter = state.scene.localToWorld(new THREE$3.Vector3(0, 0, 0)); // translate from local to world coords
73959
73962
 
73960
73963
  state.dataMapper.onUpdateObj(function (obj, d) {
@@ -73976,7 +73979,7 @@ void main() {
73976
73979
 
73977
73980
  //
73978
73981
 
73979
- var HtmlElementsLayerKapsule = index$2({
73982
+ var HtmlElementsLayerKapsule = index$3({
73980
73983
  props: {
73981
73984
  htmlElementsData: {
73982
73985
  "default": []
@@ -74009,7 +74012,7 @@ void main() {
74009
74012
  if (!state.dataMapper) return;
74010
74013
  // default to all if no obj specified
74011
74014
  var objs = obj ? [obj] : state.dataMapper.entries().map(function (_ref) {
74012
- var _ref2 = _slicedToArray$1(_ref, 2),
74015
+ var _ref2 = _slicedToArray$2(_ref, 2),
74013
74016
  o = _ref2[1];
74014
74017
  return o;
74015
74018
  }).filter(function (d) {
@@ -74032,7 +74035,7 @@ void main() {
74032
74035
  state.dataMapper = new ThreeDigest(threeObj, {
74033
74036
  objBindAttr: '__threeObjHtml'
74034
74037
  }).onCreateObj(function (d) {
74035
- var elem = index$1(state.htmlElement)(d);
74038
+ var elem = index$2(state.htmlElement)(d);
74036
74039
  var obj = new THREE$2.CSS2DObject(elem);
74037
74040
  obj.__globeObjType = 'html'; // Add object type
74038
74041
 
@@ -74042,9 +74045,9 @@ void main() {
74042
74045
  update: function update(state, changedProps) {
74043
74046
  var _this = this;
74044
74047
  // Data accessors
74045
- var latAccessor = index$1(state.htmlLat);
74046
- var lngAccessor = index$1(state.htmlLng);
74047
- var altitudeAccessor = index$1(state.htmlAltitude);
74048
+ var latAccessor = index$2(state.htmlLat);
74049
+ var lngAccessor = index$2(state.htmlLng);
74050
+ var altitudeAccessor = index$2(state.htmlAltitude);
74048
74051
 
74049
74052
  // objs need to be recreated if this prop has changed
74050
74053
  changedProps.hasOwnProperty('htmlElement') && state.dataMapper.clear();
@@ -74084,7 +74087,7 @@ void main() {
74084
74087
 
74085
74088
  //
74086
74089
 
74087
- var ObjectsLayerKapsule = index$2({
74090
+ var ObjectsLayerKapsule = index$3({
74088
74091
  props: {
74089
74092
  objectsData: {
74090
74093
  "default": []
@@ -74122,7 +74125,7 @@ void main() {
74122
74125
  state.dataMapper = new ThreeDigest(threeObj, {
74123
74126
  objBindAttr: '__threeObjObject'
74124
74127
  }).onCreateObj(function (d) {
74125
- var obj = index$1(state.objectThreeObject)(d);
74128
+ var obj = index$2(state.objectThreeObject)(d);
74126
74129
  if (state.objectThreeObject === obj) {
74127
74130
  // clone object if it's a shared object among all points
74128
74131
  obj = obj.clone();
@@ -74136,11 +74139,11 @@ void main() {
74136
74139
  },
74137
74140
  update: function update(state, changedProps) {
74138
74141
  // Data accessors
74139
- var latAccessor = index$1(state.objectLat);
74140
- var lngAccessor = index$1(state.objectLng);
74141
- var altitudeAccessor = index$1(state.objectAltitude);
74142
- var parallelAccessor = index$1(state.objectFacesSurface);
74143
- var rotationAccessor = index$1(state.objectRotation);
74142
+ var latAccessor = index$2(state.objectLat);
74143
+ var lngAccessor = index$2(state.objectLng);
74144
+ var altitudeAccessor = index$2(state.objectAltitude);
74145
+ var parallelAccessor = index$2(state.objectFacesSurface);
74146
+ var rotationAccessor = index$2(state.objectRotation);
74144
74147
 
74145
74148
  // objs need to be recreated if this prop has changed
74146
74149
  changedProps.hasOwnProperty('objectThreeObject') && state.dataMapper.clear();
@@ -74159,7 +74162,7 @@ void main() {
74159
74162
 
74160
74163
  //
74161
74164
 
74162
- var CustomLayerKapsule = index$2({
74165
+ var CustomLayerKapsule = index$3({
74163
74166
  props: {
74164
74167
  customLayerData: {
74165
74168
  "default": []
@@ -74178,7 +74181,7 @@ void main() {
74178
74181
  state.dataMapper = new ThreeDigest(threeObj, {
74179
74182
  objBindAttr: '__threeObjCustom'
74180
74183
  }).onCreateObj(function (d) {
74181
- var obj = index$1(state.customThreeObject)(d, GLOBE_RADIUS);
74184
+ var obj = index$2(state.customThreeObject)(d, GLOBE_RADIUS);
74182
74185
  if (obj) {
74183
74186
  if (state.customThreeObject === obj) {
74184
74187
  // clone object if it's a shared object among all points
@@ -74194,7 +74197,7 @@ void main() {
74194
74197
  emptyObject(state.scene);
74195
74198
  } // Clear the existing objects to create all new, if there's no update method (brute-force)
74196
74199
 
74197
- var customObjectUpdateAccessor = index$1(state.customThreeObjectUpdate);
74200
+ var customObjectUpdateAccessor = index$2(state.customThreeObjectUpdate);
74198
74201
 
74199
74202
  // objs need to be recreated if this prop has changed
74200
74203
  changedProps.hasOwnProperty('customThreeObject') && state.dataMapper.clear();
@@ -74281,7 +74284,7 @@ void main() {
74281
74284
 
74282
74285
  //
74283
74286
 
74284
- var Globe$1 = index$2({
74287
+ var Globe$1 = index$3({
74285
74288
  props: _objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1({
74286
74289
  onGlobeReady: {
74287
74290
  triggerUpdate: false
@@ -80480,16 +80483,16 @@ void main() {
80480
80483
  * @param {Node?} [elseNode=null] - The node that is evaluate when the condition ends up `false`.
80481
80484
  * @returns {ConditionalNode}
80482
80485
  */
80483
- const select = /*@__PURE__*/ nodeProxy( ConditionalNode );
80486
+ const select$1 = /*@__PURE__*/ nodeProxy( ConditionalNode );
80484
80487
 
80485
- addMethodChaining( 'select', select );
80488
+ addMethodChaining( 'select', select$1 );
80486
80489
 
80487
80490
  //
80488
80491
 
80489
80492
  const cond = ( ...params ) => { // @deprecated, r168
80490
80493
 
80491
80494
  console.warn( 'TSL.ConditionalNode: cond() has been renamed to select().' );
80492
- return select( ...params );
80495
+ return select$1( ...params );
80493
80496
 
80494
80497
  };
80495
80498
 
@@ -82585,7 +82588,7 @@ void main() {
82585
82588
  * @param {ConditionalNode?} conditional - An optional conditional node. It allows to decide whether the discard should be executed or not.
82586
82589
  * @return {Node} The `discard` expression.
82587
82590
  */
82588
- const Discard = ( conditional ) => ( conditional ? select( conditional, expression( 'discard' ) ) : expression( 'discard' ) ).append();
82591
+ const Discard = ( conditional ) => ( conditional ? select$1( conditional, expression( 'discard' ) ) : expression( 'discard' ) ).append();
82589
82592
 
82590
82593
  addMethodChaining( 'discard', Discard );
82591
82594
 
@@ -92401,19 +92404,19 @@ void main() {
92401
92404
 
92402
92405
  const r2 = roughness.pow2();
92403
92406
 
92404
- const a = select(
92407
+ const a = select$1(
92405
92408
  roughness.lessThan( 0.25 ),
92406
92409
  float( -339.2 ).mul( r2 ).add( float( 161.4 ).mul( roughness ) ).sub( 25.9 ),
92407
92410
  float( -8.48 ).mul( r2 ).add( float( 14.3 ).mul( roughness ) ).sub( 9.95 )
92408
92411
  );
92409
92412
 
92410
- const b = select(
92413
+ const b = select$1(
92411
92414
  roughness.lessThan( 0.25 ),
92412
92415
  float( 44.0 ).mul( r2 ).sub( float( 23.7 ).mul( roughness ) ).add( 3.26 ),
92413
92416
  float( 1.97 ).mul( r2 ).sub( float( 3.27 ).mul( roughness ) ).add( 0.72 )
92414
92417
  );
92415
92418
 
92416
- const DG = select( roughness.lessThan( 0.25 ), 0.0, float( 0.1 ).mul( roughness ).sub( 0.025 ) ).add( a.mul( dotNV ).add( b ).exp() );
92419
+ const DG = select$1( roughness.lessThan( 0.25 ), 0.0, float( 0.1 ).mul( roughness ).sub( 0.025 ) ).add( a.mul( dotNV ).add( b ).exp() );
92417
92420
 
92418
92421
  return DG.mul( 1.0 / Math.PI ).saturate();
92419
92422
 
@@ -92905,11 +92908,11 @@ void main() {
92905
92908
 
92906
92909
  If( absDirection.x.greaterThan( absDirection.y ), () => {
92907
92910
 
92908
- face.assign( select( direction.x.greaterThan( 0.0 ), 0.0, 3.0 ) );
92911
+ face.assign( select$1( direction.x.greaterThan( 0.0 ), 0.0, 3.0 ) );
92909
92912
 
92910
92913
  } ).Else( () => {
92911
92914
 
92912
- face.assign( select( direction.y.greaterThan( 0.0 ), 1.0, 4.0 ) );
92915
+ face.assign( select$1( direction.y.greaterThan( 0.0 ), 1.0, 4.0 ) );
92913
92916
 
92914
92917
  } );
92915
92918
 
@@ -92917,11 +92920,11 @@ void main() {
92917
92920
 
92918
92921
  If( absDirection.z.greaterThan( absDirection.y ), () => {
92919
92922
 
92920
- face.assign( select( direction.z.greaterThan( 0.0 ), 2.0, 5.0 ) );
92923
+ face.assign( select$1( direction.z.greaterThan( 0.0 ), 2.0, 5.0 ) );
92921
92924
 
92922
92925
  } ).Else( () => {
92923
92926
 
92924
- face.assign( select( direction.y.greaterThan( 0.0 ), 1.0, 4.0 ) );
92927
+ face.assign( select$1( direction.y.greaterThan( 0.0 ), 1.0, 4.0 ) );
92925
92928
 
92926
92929
  } );
92927
92930
 
@@ -93128,7 +93131,7 @@ void main() {
93128
93131
 
93129
93132
  const blur = /*@__PURE__*/ Fn( ( { n, latitudinal, poleAxis, outputDirection, weights, samples, dTheta, mipInt, envMap, CUBEUV_TEXEL_WIDTH, CUBEUV_TEXEL_HEIGHT, CUBEUV_MAX_MIP } ) => {
93130
93133
 
93131
- const axis = vec3( select( latitudinal, poleAxis, cross( poleAxis, outputDirection ) ) ).toVar();
93134
+ const axis = vec3( select$1( latitudinal, poleAxis, cross( poleAxis, outputDirection ) ) ).toVar();
93132
93135
 
93133
93136
  If( all( axis.equals( vec3( 0.0 ) ) ), () => {
93134
93137
 
@@ -99423,7 +99426,7 @@ void main() {
99423
99426
  If( boolNode, method ) {
99424
99427
 
99425
99428
  const methodNode = new ShaderNode( method );
99426
- this._currentCond = select( boolNode, methodNode );
99429
+ this._currentCond = select$1( boolNode, methodNode );
99427
99430
 
99428
99431
  return this.add( this._currentCond );
99429
99432
 
@@ -99439,7 +99442,7 @@ void main() {
99439
99442
  ElseIf( boolNode, method ) {
99440
99443
 
99441
99444
  const methodNode = new ShaderNode( method );
99442
- const ifNode = select( boolNode, methodNode );
99445
+ const ifNode = select$1( boolNode, methodNode );
99443
99446
 
99444
99447
  this._currentCond.elseNode = ifNode;
99445
99448
  this._currentCond = ifNode;
@@ -100592,7 +100595,7 @@ void main() {
100592
100595
  color = color.mul( exposure );
100593
100596
 
100594
100597
  const x = min$1( color.r, min$1( color.g, color.b ) );
100595
- const offset = select( x.lessThan( 0.08 ), x.sub( mul( 6.25, x.mul( x ) ) ), 0.04 );
100598
+ const offset = select$1( x.lessThan( 0.08 ), x.sub( mul( 6.25, x.mul( x ) ) ), 0.04 );
100596
100599
 
100597
100600
  color.subAssign( offset );
100598
100601
 
@@ -132795,6 +132798,1083 @@ var<${access}> ${name} : ${structName};`;
132795
132798
  // prettier-ignore
132796
132799
  curry /* ::<number | string, string, string> */(transparentize);
132797
132800
 
132801
+ var xhtml = "http://www.w3.org/1999/xhtml";
132802
+
132803
+ var namespaces = {
132804
+ svg: "http://www.w3.org/2000/svg",
132805
+ xhtml: xhtml,
132806
+ xlink: "http://www.w3.org/1999/xlink",
132807
+ xml: "http://www.w3.org/XML/1998/namespace",
132808
+ xmlns: "http://www.w3.org/2000/xmlns/"
132809
+ };
132810
+
132811
+ function namespace(name) {
132812
+ var prefix = name += "", i = prefix.indexOf(":");
132813
+ if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
132814
+ return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; // eslint-disable-line no-prototype-builtins
132815
+ }
132816
+
132817
+ function creatorInherit(name) {
132818
+ return function() {
132819
+ var document = this.ownerDocument,
132820
+ uri = this.namespaceURI;
132821
+ return uri === xhtml && document.documentElement.namespaceURI === xhtml
132822
+ ? document.createElement(name)
132823
+ : document.createElementNS(uri, name);
132824
+ };
132825
+ }
132826
+
132827
+ function creatorFixed(fullname) {
132828
+ return function() {
132829
+ return this.ownerDocument.createElementNS(fullname.space, fullname.local);
132830
+ };
132831
+ }
132832
+
132833
+ function creator(name) {
132834
+ var fullname = namespace(name);
132835
+ return (fullname.local
132836
+ ? creatorFixed
132837
+ : creatorInherit)(fullname);
132838
+ }
132839
+
132840
+ function none() {}
132841
+
132842
+ function selector(selector) {
132843
+ return selector == null ? none : function() {
132844
+ return this.querySelector(selector);
132845
+ };
132846
+ }
132847
+
132848
+ function selection_select(select) {
132849
+ if (typeof select !== "function") select = selector(select);
132850
+
132851
+ for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
132852
+ for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) {
132853
+ if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
132854
+ if ("__data__" in node) subnode.__data__ = node.__data__;
132855
+ subgroup[i] = subnode;
132856
+ }
132857
+ }
132858
+ }
132859
+
132860
+ return new Selection(subgroups, this._parents);
132861
+ }
132862
+
132863
+ // Given something array like (or null), returns something that is strictly an
132864
+ // array. This is used to ensure that array-like objects passed to d3.selectAll
132865
+ // or selection.selectAll are converted into proper arrays when creating a
132866
+ // selection; we don’t ever want to create a selection backed by a live
132867
+ // HTMLCollection or NodeList. However, note that selection.selectAll will use a
132868
+ // static NodeList as a group, since it safely derived from querySelectorAll.
132869
+ function array(x) {
132870
+ return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
132871
+ }
132872
+
132873
+ function empty() {
132874
+ return [];
132875
+ }
132876
+
132877
+ function selectorAll(selector) {
132878
+ return selector == null ? empty : function() {
132879
+ return this.querySelectorAll(selector);
132880
+ };
132881
+ }
132882
+
132883
+ function arrayAll(select) {
132884
+ return function() {
132885
+ return array(select.apply(this, arguments));
132886
+ };
132887
+ }
132888
+
132889
+ function selection_selectAll(select) {
132890
+ if (typeof select === "function") select = arrayAll(select);
132891
+ else select = selectorAll(select);
132892
+
132893
+ for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
132894
+ for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
132895
+ if (node = group[i]) {
132896
+ subgroups.push(select.call(node, node.__data__, i, group));
132897
+ parents.push(node);
132898
+ }
132899
+ }
132900
+ }
132901
+
132902
+ return new Selection(subgroups, parents);
132903
+ }
132904
+
132905
+ function matcher(selector) {
132906
+ return function() {
132907
+ return this.matches(selector);
132908
+ };
132909
+ }
132910
+
132911
+ function childMatcher(selector) {
132912
+ return function(node) {
132913
+ return node.matches(selector);
132914
+ };
132915
+ }
132916
+
132917
+ var find = Array.prototype.find;
132918
+
132919
+ function childFind(match) {
132920
+ return function() {
132921
+ return find.call(this.children, match);
132922
+ };
132923
+ }
132924
+
132925
+ function childFirst() {
132926
+ return this.firstElementChild;
132927
+ }
132928
+
132929
+ function selection_selectChild(match) {
132930
+ return this.select(match == null ? childFirst
132931
+ : childFind(typeof match === "function" ? match : childMatcher(match)));
132932
+ }
132933
+
132934
+ var filter = Array.prototype.filter;
132935
+
132936
+ function children() {
132937
+ return Array.from(this.children);
132938
+ }
132939
+
132940
+ function childrenFilter(match) {
132941
+ return function() {
132942
+ return filter.call(this.children, match);
132943
+ };
132944
+ }
132945
+
132946
+ function selection_selectChildren(match) {
132947
+ return this.selectAll(match == null ? children
132948
+ : childrenFilter(typeof match === "function" ? match : childMatcher(match)));
132949
+ }
132950
+
132951
+ function selection_filter(match) {
132952
+ if (typeof match !== "function") match = matcher(match);
132953
+
132954
+ for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) {
132955
+ for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
132956
+ if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
132957
+ subgroup.push(node);
132958
+ }
132959
+ }
132960
+ }
132961
+
132962
+ return new Selection(subgroups, this._parents);
132963
+ }
132964
+
132965
+ function sparse(update) {
132966
+ return new Array(update.length);
132967
+ }
132968
+
132969
+ function selection_enter() {
132970
+ return new Selection(this._enter || this._groups.map(sparse), this._parents);
132971
+ }
132972
+
132973
+ function EnterNode(parent, datum) {
132974
+ this.ownerDocument = parent.ownerDocument;
132975
+ this.namespaceURI = parent.namespaceURI;
132976
+ this._next = null;
132977
+ this._parent = parent;
132978
+ this.__data__ = datum;
132979
+ }
132980
+
132981
+ EnterNode.prototype = {
132982
+ constructor: EnterNode,
132983
+ appendChild: function(child) { return this._parent.insertBefore(child, this._next); },
132984
+ insertBefore: function(child, next) { return this._parent.insertBefore(child, next); },
132985
+ querySelector: function(selector) { return this._parent.querySelector(selector); },
132986
+ querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); }
132987
+ };
132988
+
132989
+ function constant(x) {
132990
+ return function() {
132991
+ return x;
132992
+ };
132993
+ }
132994
+
132995
+ function bindIndex(parent, group, enter, update, exit, data) {
132996
+ var i = 0,
132997
+ node,
132998
+ groupLength = group.length,
132999
+ dataLength = data.length;
133000
+
133001
+ // Put any non-null nodes that fit into update.
133002
+ // Put any null nodes into enter.
133003
+ // Put any remaining data into enter.
133004
+ for (; i < dataLength; ++i) {
133005
+ if (node = group[i]) {
133006
+ node.__data__ = data[i];
133007
+ update[i] = node;
133008
+ } else {
133009
+ enter[i] = new EnterNode(parent, data[i]);
133010
+ }
133011
+ }
133012
+
133013
+ // Put any non-null nodes that don’t fit into exit.
133014
+ for (; i < groupLength; ++i) {
133015
+ if (node = group[i]) {
133016
+ exit[i] = node;
133017
+ }
133018
+ }
133019
+ }
133020
+
133021
+ function bindKey(parent, group, enter, update, exit, data, key) {
133022
+ var i,
133023
+ node,
133024
+ nodeByKeyValue = new Map,
133025
+ groupLength = group.length,
133026
+ dataLength = data.length,
133027
+ keyValues = new Array(groupLength),
133028
+ keyValue;
133029
+
133030
+ // Compute the key for each node.
133031
+ // If multiple nodes have the same key, the duplicates are added to exit.
133032
+ for (i = 0; i < groupLength; ++i) {
133033
+ if (node = group[i]) {
133034
+ keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + "";
133035
+ if (nodeByKeyValue.has(keyValue)) {
133036
+ exit[i] = node;
133037
+ } else {
133038
+ nodeByKeyValue.set(keyValue, node);
133039
+ }
133040
+ }
133041
+ }
133042
+
133043
+ // Compute the key for each datum.
133044
+ // If there a node associated with this key, join and add it to update.
133045
+ // If there is not (or the key is a duplicate), add it to enter.
133046
+ for (i = 0; i < dataLength; ++i) {
133047
+ keyValue = key.call(parent, data[i], i, data) + "";
133048
+ if (node = nodeByKeyValue.get(keyValue)) {
133049
+ update[i] = node;
133050
+ node.__data__ = data[i];
133051
+ nodeByKeyValue.delete(keyValue);
133052
+ } else {
133053
+ enter[i] = new EnterNode(parent, data[i]);
133054
+ }
133055
+ }
133056
+
133057
+ // Add any remaining nodes that were not bound to data to exit.
133058
+ for (i = 0; i < groupLength; ++i) {
133059
+ if ((node = group[i]) && (nodeByKeyValue.get(keyValues[i]) === node)) {
133060
+ exit[i] = node;
133061
+ }
133062
+ }
133063
+ }
133064
+
133065
+ function datum(node) {
133066
+ return node.__data__;
133067
+ }
133068
+
133069
+ function selection_data(value, key) {
133070
+ if (!arguments.length) return Array.from(this, datum);
133071
+
133072
+ var bind = key ? bindKey : bindIndex,
133073
+ parents = this._parents,
133074
+ groups = this._groups;
133075
+
133076
+ if (typeof value !== "function") value = constant(value);
133077
+
133078
+ for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) {
133079
+ var parent = parents[j],
133080
+ group = groups[j],
133081
+ groupLength = group.length,
133082
+ data = arraylike(value.call(parent, parent && parent.__data__, j, parents)),
133083
+ dataLength = data.length,
133084
+ enterGroup = enter[j] = new Array(dataLength),
133085
+ updateGroup = update[j] = new Array(dataLength),
133086
+ exitGroup = exit[j] = new Array(groupLength);
133087
+
133088
+ bind(parent, group, enterGroup, updateGroup, exitGroup, data, key);
133089
+
133090
+ // Now connect the enter nodes to their following update node, such that
133091
+ // appendChild can insert the materialized enter node before this node,
133092
+ // rather than at the end of the parent node.
133093
+ for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
133094
+ if (previous = enterGroup[i0]) {
133095
+ if (i0 >= i1) i1 = i0 + 1;
133096
+ while (!(next = updateGroup[i1]) && ++i1 < dataLength);
133097
+ previous._next = next || null;
133098
+ }
133099
+ }
133100
+ }
133101
+
133102
+ update = new Selection(update, parents);
133103
+ update._enter = enter;
133104
+ update._exit = exit;
133105
+ return update;
133106
+ }
133107
+
133108
+ // Given some data, this returns an array-like view of it: an object that
133109
+ // exposes a length property and allows numeric indexing. Note that unlike
133110
+ // selectAll, this isn’t worried about “live” collections because the resulting
133111
+ // array will only be used briefly while data is being bound. (It is possible to
133112
+ // cause the data to change while iterating by using a key function, but please
133113
+ // don’t; we’d rather avoid a gratuitous copy.)
133114
+ function arraylike(data) {
133115
+ return typeof data === "object" && "length" in data
133116
+ ? data // Array, TypedArray, NodeList, array-like
133117
+ : Array.from(data); // Map, Set, iterable, string, or anything else
133118
+ }
133119
+
133120
+ function selection_exit() {
133121
+ return new Selection(this._exit || this._groups.map(sparse), this._parents);
133122
+ }
133123
+
133124
+ function selection_join(onenter, onupdate, onexit) {
133125
+ var enter = this.enter(), update = this, exit = this.exit();
133126
+ if (typeof onenter === "function") {
133127
+ enter = onenter(enter);
133128
+ if (enter) enter = enter.selection();
133129
+ } else {
133130
+ enter = enter.append(onenter + "");
133131
+ }
133132
+ if (onupdate != null) {
133133
+ update = onupdate(update);
133134
+ if (update) update = update.selection();
133135
+ }
133136
+ if (onexit == null) exit.remove(); else onexit(exit);
133137
+ return enter && update ? enter.merge(update).order() : update;
133138
+ }
133139
+
133140
+ function selection_merge(context) {
133141
+ var selection = context.selection ? context.selection() : context;
133142
+
133143
+ for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) {
133144
+ for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) {
133145
+ if (node = group0[i] || group1[i]) {
133146
+ merge[i] = node;
133147
+ }
133148
+ }
133149
+ }
133150
+
133151
+ for (; j < m0; ++j) {
133152
+ merges[j] = groups0[j];
133153
+ }
133154
+
133155
+ return new Selection(merges, this._parents);
133156
+ }
133157
+
133158
+ function selection_order() {
133159
+
133160
+ for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
133161
+ for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
133162
+ if (node = group[i]) {
133163
+ if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
133164
+ next = node;
133165
+ }
133166
+ }
133167
+ }
133168
+
133169
+ return this;
133170
+ }
133171
+
133172
+ function selection_sort(compare) {
133173
+ if (!compare) compare = ascending;
133174
+
133175
+ function compareNode(a, b) {
133176
+ return a && b ? compare(a.__data__, b.__data__) : !a - !b;
133177
+ }
133178
+
133179
+ for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) {
133180
+ for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) {
133181
+ if (node = group[i]) {
133182
+ sortgroup[i] = node;
133183
+ }
133184
+ }
133185
+ sortgroup.sort(compareNode);
133186
+ }
133187
+
133188
+ return new Selection(sortgroups, this._parents).order();
133189
+ }
133190
+
133191
+ function ascending(a, b) {
133192
+ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
133193
+ }
133194
+
133195
+ function selection_call() {
133196
+ var callback = arguments[0];
133197
+ arguments[0] = this;
133198
+ callback.apply(null, arguments);
133199
+ return this;
133200
+ }
133201
+
133202
+ function selection_nodes() {
133203
+ return Array.from(this);
133204
+ }
133205
+
133206
+ function selection_node() {
133207
+
133208
+ for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
133209
+ for (var group = groups[j], i = 0, n = group.length; i < n; ++i) {
133210
+ var node = group[i];
133211
+ if (node) return node;
133212
+ }
133213
+ }
133214
+
133215
+ return null;
133216
+ }
133217
+
133218
+ function selection_size() {
133219
+ let size = 0;
133220
+ for (const node of this) ++size; // eslint-disable-line no-unused-vars
133221
+ return size;
133222
+ }
133223
+
133224
+ function selection_empty() {
133225
+ return !this.node();
133226
+ }
133227
+
133228
+ function selection_each(callback) {
133229
+
133230
+ for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
133231
+ for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
133232
+ if (node = group[i]) callback.call(node, node.__data__, i, group);
133233
+ }
133234
+ }
133235
+
133236
+ return this;
133237
+ }
133238
+
133239
+ function attrRemove(name) {
133240
+ return function() {
133241
+ this.removeAttribute(name);
133242
+ };
133243
+ }
133244
+
133245
+ function attrRemoveNS(fullname) {
133246
+ return function() {
133247
+ this.removeAttributeNS(fullname.space, fullname.local);
133248
+ };
133249
+ }
133250
+
133251
+ function attrConstant(name, value) {
133252
+ return function() {
133253
+ this.setAttribute(name, value);
133254
+ };
133255
+ }
133256
+
133257
+ function attrConstantNS(fullname, value) {
133258
+ return function() {
133259
+ this.setAttributeNS(fullname.space, fullname.local, value);
133260
+ };
133261
+ }
133262
+
133263
+ function attrFunction(name, value) {
133264
+ return function() {
133265
+ var v = value.apply(this, arguments);
133266
+ if (v == null) this.removeAttribute(name);
133267
+ else this.setAttribute(name, v);
133268
+ };
133269
+ }
133270
+
133271
+ function attrFunctionNS(fullname, value) {
133272
+ return function() {
133273
+ var v = value.apply(this, arguments);
133274
+ if (v == null) this.removeAttributeNS(fullname.space, fullname.local);
133275
+ else this.setAttributeNS(fullname.space, fullname.local, v);
133276
+ };
133277
+ }
133278
+
133279
+ function selection_attr(name, value) {
133280
+ var fullname = namespace(name);
133281
+
133282
+ if (arguments.length < 2) {
133283
+ var node = this.node();
133284
+ return fullname.local
133285
+ ? node.getAttributeNS(fullname.space, fullname.local)
133286
+ : node.getAttribute(fullname);
133287
+ }
133288
+
133289
+ return this.each((value == null
133290
+ ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function"
133291
+ ? (fullname.local ? attrFunctionNS : attrFunction)
133292
+ : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value));
133293
+ }
133294
+
133295
+ function defaultView(node) {
133296
+ return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node
133297
+ || (node.document && node) // node is a Window
133298
+ || node.defaultView; // node is a Document
133299
+ }
133300
+
133301
+ function styleRemove(name) {
133302
+ return function() {
133303
+ this.style.removeProperty(name);
133304
+ };
133305
+ }
133306
+
133307
+ function styleConstant(name, value, priority) {
133308
+ return function() {
133309
+ this.style.setProperty(name, value, priority);
133310
+ };
133311
+ }
133312
+
133313
+ function styleFunction(name, value, priority) {
133314
+ return function() {
133315
+ var v = value.apply(this, arguments);
133316
+ if (v == null) this.style.removeProperty(name);
133317
+ else this.style.setProperty(name, v, priority);
133318
+ };
133319
+ }
133320
+
133321
+ function selection_style(name, value, priority) {
133322
+ return arguments.length > 1
133323
+ ? this.each((value == null
133324
+ ? styleRemove : typeof value === "function"
133325
+ ? styleFunction
133326
+ : styleConstant)(name, value, priority == null ? "" : priority))
133327
+ : styleValue(this.node(), name);
133328
+ }
133329
+
133330
+ function styleValue(node, name) {
133331
+ return node.style.getPropertyValue(name)
133332
+ || defaultView(node).getComputedStyle(node, null).getPropertyValue(name);
133333
+ }
133334
+
133335
+ function propertyRemove(name) {
133336
+ return function() {
133337
+ delete this[name];
133338
+ };
133339
+ }
133340
+
133341
+ function propertyConstant(name, value) {
133342
+ return function() {
133343
+ this[name] = value;
133344
+ };
133345
+ }
133346
+
133347
+ function propertyFunction(name, value) {
133348
+ return function() {
133349
+ var v = value.apply(this, arguments);
133350
+ if (v == null) delete this[name];
133351
+ else this[name] = v;
133352
+ };
133353
+ }
133354
+
133355
+ function selection_property(name, value) {
133356
+ return arguments.length > 1
133357
+ ? this.each((value == null
133358
+ ? propertyRemove : typeof value === "function"
133359
+ ? propertyFunction
133360
+ : propertyConstant)(name, value))
133361
+ : this.node()[name];
133362
+ }
133363
+
133364
+ function classArray(string) {
133365
+ return string.trim().split(/^|\s+/);
133366
+ }
133367
+
133368
+ function classList(node) {
133369
+ return node.classList || new ClassList(node);
133370
+ }
133371
+
133372
+ function ClassList(node) {
133373
+ this._node = node;
133374
+ this._names = classArray(node.getAttribute("class") || "");
133375
+ }
133376
+
133377
+ ClassList.prototype = {
133378
+ add: function(name) {
133379
+ var i = this._names.indexOf(name);
133380
+ if (i < 0) {
133381
+ this._names.push(name);
133382
+ this._node.setAttribute("class", this._names.join(" "));
133383
+ }
133384
+ },
133385
+ remove: function(name) {
133386
+ var i = this._names.indexOf(name);
133387
+ if (i >= 0) {
133388
+ this._names.splice(i, 1);
133389
+ this._node.setAttribute("class", this._names.join(" "));
133390
+ }
133391
+ },
133392
+ contains: function(name) {
133393
+ return this._names.indexOf(name) >= 0;
133394
+ }
133395
+ };
133396
+
133397
+ function classedAdd(node, names) {
133398
+ var list = classList(node), i = -1, n = names.length;
133399
+ while (++i < n) list.add(names[i]);
133400
+ }
133401
+
133402
+ function classedRemove(node, names) {
133403
+ var list = classList(node), i = -1, n = names.length;
133404
+ while (++i < n) list.remove(names[i]);
133405
+ }
133406
+
133407
+ function classedTrue(names) {
133408
+ return function() {
133409
+ classedAdd(this, names);
133410
+ };
133411
+ }
133412
+
133413
+ function classedFalse(names) {
133414
+ return function() {
133415
+ classedRemove(this, names);
133416
+ };
133417
+ }
133418
+
133419
+ function classedFunction(names, value) {
133420
+ return function() {
133421
+ (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
133422
+ };
133423
+ }
133424
+
133425
+ function selection_classed(name, value) {
133426
+ var names = classArray(name + "");
133427
+
133428
+ if (arguments.length < 2) {
133429
+ var list = classList(this.node()), i = -1, n = names.length;
133430
+ while (++i < n) if (!list.contains(names[i])) return false;
133431
+ return true;
133432
+ }
133433
+
133434
+ return this.each((typeof value === "function"
133435
+ ? classedFunction : value
133436
+ ? classedTrue
133437
+ : classedFalse)(names, value));
133438
+ }
133439
+
133440
+ function textRemove() {
133441
+ this.textContent = "";
133442
+ }
133443
+
133444
+ function textConstant(value) {
133445
+ return function() {
133446
+ this.textContent = value;
133447
+ };
133448
+ }
133449
+
133450
+ function textFunction(value) {
133451
+ return function() {
133452
+ var v = value.apply(this, arguments);
133453
+ this.textContent = v == null ? "" : v;
133454
+ };
133455
+ }
133456
+
133457
+ function selection_text(value) {
133458
+ return arguments.length
133459
+ ? this.each(value == null
133460
+ ? textRemove : (typeof value === "function"
133461
+ ? textFunction
133462
+ : textConstant)(value))
133463
+ : this.node().textContent;
133464
+ }
133465
+
133466
+ function htmlRemove() {
133467
+ this.innerHTML = "";
133468
+ }
133469
+
133470
+ function htmlConstant(value) {
133471
+ return function() {
133472
+ this.innerHTML = value;
133473
+ };
133474
+ }
133475
+
133476
+ function htmlFunction(value) {
133477
+ return function() {
133478
+ var v = value.apply(this, arguments);
133479
+ this.innerHTML = v == null ? "" : v;
133480
+ };
133481
+ }
133482
+
133483
+ function selection_html(value) {
133484
+ return arguments.length
133485
+ ? this.each(value == null
133486
+ ? htmlRemove : (typeof value === "function"
133487
+ ? htmlFunction
133488
+ : htmlConstant)(value))
133489
+ : this.node().innerHTML;
133490
+ }
133491
+
133492
+ function raise() {
133493
+ if (this.nextSibling) this.parentNode.appendChild(this);
133494
+ }
133495
+
133496
+ function selection_raise() {
133497
+ return this.each(raise);
133498
+ }
133499
+
133500
+ function lower() {
133501
+ if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
133502
+ }
133503
+
133504
+ function selection_lower() {
133505
+ return this.each(lower);
133506
+ }
133507
+
133508
+ function selection_append(name) {
133509
+ var create = typeof name === "function" ? name : creator(name);
133510
+ return this.select(function() {
133511
+ return this.appendChild(create.apply(this, arguments));
133512
+ });
133513
+ }
133514
+
133515
+ function constantNull() {
133516
+ return null;
133517
+ }
133518
+
133519
+ function selection_insert(name, before) {
133520
+ var create = typeof name === "function" ? name : creator(name),
133521
+ select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
133522
+ return this.select(function() {
133523
+ return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
133524
+ });
133525
+ }
133526
+
133527
+ function remove() {
133528
+ var parent = this.parentNode;
133529
+ if (parent) parent.removeChild(this);
133530
+ }
133531
+
133532
+ function selection_remove() {
133533
+ return this.each(remove);
133534
+ }
133535
+
133536
+ function selection_cloneShallow() {
133537
+ var clone = this.cloneNode(false), parent = this.parentNode;
133538
+ return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
133539
+ }
133540
+
133541
+ function selection_cloneDeep() {
133542
+ var clone = this.cloneNode(true), parent = this.parentNode;
133543
+ return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
133544
+ }
133545
+
133546
+ function selection_clone(deep) {
133547
+ return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
133548
+ }
133549
+
133550
+ function selection_datum(value) {
133551
+ return arguments.length
133552
+ ? this.property("__data__", value)
133553
+ : this.node().__data__;
133554
+ }
133555
+
133556
+ function contextListener(listener) {
133557
+ return function(event) {
133558
+ listener.call(this, event, this.__data__);
133559
+ };
133560
+ }
133561
+
133562
+ function parseTypenames(typenames) {
133563
+ return typenames.trim().split(/^|\s+/).map(function(t) {
133564
+ var name = "", i = t.indexOf(".");
133565
+ if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
133566
+ return {type: t, name: name};
133567
+ });
133568
+ }
133569
+
133570
+ function onRemove(typename) {
133571
+ return function() {
133572
+ var on = this.__on;
133573
+ if (!on) return;
133574
+ for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
133575
+ if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
133576
+ this.removeEventListener(o.type, o.listener, o.options);
133577
+ } else {
133578
+ on[++i] = o;
133579
+ }
133580
+ }
133581
+ if (++i) on.length = i;
133582
+ else delete this.__on;
133583
+ };
133584
+ }
133585
+
133586
+ function onAdd(typename, value, options) {
133587
+ return function() {
133588
+ var on = this.__on, o, listener = contextListener(value);
133589
+ if (on) for (var j = 0, m = on.length; j < m; ++j) {
133590
+ if ((o = on[j]).type === typename.type && o.name === typename.name) {
133591
+ this.removeEventListener(o.type, o.listener, o.options);
133592
+ this.addEventListener(o.type, o.listener = listener, o.options = options);
133593
+ o.value = value;
133594
+ return;
133595
+ }
133596
+ }
133597
+ this.addEventListener(typename.type, listener, options);
133598
+ o = {type: typename.type, name: typename.name, value: value, listener: listener, options: options};
133599
+ if (!on) this.__on = [o];
133600
+ else on.push(o);
133601
+ };
133602
+ }
133603
+
133604
+ function selection_on(typename, value, options) {
133605
+ var typenames = parseTypenames(typename + ""), i, n = typenames.length, t;
133606
+
133607
+ if (arguments.length < 2) {
133608
+ var on = this.node().__on;
133609
+ if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
133610
+ for (i = 0, o = on[j]; i < n; ++i) {
133611
+ if ((t = typenames[i]).type === o.type && t.name === o.name) {
133612
+ return o.value;
133613
+ }
133614
+ }
133615
+ }
133616
+ return;
133617
+ }
133618
+
133619
+ on = value ? onAdd : onRemove;
133620
+ for (i = 0; i < n; ++i) this.each(on(typenames[i], value, options));
133621
+ return this;
133622
+ }
133623
+
133624
+ function dispatchEvent(node, type, params) {
133625
+ var window = defaultView(node),
133626
+ event = window.CustomEvent;
133627
+
133628
+ if (typeof event === "function") {
133629
+ event = new event(type, params);
133630
+ } else {
133631
+ event = window.document.createEvent("Event");
133632
+ if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;
133633
+ else event.initEvent(type, false, false);
133634
+ }
133635
+
133636
+ node.dispatchEvent(event);
133637
+ }
133638
+
133639
+ function dispatchConstant(type, params) {
133640
+ return function() {
133641
+ return dispatchEvent(this, type, params);
133642
+ };
133643
+ }
133644
+
133645
+ function dispatchFunction(type, params) {
133646
+ return function() {
133647
+ return dispatchEvent(this, type, params.apply(this, arguments));
133648
+ };
133649
+ }
133650
+
133651
+ function selection_dispatch(type, params) {
133652
+ return this.each((typeof params === "function"
133653
+ ? dispatchFunction
133654
+ : dispatchConstant)(type, params));
133655
+ }
133656
+
133657
+ function* selection_iterator() {
133658
+ for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
133659
+ for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
133660
+ if (node = group[i]) yield node;
133661
+ }
133662
+ }
133663
+ }
133664
+
133665
+ var root = [null];
133666
+
133667
+ function Selection(groups, parents) {
133668
+ this._groups = groups;
133669
+ this._parents = parents;
133670
+ }
133671
+
133672
+ function selection_selection() {
133673
+ return this;
133674
+ }
133675
+
133676
+ Selection.prototype = {
133677
+ constructor: Selection,
133678
+ select: selection_select,
133679
+ selectAll: selection_selectAll,
133680
+ selectChild: selection_selectChild,
133681
+ selectChildren: selection_selectChildren,
133682
+ filter: selection_filter,
133683
+ data: selection_data,
133684
+ enter: selection_enter,
133685
+ exit: selection_exit,
133686
+ join: selection_join,
133687
+ merge: selection_merge,
133688
+ selection: selection_selection,
133689
+ order: selection_order,
133690
+ sort: selection_sort,
133691
+ call: selection_call,
133692
+ nodes: selection_nodes,
133693
+ node: selection_node,
133694
+ size: selection_size,
133695
+ empty: selection_empty,
133696
+ each: selection_each,
133697
+ attr: selection_attr,
133698
+ style: selection_style,
133699
+ property: selection_property,
133700
+ classed: selection_classed,
133701
+ text: selection_text,
133702
+ html: selection_html,
133703
+ raise: selection_raise,
133704
+ lower: selection_lower,
133705
+ append: selection_append,
133706
+ insert: selection_insert,
133707
+ remove: selection_remove,
133708
+ clone: selection_clone,
133709
+ datum: selection_datum,
133710
+ on: selection_on,
133711
+ dispatch: selection_dispatch,
133712
+ [Symbol.iterator]: selection_iterator
133713
+ };
133714
+
133715
+ function select(selector) {
133716
+ return typeof selector === "string"
133717
+ ? new Selection([[document.querySelector(selector)]], [document.documentElement])
133718
+ : new Selection([[selector]], root);
133719
+ }
133720
+
133721
+ function sourceEvent(event) {
133722
+ let sourceEvent;
133723
+ while (sourceEvent = event.sourceEvent) event = sourceEvent;
133724
+ return event;
133725
+ }
133726
+
133727
+ function pointer(event, node) {
133728
+ event = sourceEvent(event);
133729
+ if (node === undefined) node = event.currentTarget;
133730
+ if (node) {
133731
+ var svg = node.ownerSVGElement || node;
133732
+ if (svg.createSVGPoint) {
133733
+ var point = svg.createSVGPoint();
133734
+ point.x = event.clientX, point.y = event.clientY;
133735
+ point = point.matrixTransform(node.getScreenCTM().inverse());
133736
+ return [point.x, point.y];
133737
+ }
133738
+ if (node.getBoundingClientRect) {
133739
+ var rect = node.getBoundingClientRect();
133740
+ return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop];
133741
+ }
133742
+ }
133743
+ return [event.pageX, event.pageY];
133744
+ }
133745
+
133746
+ function _arrayLikeToArray$2(r, a) {
133747
+ (null == a || a > r.length) && (a = r.length);
133748
+ for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
133749
+ return n;
133750
+ }
133751
+ function _arrayWithHoles$1(r) {
133752
+ if (Array.isArray(r)) return r;
133753
+ }
133754
+ function _iterableToArrayLimit$1(r, l) {
133755
+ var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
133756
+ if (null != t) {
133757
+ var e,
133758
+ n,
133759
+ i,
133760
+ u,
133761
+ a = [],
133762
+ f = true,
133763
+ o = false;
133764
+ try {
133765
+ if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
133766
+ } catch (r) {
133767
+ o = true, n = r;
133768
+ } finally {
133769
+ try {
133770
+ if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
133771
+ } finally {
133772
+ if (o) throw n;
133773
+ }
133774
+ }
133775
+ return a;
133776
+ }
133777
+ }
133778
+ function _nonIterableRest$1() {
133779
+ throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
133780
+ }
133781
+ function _slicedToArray$1(r, e) {
133782
+ return _arrayWithHoles$1(r) || _iterableToArrayLimit$1(r, e) || _unsupportedIterableToArray$2(r, e) || _nonIterableRest$1();
133783
+ }
133784
+ function _typeof(o) {
133785
+ "@babel/helpers - typeof";
133786
+
133787
+ return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
133788
+ return typeof o;
133789
+ } : function (o) {
133790
+ return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
133791
+ }, _typeof(o);
133792
+ }
133793
+ function _unsupportedIterableToArray$2(r, a) {
133794
+ if (r) {
133795
+ if ("string" == typeof r) return _arrayLikeToArray$2(r, a);
133796
+ var t = {}.toString.call(r).slice(8, -1);
133797
+ return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : undefined;
133798
+ }
133799
+ }
133800
+
133801
+ function styleInject$2(css, ref) {
133802
+ if (ref === undefined) ref = {};
133803
+ var insertAt = ref.insertAt;
133804
+ if (typeof document === 'undefined') {
133805
+ return;
133806
+ }
133807
+ var head = document.head || document.getElementsByTagName('head')[0];
133808
+ var style = document.createElement('style');
133809
+ style.type = 'text/css';
133810
+ if (insertAt === 'top') {
133811
+ if (head.firstChild) {
133812
+ head.insertBefore(style, head.firstChild);
133813
+ } else {
133814
+ head.appendChild(style);
133815
+ }
133816
+ } else {
133817
+ head.appendChild(style);
133818
+ }
133819
+ if (style.styleSheet) {
133820
+ style.styleSheet.cssText = css;
133821
+ } else {
133822
+ style.appendChild(document.createTextNode(css));
133823
+ }
133824
+ }
133825
+
133826
+ var css_248z$2 = ".float-tooltip-kap {\n position: absolute;\n width: max-content; /* prevent shrinking near right edge */\n padding: 3px 5px;\n border-radius: 3px;\n font: 12px sans-serif;\n color: #eee;\n background: rgba(0,0,0,0.6);\n pointer-events: none;\n}\n";
133827
+ styleInject$2(css_248z$2);
133828
+
133829
+ var index = index$3({
133830
+ props: {
133831
+ content: {
133832
+ "default": false
133833
+ }
133834
+ },
133835
+ init: function init(domNode, state) {
133836
+ var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
133837
+ _ref$style = _ref.style,
133838
+ style = _ref$style === undefined ? {} : _ref$style;
133839
+ var isD3Selection = !!domNode && _typeof(domNode) === 'object' && !!domNode.node && typeof domNode.node === 'function';
133840
+ var el = select(isD3Selection ? domNode.node() : domNode);
133841
+ state.tooltipEl = el.append('div').attr('class', 'float-tooltip-kap');
133842
+ Object.entries(style).forEach(function (_ref2) {
133843
+ var _ref3 = _slicedToArray$1(_ref2, 2),
133844
+ k = _ref3[0],
133845
+ v = _ref3[1];
133846
+ return state.tooltipEl.style(k, v);
133847
+ });
133848
+ state.tooltipEl // start off-screen
133849
+ .style('left', '-10000px').style('display', 'none');
133850
+ state.mouseInside = false;
133851
+ el.on('mousemove.tooltip', function (ev) {
133852
+ state.mouseInside = true;
133853
+ var mousePos = pointer(ev);
133854
+ var domNode = el.node();
133855
+ var canvasWidth = domNode.offsetWidth;
133856
+ var canvasHeight = domNode.offsetHeight;
133857
+ state.tooltipEl.style('left', mousePos[0] + 'px').style('top', mousePos[1] + 'px')
133858
+ // adjust horizontal position to not exceed canvas boundaries
133859
+ .style('transform', "translate(-".concat(mousePos[0] / canvasWidth * 100, "%, ").concat(
133860
+ // flip to above if near bottom
133861
+ canvasHeight > 130 && canvasHeight - mousePos[1] < 100 ? 'calc(-100% - 6px)' : '21px', ")"));
133862
+ });
133863
+ el.on('mouseover.tooltip', function () {
133864
+ state.mouseInside = true;
133865
+ state.content && state.tooltipEl.style('display', 'inline');
133866
+ });
133867
+ el.on('mouseout.tooltip', function () {
133868
+ state.mouseInside = false;
133869
+ state.tooltipEl.style('display', 'none');
133870
+ });
133871
+ },
133872
+ update: function update(state) {
133873
+ state.tooltipEl.style('display', !!state.content && state.mouseInside ? 'inline' : 'none');
133874
+ state.tooltipEl.html(state.content || '');
133875
+ }
133876
+ });
133877
+
132798
133878
  function styleInject$1(css, ref) {
132799
133879
  if (ref === undefined) ref = {};
132800
133880
  var insertAt = ref.insertAt;
@@ -132820,7 +133900,7 @@ var<${access}> ${name} : ${structName};`;
132820
133900
  }
132821
133901
  }
132822
133902
 
132823
- var css_248z$1 = ".scene-nav-info {\n bottom: 5px;\n width: 100%;\n text-align: center;\n color: slategrey;\n opacity: 0.7;\n font-size: 10px;\n}\n\n.scene-tooltip {\n top: 0;\n color: lavender;\n font-size: 15px;\n}\n\n.scene-nav-info, .scene-tooltip {\n position: absolute;\n font-family: sans-serif;\n pointer-events: none;\n user-select: none;\n}\n\n.scene-container canvas:focus {\n outline: none;\n}";
133903
+ var css_248z$1 = ".scene-nav-info {\n position: absolute;\n bottom: 5px;\n width: 100%;\n text-align: center;\n color: slategrey;\n opacity: 0.7;\n font-size: 10px;\n font-family: sans-serif;\n pointer-events: none;\n user-select: none;\n}\n\n.scene-container canvas:focus {\n outline: none;\n}";
132824
133904
  styleInject$1(css_248z$1);
132825
133905
 
132826
133906
  function _arrayLikeToArray$1(r, a) {
@@ -132925,7 +134005,7 @@ var<${access}> ${name} : ${structName};`;
132925
134005
  Spherical: Spherical,
132926
134006
  Clock: Clock
132927
134007
  };
132928
- var threeRenderObjects = index$2({
134008
+ var threeRenderObjects = index$3({
132929
134009
  props: {
132930
134010
  width: {
132931
134011
  "default": window.innerWidth,
@@ -132961,7 +134041,7 @@ var<${access}> ${name} : ${structName};`;
132961
134041
  onChange: function onChange(_, state) {
132962
134042
  // Reset hover state
132963
134043
  state.hoverObj = null;
132964
- if (state.toolTipElem) state.toolTipElem.innerHTML = '';
134044
+ state.tooltip && state.tooltip.content(null);
132965
134045
  },
132966
134046
  triggerUpdate: false
132967
134047
  },
@@ -133031,7 +134111,7 @@ var<${access}> ${name} : ${structName};`;
133031
134111
  }
133032
134112
  if (topObject !== state.hoverObj) {
133033
134113
  state.onHover(topObject, state.hoverObj);
133034
- state.toolTipElem.innerHTML = topObject ? index$1(state.tooltipContent)(topObject) || '' : '';
134114
+ state.tooltip.content(topObject ? index$2(state.tooltipContent)(topObject) || null : null);
133035
134115
  state.hoverObj = topObject;
133036
134116
  }
133037
134117
  }
@@ -133235,9 +134315,7 @@ var<${access}> ${name} : ${structName};`;
133235
134315
  state.navInfo.style.display = state.showNavInfo ? null : 'none';
133236
134316
 
133237
134317
  // Setup tooltip
133238
- state.toolTipElem = document.createElement('div');
133239
- state.toolTipElem.classList.add('scene-tooltip');
133240
- state.container.appendChild(state.toolTipElem);
134318
+ state.tooltip = new index(state.container);
133241
134319
 
133242
134320
  // Capture pointer coords on move or touchstart
133243
134321
  state.pointerPos = new three.Vector2();
@@ -133259,14 +134337,6 @@ var<${access}> ${name} : ${structName};`;
133259
134337
  var offset = getOffset(state.container);
133260
134338
  state.pointerPos.x = ev.pageX - offset.left;
133261
134339
  state.pointerPos.y = ev.pageY - offset.top;
133262
-
133263
- // Move tooltip
133264
- state.toolTipElem.style.top = "".concat(state.pointerPos.y, "px");
133265
- state.toolTipElem.style.left = "".concat(state.pointerPos.x, "px");
133266
- // adjust horizontal position to not exceed canvas boundaries
133267
- state.toolTipElem.style.transform = "translate(-".concat(state.pointerPos.x / state.width * 100, "%, ").concat(
133268
- // flip to above if near bottom
133269
- state.height - state.pointerPos.y < 100 ? 'calc(-100% - 8px)' : '21px', ")");
133270
134340
  }
133271
134341
  function getOffset(el) {
133272
134342
  var rect = el.getBoundingClientRect(),
@@ -133617,7 +134687,7 @@ var<${access}> ${name} : ${structName};`;
133617
134687
 
133618
134688
  //
133619
134689
 
133620
- var globe = index$2({
134690
+ var globe = index$3({
133621
134691
  props: _objectSpread2(_objectSpread2({
133622
134692
  onZoom: {
133623
134693
  triggerUpdate: false
@@ -133955,11 +135025,14 @@ var<${access}> ${name} : ${structName};`;
133955
135025
  controls.dampingFactor = 0.1;
133956
135026
  controls.rotateSpeed = 0.3;
133957
135027
  controls.zoomSpeed = 0.3;
135028
+ controls.zoomToCursor = true;
133958
135029
  controls.addEventListener('change', function () {
135030
+ controls.target.setScalar(0); // Keep orbit target on center
135031
+
133959
135032
  // adjust controls speed based on altitude
133960
135033
  var pov = _this.pointOfView();
133961
135034
  controls.rotateSpeed = pov.altitude * 0.3;
133962
- controls.zoomSpeed = Math.sqrt(pov.altitude) * 0.4;
135035
+ controls.zoomSpeed = Math.sqrt(pov.altitude) * 0.5;
133963
135036
 
133964
135037
  // Update three-globe pov when camera moves, for proper hiding of elements
133965
135038
  state.globe.setPointOfView(state.renderObjs.camera());
@@ -134035,7 +135108,7 @@ var<${access}> ${name} : ${structName};`;
134035
135108
  };
134036
135109
  var globeObj = getGlobeObj(obj);
134037
135110
  var objType = globeObj && globeObj.__globeObjType;
134038
- return globeObj && objType && objAccessors.hasOwnProperty(objType) && dataAccessors.hasOwnProperty(objType) ? index$1(objAccessors[objType])(dataAccessors[objType](globeObj.__data)) || '' : '';
135111
+ return globeObj && objType && objAccessors.hasOwnProperty(objType) && dataAccessors.hasOwnProperty(objType) ? index$2(objAccessors[objType])(dataAccessors[objType](globeObj.__data)) || '' : '';
134039
135112
  }).onHover(function (obj) {
134040
135113
  // Update tooltip and trigger onHover events
134041
135114
  var hoverObjFns = {
@@ -135460,7 +136533,7 @@ var<${access}> ${name} : ${structName};`;
135460
136533
  onZoom: PropTypes.func
135461
136534
  };
135462
136535
 
135463
- var Globe = index$3(globe, {
136536
+ var Globe = index$4(globe, {
135464
136537
  methodNames: [
135465
136538
  // bind methods
135466
136539
  'pauseAnimation', 'resumeAnimation', 'pointOfView', 'lights', 'scene', 'camera', 'renderer', 'postProcessingComposer', 'controls', 'getGlobeRadius', 'getCoords', 'getScreenCoords', 'toGeoCoords', 'toGlobeCoords'],