@mapvx/web-components-ssr 1.6.1-dev.1 → 1.7.0-dev.1

package/dist/browser/chunk-Cg9Nd_Mm.js

@@ -0,0 +1,4336 @@
+import{a as v,i as u,n as s,s as x,t as r}from"./main.js";import{A as Zo$1,J as ne$1,Z as pt$1,l as Ko$1,p as Ni$1,t as De$1,w as Wr}from"./chunk-BK2bFfek.js";import{A as en$1,G as st$1,L as oe$1,M as ge$1,O as ee,P as ma,T as an,U as se,a as Dm,n as A,r as Ar,u as Ka,v as Wa}from"./chunk-ConEJto8.js";var Xi=v((mc,_t)=>{"use strict";_t.exports=Ze;_t.exports.default=Ze;function Ze(t,o,e){e=e||2;var i=o&&o.length,n=i?o[0]*e:t.length,s=$i(t,0,n,e,!0),r=[];if(!s||s.next===s.prev)return r;var a,l,c,f,d,u,p;if(i&&(s=Is(t,o,s,e)),t.length>80*e){a=c=t[0],l=f=t[1];for(var g=e;g<n;g+=e)d=t[g],u=t[g+1],d<a&&(a=d),u<l&&(l=u),d>c&&(c=d),u>f&&(f=u);p=Math.max(c-a,f-l),p=p!==0?32767/p:0}return Ce(s,r,e,a,l,p,0),r}function $i(t,o,e,i,n){var s,r;if(n===Pt(t,o,e,i)>0)for(s=o;s<e;s+=i)r=Ki(s,t[s],t[s+1],r);else for(s=e-i;s>=o;s-=i)r=Ki(s,t[s],t[s+1],r);return r&&Ke(r,r.next)&&(Se(r),r=r.next),r}function X(t,o){if(!t)return t;o||(o=t);var e=t,i;do if(i=!1,!e.steiner&&(Ke(e,e.next)||w(e.prev,e,e.next)===0)){if(Se(e),e=o=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==o);return o}function Ce(t,o,e,i,n,s,r){if(t){!r&&s&&Rs(t,i,n,s);for(var a=t,l,c;t.prev!==t.next;){if(l=t.prev,c=t.next,s?Ss(t,i,n,s):Ls(t)){o.push(l.i/e|0),o.push(t.i/e|0),o.push(c.i/e|0),Se(t),t=c.next,a=c.next;continue}if(t=c,t===a){r?r===1?(t=bs(X(t),o,e),Ce(t,o,e,i,n,s,2)):r===2&&ws(t,o,e,i,n,s):Ce(X(t),o,e,i,n,s,1);break}}}}function Ls(t){var o=t.prev,e=t,i=t.next;if(w(o,e,i)>=0)return!1;for(var n=o.x,s=e.x,r=i.x,a=o.y,l=e.y,c=i.y,f=n<s?n<r?n:r:s<r?s:r,d=a<l?a<c?a:c:l<c?l:c,u=n>s?n>r?n:r:s>r?s:r,p=a>l?a>c?a:c:l>c?l:c,g=i.next;g!==o;){if(g.x>=f&&g.x<=u&&g.y>=d&&g.y<=p&&se(n,a,s,l,r,c,g.x,g.y)&&w(g.prev,g,g.next)>=0)return!1;g=g.next}return!0}function Ss(t,o,e,i){var n=t.prev,s=t,r=t.next;if(w(n,s,r)>=0)return!1;for(var a=n.x,l=s.x,c=r.x,f=n.y,d=s.y,u=r.y,p=a<l?a<c?a:c:l<c?l:c,g=f<d?f<u?f:u:d<u?d:u,h=a>l?a>c?a:c:l>c?l:c,v=f>d?f>u?f:u:d>u?d:u,P=mt(p,g,o,e,i),C=mt(h,v,o,e,i),m=t.prevZ,x=t.nextZ;m&&m.z>=P&&x&&x.z<=C;){if(m.x>=p&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&se(a,f,l,d,c,u,m.x,m.y)&&w(m.prev,m,m.next)>=0||(m=m.prevZ,x.x>=p&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&se(a,f,l,d,c,u,x.x,x.y)&&w(x.prev,x,x.next)>=0))return!1;x=x.nextZ}for(;m&&m.z>=P;){if(m.x>=p&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&se(a,f,l,d,c,u,m.x,m.y)&&w(m.prev,m,m.next)>=0)return!1;m=m.prevZ}for(;x&&x.z<=C;){if(x.x>=p&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&se(a,f,l,d,c,u,x.x,x.y)&&w(x.prev,x,x.next)>=0)return!1;x=x.nextZ}return!0}function bs(t,o,e){var i=t;do{var n=i.prev,s=i.next.next;!Ke(n,s)&&Ji(n,i,i.next,s)&&Le(n,s)&&Le(s,n)&&(o.push(n.i/e|0),o.push(i.i/e|0),o.push(s.i/e|0),Se(i),Se(i.next),i=t=s),i=i.next}while(i!==t);return X(i)}function ws(t,o,e,i,n,s){var r=t;do{for(var a=r.next.next;a!==r.prev;){if(r.i!==a.i&&ks(r,a)){var l=Yi(r,a);r=X(r,r.next),l=X(l,l.next),Ce(r,o,e,i,n,s,0),Ce(l,o,e,i,n,s,0);return}a=a.next}r=r.next}while(r!==t)}function Is(t,o,e,i){var n=[],s,r,a,l,c;for(s=0,r=o.length;s<r;s++)a=o[s]*i,l=s<r-1?o[s+1]*i:t.length,c=$i(t,a,l,i,!1),c===c.next&&(c.steiner=!0),n.push(zs(c));for(n.sort(As),s=0;s<n.length;s++)e=Es(n[s],e);return e}function As(t,o){return t.x-o.x}function Es(t,o){var e=Ts(t,o);if(!e)return o;var i=Yi(e,t);return X(i,i.next),X(e,e.next)}function Ts(t,o){var e=o,i=t.x,n=t.y,s=-Infinity,r;do{if(n<=e.y&&n>=e.next.y&&e.next.y!==e.y){var a=e.x+(n-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(a<=i&&a>s&&(s=a,r=e.x<e.next.x?e:e.next,a===i))return r}e=e.next}while(e!==o);if(!r)return null;var l=r,c=r.x,f=r.y,d=Infinity,u;e=r;do i>=e.x&&e.x>=c&&i!==e.x&&se(n<f?i:s,n,c,f,n<f?s:i,n,e.x,e.y)&&(u=Math.abs(n-e.y)/(i-e.x),Le(e,t)&&(u<d||u===d&&(e.x>r.x||e.x===r.x&&Os(r,e)))&&(r=e,d=u)),e=e.next;while(e!==l);return r}function Os(t,o){return w(t.prev,t,o.prev)<0&&w(o.next,t,t.next)<0}function Rs(t,o,e,i){var n=t;do n.z===0&&(n.z=mt(n.x,n.y,o,e,i)),n.prevZ=n.prev,n.nextZ=n.next,n=n.next;while(n!==t);n.prevZ.nextZ=null,n.prevZ=null,Ms(n)}function Ms(t){var o,e,i,n,s,r,a,l,c=1;do{for(e=t,t=null,s=null,r=0;e;){for(r++,i=e,a=0,o=0;o<c&&(a++,i=i.nextZ,!!i);o++);for(l=c;a>0||l>0&&i;)a!==0&&(l===0||!i||e.z<=i.z)?(n=e,e=e.nextZ,a--):(n=i,i=i.nextZ,l--),s?s.nextZ=n:t=n,n.prevZ=s,s=n;e=i}s.nextZ=null,c*=2}while(r>1);return t}function mt(t,o,e,i,n){return t=(t-e)*n|0,o=(o-i)*n|0,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,o=(o|o<<8)&16711935,o=(o|o<<4)&252645135,o=(o|o<<2)&858993459,o=(o|o<<1)&1431655765,t|o<<1}function zs(t){var o=t,e=t;do(o.x<e.x||o.x===e.x&&o.y<e.y)&&(e=o),o=o.next;while(o!==t);return e}function se(t,o,e,i,n,s,r,a){return(n-r)*(o-a)>=(t-r)*(s-a)&&(t-r)*(i-a)>=(e-r)*(o-a)&&(e-r)*(s-a)>=(n-r)*(i-a)}function ks(t,o){return t.next.i!==o.i&&t.prev.i!==o.i&&!Ds(t,o)&&(Le(t,o)&&Le(o,t)&&Fs(t,o)&&(w(t.prev,t,o.prev)||w(t,o.prev,o))||Ke(t,o)&&w(t.prev,t,t.next)>0&&w(o.prev,o,o.next)>0)}function w(t,o,e){return(o.y-t.y)*(e.x-o.x)-(o.x-t.x)*(e.y-o.y)}function Ke(t,o){return t.x===o.x&&t.y===o.y}function Ji(t,o,e,i){var n=He(w(t,o,e)),s=He(w(t,o,i)),r=He(w(e,i,t)),a=He(w(e,i,o));return!!(n!==s&&r!==a||n===0&&Ve(t,e,o)||s===0&&Ve(t,i,o)||r===0&&Ve(e,t,i)||a===0&&Ve(e,o,i))}function Ve(t,o,e){return o.x<=Math.max(t.x,e.x)&&o.x>=Math.min(t.x,e.x)&&o.y<=Math.max(t.y,e.y)&&o.y>=Math.min(t.y,e.y)}function He(t){return t>0?1:t<0?-1:0}function Ds(t,o){var e=t;do{if(e.i!==t.i&&e.next.i!==t.i&&e.i!==o.i&&e.next.i!==o.i&&Ji(e,e.next,t,o))return!0;e=e.next}while(e!==t);return!1}function Le(t,o){return w(t.prev,t,t.next)<0?w(t,o,t.next)>=0&&w(t,t.prev,o)>=0:w(t,o,t.prev)<0||w(t,t.next,o)<0}function Fs(t,o){var e=t,i=!1,n=(t.x+o.x)/2,s=(t.y+o.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&n<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==t);return i}function Yi(t,o){var e=new yt(t.i,t.x,t.y),i=new yt(o.i,o.x,o.y),n=t.next,s=o.prev;return t.next=o,o.prev=t,e.next=n,n.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function Ki(t,o,e,i){var n=new yt(t,o,e);return i?(n.next=i.next,n.prev=i,i.next.prev=n,i.next=n):(n.prev=n,n.next=n),n}function Se(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function yt(t,o,e){this.i=t,this.x=o,this.y=e,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}Ze.deviation=function(t,o,e,i){var n=o&&o.length,s=n?o[0]*e:t.length,r=Math.abs(Pt(t,0,s,e));if(n)for(var a=0,l=o.length;a<l;a++){var c=o[a]*e,f=a<l-1?o[a+1]*e:t.length;r-=Math.abs(Pt(t,c,f,e))}var d=0;for(a=0;a<i.length;a+=3){var u=i[a]*e,p=i[a+1]*e,g=i[a+2]*e;d+=Math.abs((t[u]-t[g])*(t[p+1]-t[u+1])-(t[u]-t[p])*(t[g+1]-t[u+1]))}return r===0&&d===0?0:Math.abs((d-r)/r)};function Pt(t,o,e,i){for(var n=0,s=o,r=e-i;s<e;s+=i)n+=(t[r]-t[s])*(t[s+1]+t[r+1]),r=s;return n}Ze.flatten=function(t){for(var o=t[0][0].length,e={vertices:[],holes:[],dimensions:o},i=0,n=0;n<t.length;n++){for(var s=0;s<t[n].length;s++)for(var r=0;r<o;r++)e.vertices.push(t[n][s][r]);n>0&&(i+=t[n-1].length,e.holes.push(i))}return e}});var Xo=`struct ArcUniforms {
+  greatCircle: f32,
+  useShortestPath: f32,
+  numSegments: f32,
+  widthScale: f32,
+  widthMinPixels: f32,
+  widthMaxPixels: f32,
+  widthUnits: i32,
+};
+
+@group(0) @binding(auto) var<uniform> arc: ArcUniforms;
+`;var Ft=`layout(std140) uniform arcUniforms {
+  bool greatCircle;
+  bool useShortestPath;
+  float numSegments;
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  highp int widthUnits;
+} arc;
+`;var Nt={name:`arc`,source:Xo,vs:Ft,fs:Ft,uniformTypes:{greatCircle:`f32`,useShortestPath:`f32`,numSegments:`f32`,widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,widthUnits:`i32`}};var Gt=`const ZERO_OFFSET: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
+
+struct Attributes {
+  @location(0) instanceSourcePositions: vec3<f32>,
+  @location(1) instanceSourcePositions64Low: vec3<f32>,
+  @location(2) instanceTargetPositions: vec3<f32>,
+  @location(3) instanceTargetPositions64Low: vec3<f32>,
+  @location(4) instanceSourceColors: vec4<f32>,
+  @location(5) instanceTargetColors: vec4<f32>,
+  @location(6) instanceWidths: f32,
+  @location(7) instanceHeights: f32,
+  @location(8) instanceTilts: f32,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) uv: vec2<f32>,
+  @location(2) pickingColor: vec3<f32>,
+  @location(3) isValid: f32,
+};
+
+fn paraboloid(
+  distance: f32,
+  sourceZ: f32,
+  targetZ: f32,
+  ratio: f32,
+  height: f32
+) -> f32 {
+  let deltaZ = targetZ - sourceZ;
+  let dh = distance * height;
+  if (dh == 0.0) {
+    return sourceZ + deltaZ * ratio;
+  }
+  let unitZ = deltaZ / dh;
+  let p2 = unitZ * unitZ + 1.0;
+  let dir = select(0.0, 1.0, deltaZ <= 0.0);
+  let z0 = mix(sourceZ, targetZ, dir);
+  let r = mix(ratio, 1.0 - ratio, dir);
+  return sqrt(max(r * (p2 - r), 0.0)) * dh + z0;
+}
+
+fn getExtrusionOffset(lineClipspace: vec2<f32>, side: f32, width: f32) -> vec2<f32> {
+  var direction = normalize(lineClipspace * project.viewportSize);
+  direction = vec2<f32>(-direction.y, direction.x);
+  return direction * side * width / 2.0;
+}
+
+fn getSegmentRatio(index: f32) -> f32 {
+  return smoothstep(0.0, 1.0, index / max(arc.numSegments - 1.0, 1.0));
+}
+
+fn interpolateFlat(
+  source: vec3<f32>,
+  targetPosition: vec3<f32>,
+  ratio: f32,
+  height: f32,
+  tiltDegrees: f32
+) -> vec3<f32> {
+  let distance = length(source.xy - targetPosition.xy);
+  let z = paraboloid(distance, source.z, targetPosition.z, ratio, height);
+  let tiltAngle = radians(tiltDegrees);
+  let tiltDirection = normalize(targetPosition.xy - source.xy);
+  let tilt = vec2<f32>(-tiltDirection.y, tiltDirection.x) * z * sin(tiltAngle);
+  return vec3<f32>(mix(source.xy, targetPosition.xy, ratio) + tilt, z * cos(tiltAngle));
+}
+
+// Great circle interpolation
+// http://www.movable-type.co.uk/scripts/latlong.html
+fn getAngularDistance(source: vec2<f32>, targetPosition: vec2<f32>) -> f32 {
+  let sourceRadians = radians(source);
+  let targetRadians = radians(targetPosition);
+  let sinHalfDelta = sin((sourceRadians - targetRadians) / 2.0);
+  let sinHalfDeltaSquared = sinHalfDelta * sinHalfDelta;
+  let a = sinHalfDeltaSquared.y +
+    cos(sourceRadians.y) * cos(targetRadians.y) * sinHalfDeltaSquared.x;
+  return 2.0 * asin(sqrt(a));
+}
+
+fn interpolateGreatCircle(
+  source: vec3<f32>,
+  targetPosition: vec3<f32>,
+  source3D: vec3<f32>,
+  target3D: vec3<f32>,
+  angularDistance: f32,
+  ratio: f32,
+  height: f32
+) -> vec3<f32> {
+  var longitudeLatitude: vec2<f32>;
+
+  // If the angular distance is PI, use linear interpolation. Otherwise use spherical interpolation.
+  if (abs(angularDistance - PI) < 0.001) {
+    longitudeLatitude = (1.0 - ratio) * source.xy + ratio * targetPosition.xy;
+  } else {
+    let a = sin((1.0 - ratio) * angularDistance);
+    let b = sin(ratio * angularDistance);
+    let p = source3D.yxz * a + target3D.yxz * b;
+    longitudeLatitude = degrees(vec2<f32>(
+      atan2(p.y, -p.x),
+      atan2(p.z, length(p.xy))
+    ));
+  }
+
+  let z = paraboloid(
+    angularDistance * EARTH_RADIUS,
+    source.z,
+    targetPosition.z,
+    ratio,
+    height
+  );
+  return vec3<f32>(longitudeLatitude, z);
+}
+
+@vertex
+fn vertexMain(
+  attributes: Attributes,
+  @builtin(vertex_index) vertexIndex: u32,
+  @builtin(instance_index) instanceIndex: u32
+) -> Varyings {
+  geometry.worldPosition = attributes.instanceSourcePositions;
+  geometry.worldPositionAlt = attributes.instanceTargetPositions;
+
+  let segmentIndex = f32(vertexIndex / 2u);
+  let segmentSide = select(-1.0, 1.0, vertexIndex % 2u == 1u);
+  var segmentRatio = getSegmentRatio(segmentIndex);
+  let previousRatio = getSegmentRatio(max(0.0, segmentIndex - 1.0));
+  var nextRatio = getSegmentRatio(min(arc.numSegments - 1.0, segmentIndex + 1.0));
+  // If this is the first point, use next - current as direction.
+  var indexDirection = select(-1.0, 1.0, segmentIndex <= 0.0);
+  var isValid = 1.0;
+
+  var currentClip: vec4<f32>;
+  var nextClip: vec4<f32>;
+
+  if (
+    (arc.greatCircle != 0.0 || project.projectionMode == PROJECTION_MODE_GLOBE) &&
+    project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT
+  ) {
+    let source = project_globe_(vec3<f32>(attributes.instanceSourcePositions.xy, 0.0));
+    let targetPosition = project_globe_(vec3<f32>(attributes.instanceTargetPositions.xy, 0.0));
+    let angularDistance = getAngularDistance(
+      attributes.instanceSourcePositions.xy,
+      attributes.instanceTargetPositions.xy
+    );
+
+    let previousPosition = interpolateGreatCircle(
+      attributes.instanceSourcePositions,
+      attributes.instanceTargetPositions,
+      source,
+      targetPosition,
+      angularDistance,
+      previousRatio,
+      attributes.instanceHeights
+    );
+    var currentPosition = interpolateGreatCircle(
+      attributes.instanceSourcePositions,
+      attributes.instanceTargetPositions,
+      source,
+      targetPosition,
+      angularDistance,
+      segmentRatio,
+      attributes.instanceHeights
+    );
+    var nextPosition = interpolateGreatCircle(
+      attributes.instanceSourcePositions,
+      attributes.instanceTargetPositions,
+      source,
+      targetPosition,
+      angularDistance,
+      nextRatio,
+      attributes.instanceHeights
+    );
+
+    if (abs(currentPosition.x - previousPosition.x) > 180.0) {
+      indexDirection = -1.0;
+      isValid = 0.0;
+    } else if (abs(currentPosition.x - nextPosition.x) > 180.0) {
+      indexDirection = 1.0;
+      isValid = 0.0;
+    }
+    nextPosition = select(nextPosition, previousPosition, indexDirection < 0.0);
+    nextRatio = select(nextRatio, previousRatio, indexDirection < 0.0);
+
+    if (isValid == 0.0) {
+      // Split at the antimeridian.
+      nextPosition.x += select(360.0, -360.0, nextPosition.x > 0.0);
+      let ratio = (
+        select(-180.0, 180.0, currentPosition.x > 0.0) - currentPosition.x
+      ) / (nextPosition.x - currentPosition.x);
+      currentPosition = mix(currentPosition, nextPosition, ratio);
+      segmentRatio = mix(segmentRatio, nextRatio, ratio);
+    }
+
+    let currentPosition64Low = mix(
+      attributes.instanceSourcePositions64Low,
+      attributes.instanceTargetPositions64Low,
+      segmentRatio
+    );
+    let nextPosition64Low = mix(
+      attributes.instanceSourcePositions64Low,
+      attributes.instanceTargetPositions64Low,
+      nextRatio
+    );
+    let currentProjection = project_position_to_clipspace_and_commonspace(
+      currentPosition,
+      currentPosition64Low,
+      ZERO_OFFSET
+    );
+    currentClip = currentProjection.clipPosition;
+    nextClip = project_position_to_clipspace(nextPosition, nextPosition64Low, ZERO_OFFSET);
+    geometry.position = currentProjection.commonPosition;
+  } else {
+    var sourceWorld = attributes.instanceSourcePositions;
+    var targetWorld = attributes.instanceTargetPositions;
+    if (arc.useShortestPath != 0.0) {
+      sourceWorld.x = ((sourceWorld.x + 180.0) % 360.0) - 180.0;
+      targetWorld.x = ((targetWorld.x + 180.0) % 360.0) - 180.0;
+      let deltaLongitude = targetWorld.x - sourceWorld.x;
+      if (deltaLongitude > 180.0) {
+        targetWorld.x -= 360.0;
+      }
+      if (deltaLongitude < -180.0) {
+        sourceWorld.x -= 360.0;
+      }
+    }
+
+    let source = project_position_vec3_f64(
+      sourceWorld,
+      attributes.instanceSourcePositions64Low
+    );
+    let targetPosition = project_position_vec3_f64(
+      targetWorld,
+      attributes.instanceTargetPositions64Low
+    );
+
+    // Common x at longitude=-180.
+    var antimeridianX = 0.0;
+    if (arc.useShortestPath != 0.0) {
+      if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+        antimeridianX = -(project.coordinateOrigin.x + 180.0) / 360.0 * TILE_SIZE;
+      }
+      let thresholdRatio = (antimeridianX - source.x) / (targetPosition.x - source.x);
+      if (previousRatio <= thresholdRatio && nextRatio > thresholdRatio) {
+        isValid = 0.0;
+        indexDirection = sign(segmentRatio - thresholdRatio);
+        segmentRatio = thresholdRatio;
+      }
+    }
+
+    nextRatio = select(nextRatio, previousRatio, indexDirection < 0.0);
+    var currentPosition = interpolateFlat(
+      source,
+      targetPosition,
+      segmentRatio,
+      attributes.instanceHeights,
+      attributes.instanceTilts
+    );
+    var nextPosition = interpolateFlat(
+      source,
+      targetPosition,
+      nextRatio,
+      attributes.instanceHeights,
+      attributes.instanceTilts
+    );
+
+    if (arc.useShortestPath != 0.0 && nextPosition.x < antimeridianX) {
+      currentPosition.x += TILE_SIZE;
+      nextPosition.x += TILE_SIZE;
+    }
+
+    currentClip = project_common_position_to_clipspace(vec4<f32>(currentPosition, 1.0));
+    nextClip = project_common_position_to_clipspace(vec4<f32>(nextPosition, 1.0));
+    geometry.position = vec4<f32>(currentPosition, 1.0);
+  }
+
+  geometry.uv = vec2<f32>(segmentRatio, segmentSide);
+  geometry.pickingColor = picking_getPickingColorFromIndex(instanceIndex);
+
+  let widthPixels = clamp(
+    project_unit_size_to_pixel(attributes.instanceWidths * arc.widthScale, arc.widthUnits),
+    arc.widthMinPixels,
+    arc.widthMaxPixels
+  );
+#ifdef ANTIALIASING
+  var offset = getExtrusionOffset(
+#else
+  let offset = getExtrusionOffset(
+#endif
+    (nextClip.xy - currentClip.xy) * indexDirection,
+    segmentSide,
+    widthPixels
+  );
+#ifdef ANTIALIASING
+  let halfWidthPixels = length(offset);
+  if (halfWidthPixels > 0.0) {
+    // Keep the declared edge at abs(uv.y) == 1 while rasterizing the outer half of the centered
+    // one-device-pixel coverage ramp.
+    let coverageScale = 1.0 + 0.5 / project.devicePixelRatio / halfWidthPixels;
+    offset *= coverageScale;
+    geometry.uv.y *= coverageScale;
+  }
+#endif
+
+  var output: Varyings;
+  output.position = currentClip + vec4<f32>(project_pixel_size_to_clipspace(offset), 0.0, 0.0);
+  let color = mix(attributes.instanceSourceColors, attributes.instanceTargetColors, segmentRatio);
+  output.color = vec4<f32>(color.rgb, color.a * layer.opacity);
+  output.uv = geometry.uv;
+  output.pickingColor = geometry.pickingColor;
+  output.isValid = isValid;
+  return output;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+#ifdef ANTIALIASING
+  let edgeCoord = abs(varyings.uv.y);
+  let edgePixels = (1.0 - edgeCoord) / max(fwidth(edgeCoord), 1e-6);
+#endif
+
+  if (varyings.isValid == 0.0) {
+    discard;
+  }
+
+#ifdef ANTIALIASING
+  // Fragments outside the coverage ramp must not write depth or picking colors.
+  if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+    discard;
+  }
+#endif
+  var color = varyings.color;
+#ifdef ANTIALIASING
+  // Feather one device pixel across the width. Arc segments meet lengthwise, so only soften the
+  // two outer edges of the strip.
+  color.a *= smoothedge(0.0, edgePixels);
+#endif
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(varyings.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(varyings.pickingColor, 1.0);
+  }
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(varyings.pickingColor - highlightedObjectColor))) {
+      let highlightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highlightAlpha + color.a * (1.0 - highlightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highlightRatio = highlightAlpha / blendedAlpha;
+        color = vec4<f32>(
+          mix(color.rgb, picking.highlightColor.rgb, highlightRatio),
+          blendedAlpha
+        );
+      }
+    }
+  }
+  return deckgl_premultiplied_alpha(color);
+}
+`;var Bt=`#version 300 es
+#define SHADER_NAME arc-layer-vertex-shader
+in vec4 instanceSourceColors;
+in vec4 instanceTargetColors;
+in vec3 instanceSourcePositions;
+in vec3 instanceSourcePositions64Low;
+in vec3 instanceTargetPositions;
+in vec3 instanceTargetPositions64Low;
+in float instanceWidths;
+in float instanceHeights;
+in float instanceTilts;
+out vec4 vColor;
+out vec2 uv;
+out float isValid;
+float paraboloid(float distance, float sourceZ, float targetZ, float ratio) {
+float deltaZ = targetZ - sourceZ;
+float dh = distance * instanceHeights;
+if (dh == 0.0) {
+return sourceZ + deltaZ * ratio;
+}
+float unitZ = deltaZ / dh;
+float p2 = unitZ * unitZ + 1.0;
+float dir = step(deltaZ, 0.0);
+float z0 = mix(sourceZ, targetZ, dir);
+float r = mix(ratio, 1.0 - ratio, dir);
+return sqrt(r * (p2 - r)) * dh + z0;
+}
+vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) {
+vec2 dir_screenspace = normalize(line_clipspace * project.viewportSize);
+dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
+return dir_screenspace * offset_direction * width / 2.0;
+}
+float getSegmentRatio(float index) {
+return smoothstep(0.0, 1.0, index / (arc.numSegments - 1.0));
+}
+vec3 interpolateFlat(vec3 source, vec3 target, float segmentRatio) {
+float distance = length(source.xy - target.xy);
+float z = paraboloid(distance, source.z, target.z, segmentRatio);
+float tiltAngle = radians(instanceTilts);
+vec2 tiltDirection = normalize(target.xy - source.xy);
+vec2 tilt = vec2(-tiltDirection.y, tiltDirection.x) * z * sin(tiltAngle);
+return vec3(
+mix(source.xy, target.xy, segmentRatio) + tilt,
+z * cos(tiltAngle)
+);
+}
+float getAngularDist (vec2 source, vec2 target) {
+vec2 sourceRadians = radians(source);
+vec2 targetRadians = radians(target);
+vec2 sin_half_delta = sin((sourceRadians - targetRadians) / 2.0);
+vec2 shd_sq = sin_half_delta * sin_half_delta;
+float a = shd_sq.y + cos(sourceRadians.y) * cos(targetRadians.y) * shd_sq.x;
+return 2.0 * asin(sqrt(a));
+}
+vec3 interpolateGreatCircle(vec3 source, vec3 target, vec3 source3D, vec3 target3D, float angularDist, float t) {
+vec2 lngLat;
+if(abs(angularDist - PI) < 0.001) {
+lngLat = (1.0 - t) * source.xy + t * target.xy;
+} else {
+float a = sin((1.0 - t) * angularDist);
+float b = sin(t * angularDist);
+vec3 p = source3D.yxz * a + target3D.yxz * b;
+lngLat = degrees(vec2(atan(p.y, -p.x), atan(p.z, length(p.xy))));
+}
+float z = paraboloid(angularDist * EARTH_RADIUS, source.z, target.z, t);
+return vec3(lngLat, z);
+}
+void main(void) {
+geometry.worldPosition = instanceSourcePositions;
+geometry.worldPositionAlt = instanceTargetPositions;
+float segmentIndex = float(gl_VertexID / 2);
+float segmentSide = mod(float(gl_VertexID), 2.) == 0. ? -1. : 1.;
+float segmentRatio = getSegmentRatio(segmentIndex);
+float prevSegmentRatio = getSegmentRatio(max(0.0, segmentIndex - 1.0));
+float nextSegmentRatio = getSegmentRatio(min(arc.numSegments - 1.0, segmentIndex + 1.0));
+float indexDir = mix(-1.0, 1.0, step(segmentIndex, 0.0));
+isValid = 1.0;
+uv = vec2(segmentRatio, segmentSide);
+geometry.uv = uv;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+vec4 curr;
+vec4 next;
+vec3 source;
+vec3 target;
+if ((arc.greatCircle || project.projectionMode == PROJECTION_MODE_GLOBE) && project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
+source = project_globe_(vec3(instanceSourcePositions.xy, 0.0));
+target = project_globe_(vec3(instanceTargetPositions.xy, 0.0));
+float angularDist = getAngularDist(instanceSourcePositions.xy, instanceTargetPositions.xy);
+vec3 prevPos = interpolateGreatCircle(instanceSourcePositions, instanceTargetPositions, source, target, angularDist, prevSegmentRatio);
+vec3 currPos = interpolateGreatCircle(instanceSourcePositions, instanceTargetPositions, source, target, angularDist, segmentRatio);
+vec3 nextPos = interpolateGreatCircle(instanceSourcePositions, instanceTargetPositions, source, target, angularDist, nextSegmentRatio);
+if (abs(currPos.x - prevPos.x) > 180.0) {
+indexDir = -1.0;
+isValid = 0.0;
+} else if (abs(currPos.x - nextPos.x) > 180.0) {
+indexDir = 1.0;
+isValid = 0.0;
+}
+nextPos = indexDir < 0.0 ? prevPos : nextPos;
+nextSegmentRatio = indexDir < 0.0 ? prevSegmentRatio : nextSegmentRatio;
+if (isValid == 0.0) {
+nextPos.x += nextPos.x > 0.0 ? -360.0 : 360.0;
+float t = ((currPos.x > 0.0 ? 180.0 : -180.0) - currPos.x) / (nextPos.x - currPos.x);
+currPos = mix(currPos, nextPos, t);
+segmentRatio = mix(segmentRatio, nextSegmentRatio, t);
+}
+vec3 currPos64Low = mix(instanceSourcePositions64Low, instanceTargetPositions64Low, segmentRatio);
+vec3 nextPos64Low = mix(instanceSourcePositions64Low, instanceTargetPositions64Low, nextSegmentRatio);
+curr = project_position_to_clipspace(currPos, currPos64Low, vec3(0.0), geometry.position);
+next = project_position_to_clipspace(nextPos, nextPos64Low, vec3(0.0));
+} else {
+vec3 source_world = instanceSourcePositions;
+vec3 target_world = instanceTargetPositions;
+if (arc.useShortestPath) {
+source_world.x = mod(source_world.x + 180., 360.0) - 180.;
+target_world.x = mod(target_world.x + 180., 360.0) - 180.;
+float deltaLng = target_world.x - source_world.x;
+if (deltaLng > 180.) target_world.x -= 360.;
+if (deltaLng < -180.) source_world.x -= 360.;
+}
+source = project_position(source_world, instanceSourcePositions64Low);
+target = project_position(target_world, instanceTargetPositions64Low);
+float antiMeridianX = 0.0;
+if (arc.useShortestPath) {
+if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
+antiMeridianX = -(project.coordinateOrigin.x + 180.) / 360. * TILE_SIZE;
+}
+float thresholdRatio = (antiMeridianX - source.x) / (target.x - source.x);
+if (prevSegmentRatio <= thresholdRatio && nextSegmentRatio > thresholdRatio) {
+isValid = 0.0;
+indexDir = sign(segmentRatio - thresholdRatio);
+segmentRatio = thresholdRatio;
+}
+}
+nextSegmentRatio = indexDir < 0.0 ? prevSegmentRatio : nextSegmentRatio;
+vec3 currPos = interpolateFlat(source, target, segmentRatio);
+vec3 nextPos = interpolateFlat(source, target, nextSegmentRatio);
+if (arc.useShortestPath) {
+if (nextPos.x < antiMeridianX) {
+currPos.x += TILE_SIZE;
+nextPos.x += TILE_SIZE;
+}
+}
+curr = project_common_position_to_clipspace(vec4(currPos, 1.0));
+next = project_common_position_to_clipspace(vec4(nextPos, 1.0));
+geometry.position = vec4(currPos, 1.0);
+}
+float widthPixels = clamp(
+project_size_to_pixel(instanceWidths * arc.widthScale, arc.widthUnits),
+arc.widthMinPixels, arc.widthMaxPixels
+);
+vec3 offset = vec3(
+getExtrusionOffset((next.xy - curr.xy) * indexDir, segmentSide, widthPixels),
+0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+#ifdef ANTIALIASING
+float halfWidthPixels = length(offset.xy);
+if (halfWidthPixels > 0.0) {
+float coverageScale = 1.0 + 0.5 / project.devicePixelRatio / halfWidthPixels;
+offset.xy *= coverageScale;
+uv.y *= coverageScale;
+}
+geometry.uv = uv;
+#endif
+DECKGL_FILTER_GL_POSITION(curr, geometry);
+gl_Position = curr + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0);
+vec4 color = mix(instanceSourceColors, instanceTargetColors, segmentRatio);
+vColor = vec4(color.rgb, color.a * layer.opacity);
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var jt=`#version 300 es
+#define SHADER_NAME arc-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+in vec2 uv;
+in float isValid;
+out vec4 fragColor;
+void main(void) {
+#ifdef ANTIALIASING
+float edgeCoord = abs(uv.y);
+float edgePixels = (1.0 - edgeCoord) / max(fwidth(edgeCoord), 1e-6);
+#endif
+if (isValid == 0.0) {
+discard;
+}
+#ifdef ANTIALIASING
+if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+discard;
+}
+#endif
+fragColor = vColor;
+geometry.uv = uv;
+#ifdef ANTIALIASING
+fragColor.a *= smoothedge(0.0, edgePixels);
+#endif
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var ze=[0,0,0,255];var qo={getSourcePosition:{type:`accessor`,value:t=>t.sourcePosition},getTargetPosition:{type:`accessor`,value:t=>t.targetPosition},getSourceColor:{type:`accessor`,value:ze},getTargetColor:{type:`accessor`,value:ze},getWidth:{type:`accessor`,value:1},getHeight:{type:`accessor`,value:1},getTilt:{type:`accessor`,value:0},greatCircle:!1,numSegments:{type:`number`,value:50,min:1},widthUnits:`pixels`,widthScale:{type:`number`,value:1,min:0},widthMinPixels:{type:`number`,value:0,min:0},widthMaxPixels:{type:`number`,value:Number.MAX_SAFE_INTEGER,min:0},antialiasing:!1};var en=(()=>{class t extends en$1{getBounds(){return this.getAttributeManager()?.getBounds([`instanceSourcePositions`,`instanceTargetPositions`])}getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:Bt,fs:jt,source:Gt,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,Nt]})}get wrapLongitude(){return!1}initializeState(){this.getAttributeManager().addInstanced({instanceSourcePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getSourcePosition`},instanceTargetPositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getTargetPosition`},instanceSourceColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getSourceColor`,defaultValue:ze},instanceTargetColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getTargetColor`,defaultValue:ze},instanceWidths:{size:1,transition:!0,accessor:`getWidth`,defaultValue:1},instanceHeights:{size:1,transition:!0,accessor:`getHeight`,defaultValue:1},instanceTilts:{size:1,transition:!0,accessor:`getTilt`,defaultValue:0}})}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e;(s.extensionsChanged||i.antialiasing!==n.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{widthUnits:i,widthScale:n,widthMinPixels:s,widthMaxPixels:r,greatCircle:a,wrapLongitude:l,numSegments:c}=this.props,f={numSegments:c,widthUnits:ee[i],widthScale:n,widthMinPixels:s,widthMaxPixels:r,greatCircle:a,useShortestPath:l},d=this.state.model;d.shaderInputs.setProps({arc:f}),d.setVertexCount(c*2),d.draw(this.context.renderPass)}_getModel(){return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),topology:`triangle-strip`,isInstanced:!0}))}}return t.layerName=`ArcLayer`,t.defaultProps=qo,t})();var tn=new Uint32Array([0,2,1,0,3,2]);var on=new Float32Array([0,1,0,0,1,0,1,1]);function dt(t,o){if(!o)return nn(t);let e=Math.max(Math.abs(t[0][0]-t[3][0]),Math.abs(t[1][0]-t[2][0])),i=Math.max(Math.abs(t[1][1]-t[0][1]),Math.abs(t[2][1]-t[3][1])),n=Math.ceil(e/o)+1,s=Math.ceil(i/o)+1,r=(n-1)*(s-1)*6,a=new Uint32Array(r),l=new Float32Array(n*s*2),c=new Float64Array(n*s*3),f=0,d=0;for(let u=0;u<n;u++){let p=u/(n-1);for(let g=0;g<s;g++){let h=g/(s-1),v=sn(t,p,h);c[f*3+0]=v[0],c[f*3+1]=v[1],c[f*3+2]=v[2]||0,l[f*2+0]=p,l[f*2+1]=1-h,u>0&&g>0&&(a[d++]=f-s,a[d++]=f-s-1,a[d++]=f-1,a[d++]=f-s,a[d++]=f-1,a[d++]=f),f++}}return{vertexCount:r,positions:c,indices:a,texCoords:l}}function nn(t){let o=new Float64Array(12);for(let e=0;e<t.length;e++)o[e*3+0]=t[e][0],o[e*3+1]=t[e][1],o[e*3+2]=t[e][2]||0;return{vertexCount:6,positions:o,indices:tn,texCoords:on}}function sn(t,o,e){return Ni$1(Ni$1(t[0],t[1],e),Ni$1(t[3],t[2],e),o)}var rn=`
+struct BitmapUniforms {
+  bounds: vec4<f32>,
+  coordinateConversion: f32,
+  desaturate: f32,
+  tintColor: vec3<f32>,
+  transparentColor: vec4<f32>,
+};
+
+@group(0) @binding(auto) var<uniform> bitmap: BitmapUniforms;
+@group(0) @binding(auto) var bitmapTexture: texture_2d<f32>;
+@group(0) @binding(auto) var bitmapTextureSampler: sampler;
+`;var Wt=`layout(std140) uniform bitmapUniforms {
+  vec4 bounds;
+  float coordinateConversion;
+  float desaturate;
+  vec3 tintColor;
+  vec4 transparentColor;
+} bitmap;
+`;var Ut={name:`bitmap`,source:rn,vs:Wt,fs:Wt,uniformTypes:{bounds:`vec4<f32>`,coordinateConversion:`f32`,desaturate:`f32`,tintColor:`vec3<f32>`,transparentColor:`vec4<f32>`}};var Vt=`struct Attributes {
+  @location(0) positions: vec3<f32>,
+  @location(1) positions64Low: vec3<f32>,
+  @location(2) texCoords: vec2<f32>,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vTexCoord: vec2<f32>,
+  @location(1) vTexPos: vec2<f32>,
+  @location(2) pickingColor: vec3<f32>,
+  @location(3) pickingDepth: f32,
+};
+
+// from degrees to Web Mercator
+fn lnglat_to_mercator(lnglat: vec2<f32>) -> vec2<f32> {
+  let x = lnglat.x;
+  let y = clamp(lnglat.y, -89.9, 89.9);
+  return vec2<f32>(
+    radians(x) + PI,
+    PI + log(tan(PI * 0.25 + radians(y) * 0.5))
+  ) * WORLD_SCALE;
+}
+
+// from Web Mercator to degrees
+fn mercator_to_lnglat(xy: vec2<f32>) -> vec2<f32> {
+  let position = xy / WORLD_SCALE;
+  return degrees(vec2<f32>(
+    position.x - PI,
+    atan(exp(position.y - PI)) * 2.0 - PI * 0.5
+  ));
+}
+
+fn color_desaturate(colorValue: vec3<f32>) -> vec3<f32> {
+  let luminance = (colorValue.r + colorValue.g + colorValue.b) * 0.333333333;
+  return mix(colorValue, vec3<f32>(luminance), bitmap.desaturate);
+}
+
+fn color_tint(colorValue: vec3<f32>) -> vec3<f32> {
+  return colorValue * bitmap.tintColor;
+}
+
+fn apply_opacity(colorValue: vec3<f32>, alpha: f32) -> vec4<f32> {
+  if (bitmap.transparentColor.a == 0.0) {
+    return vec4<f32>(colorValue, alpha);
+  }
+  let blendedAlpha = alpha + bitmap.transparentColor.a * (1.0 - alpha);
+  let highLightRatio = alpha / blendedAlpha;
+  let blendedRGB = mix(bitmap.transparentColor.rgb, colorValue, highLightRatio);
+  return vec4<f32>(blendedRGB, blendedAlpha);
+}
+
+fn getUV(position: vec2<f32>) -> vec2<f32> {
+  return vec2<f32>(
+    (position.x - bitmap.bounds[0]) / (bitmap.bounds[2] - bitmap.bounds[0]),
+    (position.y - bitmap.bounds[3]) / (bitmap.bounds[1] - bitmap.bounds[3])
+  );
+}
+
+// Pack the top 12 bits of two normalized floats into three 8-bit values.
+fn packUVsIntoRGB(uv: vec2<f32>) -> vec3<f32> {
+  let uv8bit = floor(uv * 256.0);
+  let uvFraction = fract(uv * 256.0);
+  let uvFraction4bit = floor(uvFraction * 16.0);
+  let fractions = uvFraction4bit.x + uvFraction4bit.y * 16.0;
+  return vec3<f32>(uv8bit, fractions) / 255.0;
+}
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var output: Varyings;
+  geometry.worldPosition = attributes.positions;
+  geometry.uv = attributes.texCoords;
+  geometry.pickingColor = picking_getPickingColorFromIndex(0u);
+
+  let projectedPosition = project_position_to_clipspace_and_commonspace(
+    attributes.positions,
+    attributes.positions64Low,
+    vec3<f32>(0.0)
+  );
+  geometry.position = projectedPosition.commonPosition;
+  output.position = projectedPosition.clipPosition;
+  output.vTexCoord = attributes.texCoords;
+  output.vTexPos = vec2<f32>(0.0);
+  output.pickingColor = geometry.pickingColor;
+  output.pickingDepth = output.position.z / output.position.w;
+
+  if (bitmap.coordinateConversion < -0.5) {
+    output.vTexPos = geometry.position.xy + project.commonOrigin.xy;
+  } else if (bitmap.coordinateConversion > 0.5) {
+    output.vTexPos = geometry.worldPosition.xy;
+  }
+
+  return output;
+}
+
+@fragment
+fn fragmentMain(input: Varyings) -> @location(0) vec4<f32> {
+  var uv = input.vTexCoord;
+  if (bitmap.coordinateConversion < -0.5) {
+    uv = getUV(mercator_to_lnglat(input.vTexPos));
+  } else if (bitmap.coordinateConversion > 0.5) {
+    uv = getUV(lnglat_to_mercator(input.vTexPos));
+  }
+
+  let bitmapColor = textureSample(bitmapTexture, bitmapTextureSampler, uv);
+  var fragColor = apply_opacity(
+    color_tint(color_desaturate(bitmapColor.rgb)),
+    bitmapColor.a * layer.opacity
+  );
+
+  geometry.uv = uv;
+
+  if (picking.isActive > 0.5) {
+    if (picking.isAttribute > 0.5) {
+      return vec4<f32>(input.pickingDepth, 0.0, 0.0, 1.0);
+    }
+    return vec4<f32>(packUVsIntoRGB(uv), 1.0);
+  }
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(input.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  return deckgl_premultiplied_alpha(fragColor);
+}
+`;var Ht=`#version 300 es
+#define SHADER_NAME bitmap-layer-vertex-shader
+
+in vec2 texCoords;
+in vec3 positions;
+in vec3 positions64Low;
+
+out vec2 vTexCoord;
+out vec2 vTexPos;
+
+const vec3 pickingColor = vec3(1.0, 0.0, 0.0);
+
+void main(void) {
+  geometry.worldPosition = positions;
+  geometry.uv = texCoords;
+  geometry.pickingColor = pickingColor;
+
+  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  vTexCoord = texCoords;
+
+  if (bitmap.coordinateConversion < -0.5) {
+    vTexPos = geometry.position.xy + project.commonOrigin.xy;
+  } else if (bitmap.coordinateConversion > 0.5) {
+    vTexPos = geometry.worldPosition.xy;
+  }
+
+  vec4 color = vec4(0.0);
+  DECKGL_FILTER_COLOR(color, geometry);
+}
+`;var Zt=`#version 300 es
+#define SHADER_NAME bitmap-layer-fragment-shader
+
+#ifdef GL_ES
+precision highp float;
+#endif
+
+uniform sampler2D bitmapTexture;
+
+in vec2 vTexCoord;
+in vec2 vTexPos;
+
+out vec4 fragColor;
+
+/* projection utils */
+const float TILE_SIZE = 512.0;
+const float PI = 3.1415926536;
+const float WORLD_SCALE = TILE_SIZE / PI / 2.0;
+
+// from degrees to Web Mercator
+vec2 lnglat_to_mercator(vec2 lnglat) {
+  float x = lnglat.x;
+  float y = clamp(lnglat.y, -89.9, 89.9);
+  return vec2(
+    radians(x) + PI,
+    PI + log(tan(PI * 0.25 + radians(y) * 0.5))
+  ) * WORLD_SCALE;
+}
+
+// from Web Mercator to degrees
+vec2 mercator_to_lnglat(vec2 xy) {
+  xy /= WORLD_SCALE;
+  return degrees(vec2(
+    xy.x - PI,
+    atan(exp(xy.y - PI)) * 2.0 - PI * 0.5
+  ));
+}
+/* End projection utils */
+
+// apply desaturation
+vec3 color_desaturate(vec3 color) {
+  float luminance = (color.r + color.g + color.b) * 0.333333333;
+  return mix(color, vec3(luminance), bitmap.desaturate);
+}
+
+// apply tint
+vec3 color_tint(vec3 color) {
+  return color * bitmap.tintColor;
+}
+
+// blend with background color
+vec4 apply_opacity(vec3 color, float alpha) {
+  if (bitmap.transparentColor.a == 0.0) {
+    return vec4(color, alpha);
+  }
+  float blendedAlpha = alpha + bitmap.transparentColor.a * (1.0 - alpha);
+  float highLightRatio = alpha / blendedAlpha;
+  vec3 blendedRGB = mix(bitmap.transparentColor.rgb, color, highLightRatio);
+  return vec4(blendedRGB, blendedAlpha);
+}
+
+vec2 getUV(vec2 pos) {
+  return vec2(
+    (pos.x - bitmap.bounds[0]) / (bitmap.bounds[2] - bitmap.bounds[0]),
+    (pos.y - bitmap.bounds[3]) / (bitmap.bounds[1] - bitmap.bounds[3])
+  );
+}
+
+
+vec3 packUVsIntoRGB(vec2 uv) {
+  // Extract the top 8 bits. We want values to be truncated down so we can add a fraction
+  vec2 uv8bit = floor(uv * 256.);
+
+  // Calculate the normalized remainders of u and v parts that do not fit into 8 bits
+  // Scale and clamp to 0-1 range
+  vec2 uvFraction = fract(uv * 256.);
+  vec2 uvFraction4bit = floor(uvFraction * 16.);
+
+  // Remainder can be encoded in blue channel, encode as 4 bits for pixel coordinates
+  float fractions = uvFraction4bit.x + uvFraction4bit.y * 16.;
+
+  return vec3(uv8bit, fractions) / 255.;
+}
+
+
+void main(void) {
+  vec2 uv = vTexCoord;
+  if (bitmap.coordinateConversion < -0.5) {
+    vec2 lnglat = mercator_to_lnglat(vTexPos);
+    uv = getUV(lnglat);
+  } else if (bitmap.coordinateConversion > 0.5) {
+    vec2 commonPos = lnglat_to_mercator(vTexPos);
+    uv = getUV(commonPos);
+  }
+  vec4 bitmapColor = texture(bitmapTexture, uv);
+
+  fragColor = apply_opacity(color_tint(color_desaturate(bitmapColor.rgb)), bitmapColor.a * layer.opacity);
+
+  geometry.uv = uv;
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+
+  if (bool(picking.isActive) && !bool(picking.isAttribute)) {
+    // Since instance information is not used, we can use picking color for pixel index
+    fragColor.rgb = packUVsIntoRGB(uv);
+  }
+}
+`;var ln={image:{type:`image`,value:null,async:!0},bounds:{type:`array`,value:[1,0,0,1],compare:!0},_imageCoordinateSystem:`default`,desaturate:{type:`number`,min:0,max:1,value:0},transparentColor:{type:`color`,value:[0,0,0,0]},tintColor:{type:`color`,value:[255,255,255]},textureParameters:{type:`object`,ignore:!0,value:null}};var fn=(()=>{class t extends en$1{getShaders(){return super.getShaders({vs:Ht,fs:Zt,source:Vt,modules:[ma,Wa,Ka,Ut]})}initializeState(){let e=this.getAttributeManager(),i=!0;e.add({indices:{size:1,isIndexed:!0,update:n=>n.value=this.state.mesh.indices,noAlloc:i},positions:{size:3,type:`float64`,fp64:this.use64bitPositions(),update:n=>n.value=this.state.mesh.positions,noAlloc:i},texCoords:{size:2,update:n=>n.value=this.state.mesh.texCoords,noAlloc:i}})}updateState({props:e,oldProps:i,changeFlags:n}){let s=this.getAttributeManager();if(n.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),s.invalidateAll()),e.bounds!==i.bounds){let r$1=this.state.mesh,a=this._createMesh();this.state.model.setVertexCount(a.vertexCount);for(let l in a)r$1&&r$1[l]!==a[l]&&s.invalidate(l);this.setState(r({mesh:a},this._getCoordinateUniforms()))}else e._imageCoordinateSystem!==i._imageCoordinateSystem&&this.setState(this._getCoordinateUniforms())}getPickingInfo(e){let{image:i}=this.props,n=e.info;if(!n.color||!i)return n.bitmap=null,n;let{width:s,height:r}=i;n.index=0;let a=dn(n.color);return n.bitmap={size:{width:s,height:r},uv:a,pixel:[Math.floor(a[0]*s),Math.floor(a[1]*r)]},n}disablePickingIndex(){this.setState({disablePicking:!0})}restorePickingColors(){this.setState({disablePicking:!1})}_updateAutoHighlight(e){super._updateAutoHighlight(s(r({},e),{color:this.encodePickingColor(0)}))}_createMesh(){let{bounds:e}=this.props,i=e;return Kt(e)&&(i=[[e[0],e[1]],[e[0],e[3]],[e[2],e[3]],[e[2],e[1]]]),dt(i,this.context.viewport.resolution)}_getModel(){let e=this.context.device.type===`webgpu`?this.getAttributeManager().getBufferLayouts({isInstanced:!1}).filter(i=>i.name!==`indices`):this.getAttributeManager().getBufferLayouts();return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:e,topology:`triangle-list`,isInstanced:!1}))}draw(e){let{shaderModuleProps:i}=e,{model:n,coordinateConversion:s,bounds:r,disablePicking:a}=this.state,{image:l,desaturate:c,transparentColor:f,tintColor:d}=this.props;if(!(i.picking.isActive&&a)&&l&&n){let u={bitmapTexture:l,bounds:r,coordinateConversion:s,desaturate:c,tintColor:d.slice(0,3).map(p=>p/255),transparentColor:f.map(p=>p/255)};n.shaderInputs.setProps({bitmap:u}),n.draw(this.context.renderPass)}}_getCoordinateUniforms(){let{_imageCoordinateSystem:e}=this.props;if(e!=="default"){let{bounds:i}=this.props;if(!Kt(i))throw new Error(`_imageCoordinateSystem only supports rectangular bounds`);let n=this.context.viewport.resolution?`lnglat`:`cartesian`;if(e=e===`lnglat`?`lnglat`:`cartesian`,e===`lnglat`&&n===`cartesian`)return{coordinateConversion:-1,bounds:i};if(e===`cartesian`&&n===`lnglat`){let s=st$1([i[0],i[1]]),r=st$1([i[2],i[3]]);return{coordinateConversion:1,bounds:[s[0],s[1],r[0],r[1]]}}}return{coordinateConversion:0,bounds:[0,0,0,0]}}}return t.layerName=`BitmapLayer`,t.defaultProps=ln,t})();function dn(t){let[o,e,i]=t,n=(i&240)/256;return[(o+(i&15)/16)/256,(e+n)/256]}function Kt(t){return Number.isFinite(t[0])}var $t=`layout(std140) uniform iconUniforms {
+  float sizeScale;
+  vec2 iconsTextureDim;
+  float sizeBasis;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  bool billboard;
+  highp int sizeUnits;
+  float alphaCutoff;
+} icon;
+`;var Jt={name:`icon`,vs:$t,fs:$t,uniformTypes:{sizeScale:`f32`,iconsTextureDim:`vec2<f32>`,sizeBasis:`f32`,sizeMinPixels:`f32`,sizeMaxPixels:`f32`,billboard:`f32`,sizeUnits:`i32`,alphaCutoff:`f32`}};var Yt=`#version 300 es
+#define SHADER_NAME icon-layer-vertex-shader
+in vec2 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in float instanceSizes;
+in float instanceAngles;
+in vec4 instanceColors;
+#ifdef USE_ROW_INDEXES
+in float rowIndexes;
+#endif
+in vec4 instanceIconFrames;
+in float instanceColorModes;
+in vec2 instanceOffsets;
+in vec2 instancePixelOffset;
+out float vColorMode;
+out vec4 vColor;
+out vec2 vTextureCoords;
+out vec2 uv;
+vec2 rotate_by_angle(vec2 vertex, float angle) {
+float angle_radian = angle * PI / 180.0;
+float cos_angle = cos(angle_radian);
+float sin_angle = sin(angle_radian);
+mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle);
+return rotationMatrix * vertex;
+}
+void main(void) {
+geometry.worldPosition = instancePositions;
+geometry.uv = positions;
+#ifdef USE_ROW_INDEXES
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
+#else
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+#endif
+uv = positions;
+vec2 iconSize = instanceIconFrames.zw;
+float sizePixels = clamp(
+project_size_to_pixel(instanceSizes * icon.sizeScale, icon.sizeUnits),
+icon.sizeMinPixels, icon.sizeMaxPixels
+);
+float iconConstraint = icon.sizeBasis == 0.0 ? iconSize.x : iconSize.y;
+float instanceScale = iconConstraint == 0.0 ? 0.0 : sizePixels / iconConstraint;
+vec2 pixelOffset = positions / 2.0 * iconSize + instanceOffsets;
+pixelOffset = rotate_by_angle(pixelOffset, instanceAngles) * instanceScale;
+pixelOffset += instancePixelOffset;
+pixelOffset.y *= -1.0;
+if (icon.billboard)  {
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vec3 offset = vec3(pixelOffset, 0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+} else {
+vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0);
+DECKGL_FILTER_SIZE(offset_common, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+vTextureCoords = mix(
+instanceIconFrames.xy,
+instanceIconFrames.xy + iconSize,
+(positions.xy + 1.0) / 2.0
+) / icon.iconsTextureDim;
+vColor = instanceColors;
+DECKGL_FILTER_COLOR(vColor, geometry);
+vColorMode = instanceColorModes;
+}
+`;var Xt=`#version 300 es
+#define SHADER_NAME icon-layer-fragment-shader
+precision highp float;
+uniform sampler2D iconsTexture;
+in float vColorMode;
+in vec4 vColor;
+in vec2 vTextureCoords;
+in vec2 uv;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = uv;
+vec4 texColor = texture(iconsTexture, vTextureCoords);
+vec3 color = mix(texColor.rgb, vColor.rgb, vColorMode);
+float a = texColor.a * layer.opacity * vColor.a;
+if (a < icon.alphaCutoff) {
+discard;
+}
+fragColor = vec4(color, a);
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var un=`struct IconUniforms {
+  sizeScale: f32,
+  iconsTextureDim: vec2<f32>,
+  sizeBasis: f32,
+  sizeMinPixels: f32,
+  sizeMaxPixels: f32,
+  billboard: i32,
+  sizeUnits: i32,
+  alphaCutoff: f32
+};
+
+@group(0) @binding(auto) var<uniform> icon: IconUniforms;
+@group(0) @binding(auto) var iconsTexture : texture_2d<f32>;
+@group(0) @binding(auto) var iconsTextureSampler : sampler;
+
+fn rotate_by_angle(vertex: vec2<f32>, angle_deg: f32) -> vec2<f32> {
+  let angle_radian = angle_deg * PI / 180.0;
+  let c = cos(angle_radian);
+  let s = sin(angle_radian);
+  let rotation = mat2x2<f32>(vec2<f32>(c, s), vec2<f32>(-s, c));
+  return rotation * vertex;
+}
+
+struct Attributes {
+  @builtin(instance_index) instanceIndex : u32,
+  @location(0) positions: vec2<f32>,
+
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceSizes: f32,
+  @location(4) instanceAngles: f32,
+  @location(5) instanceColors: vec4<f32>,
+  @location(6) instanceIconFrames: vec4<f32>,
+  @location(7) instanceColorModes: f32,
+  @location(8) instanceOffsets: vec2<f32>,
+  @location(9) instancePixelOffset: vec2<f32>,
+  PICKING_COLOR_ATTRIBUTE
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+
+  @location(0) vColorMode: f32,
+  @location(1) vColor: vec4<f32>,
+  @location(2) vTextureCoords: vec2<f32>,
+  @location(3) uv: vec2<f32>,
+  @location(4) pickingColor: vec3<f32>,
+};
+
+@vertex
+fn vertexMain(inp: Attributes) -> Varyings {
+  // write geometry fields used by filters + FS
+  geometry.worldPosition = inp.instancePositions;
+  geometry.uv = inp.positions;
+  geometry.pickingColor = PICKING_COLOR_VALUE;
+
+  var outp: Varyings;
+  outp.uv = inp.positions;
+
+  let iconSize = inp.instanceIconFrames.zw;
+
+  // convert size in meters to pixels, then clamp
+  let sizePixels = clamp(
+    project_unit_size_to_pixel(inp.instanceSizes * icon.sizeScale, icon.sizeUnits),
+    icon.sizeMinPixels, icon.sizeMaxPixels
+  );
+
+  // scale icon height to match instanceSize
+  let iconConstraint = select(iconSize.y, iconSize.x, icon.sizeBasis == 0.0);
+  let instanceScale = select(sizePixels / iconConstraint, 0.0, iconConstraint == 0.0);
+
+  // scale and rotate vertex in "pixel" units; then add per-instance pixel offset
+  var pixelOffset = inp.positions / 2.0 * iconSize + inp.instanceOffsets;
+  pixelOffset = rotate_by_angle(pixelOffset, inp.instanceAngles) * instanceScale;
+  pixelOffset = pixelOffset + inp.instancePixelOffset;
+  pixelOffset.y = pixelOffset.y * -1.0;
+
+  if (icon.billboard != 0) {
+    var pos = project_position_to_clipspace(inp.instancePositions, inp.instancePositions64Low, vec3<f32>(0.0)); // TODO, &geometry.position);
+    // DECKGL_FILTER_GL_POSITION(pos, geometry);
+
+    var offset = vec3<f32>(pixelOffset, 0.0);
+    // DECKGL_FILTER_SIZE(offset, geometry);
+    let clipOffset = project_pixel_size_to_clipspace(offset.xy);
+    pos = vec4<f32>(pos.x + clipOffset.x, pos.y + clipOffset.y, pos.z, pos.w);
+    outp.position = pos;
+  } else {
+    var offset_common = vec3<f32>(project_pixel_size_vec2(pixelOffset), 0.0);
+    // DECKGL_FILTER_SIZE(offset_common, geometry);
+    var pos = project_position_to_clipspace(inp.instancePositions, inp.instancePositions64Low, offset_common); // TODO, &geometry.position);
+    // DECKGL_FILTER_GL_POSITION(pos, geometry);
+    outp.position = pos;
+  }
+
+  let uvMix = (inp.positions.xy + vec2<f32>(1.0, 1.0)) * 0.5;
+  outp.vTextureCoords = mix(inp.instanceIconFrames.xy, inp.instanceIconFrames.xy + iconSize, uvMix) / icon.iconsTextureDim;
+
+  outp.vColor = inp.instanceColors;
+  // DECKGL_FILTER_COLOR(outp.vColor, geometry);
+
+  outp.vColorMode = inp.instanceColorModes;
+  outp.pickingColor = geometry.pickingColor;
+
+  return outp;
+}
+
+@fragment
+fn fragmentMain(inp: Varyings) -> @location(0) vec4<f32> {
+  // expose to deck.gl filter hooks
+  geometry.uv = inp.uv;
+
+  let texColor = textureSample(iconsTexture, iconsTextureSampler, inp.vTextureCoords);
+
+  // if colorMode == 0, use pixel color from the texture
+  // if colorMode == 1 (or picking), use texture as transparency mask
+  let rgb = mix(texColor.rgb, inp.vColor.rgb, inp.vColorMode);
+  let a = texColor.a * layer.opacity * inp.vColor.a;
+
+  if (a < icon.alphaCutoff) {
+    discard;
+  }
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(inp.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(inp.pickingColor, 1.0);
+  }
+
+  var fragColor = deckgl_premultiplied_alpha(vec4<f32>(rgb, a));
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(inp.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  return fragColor;
+}
+`;function qt(t){return un.replace(`PICKING_COLOR_ATTRIBUTE`,t?`@location(10) rowIndexes: u32,`:``).replace(`PICKING_COLOR_VALUE`,t?`picking_getPickingColorFromIndex(inp.rowIndexes)`:`picking_getPickingColorFromIndex(inp.instanceIndex)`)}var pn=1024;var gn=4;var Qt=()=>{};var ei={minFilter:`linear`,mipmapFilter:`linear`,magFilter:`linear`,addressModeU:`clamp-to-edge`,addressModeV:`clamp-to-edge`};var hn={x:0,y:0,width:0,height:0};function xn(t){return Math.pow(2,Math.ceil(Math.log2(t)))}function vn(t,o,e,i){let n=Math.min(e/o.width,i/o.height),s=Math.floor(o.width*n),r=Math.floor(o.height*n);return n===1?{image:o,width:s,height:r}:(t.canvas.height=r,t.canvas.width=s,t.clearRect(0,0,s,r),t.drawImage(o,0,0,o.width,o.height,0,0,s,r),{image:t.canvas,width:s,height:r})}function le(t){return t&&(t.id||t.url)}function ii(t){let{device:o}=t;o.type===`webgl`?t.generateMipmapsWebGL():o.type===`webgpu`&&o.generateMipmapsWebGPU(t)}function mn(t,o,e,i){let{width:n,height:s,device:r}=t,a=r.createTexture({format:`rgba8unorm`,width:o,height:e,sampler:i,mipLevels:r.getMipLevelCount(o,e)}),l=r.createCommandEncoder();l.copyTextureToTexture({sourceTexture:t,destinationTexture:a,width:n,height:s});let c=l.finish();return r.submit(c),ii(a),t.destroy(),a}function ti(t,o,e){for(let i=0;i<o.length;i++){let{icon:n,xOffset:s$1}=o[i],r$2=le(n);t[r$2]=s(r({},n),{x:s$1,y:e})}}function yn({icons:t,buffer:o,mapping:e={},xOffset:i=0,yOffset:n=0,rowHeight:s=0,canvasWidth:r}){let a=[];for(let l=0;l<t.length;l++){let c=t[l];if(!e[le(c)]){let{height:d,width:u}=c;i+u+o>r&&(ti(e,a,n),i=0,n=s+n+o,s=0,a=[]),a.push({icon:c,xOffset:i}),i=i+u+o,s=Math.max(s,d)}}return a.length>0&&ti(e,a,n),{mapping:e,rowHeight:s,xOffset:i,yOffset:n,canvasWidth:r,canvasHeight:xn(s+n+o)}}function Pn(t,o,e){if(!t||!o)return null;e=e||{};let i={},{iterable:n,objectInfo:s$2}=Ar(t);for(let r$3 of n){s$2.index++;let a=o(r$3,s$2),l=le(a);if(!a)throw new Error(`Icon is missing.`);if(!a.url)throw new Error(`Icon url is missing.`);!i[l]&&(!e[l]||a.url!==e[l].url)&&(i[l]=s(r({},a),{source:r$3,sourceIndex:s$2.index}))}return i}var ke=class{constructor(o,{onUpdate:e=Qt,onError:i=Qt}){this._loadOptions=null,this._texture=null,this._externalTexture=null,this._mapping={},this._samplerParameters=null,this._pendingCount=0,this._autoPacking=!1,this._xOffset=0,this._yOffset=0,this._rowHeight=0,this._buffer=gn,this._canvasWidth=pn,this._canvasHeight=0,this._canvas=null,this.device=o,this.onUpdate=e,this.onError=i}finalize(){this._texture?.delete()}getTexture(){return this._texture||this._externalTexture}getIconMapping(o){let e=this._autoPacking?le(o):o;return this._mapping[e]||hn}setProps({loadOptions:o,autoPacking:e,iconAtlas:i,iconMapping:n,textureParameters:s}){o&&(this._loadOptions=o),e!==void 0&&(this._autoPacking=e),n&&(this._mapping=n),i&&(this._texture?.delete(),this._texture=null,this._externalTexture=i),s&&(this._samplerParameters=s)}get isLoaded(){return this._pendingCount===0}packIcons(o,e){if(!this._autoPacking||typeof document>`u`)return;let i=Object.values(Pn(o,e,this._mapping)||{});if(i.length>0){let{mapping:n,xOffset:s,yOffset:r,rowHeight:a,canvasHeight:l}=yn({icons:i,buffer:this._buffer,canvasWidth:this._canvasWidth,mapping:this._mapping,rowHeight:this._rowHeight,xOffset:this._xOffset,yOffset:this._yOffset});this._rowHeight=a,this._mapping=n,this._xOffset=s,this._yOffset=r,this._canvasHeight=l,this._texture||(this._texture=this.device.createTexture({format:`rgba8unorm`,data:null,width:this._canvasWidth,height:this._canvasHeight,sampler:this._samplerParameters||ei,mipLevels:this.device.getMipLevelCount(this._canvasWidth,this._canvasHeight)})),this._texture.height!==this._canvasHeight&&(this._texture=mn(this._texture,this._canvasWidth,this._canvasHeight,this._samplerParameters||ei)),this.onUpdate(!0),this._canvas=this._canvas||document.createElement(`canvas`),this._loadIcons(i)}}_loadIcons(o){let e=this._canvas.getContext(`2d`,{willReadFrequently:!0});for(let i of o)this._pendingCount++,ge$1(i.url,this._loadOptions).then(n=>{let s=le(i),r=this._mapping[s],{x:a,y:l,width:c,height:f}=r,{image:d,width:u,height:p}=vn(e,n,c,f),g=a+(c-u)/2,h=l+(f-p)/2;this._texture?.copyExternalImage({image:d,x:g,y:h,width:u,height:p}),r.x=g,r.y=h,r.width=u,r.height=p,this._texture&&ii(this._texture),this.onUpdate(u!==c||p!==f)}).catch(n=>{this.onError({url:i.url,source:i.source,sourceIndex:i.sourceIndex,loadOptions:this._loadOptions,error:n})}).finally(()=>{this._pendingCount--})}};var oi=[0,0,0,255];var _n={iconAtlas:{type:`image`,value:null,async:!0},iconMapping:{type:`object`,value:{},async:!0},sizeScale:{type:`number`,value:1,min:0},billboard:!0,sizeUnits:`pixels`,sizeBasis:`height`,sizeMinPixels:{type:`number`,min:0,value:0},sizeMaxPixels:{type:`number`,min:0,value:Number.MAX_SAFE_INTEGER},alphaCutoff:{type:`number`,value:.05,min:0,max:1},getPosition:{type:`accessor`,value:t=>t.position},getIcon:{type:`accessor`,value:t=>t.icon},getColor:{type:`accessor`,value:oi},getSize:{type:`accessor`,value:1},getAngle:{type:`accessor`,value:0},getPixelOffset:{type:`accessor`,value:[0,0]},onIconError:{type:`function`,value:null,optional:!0},textureParameters:{type:`object`,ignore:!0,value:null}};var ce=(()=>{class t extends en$1{getShaders(){let e=!!this.props.data?.attributes?.rowIndexes;return super.getShaders({vs:Yt,fs:Xt,source:qt(e),defines:e?{USE_ROW_INDEXES:!0}:{},modules:[Wa,ma,Ka,Jt]})}initializeState(){this.state={iconManager:new ke(this.context.device,{onUpdate:this._onUpdate.bind(this),onError:this._onError.bind(this)})},this.getAttributeManager().addInstanced(r({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceSizes:{size:1,transition:!0,bufferGroup:`icon-instance-data`,accessor:`getSize`,defaultValue:1},instanceIconDefs:{size:7,bufferGroup:`icon-instance-data`,accessor:`getIcon`,transform:this.getInstanceIconDef,shaderAttributes:{instanceOffsets:{size:2,elementOffset:0},instanceIconFrames:{size:4,elementOffset:2},instanceColorModes:{size:1,elementOffset:6}}},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,bufferGroup:`icon-instance-data`,accessor:`getColor`,defaultValue:oi},instanceAngles:{size:1,transition:!0,bufferGroup:`icon-instance-data`,accessor:`getAngle`},instancePixelOffset:{size:2,transition:!0,bufferGroup:`icon-instance-data`,accessor:`getPixelOffset`}},this.props.data?.attributes?.rowIndexes?{rowIndexes:{size:1,type:`uint32`,noAlloc:!0}}:{}))}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e,r=this.getAttributeManager(),{iconAtlas:a,iconMapping:l,data:c,getIcon:f,textureParameters:d}=i,{iconManager:u}=this.state;if(typeof a==`string`)return;let p=a||this.internalState.isAsyncPropLoading(`iconAtlas`);u.setProps({loadOptions:i.loadOptions,autoPacking:!p,iconAtlas:a,iconMapping:p?l:null,textureParameters:d}),p?n.iconMapping!==i.iconMapping&&r.invalidate(`getIcon`):(s.dataChanged||s.updateTriggersChanged&&(s.updateTriggersChanged.all||s.updateTriggersChanged.getIcon))&&u.packIcons(c,f),s.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll())}get isLoaded(){return super.isLoaded&&this.state.iconManager.isLoaded}finalizeState(e){super.finalizeState(e),this.state.iconManager.finalize()}draw({uniforms:e}){this._drawModel(this.state.model)}_drawModel(e){let{sizeScale:i,sizeBasis:n,sizeMinPixels:s,sizeMaxPixels:r,sizeUnits:a,billboard:l,alphaCutoff:c}=this.props,{iconManager:f}=this.state,d=f.getTexture();if(d){let u={iconsTexture:d,iconsTextureDim:[d.width,d.height],sizeUnits:ee[a],sizeScale:i,sizeBasis:n===`height`?1:0,sizeMinPixels:s,sizeMaxPixels:r,billboard:l,alphaCutoff:c};e.shaderInputs.setProps({icon:u}),e.draw(this.context.renderPass)}}_getModel(e=this.props.id){return new De$1(this.context.device,s(r({},this.getShaders()),{id:e,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-strip`,attributes:{positions:{size:2,value:new Float32Array([-1,-1,1,-1,-1,1,1,1])}}}),isInstanced:!0}))}_onUpdate(e){e?(this.getAttributeManager()?.invalidate(`getIcon`),this.setNeedsUpdate()):this.setNeedsRedraw()}_onError(e){let i=this.getCurrentLayer()?.props.onIconError;i?i(e):A.error(e.error.message)()}getInstanceIconDef(e){let{x:i,y:n,width:s,height:r,mask:a,anchorX:l=s/2,anchorY:c=r/2}=this.state.iconManager.getIconMapping(e);return[s/2-l,r/2-c,i,n,s,r,a?1:0]}}return t.defaultProps=_n,t.layerName=`IconLayer`,t})();var ni=`layout(std140) uniform lineUniforms {
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  float useShortestPath;
+  highp int widthUnits;
+} line;
+`;var si={name:`line`,source:``,vs:ni,fs:ni,uniformTypes:{widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,useShortestPath:`f32`,widthUnits:`i32`}};var ri=`// ---------- Helper Structures & Functions ----------
+
+// Placeholder filter functions.
+fn deckgl_filter_size(offset: vec3<f32>, geometry: Geometry) -> vec3<f32> {
+  return offset;
+}
+fn deckgl_filter_gl_position(p: vec4<f32>, geometry: Geometry) -> vec4<f32> {
+  if (picking.isAttribute > 0.5) {
+    // For depth picking, write normalized depth into the picking payload.
+    // This mirrors the legacy DECKGL_FILTER_GL_POSITION hook on WebGL.
+  }
+  return p;
+}
+
+// Compute an extrusion offset given a line direction (in clipspace),
+// an offset direction (-1 or 1), and a width in pixels.
+// Assumes a uniform "project" with a viewportSize field is available.
+fn getExtrusionOffset(line_clipspace: vec2<f32>, offset_direction: f32, width: f32) -> vec2<f32> {
+  // project.viewportSize should be provided as a uniform (not shown here)
+  let dir_screenspace = normalize(line_clipspace * project.viewportSize);
+  // Rotate by 90\xB0: (x,y) becomes (-y,x)
+  let rotated = vec2<f32>(-dir_screenspace.y, dir_screenspace.x);
+  return rotated * offset_direction * width / 2.0;
+}
+
+// Splits the line between two points at a given x coordinate.
+// Interpolates the y and z components.
+fn splitLine(a: vec3<f32>, b: vec3<f32>, x: f32) -> vec3<f32> {
+  let t: f32 = (x - a.x) / (b.x - a.x);
+  return vec3<f32>(x, a.yz + t * (b.yz - a.yz));
+}
+
+// ---------- Uniforms & Global Structures ----------
+
+struct LineUniforms {
+  widthScale: f32,
+  widthMinPixels: f32,
+  widthMaxPixels: f32,
+  useShortestPath: f32,
+  widthUnits: i32,
+};
+
+@group(0) @binding(0)
+var<uniform> line: LineUniforms;
+
+
+
+// ---------- Vertex Output Structure ----------
+
+struct Varyings {
+  @builtin(position) gl_Position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) uv: vec2<f32>,
+  @location(2) pickingColor: vec3<f32>,
+};
+
+// ---------- Vertex Shader Entry Point ----------
+
+@vertex
+fn vertexMain(
+  @builtin(instance_index) instanceIndex: u32,
+  @location(0) positions: vec3<f32>,
+  @location(1) instanceSourcePositions: vec3<f32>,
+  @location(2) instanceTargetPositions: vec3<f32>,
+  @location(3) instanceSourcePositions64Low: vec3<f32>,
+  @location(4) instanceTargetPositions64Low: vec3<f32>,
+  @location(5) instanceColors: vec4<f32>,
+  @location(6) instanceWidths: f32
+) -> Varyings {
+  geometry.worldPosition = instanceSourcePositions;
+  geometry.worldPositionAlt = instanceTargetPositions;
+
+  var source_world: vec3<f32> = instanceSourcePositions;
+  var target_world: vec3<f32> = instanceTargetPositions;
+  var source_world_64low: vec3<f32> = instanceSourcePositions64Low;
+  var target_world_64low: vec3<f32> = instanceTargetPositions64Low;
+
+  // Apply shortest-path adjustments if needed.
+  if (line.useShortestPath > 0.5 || line.useShortestPath < -0.5) {
+    source_world.x = (source_world.x + 180.0 % 360.0) - 180.0;
+    target_world.x = (target_world.x + 180.0 % 360.0) - 180.0;
+    let deltaLng: f32 = target_world.x - source_world.x;
+
+    if (deltaLng * line.useShortestPath > 180.0) {
+      source_world.x = source_world.x + 360.0 * line.useShortestPath;
+      source_world = splitLine(source_world, target_world, 180.0 * line.useShortestPath);
+      source_world_64low = vec3<f32>(0.0, 0.0, 0.0);
+    } else if (deltaLng * line.useShortestPath < -180.0) {
+      target_world.x = target_world.x + 360.0 * line.useShortestPath;
+      target_world = splitLine(source_world, target_world, 180.0 * line.useShortestPath);
+      target_world_64low = vec3<f32>(0.0, 0.0, 0.0);
+    } else if (line.useShortestPath < 0.0) {
+      var abortOut: Varyings;
+      abortOut.gl_Position = vec4<f32>(0.0);
+      abortOut.vColor = vec4<f32>(0.0);
+      abortOut.uv = vec2<f32>(0.0);
+      return abortOut;
+    }
+  }
+
+  // Project Pos and target positions to clip space.
+  let sourceResult = project_position_to_clipspace_and_commonspace(source_world, source_world_64low, vec3<f32>(0.0));
+  let targetResult = project_position_to_clipspace_and_commonspace(target_world, target_world_64low, vec3<f32>(0.0));
+  let sourcePos: vec4<f32> = sourceResult.clipPosition;
+  let targetPos: vec4<f32> = targetResult.clipPosition;
+  let source_commonspace: vec4<f32> = sourceResult.commonPosition;
+  let target_commonspace: vec4<f32> = targetResult.commonPosition;
+
+  // Interpolate along the line segment.
+  let segmentIndex: f32 = positions.x;
+  let p: vec4<f32> = sourcePos + segmentIndex * (targetPos - sourcePos);
+  geometry.position = source_commonspace + segmentIndex * (target_commonspace - source_commonspace);
+#ifdef ANTIALIASING
+  var uv: vec2<f32> = positions.xy;
+#else
+  let uv: vec2<f32> = positions.xy;
+#endif
+  geometry.uv = uv;
+  geometry.pickingColor = picking_getPickingColorFromIndex(instanceIndex);
+
+  // Determine width in pixels.
+  let widthPixels: f32 = clamp(
+    project_unit_size_to_pixel(instanceWidths * line.widthScale, line.widthUnits),
+    line.widthMinPixels, line.widthMaxPixels
+  );
+
+  // Compute extrusion offset.
+  let extrusion: vec2<f32> = getExtrusionOffset(targetPos.xy - sourcePos.xy, positions.y, widthPixels);
+  let offset: vec3<f32> = vec3<f32>(extrusion, 0.0);
+
+  // Apply deck.gl filter functions.
+#ifdef ANTIALIASING
+  var filteredOffset = deckgl_filter_size(offset, geometry);
+  let halfWidthPixels = length(filteredOffset.xy);
+  if (halfWidthPixels > 0.0) {
+    // Keep the declared edge at abs(uv.y) == 1 while rasterizing the outer half of the centered
+    // one-device-pixel coverage ramp.
+    let coverageScale = 1.0 + 0.5 / project.devicePixelRatio / halfWidthPixels;
+    filteredOffset *= coverageScale;
+    uv.y *= coverageScale;
+  }
+  geometry.uv = uv;
+#else
+  let filteredOffset = deckgl_filter_size(offset, geometry);
+#endif
+  let filteredP = deckgl_filter_gl_position(p, geometry);
+
+  let clipOffset: vec2<f32> = project_pixel_size_to_clipspace(filteredOffset.xy);
+  let finalPosition: vec4<f32> = filteredP + vec4<f32>(clipOffset, 0.0, 0.0);
+
+  // Compute color.
+  var vColor: vec4<f32> = vec4<f32>(instanceColors.rgb, instanceColors.a * layer.opacity);
+  // vColor = deckgl_filter_color(vColor, geometry);
+
+  var output: Varyings;
+  output.gl_Position = finalPosition;
+  output.vColor = vColor;
+  output.uv = uv;
+  output.pickingColor = geometry.pickingColor;
+  return output;
+}
+
+@fragment
+fn fragmentMain(
+  @location(0) vColor: vec4<f32>,
+  @location(1) uv: vec2<f32>,
+  @location(2) pickingColor: vec3<f32>
+) -> @location(0) vec4<f32> {
+  // Create and initialize geometry with the provided uv.
+  var geometry: Geometry;
+  geometry.uv = uv;
+
+  // Start with the input color.
+  var fragColor: vec4<f32> = vColor;
+
+#ifdef ANTIALIASING
+  // Distance to the edge in device pixels, from the derivative of uv.y. Taken in uniform control
+  // flow, ahead of the picking discard below
+  let edgeCoord = abs(uv.y);
+  let edgePixels = (1.0 - edgeCoord) / max(fwidth(edgeCoord), 1e-6);
+
+  // Fragments outside the coverage ramp must not write depth or picking colors.
+  if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+    discard;
+  }
+
+  // Feather one device pixel across the width, before premultiplication below. The ends are left
+  // hard - they abut neighbors
+  fragColor.a *= smoothedge(0.0, edgePixels);
+#endif
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(pickingColor, 1.0);
+  }
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  // Apply premultiplied alpha as required by transparent canvas
+  fragColor = deckgl_premultiplied_alpha(fragColor);
+
+  return fragColor;
+}
+`;var ai=`#version 300 es
+#define SHADER_NAME line-layer-vertex-shader
+in vec3 positions;
+in vec3 instanceSourcePositions;
+in vec3 instanceTargetPositions;
+in vec3 instanceSourcePositions64Low;
+in vec3 instanceTargetPositions64Low;
+in vec4 instanceColors;
+in float instanceWidths;
+out vec4 vColor;
+out vec2 uv;
+vec2 getExtrusionOffset(vec2 line_clipspace, float offset_direction, float width) {
+vec2 dir_screenspace = normalize(line_clipspace * project.viewportSize);
+dir_screenspace = vec2(-dir_screenspace.y, dir_screenspace.x);
+return dir_screenspace * offset_direction * width / 2.0;
+}
+vec3 splitLine(vec3 a, vec3 b, float x) {
+float t = (x - a.x) / (b.x - a.x);
+return vec3(x, mix(a.yz, b.yz, t));
+}
+void main(void) {
+geometry.worldPosition = instanceSourcePositions;
+geometry.worldPositionAlt = instanceTargetPositions;
+vec3 source_world = instanceSourcePositions;
+vec3 target_world = instanceTargetPositions;
+vec3 source_world_64low = instanceSourcePositions64Low;
+vec3 target_world_64low = instanceTargetPositions64Low;
+if (line.useShortestPath > 0.5 || line.useShortestPath < -0.5) {
+source_world.x = mod(source_world.x + 180., 360.0) - 180.;
+target_world.x = mod(target_world.x + 180., 360.0) - 180.;
+float deltaLng = target_world.x - source_world.x;
+if (deltaLng * line.useShortestPath > 180.) {
+source_world.x += 360. * line.useShortestPath;
+source_world = splitLine(source_world, target_world, 180. * line.useShortestPath);
+source_world_64low = vec3(0.0);
+} else if (deltaLng * line.useShortestPath < -180.) {
+target_world.x += 360. * line.useShortestPath;
+target_world = splitLine(source_world, target_world, 180. * line.useShortestPath);
+target_world_64low = vec3(0.0);
+} else if (line.useShortestPath < 0.) {
+gl_Position = vec4(0.);
+return;
+}
+}
+vec4 source_commonspace;
+vec4 target_commonspace;
+vec4 source = project_position_to_clipspace(source_world, source_world_64low, vec3(0.), source_commonspace);
+vec4 target = project_position_to_clipspace(target_world, target_world_64low, vec3(0.), target_commonspace);
+float segmentIndex = positions.x;
+vec4 p = mix(source, target, segmentIndex);
+geometry.position = mix(source_commonspace, target_commonspace, segmentIndex);
+uv = positions.xy;
+geometry.uv = uv;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+float widthPixels = clamp(
+project_size_to_pixel(instanceWidths * line.widthScale, line.widthUnits),
+line.widthMinPixels, line.widthMaxPixels
+);
+vec3 offset = vec3(
+getExtrusionOffset(target.xy - source.xy, positions.y, widthPixels),
+0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+#ifdef ANTIALIASING
+float halfWidthPixels = length(offset.xy);
+if (halfWidthPixels > 0.0) {
+float coverageScale = 1.0 + 0.5 / project.devicePixelRatio / halfWidthPixels;
+offset.xy *= coverageScale;
+uv.y *= coverageScale;
+}
+geometry.uv = uv;
+#endif
+DECKGL_FILTER_GL_POSITION(p, geometry);
+gl_Position = p + vec4(project_pixel_size_to_clipspace(offset.xy), 0.0, 0.0);
+vColor = vec4(instanceColors.rgb, instanceColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var li=`#version 300 es
+#define SHADER_NAME line-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+in vec2 uv;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = uv;
+fragColor = vColor;
+#ifdef ANTIALIASING
+float edgeCoord = abs(uv.y);
+float edgePixels = (1.0 - edgeCoord) / max(fwidth(edgeCoord), 1e-6);
+if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+discard;
+}
+fragColor.a *= smoothedge(0.0, edgePixels);
+#endif
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var Sn={getSourcePosition:{type:`accessor`,value:t=>t.sourcePosition},getTargetPosition:{type:`accessor`,value:t=>t.targetPosition},getColor:{type:`accessor`,value:[0,0,0,255]},getWidth:{type:`accessor`,value:1},widthUnits:`pixels`,widthScale:{type:`number`,value:1,min:0},widthMinPixels:{type:`number`,value:0,min:0},widthMaxPixels:{type:`number`,value:Number.MAX_SAFE_INTEGER,min:0},antialiasing:!1};var wn=(()=>{class t extends en$1{getBounds(){return this.getAttributeManager()?.getBounds([`instanceSourcePositions`,`instanceTargetPositions`])}getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:ai,fs:li,source:ri,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,si]})}get wrapLongitude(){return!1}initializeState(){this.getAttributeManager().addInstanced({instanceSourcePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getSourcePosition`},instanceTargetPositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getTargetPosition`},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getColor`,defaultValue:[0,0,0,255]},instanceWidths:{size:1,transition:!0,accessor:`getWidth`,defaultValue:1}})}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e;(s.extensionsChanged||i.antialiasing!==n.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{widthUnits:i,widthScale:n,widthMinPixels:s$3,widthMaxPixels:r$4,wrapLongitude:a}=this.props,l=this.state.model,c={widthUnits:ee[i],widthScale:n,widthMinPixels:s$3,widthMaxPixels:r$4,useShortestPath:a?1:0};l.shaderInputs.setProps({line:c}),l.draw(this.context.renderPass),a&&(l.shaderInputs.setProps({line:s(r({},c),{useShortestPath:-1})}),l.draw(this.context.renderPass))}_getModel(){return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-strip`,attributes:{positions:{size:3,value:new Float32Array([0,-1,0,0,1,0,1,-1,0,1,1,0])}}}),isInstanced:!0}))}}return t.layerName=`LineLayer`,t.defaultProps=Sn,t})();var ci=`layout(std140) uniform pointCloudUniforms {
+  float radiusPixels;
+  highp int sizeUnits;
+} pointCloud;
+`;var fi={name:`pointCloud`,source:``,vs:ci,fs:ci,uniformTypes:{radiusPixels:`f32`,sizeUnits:`i32`}};var di=`#version 300 es
+#define SHADER_NAME point-cloud-layer-vertex-shader
+in vec3 positions;
+in vec3 instanceNormals;
+in vec4 instanceColors;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+out vec4 vColor;
+out vec2 unitPosition;
+void main(void) {
+geometry.worldPosition = instancePositions;
+geometry.normal = project_normal(instanceNormals);
+unitPosition = positions.xy;
+geometry.uv = unitPosition;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+vec3 offset = vec3(positions.xy * project_size_to_pixel(pointCloud.radiusPixels, pointCloud.sizeUnits), 0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+#ifdef ANTIALIASING
+float triangleRadiusPixels = length(offset.xy);
+if (triangleRadiusPixels > 0.0) {
+float coverageScale = 1.0 + 1.0 / project.devicePixelRatio / triangleRadiusPixels;
+offset.xy *= coverageScale;
+unitPosition *= coverageScale;
+geometry.uv = unitPosition;
+}
+#endif
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+vec3 lightColor = lighting_getLightColor(instanceColors.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+vColor = vec4(lightColor, instanceColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var ui=`#version 300 es
+#define SHADER_NAME point-cloud-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+in vec2 unitPosition;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = unitPosition.xy;
+float distToCenter = length(unitPosition);
+#ifdef ANTIALIASING
+float edgePixels = (1.0 - distToCenter) / max(fwidth(distToCenter), 1e-6);
+if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+#else
+if (distToCenter > 1.0) {
+#endif
+discard;
+}
+fragColor = vColor;
+#ifdef ANTIALIASING
+fragColor.a *= smoothedge(0.0, edgePixels);
+#endif
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var pi=`struct PointCloudUniforms {
+  radiusPixels: f32,
+  sizeUnits: i32,
+};
+
+@group(0) @binding(0)
+var<uniform> pointCloudUniforms: PointCloudUniforms;
+
+struct Attributes {
+  @builtin(instance_index) instanceIndex : u32,
+  @builtin(vertex_index) vertexIndex : u32,
+  @location(0) positions: vec3<f32>,
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceNormals: vec3<f32>,
+  @location(4) instanceColors: vec4<f32>
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) unitPosition: vec2<f32>,
+  @location(2) pickingColor: vec3<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  geometry.worldPosition = attributes.instancePositions;
+
+  let centerResult = project_position_to_clipspace_and_commonspace(
+    attributes.instancePositions,
+    attributes.instancePositions64Low,
+    vec3<f32>(0.0)
+  );
+  geometry.position = centerResult.commonPosition;
+  geometry.normal = project_normal(attributes.instanceNormals);
+
+  // Position on the enclosing triangle. Its edges are tangent to the unit circle.
+  varyings.unitPosition = attributes.positions.xy;
+  geometry.uv = varyings.unitPosition;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.instanceIndex);
+
+  // Find the center of the point and add the current vertex
+#ifdef ANTIALIASING
+  var offset = vec3<f32>(
+#else
+  let offset = vec3<f32>(
+#endif
+    attributes.positions.xy *
+      project_unit_size_to_pixel(pointCloudUniforms.radiusPixels, pointCloudUniforms.sizeUnits),
+    0.0
+  );
+  // DECKGL_FILTER_SIZE(offset, geometry);
+#ifdef ANTIALIASING
+  let triangleRadiusPixels = length(offset.xy);
+  if (triangleRadiusPixels > 0.0) {
+    // The triangle's inradius is half its vertex radius. Scaling its vertex radius by one device
+    // pixel therefore adds half a device pixel around all three tangent points.
+    let coverageScale = 1.0 + 1.0 / project.devicePixelRatio / triangleRadiusPixels;
+    offset *= coverageScale;
+    varyings.unitPosition *= coverageScale;
+    geometry.uv = varyings.unitPosition;
+  }
+#endif
+
+  varyings.position = centerResult.clipPosition;
+  // DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+  let clipPixels = project_pixel_size_to_clipspace(offset.xy);
+  varyings.position.x += clipPixels.x;
+  varyings.position.y += clipPixels.y;
+
+  // Apply lighting
+  let lightColor = lighting_getLightColor2(attributes.instanceColors.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+
+  // Apply opacity to instance color, or return instance picking color
+  varyings.vColor = vec4(lightColor, attributes.instanceColors.a * layer.opacity);
+  // DECKGL_FILTER_COLOR(vColor, geometry);
+  varyings.pickingColor = geometry.pickingColor;
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  // var geometry: Geometry;
+  // geometry.uv = unitPosition.xy;
+
+  let distToCenter = length(varyings.unitPosition);
+#ifdef ANTIALIASING
+  let edgePixels = (1.0 - distToCenter) / max(fwidth(distToCenter), 1e-6);
+  if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+#else
+  if (distToCenter > 1.0) {
+#endif
+    discard;
+  }
+
+  var fragColor: vec4<f32>;
+
+  fragColor = varyings.vColor;
+
+#ifdef ANTIALIASING
+  fragColor.a *= smoothedge(0.0, edgePixels);
+#endif
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(varyings.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(varyings.pickingColor, 1.0);
+  }
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(varyings.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  // Apply premultiplied alpha as required by transparent canvas
+  fragColor = deckgl_premultiplied_alpha(fragColor);
+
+  return fragColor;
+}
+`;var gi=[0,0,0,255];var hi=[0,0,1];var In={sizeUnits:`pixels`,pointSize:{type:`number`,min:0,value:10},antialiasing:!1,getPosition:{type:`accessor`,value:t=>t.position},getNormal:{type:`accessor`,value:hi},getColor:{type:`accessor`,value:gi},material:!0,radiusPixels:{deprecatedFor:`pointSize`}};function An(t){let{header:o,attributes:e}=t;if(!(!o||!e)&&(t.length=o.vertexCount,e.POSITION&&(e.instancePositions=e.POSITION),e.NORMAL&&(e.instanceNormals=e.NORMAL),e.COLOR_0)){let{size:i,value:n}=e.COLOR_0;e.instanceColors={size:i,type:`unorm8`,value:n}}}var Tn=(()=>{class t extends en$1{getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:di,fs:ui,source:pi,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Zo$1,Ka,fi]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceNormals:{size:3,transition:!0,accessor:`getNormal`,defaultValue:hi},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getColor`,defaultValue:gi}})}updateState(e){let{changeFlags:i,props:n,oldProps:s}=e;super.updateState(e),(i.extensionsChanged||n.antialiasing!==s.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll()),i.dataChanged&&An(n.data)}draw({uniforms:e}){let{pointSize:i,sizeUnits:n}=this.props,s=this.state.model,r={sizeUnits:ee[n],radiusPixels:i};s.shaderInputs.setProps({pointCloud:r}),s.draw(this.context.renderPass)}_getModel(){let e=[];for(let i=0;i<3;i++){let n=i/3*Math.PI*2;e.push(Math.cos(n)*2,Math.sin(n)*2,0)}return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-list`,attributes:{positions:new Float32Array(e)}}),isInstanced:!0}))}}return t.layerName=`PointCloudLayer`,t.defaultProps=In,t})();var xi=`layout(std140) uniform scatterplotUniforms {
+  float radiusScale;
+  float radiusMinPixels;
+  float radiusMaxPixels;
+  float lineWidthScale;
+  float lineWidthMinPixels;
+  float lineWidthMaxPixels;
+  float stroked;
+  float filled;
+  bool antialiasing;
+  bool billboard;
+  highp int radiusUnits;
+  highp int lineWidthUnits;
+} scatterplot;
+`;var vi={name:`scatterplot`,vs:xi,fs:xi,source:``,uniformTypes:{radiusScale:`f32`,radiusMinPixels:`f32`,radiusMaxPixels:`f32`,lineWidthScale:`f32`,lineWidthMinPixels:`f32`,lineWidthMaxPixels:`f32`,stroked:`f32`,filled:`f32`,antialiasing:`f32`,billboard:`f32`,radiusUnits:`i32`,lineWidthUnits:`i32`}};var mi=`#version 300 es
+#define SHADER_NAME scatterplot-layer-vertex-shader
+in vec3 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in float instanceRadius;
+in float instanceLineWidths;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+#ifdef USE_ROW_INDEXES
+in float rowIndexes;
+#endif
+in vec2 instancePixelOffset;
+out vec4 vFillColor;
+out vec4 vLineColor;
+out vec2 unitPosition;
+out float innerUnitRadius;
+out float outerRadiusPixels;
+void main(void) {
+geometry.worldPosition = instancePositions;
+outerRadiusPixels = clamp(
+project_size_to_pixel(scatterplot.radiusScale * instanceRadius, scatterplot.radiusUnits),
+scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels
+);
+float lineWidthPixels = clamp(
+project_size_to_pixel(scatterplot.lineWidthScale * instanceLineWidths, scatterplot.lineWidthUnits),
+scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels
+);
+outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;
+float edgePadding = scatterplot.antialiasing ? (outerRadiusPixels + SMOOTH_EDGE_RADIUS) / outerRadiusPixels : 1.0;
+unitPosition = edgePadding * positions.xy;
+geometry.uv = unitPosition;
+#ifdef USE_ROW_INDEXES
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
+#else
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+#endif
+innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / outerRadiusPixels;
+if (scatterplot.billboard) {
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vec3 offset = edgePadding * positions * outerRadiusPixels;
+offset.xy += instancePixelOffset;
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+} else {
+vec3 offset = edgePadding * positions * project_pixel_size(outerRadiusPixels);
+offset.xy += project_pixel_size(instancePixelOffset);
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset, geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vFillColor, geometry);
+vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vLineColor, geometry);
+}
+`;var yi=`#version 300 es
+#define SHADER_NAME scatterplot-layer-fragment-shader
+precision highp float;
+in vec4 vFillColor;
+in vec4 vLineColor;
+in vec2 unitPosition;
+in float innerUnitRadius;
+in float outerRadiusPixels;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = unitPosition;
+float distToCenter = length(unitPosition) * outerRadiusPixels;
+float inCircle = scatterplot.antialiasing ?
+smoothedge(distToCenter, outerRadiusPixels) :
+step(distToCenter, outerRadiusPixels);
+if (inCircle == 0.0) {
+discard;
+}
+if (scatterplot.stroked > 0.5) {
+float isLine = scatterplot.antialiasing ?
+smoothedge(innerUnitRadius * outerRadiusPixels, distToCenter) :
+step(innerUnitRadius * outerRadiusPixels, distToCenter);
+if (scatterplot.filled > 0.5) {
+fragColor = mix(vFillColor, vLineColor, isLine);
+} else {
+if (isLine == 0.0) {
+discard;
+}
+fragColor = vec4(vLineColor.rgb, vLineColor.a * isLine);
+}
+} else if (scatterplot.filled < 0.5) {
+discard;
+} else {
+fragColor = vFillColor;
+}
+fragColor.a *= inCircle;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var On=`// Main shaders
+
+struct ScatterplotUniforms {
+  radiusScale: f32,
+  radiusMinPixels: f32,
+  radiusMaxPixels: f32,
+  lineWidthScale: f32,
+  lineWidthMinPixels: f32,
+  lineWidthMaxPixels: f32,
+  stroked: f32,
+  filled: i32,
+  antialiasing: i32,
+  billboard: i32,
+  radiusUnits: i32,
+  lineWidthUnits: i32,
+};
+
+@group(0) @binding(0) var<uniform> scatterplot: ScatterplotUniforms;
+
+struct Attributes {
+  @builtin(instance_index) instanceIndex : u32,
+  @builtin(vertex_index) vertexIndex : u32,
+  @location(0) positions: vec3<f32>,
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceRadius: f32,
+  @location(4) instanceLineWidths: f32,
+  @location(5) instanceFillColors: vec4<f32>,
+  @location(6) instanceLineColors: vec4<f32>,
+  @location(7) instancePixelOffset: vec2<f32>,
+  PICKING_COLOR_ATTRIBUTE
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vFillColor: vec4<f32>,
+  @location(1) vLineColor: vec4<f32>,
+  @location(2) unitPosition: vec2<f32>,
+  @location(3) innerUnitRadius: f32,
+  @location(4) outerRadiusPixels: f32,
+  @location(5) pickingColor: vec3<f32>,
+  @location(6) clipCoordinates: vec2<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  // Draw an inline geometry constant array clip space triangle to verify that rendering works.
+  // var positions = array<vec2<f32>, 3>(vec2(0.0, 0.5), vec2(-0.5, -0.5), vec2(0.5, -0.5));
+  // if (attributes.instanceIndex == 0) {
+  //   varyings.position = vec4<f32>(positions[attributes.vertexIndex], 0.0, 1.0);
+  //   return varyings;
+  // }
+
+  geometry.worldPosition = attributes.instancePositions;
+
+  // Multiply out radius and clamp to limits
+  varyings.outerRadiusPixels = clamp(
+    project_unit_size_to_pixel(scatterplot.radiusScale * attributes.instanceRadius, scatterplot.radiusUnits),
+    scatterplot.radiusMinPixels, scatterplot.radiusMaxPixels
+  );
+
+  // Multiply out line width and clamp to limits
+  let lineWidthPixels = clamp(
+    project_unit_size_to_pixel(scatterplot.lineWidthScale * attributes.instanceLineWidths, scatterplot.lineWidthUnits),
+    scatterplot.lineWidthMinPixels, scatterplot.lineWidthMaxPixels
+  );
+
+  // outer radius needs to offset by half stroke width
+  varyings.outerRadiusPixels += scatterplot.stroked * lineWidthPixels / 2.0;
+  // Expand geometry to accommodate edge smoothing
+  // WGSL selects the second value when the condition is true, so keep the antialiased path second.
+  let edgePadding = select(
+    1.0,
+    (varyings.outerRadiusPixels + SMOOTH_EDGE_RADIUS) / varyings.outerRadiusPixels,
+    scatterplot.antialiasing != 0
+  );
+
+  // position on the containing square in [-1, 1] space
+  varyings.unitPosition = edgePadding * attributes.positions.xy;
+  geometry.uv = varyings.unitPosition;
+  geometry.pickingColor = PICKING_COLOR_VALUE;
+
+  varyings.innerUnitRadius = 1.0 - scatterplot.stroked * lineWidthPixels / varyings.outerRadiusPixels;
+
+  if (scatterplot.billboard != 0) {
+    let projectedPosition = project_position_to_clipspace_and_commonspace(
+      attributes.instancePositions,
+      attributes.instancePositions64Low,
+      vec3<f32>(0.0)
+    );
+    geometry.position = projectedPosition.commonPosition;
+    varyings.position = projectedPosition.clipPosition;
+    // DECKGL_FILTER_GL_POSITION(varyings.position, geometry);
+    var offset = edgePadding * attributes.positions * varyings.outerRadiusPixels;
+    offset = vec3<f32>(offset.xy + attributes.instancePixelOffset, offset.z);
+    // DECKGL_FILTER_SIZE(offset, geometry);
+    let clipPixels = project_pixel_size_to_clipspace(offset.xy);
+    varyings.position = vec4<f32>(varyings.position.x + clipPixels.x, varyings.position.y + clipPixels.y, varyings.position.z, varyings.position.w);
+    geometry.position = vec4<f32>(
+      geometry.position.xy + project_pixel_size_vec2(offset.xy),
+      geometry.position.zw
+    );
+  } else {
+    var offset = edgePadding * attributes.positions * project_pixel_size_float(varyings.outerRadiusPixels);
+    offset = vec3<f32>(offset.xy + project_pixel_size_vec2(attributes.instancePixelOffset), offset.z);
+    // DECKGL_FILTER_SIZE(offset, geometry);
+    let projectedPosition = project_position_to_clipspace_and_commonspace(
+      attributes.instancePositions,
+      attributes.instancePositions64Low,
+      offset
+    );
+    geometry.position = projectedPosition.commonPosition;
+    varyings.position = projectedPosition.clipPosition;
+    // DECKGL_FILTER_GL_POSITION(varyings.position, geometry);
+  }
+
+  varyings.clipCoordinates = geometry.position.xy;
+  clip_filterPosition(&varyings.position, geometry.worldPosition.xy);
+
+  // Apply opacity to instance color, or return instance picking color
+  varyings.vFillColor = vec4<f32>(attributes.instanceFillColors.rgb, attributes.instanceFillColors.a * layer.opacity);
+  // DECKGL_FILTER_COLOR(varyings.vFillColor, geometry);
+  varyings.vLineColor = vec4<f32>(attributes.instanceLineColors.rgb, attributes.instanceLineColors.a * layer.opacity);
+  // DECKGL_FILTER_COLOR(varyings.vLineColor, geometry);
+  varyings.pickingColor = geometry.pickingColor;
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  // var geometry: Geometry;
+  // geometry.uv = unitPosition;
+
+  let distToCenter = length(varyings.unitPosition) * varyings.outerRadiusPixels;
+  let inCircle = select(
+    step(distToCenter, varyings.outerRadiusPixels),
+    smoothedge(distToCenter, varyings.outerRadiusPixels),
+    scatterplot.antialiasing != 0
+  );
+
+  if (inCircle == 0.0) {
+    discard;
+  }
+
+  var fragColor: vec4<f32>;
+
+  if (scatterplot.stroked != 0) {
+    let isLine = select(
+      step(varyings.innerUnitRadius * varyings.outerRadiusPixels, distToCenter),
+      smoothedge(varyings.innerUnitRadius * varyings.outerRadiusPixels, distToCenter),
+      scatterplot.antialiasing != 0
+    );
+
+    if (scatterplot.filled != 0) {
+      fragColor = mix(varyings.vFillColor, varyings.vLineColor, isLine);
+    } else {
+      if (isLine == 0.0) {
+        discard;
+      }
+      fragColor = vec4<f32>(varyings.vLineColor.rgb, varyings.vLineColor.a * isLine);
+    }
+  } else if (scatterplot.filled == 0) {
+    discard;
+  } else {
+    fragColor = varyings.vFillColor;
+  }
+
+  fragColor.a *= inCircle;
+
+  clip_filterColor(varyings.clipCoordinates);
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(varyings.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(varyings.pickingColor, 1.0);
+  }
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(varyings.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  // Apply premultiplied alpha as required by transparent canvas
+  fragColor = deckgl_premultiplied_alpha(fragColor);
+
+  return fragColor;
+  // return vec4<f32>(0, 0, 1, 1);
+}
+`;function Pi(t){return On.replace(`PICKING_COLOR_ATTRIBUTE`,t?`@location(8) rowIndexes: u32,`:``).replace(`PICKING_COLOR_VALUE`,t?`picking_getPickingColorFromIndex(attributes.rowIndexes)`:`picking_getPickingColorFromIndex(attributes.instanceIndex)`)}var ie={name:`clip`,source:`struct ClipUniforms {
+  enabled: i32,
+  mode: i32,
+  bounds: vec4<f32>,
+};
+
+@group(2) @binding(auto) var<uniform> clipUniforms: ClipUniforms;
+
+fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
+  return coordinates.x >= clipUniforms.bounds.x &&
+    coordinates.y >= clipUniforms.bounds.y &&
+    coordinates.x < clipUniforms.bounds.z &&
+    coordinates.y < clipUniforms.bounds.w;
+}
+
+fn clip_filterPosition(position: ptr<function, vec4<f32>>, instanceCoordinates: vec2<f32>) {
+  if (
+    clipUniforms.enabled != 0 &&
+    clipUniforms.mode == 1 &&
+    !clip_isInBounds(instanceCoordinates)
+  ) {
+    *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+  }
+}
+
+fn clip_filterColor(geometryCoordinates: vec2<f32>) {
+  if (
+    clipUniforms.enabled != 0 &&
+    clipUniforms.mode == 0 &&
+    !clip_isInBounds(geometryCoordinates)
+  ) {
+    discard;
+  }
+}
+`,props:{},uniforms:{},bindingLayout:[{name:`clip`,group:2}],uniformTypes:{enabled:`i32`,mode:`i32`,bounds:`vec4<f32>`},defaultUniforms:{enabled:0,mode:0,bounds:[0,0,1,1]},getUniforms(t={}){let o={};return t.enabled!==void 0&&(o.enabled=t.enabled?1:0),t.mode!==void 0&&(o.mode=t.mode===`instance`?1:0),t.bounds!==void 0&&(o.bounds=t.bounds),o}};var _i=[0,0,0,255];var zn={radiusUnits:`meters`,radiusScale:{type:`number`,min:0,value:1},radiusMinPixels:{type:`number`,min:0,value:0},radiusMaxPixels:{type:`number`,min:0,value:Number.MAX_SAFE_INTEGER},lineWidthUnits:`meters`,lineWidthScale:{type:`number`,min:0,value:1},lineWidthMinPixels:{type:`number`,min:0,value:0},lineWidthMaxPixels:{type:`number`,min:0,value:Number.MAX_SAFE_INTEGER},stroked:!1,filled:!0,billboard:!1,antialiasing:!0,getPosition:{type:`accessor`,value:t=>t.position},getRadius:{type:`accessor`,value:1},getFillColor:{type:`accessor`,value:_i},getLineColor:{type:`accessor`,value:_i},getLineWidth:{type:`accessor`,value:1},getPixelOffset:{type:`accessor`,value:[0,0]},strokeWidth:{deprecatedFor:`getLineWidth`},outline:{deprecatedFor:`stroked`},getColor:{deprecatedFor:[`getFillColor`,`getLineColor`]}};var ut=(()=>{class t extends en$1{getShaders(){let e=!!this.props.data?.attributes?.rowIndexes;return super.getShaders({vs:mi,fs:yi,source:Pi(e),defines:e?{USE_ROW_INDEXES:!0}:{},modules:[Wa,ma,Ka,vi,...this.context.device.type===`webgpu`?[ie]:[]]})}initializeState(){let e=this.props.data?.attributes?.rowIndexes?{rowIndexes:{size:1,type:`uint32`,noAlloc:!0}}:{};this.getAttributeManager().addInstanced(r({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceRadius:{size:1,transition:!0,accessor:`getRadius`,defaultValue:1,bufferGroup:`scatterplot-instance-data`},instanceFillColors:{size:this.props.colorFormat.length,transition:!0,type:`unorm8`,accessor:`getFillColor`,defaultValue:[0,0,0,255],bufferGroup:`scatterplot-instance-data`},instanceLineColors:{size:this.props.colorFormat.length,transition:!0,type:`unorm8`,accessor:`getLineColor`,defaultValue:[0,0,0,255],bufferGroup:`scatterplot-instance-data`},instanceLineWidths:{size:1,transition:!0,accessor:`getLineWidth`,defaultValue:1,bufferGroup:`scatterplot-instance-data`},instancePixelOffset:{size:2,transition:!0,accessor:`getPixelOffset`,bufferGroup:`scatterplot-instance-data`}},e))}updateState(e){super.updateState(e),e.changeFlags.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{radiusUnits:i,radiusScale:n,radiusMinPixels:s,radiusMaxPixels:r,stroked:a,filled:l,billboard:c,antialiasing:f,lineWidthUnits:d,lineWidthScale:u,lineWidthMinPixels:p,lineWidthMaxPixels:g}=this.props,h={stroked:a,filled:l,billboard:c,antialiasing:f,radiusUnits:ee[i],radiusScale:n,radiusMinPixels:s,radiusMaxPixels:r,lineWidthUnits:ee[d],lineWidthScale:u,lineWidthMinPixels:p,lineWidthMaxPixels:g},v=this.state.model;v.shaderInputs.setProps({scatterplot:h}),v.draw(this.context.renderPass)}_getModel(){return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-strip`,attributes:{positions:{size:3,value:new Float32Array([-1,-1,0,1,-1,0,-1,1,0,1,1,0])}}}),isInstanced:!0}))}}return t.defaultProps=zn,t.layerName=`ScatterplotLayer`,t})();var oe={CLOCKWISE:1,COUNTER_CLOCKWISE:-1};function J(t,o,e={}){return Ci(t,e)!==o?(Dn(t,e),!0):!1}function Ci(t,o={}){return Math.sign(de(t,o))}var fe={x:0,y:1,z:2};function de(t,o={}){let{start:e=0,end:i=t.length,plane:n=`xy`}=o,s=o.size||2,r=0,a=fe[n[0]],l=fe[n[1]];for(let c=e,f=i-s;c<i;c+=s)r+=(t[c+a]-t[f+a])*(t[c+l]+t[f+l]),f=c;return r/2}function Dn(t,o){let{start:e=0,end:i=t.length,size:n=2}=o,s=(i-e)/n,r=Math.floor(s/2);for(let a=0;a<r;++a){let l=e+a*n,c=e+(s-1-a)*n;for(let f=0;f<n;++f){let d=t[l+f];t[l+f]=t[c+f],t[c+f]=d}}}function Nn(t,o,e=2,i,n=`xy`){let s=o&&o.length,r=s?o[0]*e:t.length,a=Si(t,0,r,e,!0,i&&i[0],n),l=[];if(!a||a.next===a.prev)return l;let c,f,d,u,p,g,h;if(s&&(a=Un(t,o,a,e,i,n)),t.length>80*e){u=f=t[0],p=d=t[1];for(let v=e;v<r;v+=e)g=t[v],h=t[v+1],g<u&&(u=g),h<p&&(p=h),g>f&&(f=g),h>d&&(d=h);c=Math.max(f-u,d-p),c=c!==0?32767/c:0}return ue(a,l,e,u,p,c,0),l}function Si(t,o,e,i,n,s,r){let a,l;s===void 0&&(s=de(t,{start:o,end:e,size:i,plane:r}));let c=fe[r[0]],f=fe[r[1]];if(n===s<0)for(a=o;a<e;a+=i)l=Li(a,t[a+c],t[a+f],l);else for(a=e-i;a>=o;a-=i)l=Li(a,t[a+c],t[a+f],l);return l&&Ne(l,l.next)&&(ge(l),l=l.next),l}function Y(t,o){if(!t)return t;o||(o=t);let e=t,i;do if(i=!1,!e.steiner&&(Ne(e,e.next)||b(e.prev,e,e.next)===0)){if(ge(e),e=o=e.prev,e===e.next)break;i=!0}else e=e.next;while(i||e!==o);return o}function ue(t,o,e,i,n,s,r){if(!t)return;!r&&s&&$n(t,i,n,s);let a=t,l,c;for(;t.prev!==t.next;){if(l=t.prev,c=t.next,s?Bn(t,i,n,s):Gn(t)){o.push(l.i/e|0),o.push(t.i/e|0),o.push(c.i/e|0),ge(t),t=c.next,a=c.next;continue}if(t=c,t===a){r?r===1?(t=jn(Y(t),o,e),ue(t,o,e,i,n,s,2)):r===2&&Wn(t,o,e,i,n,s):ue(Y(t),o,e,i,n,s,1);break}}}function Gn(t){let o=t.prev,e=t,i=t.next;if(b(o,e,i)>=0)return!1;let n=o.x,s=e.x,r=i.x,a=o.y,l=e.y,c=i.y,f=n<s?n<r?n:r:s<r?s:r,d=a<l?a<c?a:c:l<c?l:c,u=n>s?n>r?n:r:s>r?s:r,p=a>l?a>c?a:c:l>c?l:c,g=i.next;for(;g!==o;){if(g.x>=f&&g.x<=u&&g.y>=d&&g.y<=p&&ne(n,a,s,l,r,c,g.x,g.y)&&b(g.prev,g,g.next)>=0)return!1;g=g.next}return!0}function Bn(t,o,e,i){let n=t.prev,s=t,r=t.next;if(b(n,s,r)>=0)return!1;let a=n.x,l=s.x,c=r.x,f=n.y,d=s.y,u=r.y,p=a<l?a<c?a:c:l<c?l:c,g=f<d?f<u?f:u:d<u?d:u,h=a>l?a>c?a:c:l>c?l:c,v=f>d?f>u?f:u:d>u?d:u,P=pt(p,g,o,e,i),C=pt(h,v,o,e,i),m=t.prevZ,x=t.nextZ;for(;m&&m.z>=P&&x&&x.z<=C;){if(m.x>=p&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&ne(a,f,l,d,c,u,m.x,m.y)&&b(m.prev,m,m.next)>=0||(m=m.prevZ,x.x>=p&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&ne(a,f,l,d,c,u,x.x,x.y)&&b(x.prev,x,x.next)>=0))return!1;x=x.nextZ}for(;m&&m.z>=P;){if(m.x>=p&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&ne(a,f,l,d,c,u,m.x,m.y)&&b(m.prev,m,m.next)>=0)return!1;m=m.prevZ}for(;x&&x.z<=C;){if(x.x>=p&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&ne(a,f,l,d,c,u,x.x,x.y)&&b(x.prev,x,x.next)>=0)return!1;x=x.nextZ}return!0}function jn(t,o,e){let i=t;do{let n=i.prev,s=i.next.next;!Ne(n,s)&&bi(n,i,i.next,s)&&pe(n,s)&&pe(s,n)&&(o.push(n.i/e|0),o.push(i.i/e|0),o.push(s.i/e|0),ge(i),ge(i.next),i=t=s),i=i.next}while(i!==t);return Y(i)}function Wn(t,o,e,i,n,s){let r=t;do{let a=r.next.next;for(;a!==r.prev;){if(r.i!==a.i&&Xn(r,a)){let l=wi(r,a);r=Y(r,r.next),l=Y(l,l.next),ue(r,o,e,i,n,s,0),ue(l,o,e,i,n,s,0);return}a=a.next}r=r.next}while(r!==t)}function Un(t,o,e,i,n,s){let r=[],a,l,c,f,d;for(a=0,l=o.length;a<l;a++)c=o[a]*i,f=a<l-1?o[a+1]*i:t.length,d=Si(t,c,f,i,!1,n&&n[a+1],s),d===d.next&&(d.steiner=!0),r.push(Yn(d));for(r.sort(Vn),a=0;a<r.length;a++)e=Hn(r[a],e);return e}function Vn(t,o){return t.x-o.x}function Hn(t,o){let e=Zn(t,o);if(!e)return o;let i=wi(e,t);return Y(i,i.next),Y(e,e.next)}function Zn(t,o){let e=o,i=t.x,n=t.y,s=-Infinity,r;do{if(n<=e.y&&n>=e.next.y&&e.next.y!==e.y){let u=e.x+(n-e.y)*(e.next.x-e.x)/(e.next.y-e.y);if(u<=i&&u>s&&(s=u,r=e.x<e.next.x?e:e.next,u===i))return r}e=e.next}while(e!==o);if(!r)return null;let a=r,l=r.x,c=r.y,f=Infinity,d;e=r;do i>=e.x&&e.x>=l&&i!==e.x&&ne(n<c?i:s,n,l,c,n<c?s:i,n,e.x,e.y)&&(d=Math.abs(n-e.y)/(i-e.x),pe(e,t)&&(d<f||d===f&&(e.x>r.x||e.x===r.x&&Kn(r,e)))&&(r=e,f=d)),e=e.next;while(e!==a);return r}function Kn(t,o){return b(t.prev,t,o.prev)<0&&b(o.next,t,t.next)<0}function $n(t,o,e,i){let n=t;do n.z===0&&(n.z=pt(n.x,n.y,o,e,i)),n.prevZ=n.prev,n.nextZ=n.next,n=n.next;while(n!==t);n.prevZ.nextZ=null,n.prevZ=null,Jn(n)}function Jn(t){let o,e,i=1,n,s,r,a,l,c;do{for(s=t,t=null,c=null,n=0;s;){for(n++,a=s,r=0,e=0;e<i&&(r++,a=a.nextZ,!!a);e++);for(l=i;r>0||l>0&&a;)r!==0&&(l===0||!a||s.z<=a.z)?(o=s,s=s.nextZ,r--):(o=a,a=a.nextZ,l--),c?c.nextZ=o:t=o,o.prevZ=c,c=o;s=a}c.nextZ=null,i*=2}while(n>1);return t}function pt(t,o,e,i,n){return t=(t-e)*n|0,o=(o-i)*n|0,t=(t|t<<8)&16711935,t=(t|t<<4)&252645135,t=(t|t<<2)&858993459,t=(t|t<<1)&1431655765,o=(o|o<<8)&16711935,o=(o|o<<4)&252645135,o=(o|o<<2)&858993459,o=(o|o<<1)&1431655765,t|o<<1}function Yn(t){let o=t,e=t;do(o.x<e.x||o.x===e.x&&o.y<e.y)&&(e=o),o=o.next;while(o!==t);return e}function ne(t,o,e,i,n,s,r,a){return(n-r)*(o-a)>=(t-r)*(s-a)&&(t-r)*(i-a)>=(e-r)*(o-a)&&(e-r)*(s-a)>=(n-r)*(i-a)}function Xn(t,o){return t.next.i!==o.i&&t.prev.i!==o.i&&!qn(t,o)&&(pe(t,o)&&pe(o,t)&&Qn(t,o)&&(b(t.prev,t,o.prev)||b(t,o.prev,o))||Ne(t,o)&&b(t.prev,t,t.next)>0&&b(o.prev,o,o.next)>0)}function b(t,o,e){return(o.y-t.y)*(e.x-o.x)-(o.x-t.x)*(e.y-o.y)}function Ne(t,o){return t.x===o.x&&t.y===o.y}function bi(t,o,e,i){let n=Fe(b(t,o,e)),s=Fe(b(t,o,i)),r=Fe(b(e,i,t)),a=Fe(b(e,i,o));return!!(n!==s&&r!==a||n===0&&De(t,e,o)||s===0&&De(t,i,o)||r===0&&De(e,t,i)||a===0&&De(e,o,i))}function De(t,o,e){return o.x<=Math.max(t.x,e.x)&&o.x>=Math.min(t.x,e.x)&&o.y<=Math.max(t.y,e.y)&&o.y>=Math.min(t.y,e.y)}function Fe(t){return t>0?1:t<0?-1:0}function qn(t,o){let e=t;do{if(e.i!==t.i&&e.next.i!==t.i&&e.i!==o.i&&e.next.i!==o.i&&bi(e,e.next,t,o))return!0;e=e.next}while(e!==t);return!1}function pe(t,o){return b(t.prev,t,t.next)<0?b(t,o,t.next)>=0&&b(t,t.prev,o)>=0:b(t,o,t.prev)<0||b(t,t.next,o)<0}function Qn(t,o){let e=t,i=!1,n=(t.x+o.x)/2,s=(t.y+o.y)/2;do e.y>s!=e.next.y>s&&e.next.y!==e.y&&n<(e.next.x-e.x)*(s-e.y)/(e.next.y-e.y)+e.x&&(i=!i),e=e.next;while(e!==t);return i}function wi(t,o){let e=new he(t.i,t.x,t.y),i=new he(o.i,o.x,o.y),n=t.next,s=o.prev;return t.next=o,o.prev=t,e.next=n,n.prev=e,i.next=e,e.prev=i,s.next=i,i.prev=s,i}function Li(t,o,e,i){let n=new he(t,o,e);return i?(n.next=i.next,n.prev=i,i.next.prev=n,i.next=n):(n.prev=n,n.next=n),n}function ge(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}var he=class{constructor(o,e,i){this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1,this.i=o,this.x=e,this.y=i}};function B(t,o){let e=o.length,i=t.length;if(i>0){let n=!0;for(let s=0;s<e;s++)if(t[i-e+s]!==o[s]){n=!1;break}if(n)return!1}for(let n=0;n<e;n++)t[i+n]=o[n];return!0}function xe(t,o){let e=o.length;for(let i=0;i<e;i++)t[i]=o[i]}function K(t,o,e,i,n=[]){let s=i+o*e;for(let r=0;r<e;r++)n[r]=t[s+r];return n}function Ge(t,o,e,i,n=[]){let s,r;if(e&8)s=(i[3]-t[1])/(o[1]-t[1]),r=3;else if(e&4)s=(i[1]-t[1])/(o[1]-t[1]),r=1;else if(e&2)s=(i[2]-t[0])/(o[0]-t[0]),r=2;else if(e&1)s=(i[0]-t[0])/(o[0]-t[0]),r=0;else return null;for(let a=0;a<t.length;a++)n[a]=(r&1)===a?i[r]:s*(o[a]-t[a])+t[a];return n}function ve(t,o){let e=0;return t[0]<o[0]?e|=1:t[0]>o[2]&&(e|=2),t[1]<o[1]?e|=4:t[1]>o[3]&&(e|=8),e}function me(t,o){let{size:e=2,broken:i=!1,gridResolution:n=10,gridOffset:s=[0,0],startIndex:r=0,endIndex:a=t.length}=o||{},l=(a-r)/e,c=[],f=[c],d=K(t,0,e,r),u,p,g=Ei(d,n,s,[]),h=[];B(c,d);for(let v=1;v<l;v++){for(u=K(t,v,e,r,u),p=ve(u,g);p;){Ge(d,u,p,g,h);let P=ve(h,g);P&&(Ge(d,h,P,g,h),p=P),B(c,h),xe(d,h),ts(g,n,p),i&&c.length>e&&(c=[],f.push(c),B(c,d)),p=ve(u,g)}B(c,u),xe(d,u)}return i?f:f[0]}var Ii=0;var es=1;function ye(t,o=null,e){if(!t.length)return[];let{size:i=2,gridResolution:n=10,gridOffset:s=[0,0],edgeTypes:r=!1}=e||{},a=[],l=[{pos:t,types:r?new Array(t.length/i).fill(es):null,holes:o||[]}],c=[[],[]],f=[];for(;l.length;){let{pos:d,types:u,holes:p}=l.shift();is(d,i,p[0]||d.length,c),f=Ei(c[0],n,s,f);let g=ve(c[1],f);if(g){let h=Ai(d,u,i,0,p[0]||d.length,f,g),v={pos:h[0].pos,types:h[0].types,holes:[]},P={pos:h[1].pos,types:h[1].types,holes:[]};l.push(v,P);for(let C=0;C<p.length;C++)h=Ai(d,u,i,p[C],p[C+1]||d.length,f,g),h[0]&&(v.holes.push(v.pos.length),v.pos=Be(v.pos,h[0].pos),r&&(v.types=Be(v.types,h[0].types))),h[1]&&(P.holes.push(P.pos.length),P.pos=Be(P.pos,h[1].pos),r&&(P.types=Be(P.types,h[1].types)))}else{let h={positions:d};r&&(h.edgeTypes=u),p.length&&(h.holeIndices=p),a.push(h)}}return a}function Ai(t,o,e,i,n,s,r){let a=(n-i)/e,l=[],c=[],f=[],d=[],u=[],p,g,h,v=K(t,a-1,e,i),P=Math.sign(r&8?v[1]-s[3]:v[0]-s[2]),C=o&&o[a-1],m=0,x=0;for(let L=0;L<a;L++)p=K(t,L,e,i,p),g=Math.sign(r&8?p[1]-s[3]:p[0]-s[2]),h=o&&o[i/e+L],g&&P&&P!==g&&(Ge(v,p,r,s,u),B(l,u)&&f.push(C),B(c,u)&&d.push(C)),g<=0?(B(l,p)&&f.push(h),m-=g):f.length&&(f[f.length-1]=Ii),g>=0?(B(c,p)&&d.push(h),x+=g):d.length&&(d[d.length-1]=Ii),xe(v,p),P=g,C=h;return[m?{pos:l,types:o&&f}:null,x?{pos:c,types:o&&d}:null]}function Ei(t,o,e,i){let n=Math.floor((t[0]-e[0])/o)*o+e[0],s=Math.floor((t[1]-e[1])/o)*o+e[1];return i[0]=n,i[1]=s,i[2]=n+o,i[3]=s+o,i}function ts(t,o,e){e&8?(t[1]+=o,t[3]+=o):e&4?(t[1]-=o,t[3]-=o):e&2?(t[0]+=o,t[2]+=o):e&1&&(t[0]-=o,t[2]-=o)}function is(t,o,e,i){let n=Infinity,s=-Infinity,r=Infinity,a=-Infinity;for(let l=0;l<e;l+=o){let c=t[l],f=t[l+1];n=c<n?c:n,s=c>s?c:s,r=f<r?f:r,a=f>a?f:a}return i[0][0]=n,i[0][1]=r,i[1][0]=s,i[1][1]=a,i}function Be(t,o){for(let e=0;e<o.length;e++)t.push(o[e]);return t}var os=85.051129;function gt(t,o){let{size:e=2,startIndex:i=0,endIndex:n=t.length,normalize:s=!0}=o||{},r=t.slice(i,n);Ti(r,e,0,n-i);let a=me(r,{size:e,broken:!0,gridResolution:360,gridOffset:[-180,-180]});if(s)for(let l of a)Oi(l,e);return a}function ht(t,o=null,e){let{size:i=2,normalize:n=!0,edgeTypes:s=!1}=e||{};o=o||[];let r=[],a=[],l=0,c=0;for(let d=0;d<=o.length;d++){let u=o[d]||t.length,p=c,g=ns(t,i,l,u);for(let h=g;h<u;h++)r[c++]=t[h];for(let h=l;h<g;h++)r[c++]=t[h];Ti(r,i,p,c),ss(r,i,p,c,e?.maxLatitude),l=u,a[d]=c}a.pop();let f=ye(r,a,{size:i,gridResolution:360,gridOffset:[-180,-180],edgeTypes:s});if(n)for(let d of f)Oi(d.positions,i);return f}function ns(t,o,e,i){let n=-1,s=-1;for(let r=e+1;r<i;r+=o){let a=Math.abs(t[r]);a>n&&(n=a,s=r-1)}return s}function ss(t,o,e,i,n=os){let s=t[e],r=t[i-o];if(Math.abs(s-r)>180){let a=K(t,0,o,e);a[0]+=Math.round((r-s)/360)*360,B(t,a),a[1]=Math.sign(a[1])*n,B(t,a),a[0]=s,B(t,a)}}function Ti(t,o,e,i){let n=t[0],s;for(let r=e;r<i;r+=o){s=t[r];let a=s-n;(a>180||a<-180)&&(s-=Math.round(a/360)*360),t[r]=n=s}}function Oi(t,o){let e,i=t.length/o;for(let s=0;s<i&&(e=t[s*o],(e+180)%360===0);s++);let n=-Math.round(e/360)*360;if(n!==0)for(let s=0;s<i;s++)t[s*o]+=n}var je=class extends ne$1{constructor(o){let{indices:e,attributes:i}=as(o);super(s(r({},o),{topology:`line-list`,indices:e,attributes:i}))}};function as(t){let{radius:o,height:e=1,nradial:i=10}=t,{vertices:n}=t;n&&(A.assert(n.length>=i),n=n.flatMap(p=>[p[0],p[1]]),J(n,oe.COUNTER_CLOCKWISE));let s=e>0,r=i+1,a=s?r*3+1:i,l=Math.PI*2/i,c=new Uint16Array(s?i*3*2:0),f=new Float32Array(a*3),d=new Float32Array(a*3),u=0;if(s){for(let p=0;p<r;p++){let g=p*l,h=p%i,v=Math.sin(g),P=Math.cos(g);for(let C=0;C<2;C++)f[u+0]=n?n[h*2]:P*o,f[u+1]=n?n[h*2+1]:v*o,f[u+2]=(1/2-C)*e,d[u+0]=n?n[h*2]:P,d[u+1]=n?n[h*2+1]:v,u+=3}f[u+0]=f[u-3],f[u+1]=f[u-2],f[u+2]=f[u-1],u+=3}for(let p=s?0:1;p<r;p++){let g=Math.floor(p/2)*Math.sign(.5-p%2),h=g*l,v=(g+i)%i,P=Math.sin(h),C=Math.cos(h);f[u+0]=n?n[v*2]:C*o,f[u+1]=n?n[v*2+1]:P*o,f[u+2]=e/2,d[u+2]=1,u+=3}if(s){let p=0;for(let g=0;g<i;g++)c[p++]=g*2+0,c[p++]=g*2+2,c[p++]=g*2+0,c[p++]=g*2+1,c[p++]=g*2+1,c[p++]=g*2+3}return{indices:c,attributes:{POSITION:{size:3,value:f},NORMAL:{size:3,value:d}}}}var ls=`struct ColumnUniforms {
+  radius: f32,
+  angle: f32,
+  offset: vec2<f32>,
+  extruded: f32,
+  stroked: f32,
+  isStroke: f32,
+  coverage: f32,
+  elevationScale: f32,
+  edgeDistance: f32,
+  widthScale: f32,
+  widthMinPixels: f32,
+  widthMaxPixels: f32,
+  radiusUnits: i32,
+  widthUnits: i32,
+};
+
+@group(0) @binding(auto) var<uniform> column: ColumnUniforms;
+`;var Ri=`layout(std140) uniform columnUniforms {
+  float radius;
+  float angle;
+  vec2 offset;
+  bool extruded;
+  bool stroked;
+  bool isStroke;
+  float coverage;
+  float elevationScale;
+  float edgeDistance;
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  highp int radiusUnits;
+  highp int widthUnits;
+} column;
+`;var Mi={name:`column`,source:ls,vs:Ri,fs:Ri,uniformTypes:{radius:`f32`,angle:`f32`,offset:`vec2<f32>`,extruded:`f32`,stroked:`f32`,isStroke:`f32`,coverage:`f32`,elevationScale:`f32`,edgeDistance:`f32`,widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,radiusUnits:`i32`,widthUnits:`i32`}};var zi=`struct Attributes {
+  @builtin(instance_index) instanceIndex: u32,
+  @location(0) positions: vec3<f32>,
+  @location(1) normals: vec3<f32>,
+  @location(2) instancePositions: vec3<f32>,
+  @location(3) instancePositions64Low: vec3<f32>,
+  @location(4) instanceElevations: f32,
+  @location(5) instanceFillColors: vec4<f32>,
+  @location(6) instanceLineColors: vec4<f32>,
+  @location(7) instanceStrokeWidths: f32
+};
+
+fn getRotationMatrix(angle: f32) -> mat2x2<f32> {
+  let s = sin(angle);
+  let c = cos(angle);
+  return mat2x2<f32>(
+    vec2<f32>(c, s),
+    vec2<f32>(-s, c)
+  );
+}
+
+fn getOffset(
+  positions: vec3<f32>,
+  strokeOffsetRatio: f32,
+  dotRadius: f32,
+  rotationMatrix: mat2x2<f32>
+) -> vec3<f32> {
+  var offset = (rotationMatrix * positions.xy * strokeOffsetRatio + column.offset) * dotRadius;
+  if (column.radiusUnits == UNIT_METERS) {
+    offset = project_size_vec2(offset);
+  } else if (column.radiusUnits == UNIT_PIXELS) {
+    offset = project_pixel_size_vec2(offset);
+  }
+  return vec3<f32>(offset, 0.0);
+}
+`;var cs=`${zi}
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  geometry.worldPosition = attributes.instancePositions;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.instanceIndex);
+
+  let isStroke = column.isStroke > 0.5;
+  let baseColor = select(attributes.instanceFillColors, attributes.instanceLineColors, isStroke);
+  let rotationMatrix = getRotationMatrix(column.angle);
+
+  var elevation = 0.0;
+  var strokeOffsetRatio = 1.0;
+
+  if (column.extruded > 0.5) {
+    elevation =
+      attributes.instanceElevations * (attributes.positions.z + 1.0) / 2.0 * column.elevationScale;
+  } else if (column.stroked > 0.5) {
+    let widthPixels = clamp(
+      project_unit_size_to_pixel(attributes.instanceStrokeWidths * column.widthScale, column.widthUnits),
+      column.widthMinPixels,
+      column.widthMaxPixels
+    ) / 2.0;
+    let halfOffset =
+      project_pixel_size_float(widthPixels) /
+      project_size_float(column.edgeDistance * column.coverage * column.radius);
+    if (isStroke) {
+      strokeOffsetRatio -= sign(attributes.positions.z) * halfOffset;
+    } else {
+      strokeOffsetRatio -= halfOffset;
+    }
+  }
+
+  let shouldRender = select(0.0, 1.0, baseColor.a > 0.0 && attributes.instanceElevations >= 0.0);
+  let dotRadius = column.radius * column.coverage * shouldRender;
+  let centroidPosition =
+    vec3<f32>(
+      attributes.instancePositions.xy,
+      attributes.instancePositions.z + elevation
+    );
+  let offset = getOffset(attributes.positions, strokeOffsetRatio, dotRadius, rotationMatrix);
+  let projected = project_position_to_clipspace_and_commonspace(
+    centroidPosition,
+    attributes.instancePositions64Low,
+    offset
+  );
+
+  geometry.position = projected.commonPosition;
+  geometry.normal = project_normal(vec3<f32>(rotationMatrix * attributes.normals.xy, attributes.normals.z));
+
+  let lightColor = lighting_getLightColor2(
+    baseColor.rgb,
+    project.cameraPosition,
+    geometry.position.xyz,
+    geometry.normal
+  );
+
+  varyings.position = projected.clipPosition;
+  varyings.color = vec4<f32>(
+    select(baseColor.rgb, lightColor, column.extruded > 0.5 && !isStroke),
+    baseColor.a * layer.opacity
+  );
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = vec2<f32>(0.0);
+  return deckgl_premultiplied_alpha(varyings.color);
+}
+`;var fs=`${zi}
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) color: vec4<f32>,
+  @location(1) cameraPosition: vec3<f32>,
+  @location(2) positionCommonspace: vec4<f32>
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  geometry.worldPosition = attributes.instancePositions;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.instanceIndex);
+
+  let isStroke = column.isStroke > 0.5;
+  let baseColor = select(attributes.instanceFillColors, attributes.instanceLineColors, isStroke);
+  let rotationMatrix = getRotationMatrix(column.angle);
+
+  var elevation = 0.0;
+  var strokeOffsetRatio = 1.0;
+
+  if (column.extruded > 0.5) {
+    elevation =
+      attributes.instanceElevations * (attributes.positions.z + 1.0) / 2.0 * column.elevationScale;
+  } else if (column.stroked > 0.5) {
+    let widthPixels = clamp(
+      project_unit_size_to_pixel(attributes.instanceStrokeWidths * column.widthScale, column.widthUnits),
+      column.widthMinPixels,
+      column.widthMaxPixels
+    ) / 2.0;
+    let halfOffset =
+      project_pixel_size_float(widthPixels) /
+      project_size_float(column.edgeDistance * column.coverage * column.radius);
+    if (isStroke) {
+      strokeOffsetRatio -= sign(attributes.positions.z) * halfOffset;
+    } else {
+      strokeOffsetRatio -= halfOffset;
+    }
+  }
+
+  let shouldRender = select(0.0, 1.0, baseColor.a > 0.0 && attributes.instanceElevations >= 0.0);
+  let dotRadius = column.radius * column.coverage * shouldRender;
+  let centroidPosition =
+    vec3<f32>(
+      attributes.instancePositions.xy,
+      attributes.instancePositions.z + elevation
+    );
+  let offset = getOffset(attributes.positions, strokeOffsetRatio, dotRadius, rotationMatrix);
+  let projected = project_position_to_clipspace_and_commonspace(
+    centroidPosition,
+    attributes.instancePositions64Low,
+    offset
+  );
+
+  geometry.position = projected.commonPosition;
+  geometry.normal = project_normal(vec3<f32>(rotationMatrix * attributes.normals.xy, attributes.normals.z));
+
+  varyings.position = projected.clipPosition;
+  varyings.color = vec4<f32>(baseColor.rgb, baseColor.a * layer.opacity);
+  varyings.cameraPosition = project.cameraPosition;
+  varyings.positionCommonspace = projected.commonPosition;
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = vec2<f32>(0.0);
+
+  var fragColor = varyings.color;
+  if (column.extruded > 0.5 && column.isStroke < 0.5) {
+    // WebGPU's screen-space Y axis reverses the derivative orientation used by GLSL flat shading.
+    let normal = normalize(cross(dpdy(varyings.positionCommonspace.xyz), dpdx(varyings.positionCommonspace.xyz)));
+    fragColor = vec4<f32>(
+      lighting_getLightColor2(
+        varyings.color.rgb,
+        varyings.cameraPosition,
+        varyings.positionCommonspace.xyz,
+        normal
+      ),
+      varyings.color.a
+    );
+  }
+
+  return deckgl_premultiplied_alpha(fragColor);
+}
+`;function ki(t){return t?fs:cs}var Di=`#version 300 es
+#define SHADER_NAME column-layer-vertex-shader
+in vec3 positions;
+in vec3 normals;
+in vec3 instancePositions;
+in float instanceElevations;
+in vec3 instancePositions64Low;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+in float instanceStrokeWidths;
+out vec4 vColor;
+#ifdef FLAT_SHADING
+out vec3 cameraPosition;
+out vec4 position_commonspace;
+#endif
+void main(void) {
+geometry.worldPosition = instancePositions;
+vec4 color = column.isStroke ? instanceLineColors : instanceFillColors;
+mat2 rotationMatrix = mat2(cos(column.angle), sin(column.angle), -sin(column.angle), cos(column.angle));
+float elevation = 0.0;
+float strokeOffsetRatio = 1.0;
+if (column.extruded) {
+elevation = instanceElevations * (positions.z + 1.0) / 2.0 * column.elevationScale;
+} else if (column.stroked) {
+float widthPixels = clamp(
+project_size_to_pixel(instanceStrokeWidths * column.widthScale, column.widthUnits),
+column.widthMinPixels, column.widthMaxPixels) / 2.0;
+float halfOffset = project_pixel_size(widthPixels) / project_size(column.edgeDistance * column.coverage * column.radius);
+if (column.isStroke) {
+strokeOffsetRatio -= sign(positions.z) * halfOffset;
+} else {
+strokeOffsetRatio -= halfOffset;
+}
+}
+float shouldRender = float(color.a > 0.0 && instanceElevations >= 0.0);
+float dotRadius = column.radius * column.coverage * shouldRender;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+vec3 centroidPosition = vec3(instancePositions.xy, instancePositions.z + elevation);
+vec3 centroidPosition64Low = instancePositions64Low;
+vec2 offset = (rotationMatrix * positions.xy * strokeOffsetRatio + column.offset) * dotRadius;
+if (column.radiusUnits == UNIT_METERS) {
+offset = project_size(offset);
+} else if (column.radiusUnits == UNIT_PIXELS) {
+offset = project_pixel_size(offset);
+}
+vec3 pos = vec3(offset, 0.);
+DECKGL_FILTER_SIZE(pos, geometry);
+gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);
+geometry.normal = project_normal(vec3(rotationMatrix * normals.xy, normals.z));
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+if (column.extruded && !column.isStroke) {
+#ifdef FLAT_SHADING
+cameraPosition = project.cameraPosition;
+position_commonspace = geometry.position;
+vColor = vec4(color.rgb, color.a * layer.opacity);
+#else
+vec3 lightColor = lighting_getLightColor(color.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+vColor = vec4(lightColor, color.a * layer.opacity);
+#endif
+} else {
+vColor = vec4(color.rgb, color.a * layer.opacity);
+}
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var Fi=`#version 300 es
+#define SHADER_NAME column-layer-fragment-shader
+precision highp float;
+out vec4 fragColor;
+in vec4 vColor;
+#ifdef FLAT_SHADING
+in vec3 cameraPosition;
+in vec4 position_commonspace;
+#endif
+void main(void) {
+fragColor = vColor;
+geometry.uv = vec2(0.);
+#ifdef FLAT_SHADING
+if (column.extruded && !column.isStroke && !bool(picking.isActive)) {
+vec3 normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
+fragColor.rgb = lighting_getLightColor(vColor.rgb, cameraPosition, position_commonspace.xyz, normal);
+}
+#endif
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var We=[0,0,0,255];var ds={name:`geometry`,stepMode:`vertex`,byteStride:24,attributes:[{attribute:`positions`,format:`float32x3`,byteOffset:0},{attribute:`normals`,format:`float32x3`,byteOffset:12}]};var us={diskResolution:{type:`number`,min:4,value:20},vertices:null,radius:{type:`number`,min:0,value:1e3},angle:{type:`number`,value:0},offset:{type:`array`,value:[0,0]},coverage:{type:`number`,min:0,max:1,value:1},elevationScale:{type:`number`,min:0,value:1},radiusUnits:`meters`,lineWidthUnits:`meters`,lineWidthScale:1,lineWidthMinPixels:0,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,extruded:!0,wireframe:!1,filled:!0,stroked:!1,flatShading:!1,getPosition:{type:`accessor`,value:t=>t.position},getFillColor:{type:`accessor`,value:We},getLineColor:{type:`accessor`,value:We},getLineWidth:{type:`accessor`,value:1},getElevation:{type:`accessor`,value:1e3},material:!0,getColor:{deprecatedFor:[`getFillColor`,`getLineColor`]}};var xt=(()=>{class t extends en$1{getShaders(){let e={},{flatShading:i}=this.props;return i&&(e.FLAT_SHADING=1),super.getShaders({vs:Di,fs:Fi,source:ki(i),defines:e,modules:[Wa,ma,i?Ko$1:Zo$1,Ka,Mi]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceElevations:{size:1,transition:!0,accessor:`getElevation`},instanceFillColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getFillColor`,defaultValue:We},instanceLineColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getLineColor`,defaultValue:We},instanceStrokeWidths:{size:1,accessor:`getLineWidth`,transition:!0}})}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e,r=s.extensionsChanged||i.flatShading!==n.flatShading;r&&(this.state.models?.forEach(l=>l.destroy()),this.setState(this._getModels()),this.getAttributeManager().invalidateAll());let a=this.getNumInstances();this.state.fillModel.setInstanceCount(a),this.state.strokeModel.setInstanceCount(a),this.state.wireframeModel.setInstanceCount(a),(r||i.diskResolution!==n.diskResolution||i.vertices!==n.vertices||i.extruded!==n.extruded||i.stroked!==n.stroked)&&this._updateGeometry(i)}getGeometry(e,i,n){let s=new je({radius:1,height:n?2:0,vertices:i,nradial:e}),r=0;if(i)for(let a=0;a<e;a++){let l=i[a],c=Math.sqrt(l[0]*l[0]+l[1]*l[1]);r+=c/e}else r=1;return this.setState({edgeDistance:Math.cos(Math.PI/e)*r}),s}_getModels(){let e=this.getShaders(),i=[...this.getAttributeManager().getBufferLayouts(),ds],n=new De$1(this.context.device,s(r({},e),{id:`${this.props.id}-fill`,bufferLayout:i,isInstanced:!0})),s$4=new De$1(this.context.device,s(r({},e),{id:`${this.props.id}-stroke`,bufferLayout:i,isInstanced:!0})),r$5=new De$1(this.context.device,s(r({},e),{id:`${this.props.id}-wireframe`,bufferLayout:i,isInstanced:!0}));return{fillModel:n,strokeModel:s$4,wireframeModel:r$5,models:[r$5,n,s$4]}}_updateGeometry({diskResolution:e,vertices:i,extruded:n,stroked:s}){let r=this.getGeometry(e,i,n||s),a=r.attributes.POSITION,l=r.attributes.NORMAL;if(this._setFillGeometry(new ne$1({topology:`triangle-strip`,attributes:{POSITION:a,NORMAL:l}})),!n&&s){let c=a.value.length/3;this._setStrokeGeometry(new ne$1({topology:`triangle-strip`,vertexCount:c-e-1,attributes:{POSITION:a,NORMAL:l}}))}n&&this._setWireframeGeometry(r)}_setFillGeometry(e){let i=pt$1(e,{attributes:[`POSITION`,`NORMAL`]});this.state.fillModel.setGeometry(i)}_setStrokeGeometry(e){let i=pt$1(e,{attributes:[`POSITION`,`NORMAL`]});this.state.strokeModel.setGeometry(i)}_setWireframeGeometry(e){let i=pt$1(e,{attributes:[`POSITION`,`NORMAL`]}),n=this.state.wireframeModel;n.setGeometry(i),n.setTopology(`line-list`)}draw({uniforms:e}){let{lineWidthUnits:i,lineWidthScale:n,lineWidthMinPixels:s$5,lineWidthMaxPixels:r$6,radiusUnits:a,elevationScale:l,extruded:c,filled:f,stroked:d,wireframe:u,offset:p,coverage:g,radius:h,angle:v}=this.props,P=this.state.fillModel,C=this.state.strokeModel,m=this.state.wireframeModel,{edgeDistance:x}=this.state,L={radius:h,angle:v/180*Math.PI,offset:p,extruded:c,stroked:d,coverage:g,elevationScale:l,edgeDistance:x,radiusUnits:ee[a],widthUnits:ee[i],widthScale:n,widthMinPixels:s$5,widthMaxPixels:r$6};c&&u&&(m.shaderInputs.setProps({column:s(r({},L),{isStroke:!0})}),m.draw(this.context.renderPass)),f&&(P.shaderInputs.setProps({column:s(r({},L),{isStroke:!1})}),P.draw(this.context.renderPass)),!c&&d&&(C.shaderInputs.setProps({column:s(r({},L),{isStroke:!0})}),C.draw(this.context.renderPass))}}return t.layerName=`ColumnLayer`,t.defaultProps=us,t})();var gs={cellSize:{type:`number`,min:0,value:1e3},offset:{type:`array`,value:[1,1]}};var xs=(()=>{class t extends xt{_updateGeometry(){let e=new Wr;this._setFillGeometry(e)}draw({uniforms:e}){let{elevationScale:i,extruded:n,offset:s,coverage:r,cellSize:a,angle:l,radiusUnits:c}=this.props,f=this.state.fillModel,d={radius:a/2,radiusUnits:ee[c],angle:l,offset:s,extruded:n,stroked:!1,coverage:r,elevationScale:i,edgeDistance:1,isStroke:!1,widthUnits:0,widthScale:0,widthMinPixels:0,widthMaxPixels:0};f.shaderInputs.setProps({column:d}),f.draw(this.context.renderPass)}}return t.layerName=`GridCellLayer`,t.defaultProps=gs,t})();function Ni(t,o,e,i){let n;if(Array.isArray(t[0])){let s=t.length*o;n=new Array(s);for(let r=0;r<t.length;r++)for(let a=0;a<o;a++)n[r*o+a]=t[r][a]||0}else n=t;return e?me(n,{size:o,gridResolution:e}):i?gt(n,{size:o}):n}var vs=1;var ms=2;var Pe=4;var Ue=class extends an{constructor(o){super(s(r({},o),{attributes:{positions:{size:3,padding:18,initialize:!0,type:o.fp64?Float64Array:Float32Array},segmentTypes:{size:1,type:o.isWebGPU?Float32Array:Uint8ClampedArray}}}))}get(o){return this.attributes[o]}getPathSegmentIndices(o){let e=this.attributes.segmentTypes,i=this.vertexStarts[o],n=Math.min(this.vertexStarts[o+1]??this.instanceCount,this.instanceCount),s=[];for(let r=i;r<n-1;r++)(e[r]&Pe)===0&&s.push(r);return s.length&&(e[i]&Pe)!==0&&s.unshift(s.pop()),s}getGeometryFromBuffer(o){return this.normalize||this.opts.isWebGPU?super.getGeometryFromBuffer(o):null}normalizeGeometry(o){return this.normalize?Ni(o,this.positionSize,this.opts.resolution,this.opts.wrapLongitude):o}getGeometrySize(o){if(Gi(o)){let i=0;for(let n of o)i+=this.getGeometrySize(n);return i}let e=this.getPathLength(o);return e<2?0:this.isClosed(o)?e<3?0:e+2:e}updateGeometryAttributes(o,e){if(e.geometrySize!==0)if(o&&Gi(o))for(let i of o){let n=this.getGeometrySize(i);e.geometrySize=n,this.updateGeometryAttributes(i,e),e.vertexStart+=n}else this._updateSegmentTypes(o,e),this._updatePositions(o,e)}_updateSegmentTypes(o,e){let i=this.attributes.segmentTypes,n=o?this.isClosed(o):!1,{vertexStart:s,geometrySize:r}=e;i.fill(0,s,s+r),n?(i[s]=Pe,i[s+r-2]=Pe):(i[s]+=vs,i[s+r-2]+=ms),i[s+r-1]=Pe}_updatePositions(o,e){let{positions:i}=this.attributes;if(!i||!o)return;let{vertexStart:n,geometrySize:s}=e,r=new Array(3);for(let a=n,l=0;l<s;a++,l++)this.getPointOnPath(o,l,r),i[a*3]=r[0],i[a*3+1]=r[1],i[a*3+2]=r[2]}getPathLength(o){return o.length/this.positionSize}getPointOnPath(o,e,i=[]){let{positionSize:n}=this;e*n>=o.length&&(e+=1-o.length/n);let s=e*n;return i[0]=o[s],i[1]=o[s+1],i[2]=n===3&&o[s+2]||0,i}isClosed(o){if(!this.normalize)return!!this.opts.loop;let{positionSize:e}=this,i=o.length-e;return o[0]===o[i]&&o[1]===o[i+1]&&(e===2||o[2]===o[i+2])}};function Gi(t){return Array.isArray(t[0])}var ys=`struct PathUniforms {
+  widthScale: f32,
+  widthMinPixels: f32,
+  widthMaxPixels: f32,
+  jointType: f32,
+  capType: f32,
+  miterLimit: f32,
+  billboard: f32,
+  widthUnits: i32,
+};
+
+@group(0) @binding(auto)
+var<uniform> path: PathUniforms;
+`;var Bi=`layout(std140) uniform pathUniforms {
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  float jointType;
+  float capType;
+  float miterLimit;
+  bool billboard;
+  highp int widthUnits;
+} path;
+`;var ji={name:`path`,source:ys,vs:Bi,fs:Bi,uniformTypes:{widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,jointType:`f32`,capType:`f32`,miterLimit:`f32`,billboard:`f32`,widthUnits:`i32`}};var Wi=`const EPSILON: f32 = 0.001;
+const ZERO_OFFSET: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
+
+struct JoinResult {
+  offset: vec3<f32>,
+  cornerOffset: vec2<f32>,
+  miterLength: f32,
+  pathPosition: vec2<f32>,
+  pathLength: f32,
+  jointType: f32,
+};
+
+struct Attributes {
+  @location(0) positions: vec2<f32>,
+  @location(1) instanceTypes: f32,
+  @location(2) instanceLeftPositions: vec3<f32>,
+  @location(3) instanceStartPositions: vec3<f32>,
+  @location(4) instanceEndPositions: vec3<f32>,
+  @location(5) instanceRightPositions: vec3<f32>,
+  @location(6) instanceLeftPositions64Low: vec3<f32>,
+  @location(7) instanceStartPositions64Low: vec3<f32>,
+  @location(8) instanceEndPositions64Low: vec3<f32>,
+  @location(9) instanceRightPositions64Low: vec3<f32>,
+  @location(10) instanceStrokeWidths: f32,
+  @location(11) instanceColors: vec4<f32>,
+  @location(12) rowIndexes: u32,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) vCornerOffset: vec2<f32>,
+  @location(2) vMiterLength: f32,
+  @location(3) vPathPosition: vec2<f32>,
+  @location(4) vPathLength: f32,
+  @location(5) vJointType: f32,
+  // Location 6 is reserved for TripsLayer's injected vTime varying.
+  @location(7) clipCoordinates: vec2<f32>,
+#ifdef DASH_ENABLED
+  @location(8) vPathBounds: vec2<f32>,
+#endif
+};
+
+fn flipIfTrue(flag: bool) -> f32 {
+  return select(1.0, -1.0, flag);
+}
+
+fn clipLine(position: vec4<f32>, refPosition: vec4<f32>) -> vec4<f32> {
+  if (position.w < EPSILON) {
+    let r = (EPSILON - refPosition.w) / (position.w - refPosition.w);
+    return refPosition + (position - refPosition) * r;
+  }
+  return position;
+}
+
+#ifdef DASH_ENABLED
+// Return the visible interval of the original segment before clipLine moves either endpoint.
+fn getClippedPathRange(startW: f32, endW: f32) -> vec2<f32> {
+  let startClipped = startW < EPSILON;
+  let endClipped = endW < EPSILON;
+  if (startClipped && endClipped) {
+    return vec2<f32>(0.0, 0.0);
+  }
+  if (startClipped || endClipped) {
+    let intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+    if (startClipped) {
+      return vec2<f32>(intersection, 1.0);
+    }
+    return vec2<f32>(0.0, intersection);
+  }
+  return vec2<f32>(0.0, 1.0);
+}
+#endif
+
+fn getLineJoinOffset(
+  prevPoint: vec3<f32>,
+  currPoint: vec3<f32>,
+  nextPoint: vec3<f32>,
+  width: vec2<f32>,
+#ifdef DASH_ENABLED
+  sourcePathLength: f32,
+  sourcePathRange: vec2<f32>,
+#endif
+#ifdef ANTIALIASING
+  coverageScale: f32,
+#endif
+  positions: vec2<f32>,
+  instanceTypes: f32
+) -> JoinResult {
+  let isEnd = positions.x > 0.0;
+  let sideOfPath = positions.y;
+  let isJoint = select(0.0, 1.0, sideOfPath == 0.0);
+
+  var deltaA3 = currPoint - prevPoint;
+  var deltaB3 = nextPoint - currPoint;
+
+  let rotationResult = project_needs_rotation(currPoint);
+  if (path.billboard == 0.0 && rotationResult.needsRotation) {
+    deltaA3 = rotationResult.transform * deltaA3;
+    deltaB3 = rotationResult.transform * deltaB3;
+  }
+
+  let deltaA = deltaA3.xy / width;
+  let deltaB = deltaB3.xy / width;
+
+  let lenA = length(deltaA);
+  let lenB = length(deltaB);
+
+  let dirA = select(vec2<f32>(0.0, 0.0), normalize(deltaA), lenA > 0.0);
+  let dirB = select(vec2<f32>(0.0, 0.0), normalize(deltaB), lenB > 0.0);
+
+  let perpA = vec2<f32>(-dirA.y, dirA.x);
+  let perpB = vec2<f32>(-dirB.y, dirB.x);
+
+  var tangent = dirA + dirB;
+  tangent = select(perpA, normalize(tangent), length(tangent) > 0.0);
+  let miterVec = vec2<f32>(-tangent.y, tangent.x);
+  let dir = select(dirB, dirA, isEnd);
+  let perp = select(perpB, perpA, isEnd);
+#ifdef DASH_ENABLED
+  let segmentLength2D = select(lenB, lenA, isEnd);
+
+  // Extrusion happens in the XY plane, so segmentLength2D is a 2D length and pathPosition.y
+  // below measures 2D distance along the segment. For a path that also moves in Z the true
+  // arc length is longer by this ratio. Scaling pathLength and pathPosition.y by it makes
+  // the coordinate measure real 3D distance while leaving the joint tests unchanged, since
+  // they compare the two against each other and both are scaled alike. Billboard mode
+  // extrudes in clip space, where the perspective divide has already reduced the segment to
+  // its screen projection, so its complete common-space length is supplied by the caller.
+  // Mirrors path-layer-vertex.glsl.ts.
+  let currDelta3 = select(deltaB3, deltaA3, isEnd);
+  let currLength2D = length(currDelta3.xy);
+  // Do not clamp a valid denominator to EPSILON: high-zoom Web Mercator deltas are often
+  // smaller than that in common space, and changing their scale corrupts even flat paths.
+  let safeLength2D = select(1.0, currLength2D, currLength2D > 0.0);
+  var arcLengthRatio = 1.0;
+  var pathPositionOffset = 0.0;
+  var pathLength = segmentLength2D;
+  if (path.billboard != 0.0) {
+    // clipLine may shorten the visible screen-space segment. Preserve the corresponding interval
+    // of the complete common-space arclength instead of compressing the full dash period into the
+    // visible span. Keep pathLength complete so justification is stable as the camera clips it.
+    let visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+    arcLengthRatio = 0.0;
+    if (segmentLength2D > 0.0) {
+      arcLengthRatio = visiblePathLength / segmentLength2D;
+    }
+    pathPositionOffset = sourcePathLength * sourcePathRange.x;
+    pathLength = sourcePathLength;
+  } else if (currLength2D > 0.0) {
+    arcLengthRatio = length(currDelta3) / safeLength2D;
+    pathLength = segmentLength2D * arcLengthRatio;
+  }
+#else
+  let pathLength = select(lenB, lenA, isEnd);
+#endif
+
+  let sinHalfA = abs(dot(miterVec, perp));
+  let cosHalfA = abs(dot(dirA, miterVec));
+  let turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x);
+  let cornerPosition = sideOfPath * turnDirection;
+
+  var miterSize = 1.0 / max(sinHalfA, EPSILON);
+  miterSize = mix(
+    min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)),
+    miterSize,
+    step(0.0, cornerPosition)
+  );
+
+  var offsetVec =
+    mix(miterVec * miterSize, perp, step(0.5, cornerPosition)) *
+    (sideOfPath + isJoint * turnDirection);
+
+  let isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0));
+  let isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0));
+  let isCap = isStartCap || isEndCap;
+
+  var jointType = path.jointType;
+  if (isCap) {
+    offsetVec = mix(
+      perp * sideOfPath,
+      dir * path.capType * 4.0 * flipIfTrue(isStartCap),
+      isJoint
+    );
+    jointType = path.capType;
+  }
+
+#ifdef ANTIALIASING
+  let coverageOffsetVec = offsetVec * coverageScale;
+  var miterLength = dot(coverageOffsetVec, miterVec * turnDirection);
+#else
+  var miterLength = dot(offsetVec, miterVec * turnDirection);
+#endif
+  miterLength = select(miterLength, isJoint, isCap);
+
+#ifdef ANTIALIASING
+  let offsetFromStartOfPath = coverageOffsetVec + deltaA * select(0.0, 1.0, isEnd);
+#else
+  let offsetFromStartOfPath = offsetVec + deltaA * select(0.0, 1.0, isEnd);
+#endif
+  let pathPosition = vec2<f32>(
+    dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+    pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
+    dot(offsetFromStartOfPath, dir)
+#endif
+  );
+  let isValid = step(f32(instanceTypes), 3.5);
+#ifdef ANTIALIASING
+  var offset = vec3<f32>(coverageOffsetVec * width * isValid, 0.0);
+#else
+  var offset = vec3<f32>(offsetVec * width * isValid, 0.0);
+#endif
+
+  if (path.billboard == 0.0 && rotationResult.needsRotation) {
+    offset = rotationResult.transform * offset;
+  }
+
+#ifdef ANTIALIASING
+  return JoinResult(
+    offset, coverageOffsetVec, miterLength, pathPosition, pathLength, jointType
+  );
+#else
+  return JoinResult(offset, offsetVec, miterLength, pathPosition, pathLength, jointType);
+#endif
+}
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.rowIndexes);
+
+  let isEnd = attributes.positions.x;
+
+  let prevPosition = mix(attributes.instanceLeftPositions, attributes.instanceStartPositions, isEnd);
+  let prevPosition64Low = mix(
+    attributes.instanceLeftPositions64Low,
+    attributes.instanceStartPositions64Low,
+    isEnd
+  );
+  let currPosition = mix(attributes.instanceStartPositions, attributes.instanceEndPositions, isEnd);
+  let currPosition64Low = mix(
+    attributes.instanceStartPositions64Low,
+    attributes.instanceEndPositions64Low,
+    isEnd
+  );
+  let nextPosition = mix(attributes.instanceEndPositions, attributes.instanceRightPositions, isEnd);
+  let nextPosition64Low = mix(
+    attributes.instanceEndPositions64Low,
+    attributes.instanceRightPositions64Low,
+    isEnd
+  );
+
+  geometry.worldPosition = currPosition;
+
+  let widthPixels =
+    clamp(
+      project_unit_size_to_pixel(attributes.instanceStrokeWidths * path.widthScale, path.widthUnits),
+      path.widthMinPixels,
+      path.widthMaxPixels
+    ) / 2.0;
+
+  if (path.billboard != 0.0) {
+#ifdef DASH_ENABLED
+    let prevProjection = project_position_to_clipspace_and_commonspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    let nextProjection = project_position_to_clipspace_and_commonspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+    let prevPositionCommon = prevProjection.commonPosition.xyz;
+    let nextPositionCommon = nextProjection.commonPosition.xyz;
+    var prevPositionScreen = prevProjection.clipPosition;
+    var nextPositionScreen = nextProjection.clipPosition;
+#else
+    var prevPositionScreen = project_position_to_clipspace(
+      prevPosition, prevPosition64Low, ZERO_OFFSET
+    );
+    var nextPositionScreen = project_position_to_clipspace(
+      nextPosition, nextPosition64Low, ZERO_OFFSET
+    );
+#endif
+    let currProjection = project_position_to_clipspace_and_commonspace(
+      currPosition, currPosition64Low, ZERO_OFFSET
+    );
+    geometry.position = currProjection.commonPosition;
+    var currPositionScreen = currProjection.clipPosition;
+#ifdef DASH_ENABLED
+    let currPositionCommon = currProjection.commonPosition.xyz;
+    let sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+    let sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+    let billboardPathRange = getClippedPathRange(
+      sourcePathStartScreen.w, sourcePathEndScreen.w
+    );
+#endif
+
+    prevPositionScreen = clipLine(prevPositionScreen, currPositionScreen);
+    nextPositionScreen = clipLine(nextPositionScreen, currPositionScreen);
+    currPositionScreen = clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd));
+
+#ifdef ANTIALIASING
+    let coverageScale = select(
+      1.0,
+      (widthPixels + 0.5 / project.devicePixelRatio) / max(widthPixels, 1e-6),
+      widthPixels > 0.0
+    );
+#endif
+#ifdef DASH_ENABLED
+    let currentDeltaCommon = select(
+      nextPositionCommon - currPositionCommon,
+      currPositionCommon - prevPositionCommon,
+      isEnd > 0.0
+    );
+    let billboardPathLength = select(
+      0.0,
+      length(currentDeltaCommon) * project.scale / (widthPixels * project.focalDistance),
+      widthPixels > 0.0
+    );
+#endif
+    let join = getLineJoinOffset(
+      prevPositionScreen.xyz / prevPositionScreen.w,
+      currPositionScreen.xyz / currPositionScreen.w,
+      nextPositionScreen.xyz / nextPositionScreen.w,
+      project_pixel_size_to_clipspace(vec2<f32>(widthPixels, widthPixels)),
+#ifdef DASH_ENABLED
+      billboardPathLength,
+      billboardPathRange,
+#endif
+#ifdef ANTIALIASING
+      coverageScale,
+#endif
+      attributes.positions,
+      attributes.instanceTypes
+    );
+#ifdef DASH_ENABLED
+    // Phase and justification use the complete source segment, while cap and joint coverage
+    // must still recognize the endpoints moved by clipLine.
+    varyings.vPathBounds = billboardPathLength * billboardPathRange;
+#endif
+
+    geometry.uv = join.pathPosition;
+    varyings.position = vec4<f32>(
+      currPositionScreen.xyz + join.offset * currPositionScreen.w,
+      currPositionScreen.w
+    );
+    varyings.vCornerOffset = join.cornerOffset;
+    varyings.vMiterLength = join.miterLength;
+    varyings.vPathPosition = join.pathPosition;
+    varyings.vPathLength = join.pathLength;
+    varyings.vJointType = join.jointType;
+  } else {
+    let prevPositionCommon = project_position_vec3_f64(prevPosition, prevPosition64Low);
+    let currPositionCommon = project_position_vec3_f64(currPosition, currPosition64Low);
+    let nextPositionCommon = project_position_vec3_f64(nextPosition, nextPosition64Low);
+
+    let width = vec2<f32>(
+      project_pixel_size_float(widthPixels),
+      project_pixel_size_float(widthPixels)
+    );
+#ifdef ANTIALIASING
+    let coverageScale = select(
+      1.0,
+      (widthPixels + 0.5 / project.devicePixelRatio) / max(widthPixels, 1e-6),
+      widthPixels > 0.0
+    );
+#endif
+    let join = getLineJoinOffset(
+      prevPositionCommon,
+      currPositionCommon,
+      nextPositionCommon,
+      width,
+#ifdef DASH_ENABLED
+      1.0,
+      vec2<f32>(0.0, 1.0),
+#endif
+#ifdef ANTIALIASING
+      coverageScale,
+#endif
+      attributes.positions,
+      attributes.instanceTypes
+    );
+#ifdef DASH_ENABLED
+    varyings.vPathBounds = vec2<f32>(0.0, join.pathLength);
+#endif
+
+    geometry.position = vec4<f32>(currPositionCommon + join.offset, 1.0);
+    geometry.uv = join.pathPosition;
+    varyings.position = project_common_position_to_clipspace(geometry.position);
+    varyings.vCornerOffset = join.cornerOffset;
+    varyings.vMiterLength = join.miterLength;
+    varyings.vPathPosition = join.pathPosition;
+    varyings.vPathLength = join.pathLength;
+    varyings.vJointType = join.jointType;
+  }
+
+  varyings.clipCoordinates = geometry.position.xy;
+  clip_filterPosition(&varyings.position, geometry.worldPosition.xy);
+
+  varyings.vColor = vec4<f32>(
+    attributes.instanceColors.rgb,
+    attributes.instanceColors.a * layer.opacity
+  );
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = varyings.vPathPosition;
+
+#ifdef ANTIALIASING
+  // Coordinates of the outer silhouette, in units of half-width: rounded joints and caps are
+  // bounded by the corner offset, everywhere else by the edge of the stroke. Dividing by the
+  // screen-space derivative converts the distance to the boundary into device pixels, which stays
+  // correct under perspective foreshortening and under extensions that rescale the stroke.
+#ifdef DASH_ENABLED
+  let isCorner =
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y;
+#else
+  let isCorner = varyings.vPathPosition.y < 0.0 || varyings.vPathPosition.y > varyings.vPathLength;
+#endif
+  let isRound = varyings.vJointType > 0.5;
+
+  // Distance to the silhouette in device pixels, from the derivative of the coordinate that
+  // bounds it. Computed before the discards below: derivatives need uniform control flow and are
+  // undefined after a discard in the quad. See dev-docs/RFCs/v9.4/analytic-antialiasing-rfc.md
+  let bodyCoord = abs(varyings.vPathPosition.x);
+  let cornerCoord = length(varyings.vCornerOffset);
+  // Both evaluated so each derivative stays on one field across the corner/body boundary
+  let bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
+  let cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+  // Rounded corners still intersect the stroke-width envelope. Extensions may remap
+  // vPathPosition.x independently of vCornerOffset, as PathStyleExtension does for offsets.
+  let edgePixels = select(bodyPixels, min(cornerPixels, bodyPixels), isRound && isCorner);
+#else
+  let edgePixels = select(bodyPixels, cornerPixels, isRound && isCorner);
+#endif
+
+  // Fragments outside the coverage ramp must not write depth or picking colors.
+  if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+    discard;
+  }
+
+  if (isCorner) {
+    if (!isRound && varyings.vMiterLength > path.miterLimit + 1.0) {
+      discard;
+    }
+  }
+
+  var color = varyings.vColor;
+
+  // Feather one device pixel across the width only, before premultiplication. edgePixels is a
+  // signed device-pixel distance and SMOOTH_EDGE_RADIUS is 0.5, so this ramps across one pixel.
+  color.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+  if (
+    varyings.vPathPosition.y < varyings.vPathBounds.x ||
+    varyings.vPathPosition.y > varyings.vPathBounds.y
+  ) {
+#else
+  if (
+    varyings.vPathPosition.y < 0.0 ||
+    varyings.vPathPosition.y > varyings.vPathLength
+  ) {
+#endif
+    if (varyings.vJointType > 0.5 && length(varyings.vCornerOffset) > 1.0) {
+      discard;
+    }
+    if (
+      varyings.vJointType < 0.5 &&
+      varyings.vMiterLength > path.miterLimit + 1.0
+    ) {
+      discard;
+    }
+  }
+#endif
+
+  // Fragment-layer injections that discard pixels must run after analytic coverage derivatives.
+  // See TripsLayer, which rejects fragments outside of the active time window at this anchor.
+  // DECKGL_FILTER_COLOR
+  clip_filterColor(varyings.clipCoordinates);
+#ifdef ANTIALIASING
+  return deckgl_premultiplied_alpha(color);
+#else
+  return deckgl_premultiplied_alpha(varyings.vColor);
+#endif
+}
+`;var Ui=`#version 300 es
+#define SHADER_NAME path-layer-vertex-shader
+in vec2 positions;
+in float instanceTypes;
+in vec3 instanceStartPositions;
+in vec3 instanceEndPositions;
+in vec3 instanceLeftPositions;
+in vec3 instanceRightPositions;
+in vec3 instanceLeftPositions64Low;
+in vec3 instanceStartPositions64Low;
+in vec3 instanceEndPositions64Low;
+in vec3 instanceRightPositions64Low;
+in float instanceStrokeWidths;
+in vec4 instanceColors;
+in float rowIndexes;
+uniform float opacity;
+out vec4 vColor;
+out vec2 vCornerOffset;
+out float vMiterLength;
+out vec2 vPathPosition;
+out float vPathLength;
+out float vJointType;
+#ifdef DASH_ENABLED
+out vec2 vPathBounds;
+#endif
+const float EPSILON = 0.001;
+const vec3 ZERO_OFFSET = vec3(0.0);
+float flipIfTrue(bool flag) {
+return -(float(flag) * 2. - 1.);
+}
+vec3 getLineJoinOffset(
+vec3 prevPoint, vec3 currPoint, vec3 nextPoint,
+vec2 width
+#ifdef DASH_ENABLED
+, float sourcePathLength, vec2 sourcePathRange
+#endif
+#ifdef ANTIALIASING
+, float coverageScale
+#endif
+) {
+bool isEnd = positions.x > 0.0;
+float sideOfPath = positions.y;
+float isJoint = float(sideOfPath == 0.0);
+vec3 deltaA3 = (currPoint - prevPoint);
+vec3 deltaB3 = (nextPoint - currPoint);
+mat3 rotationMatrix;
+bool needsRotation = !path.billboard && project_needs_rotation(currPoint, rotationMatrix);
+if (needsRotation) {
+deltaA3 = deltaA3 * rotationMatrix;
+deltaB3 = deltaB3 * rotationMatrix;
+}
+vec2 deltaA = deltaA3.xy / width;
+vec2 deltaB = deltaB3.xy / width;
+float lenA = length(deltaA);
+float lenB = length(deltaB);
+vec2 dirA = lenA > 0. ? normalize(deltaA) : vec2(0.0, 0.0);
+vec2 dirB = lenB > 0. ? normalize(deltaB) : vec2(0.0, 0.0);
+vec2 perpA = vec2(-dirA.y, dirA.x);
+vec2 perpB = vec2(-dirB.y, dirB.x);
+vec2 tangent = dirA + dirB;
+tangent = length(tangent) > 0. ? normalize(tangent) : perpA;
+vec2 miterVec = vec2(-tangent.y, tangent.x);
+vec2 dir = isEnd ? dirA : dirB;
+vec2 perp = isEnd ? perpA : perpB;
+float L = isEnd ? lenA : lenB;
+#ifdef DASH_ENABLED
+vec3 currDelta3 = isEnd ? deltaA3 : deltaB3;
+float currLength2D = length(currDelta3.xy);
+float arcLengthRatio = 1.0;
+float pathPositionOffset = 0.0;
+float pathLength = L;
+if (path.billboard) {
+float visiblePathLength = sourcePathLength * (sourcePathRange.y - sourcePathRange.x);
+arcLengthRatio = L > 0.0 ? visiblePathLength / L : 0.0;
+pathPositionOffset = sourcePathLength * sourcePathRange.x;
+pathLength = sourcePathLength;
+} else if (currLength2D > 0.0) {
+arcLengthRatio = length(currDelta3) / currLength2D;
+pathLength = L * arcLengthRatio;
+}
+#endif
+float sinHalfA = abs(dot(miterVec, perp));
+float cosHalfA = abs(dot(dirA, miterVec));
+float turnDirection = flipIfTrue(dirA.x * dirB.y >= dirA.y * dirB.x);
+float cornerPosition = sideOfPath * turnDirection;
+float miterSize = 1.0 / max(sinHalfA, EPSILON);
+miterSize = mix(
+min(miterSize, max(lenA, lenB) / max(cosHalfA, EPSILON)),
+miterSize,
+step(0.0, cornerPosition)
+);
+vec2 offsetVec = mix(miterVec * miterSize, perp, step(0.5, cornerPosition))
+* (sideOfPath + isJoint * turnDirection);
+bool isStartCap = lenA == 0.0 || (!isEnd && (instanceTypes == 1.0 || instanceTypes == 3.0));
+bool isEndCap = lenB == 0.0 || (isEnd && (instanceTypes == 2.0 || instanceTypes == 3.0));
+bool isCap = isStartCap || isEndCap;
+if (isCap) {
+offsetVec = mix(perp * sideOfPath, dir * path.capType * 4.0 * flipIfTrue(isStartCap), isJoint);
+vJointType = path.capType;
+} else {
+vJointType = path.jointType;
+}
+#ifdef ANTIALIASING
+vec2 coverageOffsetVec = offsetVec * coverageScale;
+#ifdef DASH_ENABLED
+vPathLength = pathLength;
+#else
+vPathLength = L;
+#endif
+vCornerOffset = coverageOffsetVec;
+vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
+vMiterLength = isCap ? isJoint : vMiterLength;
+vec2 offsetFromStartOfPath = coverageOffsetVec + deltaA * float(isEnd);
+vPathPosition = vec2(
+dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
+dot(offsetFromStartOfPath, dir)
+#endif
+);
+geometry.uv = vPathPosition;
+float isValid = step(instanceTypes, 3.5);
+vec3 offset = vec3(coverageOffsetVec * width * isValid, 0.0);
+#else
+#ifdef DASH_ENABLED
+vPathLength = pathLength;
+#else
+vPathLength = L;
+#endif
+vCornerOffset = offsetVec;
+vMiterLength = dot(vCornerOffset, miterVec * turnDirection);
+vMiterLength = isCap ? isJoint : vMiterLength;
+vec2 offsetFromStartOfPath = vCornerOffset + deltaA * float(isEnd);
+vPathPosition = vec2(
+dot(offsetFromStartOfPath, perp),
+#ifdef DASH_ENABLED
+pathPositionOffset + dot(offsetFromStartOfPath, dir) * arcLengthRatio
+#else
+dot(offsetFromStartOfPath, dir)
+#endif
+);
+geometry.uv = vPathPosition;
+float isValid = step(instanceTypes, 3.5);
+vec3 offset = vec3(offsetVec * width * isValid, 0.0);
+#endif
+if (needsRotation) {
+offset = rotationMatrix * offset;
+}
+return offset;
+}
+void clipLine(inout vec4 position, vec4 refPosition) {
+if (position.w < EPSILON) {
+float r = (EPSILON - refPosition.w) / (position.w - refPosition.w);
+position = refPosition + (position - refPosition) * r;
+}
+}
+#ifdef DASH_ENABLED
+vec2 getClippedPathRange(float startW, float endW) {
+bool startClipped = startW < EPSILON;
+bool endClipped = endW < EPSILON;
+if (startClipped && endClipped) {
+return vec2(0.0);
+}
+if (startClipped || endClipped) {
+float intersection = clamp((EPSILON - startW) / (endW - startW), 0.0, 1.0);
+return startClipped ? vec2(intersection, 1.0) : vec2(0.0, intersection);
+}
+return vec2(0.0, 1.0);
+}
+#endif
+void main() {
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
+vColor = vec4(instanceColors.rgb, instanceColors.a * layer.opacity);
+float isEnd = positions.x;
+vec3 prevPosition = mix(instanceLeftPositions, instanceStartPositions, isEnd);
+vec3 prevPosition64Low = mix(instanceLeftPositions64Low, instanceStartPositions64Low, isEnd);
+vec3 currPosition = mix(instanceStartPositions, instanceEndPositions, isEnd);
+vec3 currPosition64Low = mix(instanceStartPositions64Low, instanceEndPositions64Low, isEnd);
+vec3 nextPosition = mix(instanceEndPositions, instanceRightPositions, isEnd);
+vec3 nextPosition64Low = mix(instanceEndPositions64Low, instanceRightPositions64Low, isEnd);
+geometry.worldPosition = currPosition;
+vec2 widthPixels = vec2(clamp(
+project_size_to_pixel(instanceStrokeWidths * path.widthScale, path.widthUnits),
+path.widthMinPixels, path.widthMaxPixels) / 2.0);
+vec3 width;
+if (path.billboard) {
+#ifdef DASH_ENABLED
+vec4 prevPositionCommon;
+vec4 nextPositionCommon;
+vec4 prevPositionScreen = project_position_to_clipspace(
+prevPosition, prevPosition64Low, ZERO_OFFSET, prevPositionCommon
+);
+#else
+vec4 prevPositionScreen = project_position_to_clipspace(
+prevPosition, prevPosition64Low, ZERO_OFFSET
+);
+#endif
+vec4 currPositionScreen = project_position_to_clipspace(currPosition, currPosition64Low, ZERO_OFFSET, geometry.position);
+#ifdef DASH_ENABLED
+vec4 nextPositionScreen = project_position_to_clipspace(
+nextPosition, nextPosition64Low, ZERO_OFFSET, nextPositionCommon
+);
+#else
+vec4 nextPositionScreen = project_position_to_clipspace(
+nextPosition, nextPosition64Low, ZERO_OFFSET
+);
+#endif
+#ifdef DASH_ENABLED
+vec4 sourcePathStartScreen = mix(currPositionScreen, prevPositionScreen, isEnd);
+vec4 sourcePathEndScreen = mix(nextPositionScreen, currPositionScreen, isEnd);
+vec2 billboardPathRange = getClippedPathRange(
+sourcePathStartScreen.w, sourcePathEndScreen.w
+);
+#endif
+clipLine(prevPositionScreen, currPositionScreen);
+clipLine(nextPositionScreen, currPositionScreen);
+clipLine(currPositionScreen, mix(nextPositionScreen, prevPositionScreen, isEnd));
+width = vec3(widthPixels, 0.0);
+DECKGL_FILTER_SIZE(width, geometry);
+#ifdef ANTIALIASING
+vec2 coveragePadding = vec2(0.5 / project.devicePixelRatio);
+float coverageScale = length(width.xy) > 0.0
+? length(width.xy + coveragePadding) / length(width.xy)
+: 1.0;
+#endif
+#ifdef DASH_ENABLED
+vec3 currentDeltaCommon = isEnd > 0.0
+? geometry.position.xyz - prevPositionCommon.xyz
+: nextPositionCommon.xyz - geometry.position.xyz;
+float billboardPathLength = width.x > 0.0
+? length(currentDeltaCommon) * project.scale / (width.x * project.focalDistance)
+: 0.0;
+#endif
+vec3 offset = getLineJoinOffset(
+prevPositionScreen.xyz / prevPositionScreen.w,
+currPositionScreen.xyz / currPositionScreen.w,
+nextPositionScreen.xyz / nextPositionScreen.w,
+project_pixel_size_to_clipspace(width.xy)
+#ifdef DASH_ENABLED
+,
+billboardPathLength, billboardPathRange
+#endif
+#ifdef ANTIALIASING
+,
+coverageScale
+#endif
+);
+#ifdef DASH_ENABLED
+vPathBounds = billboardPathLength * billboardPathRange;
+#endif
+DECKGL_FILTER_GL_POSITION(currPositionScreen, geometry);
+gl_Position = vec4(currPositionScreen.xyz + offset * currPositionScreen.w, currPositionScreen.w);
+} else {
+prevPosition = project_position(prevPosition, prevPosition64Low);
+currPosition = project_position(currPosition, currPosition64Low);
+nextPosition = project_position(nextPosition, nextPosition64Low);
+width = vec3(project_pixel_size(widthPixels), 0.0);
+DECKGL_FILTER_SIZE(width, geometry);
+#ifdef ANTIALIASING
+vec2 coveragePadding = project_pixel_size(vec2(0.5 / project.devicePixelRatio));
+float coverageScale = length(width.xy) > 0.0
+? length(width.xy + coveragePadding) / length(width.xy)
+: 1.0;
+#endif
+vec3 offset = getLineJoinOffset(
+prevPosition, currPosition, nextPosition, width.xy
+#ifdef DASH_ENABLED
+, 1.0, vec2(0.0, 1.0)
+#endif
+#ifdef ANTIALIASING
+, coverageScale
+#endif
+);
+#ifdef DASH_ENABLED
+vPathBounds = vec2(0.0, vPathLength);
+#endif
+geometry.position = vec4(currPosition + offset, 1.0);
+gl_Position = project_common_position_to_clipspace(geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var Vi=`#version 300 es
+#define SHADER_NAME path-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+in vec2 vCornerOffset;
+in float vMiterLength;
+in vec2 vPathPosition;
+in float vPathLength;
+in float vJointType;
+#ifdef DASH_ENABLED
+in vec2 vPathBounds;
+#endif
+out vec4 fragColor;
+void main(void) {
+geometry.uv = vPathPosition;
+#ifdef ANTIALIASING
+#ifdef DASH_ENABLED
+bool isCorner = vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y;
+#else
+bool isCorner = vPathPosition.y < 0.0 || vPathPosition.y > vPathLength;
+#endif
+bool isRound = vJointType > 0.5;
+float bodyCoord = abs(vPathPosition.x);
+float cornerCoord = length(vCornerOffset);
+float bodyPixels = (1.0 - bodyCoord) / max(fwidth(bodyCoord), 1e-6);
+float cornerPixels = (1.0 - cornerCoord) / max(fwidth(cornerCoord), 1e-6);
+#ifdef PATH_STYLE_OFFSET
+float edgePixels = isRound && isCorner ? min(cornerPixels, bodyPixels) : bodyPixels;
+#else
+float edgePixels = isRound && isCorner ? cornerPixels : bodyPixels;
+#endif
+if (edgePixels <= -SMOOTH_EDGE_RADIUS) {
+discard;
+}
+if (isCorner) {
+if (!isRound && vMiterLength > path.miterLimit + 1.0) {
+discard;
+}
+}
+fragColor = vColor;
+fragColor.a *= smoothedge(0.0, edgePixels);
+#else
+#ifdef DASH_ENABLED
+if (vPathPosition.y < vPathBounds.x || vPathPosition.y > vPathBounds.y) {
+#else
+if (vPathPosition.y < 0.0 || vPathPosition.y > vPathLength) {
+#endif
+if (vJointType > 0.5 && length(vCornerOffset) > 1.0) {
+discard;
+}
+if (vJointType < 0.5 && vMiterLength > path.miterLimit + 1.0) {
+discard;
+}
+}
+fragColor = vColor;
+#endif
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var Zi=[0,0,0,255];var Ps={widthUnits:`meters`,widthScale:{type:`number`,min:0,value:1},widthMinPixels:{type:`number`,min:0,value:0},widthMaxPixels:{type:`number`,min:0,value:Number.MAX_SAFE_INTEGER},jointRounded:!1,capRounded:!1,miterLimit:{type:`number`,min:0,value:4},antialiasing:!1,billboard:!1,_pathType:null,getPath:{type:`accessor`,value:t=>t.path},getColor:{type:`accessor`,value:Zi},getWidth:{type:`accessor`,value:1},rounded:{deprecatedFor:[`jointRounded`,`capRounded`]}};var vt={enter:(t,o)=>o.length?o.subarray(o.length-t.length):t};function _s(t){if(t.isGeospatial)return null;let{unitsPerMeter:o}=t.distanceScales;return[o[0],o[1],o[2]]}function Hi(t,o){return t===o||!!(t&&o&&t.length===o.length&&t.every((e,i)=>e===o[i]))}var _e=(()=>{class t extends en$1{getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:Ui,fs:Vi,source:Wi,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,ji,...this.context.device.type===`webgpu`?[ie]:[]]})}get wrapLongitude(){return!1}getBounds(){return this.context.device.type===`webgpu`?null:this.getAttributeManager()?.getBounds([`vertexPositions`])}getPathProjectionScale(e){let i=this.props.coordinateSystem;if(!!!this.getAttributeManager()?.getAttributes().instanceDashOffsets)return null;if(e instanceof se&&e.zoom>=12&&(i==="default"||i===`lnglat`||i===`cartesian`)){let a=oe$1.getUniforms({viewport:e,coordinateSystem:i,coordinateOrigin:this.props.coordinateOrigin,autoWrapLongitude:this.wrapLongitude});return[e.projectionMode,a.coordinateOrigin[1],a.commonOrigin[1],...a.commonUnitsPerWorldUnit,...a.commonUnitsPerWorldUnit2,a.commonUnitsPerMeter[2]]}let r=_s(e);return r?[e.projectionMode,...r]:[e.projectionMode]}shouldUpdateState(e){let{viewport:i}=this.context;return super.shouldUpdateState(e)||this.state?.tessellationResolution!==i.resolution||!Hi(this.state?.pathProjectionScale,this.getPathProjectionScale(i))}initializeState(){let i=this.context.device.type===`webgpu`;this.getAttributeManager().addInstanced(s(r({},i?{pathPositions:{size:24,type:`float32`,transition:!1,accessor:`getPath`,update:this.calculateWebGPUPositions,shaderAttributes:{instanceLeftPositions:{size:3,elementOffset:0},instanceStartPositions:{size:3,elementOffset:3},instanceEndPositions:{size:3,elementOffset:6},instanceRightPositions:{size:3,elementOffset:9},instanceLeftPositions64Low:{size:3,elementOffset:12},instanceStartPositions64Low:{size:3,elementOffset:15},instanceEndPositions64Low:{size:3,elementOffset:18},instanceRightPositions64Low:{size:3,elementOffset:21}},noAlloc:!0}}:{vertexPositions:{size:3,vertexOffset:1,type:`float64`,fp64:this.use64bitPositions(),transition:vt,accessor:`getPath`,update:this.calculatePositions,noAlloc:!0,shaderAttributes:{instanceLeftPositions:{vertexOffset:0},instanceStartPositions:{vertexOffset:1},instanceEndPositions:{vertexOffset:2},instanceRightPositions:{vertexOffset:3}}}}),{instanceTypes:{size:1,type:i?`float32`:`uint8`,update:this.calculateSegmentTypes,noAlloc:!0},instanceStrokeWidths:{size:1,accessor:`getWidth`,transition:i?!1:vt,defaultValue:1,bufferGroup:`path-instance-data`},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,accessor:`getColor`,transition:i?!1:vt,defaultValue:Zi,bufferGroup:`path-instance-data`},rowIndexes:{size:1,type:`uint32`,accessor:(s,{index:r})=>s&&s.__source?s.__source.index:r,bufferGroup:`path-instance-data`}})),this.setState({pathTesselator:new Ue({fp64:this.use64bitPositions(),isWebGPU:i}),tessellationResolution:this.context.viewport.resolution,pathProjectionScale:this.getPathProjectionScale(this.context.viewport)})}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e,r=this.getAttributeManager(),{viewport:a}=this.context,l=this.state.tessellationResolution!==a.resolution,c=this.getPathProjectionScale(a),f=!Hi(this.state.pathProjectionScale,c),u=s.updateTriggersChanged&&(s.updateTriggersChanged.all||s.updateTriggersChanged.getPath)||i._pathType!==n._pathType||i.positionFormat!==n.positionFormat||i.wrapLongitude!==n.wrapLongitude||l;if(s.dataChanged||u){let{pathTesselator:g}=this.state,h=i.data.attributes||{};g.updateGeometry({data:i.data,geometryBuffer:h.getPath,buffers:h,normalize:!i._pathType,loop:i._pathType===`loop`,getGeometry:i.getPath,positionFormat:i.positionFormat,wrapLongitude:i.wrapLongitude,resolution:a.resolution,dataChanged:u?void 0:s.dataChanged}),this.setState({numInstances:g.instanceCount,startIndices:g.vertexStarts,tessellationResolution:a.resolution,pathProjectionScale:c}),!s.dataChanged||u?r.invalidateAll():f&&r.invalidate(`instanceDashOffsets`)}else f&&(this.setState({pathProjectionScale:c}),r.invalidate(`instanceDashOffsets`));(s.extensionsChanged||i.antialiasing!==n.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),r.invalidateAll())}getPickingInfo(e){let i=super.getPickingInfo(e),{index:n}=i,s=this.props.data;return s[0]&&s[0].__source&&(i.object=s.find(r=>r.__source.index===n)),i}disablePickingIndex(e){let i=this.props.data;if(i[0]&&i[0].__source)for(let n=0;n<i.length;n++)i[n].__source.index===e&&this._disablePickingIndex(n);else super.disablePickingIndex(e)}draw({uniforms:e}){let{jointRounded:i,capRounded:n,billboard:s,miterLimit:r,widthUnits:a,widthScale:l,widthMinPixels:c,widthMaxPixels:f}=this.props,d=this.state.model,u={jointType:Number(i),capType:Number(n),billboard:s,widthUnits:ee[a],widthScale:l,miterLimit:r,widthMinPixels:c,widthMaxPixels:f};d.shaderInputs.setProps({path:u}),d.draw(this.context.renderPass)}_getModel(){return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-list`,attributes:{indices:new Uint16Array([0,1,2,1,4,2,1,3,4,3,5,4]),positions:{value:new Float32Array([0,0,0,-1,0,1,1,-1,1,1,1,0]),size:2}}}),isInstanced:!0}))}calculatePositions(e){let{pathTesselator:i}=this.state;e.startIndices=i.vertexStarts,e.value=i.get(`positions`)}calculateSegmentTypes(e){let{pathTesselator:i}=this.state;e.startIndices=i.vertexStarts,e.value=i.get(`segmentTypes`)}calculateWebGPUPositions(e){let{pathTesselator:i}=this.state,n=i.get(`positions`);if(!n){e.value=null;return}let s=i.instanceCount,r=new Float32Array(s*24),a=[-1,0,1,2];for(let l=0;l<s;l++){let c=l*24;for(let f=0;f<4;f++){let d=l+a[f],u=c+f*3;for(let p=0;p<3;p++){let g=d>=0&&d<s?n[d*3+p]:0,h=Math.fround(g);r[u+p]=h,r[u+p+12]=g-h}}}e.startIndices=i.vertexStarts,e.value=r}}return t.defaultProps=Ps,t.layerName=`PathLayer`,t})();var io=x(Xi(),1);var $e=oe.CLOCKWISE;var qi=oe.COUNTER_CLOCKWISE;var $={isClosed:!0};function Ns(t){if(t=t&&t.positions||t,!Array.isArray(t)&&!ArrayBuffer.isView(t))throw new Error(`invalid polygon`)}function re(t){return`positions`in t?t.positions:t}function be(t){return`holeIndices`in t?t.holeIndices:null}function Gs(t){return Array.isArray(t[0])}function Bs(t){return t.length>=1&&t[0].length>=2&&Number.isFinite(t[0][0])}function js(t){let o=t[0],e=t[t.length-1];return o[0]===e[0]&&o[1]===e[1]&&o[2]===e[2]}function Ws(t,o,e,i){for(let n=0;n<o;n++)if(t[e+n]!==t[i-o+n])return!1;return!0}function Qi(t,o,e,i,n){let s=o,r=e.length;for(let a=0;a<r;a++)for(let l=0;l<i;l++)t[s++]=e[a][l]||0;if(!js(e))for(let a=0;a<i;a++)t[s++]=e[0][a]||0;return $.start=o,$.end=s,$.size=i,J(t,n,$),s}function eo(t,o,e,i,n=0,s,r){s=s||e.length;let a=s-n;if(a<=0)return o;let l=o;for(let c=0;c<a;c++)t[l++]=e[n+c];if(!Ws(e,i,n,s))for(let c=0;c<i;c++)t[l++]=e[n+c];return $.start=o,$.end=l,$.size=i,J(t,r,$),l}function Je(t,o){Ns(t);let e=[],i=[];if(`positions`in t){let{positions:n,holeIndices:s}=t;if(s){let r=0;for(let a=0;a<=s.length;a++)r=eo(e,r,n,o,s[a-1],s[a],a===0?$e:qi),i.push(r);return i.pop(),{positions:e,holeIndices:i}}t=n}if(!Gs(t))return eo(e,0,t,o,0,e.length,$e),e;if(!Bs(t)){let n=0;for(let[s,r]of t.entries())n=Qi(e,n,r,o,s===0?$e:qi),i.push(n);return i.pop(),{positions:e,holeIndices:i}}return Qi(e,0,t,o,$e),e}function Ct(t,o,e){let i=t.length/3,n=0;for(let s=0;s<i;s++){let r=(s+1)%i;n+=t[s*3+o]*t[r*3+e],n-=t[r*3+o]*t[s*3+e]}return Math.abs(n/2)}function to(t,o,e,i){let n=t.length/3;for(let s=0;s<n;s++){let r=s*3,a=t[r+0],l=t[r+1],c=t[r+2];t[r+o]=a,t[r+e]=l,t[r+i]=c}}function oo(t,o,e,i){let n=be(t);n&&(n=n.map(a=>a/o));let s=re(t),r=i&&o===3;if(e){let a=s.length;s=s.slice();let l=[];for(let c=0;c<a;c+=o){l[0]=s[c],l[1]=s[c+1],r&&(l[2]=s[c+2]);let f=e(l);s[c]=f[0],s[c+1]=f[1],r&&(s[c+2]=f[2])}}if(r){let a=Ct(s,0,1),l=Ct(s,0,2),c=Ct(s,1,2);if(!a&&!l&&!c)return[];a>l&&a>c||(l>c?(e||(s=s.slice()),to(s,0,2,1)):(e||(s=s.slice()),to(s,2,0,1)))}return(0,io.default)(s,n,o)}var Ye=class extends an{constructor(o){let{fp64:e,IndexType:i=Uint32Array}=o;super(s(r({},o),{attributes:{positions:{size:3,type:e?Float64Array:Float32Array},vertexValid:{type:Uint16Array,size:1},indices:{type:i,size:1}}}))}get(o){let{attributes:e}=this;return o===`indices`?e.indices&&e.indices.subarray(0,this.vertexCount):e[o]}updateGeometry(o){super.updateGeometry(o);let e=this.buffers.indices;if(e)this.vertexCount=(e.value||e).length;else if(this.data&&!this.getGeometry)throw new Error(`missing indices buffer`)}normalizeGeometry(o){if(this.normalize){let e=Je(o,this.positionSize);return this.opts.resolution?ye(re(e),be(e),{size:this.positionSize,gridResolution:this.opts.resolution,edgeTypes:!0}):this.opts.wrapLongitude?ht(re(e),be(e),{size:this.positionSize,maxLatitude:86,edgeTypes:!0}):e}return o}getGeometrySize(o){if(so(o)){let e=0;for(let i of o)e+=this.getGeometrySize(i);return e}return re(o).length/this.positionSize}getGeometryFromBuffer(o){return this.normalize||!this.buffers.indices?super.getGeometryFromBuffer(o):null}updateGeometryAttributes(o,e){if(o&&so(o))for(let i of o){let n=this.getGeometrySize(i);e.geometrySize=n,this.updateGeometryAttributes(i,e),e.vertexStart+=n,e.indexStart=this.indexStarts[e.geometryIndex+1]}else{let i=o;this._updateIndices(i,e),this._updatePositions(i,e),this._updateVertexValid(i,e)}}_updateIndices(o,{geometryIndex:e,vertexStart:i,indexStart:n}){let{attributes:s,indexStarts:r,typedArrayManager:a}=this,l=s.indices;if(!l||!o)return;let c=n,f=oo(o,this.positionSize,this.opts.preproject,this.opts.full3d);l=a.allocate(l,n+f.length,{copy:!0});for(let d=0;d<f.length;d++)l[c++]=f[d]+i;r[e+1]=n+f.length,s.indices=l}_updatePositions(o,{vertexStart:e,geometrySize:i}){let{attributes:{positions:n},positionSize:s}=this;if(!n||!o)return;let r=re(o);for(let a=e,l=0;l<i;a++,l++){let c=r[l*s],f=r[l*s+1],d=s>2?r[l*s+2]:0;n[a*3]=c,n[a*3+1]=f,n[a*3+2]=d}}_updateVertexValid(o,{vertexStart:e,geometrySize:i}){let{positionSize:n}=this,s=this.attributes.vertexValid,r=o&&be(o);if(o&&o.edgeTypes?s.set(o.edgeTypes,e):s.fill(1,e,e+i),r)for(let a=0;a<r.length;a++)s[e+r[a]/n-1]=0;s[e+i-1]=0}};function so(t){return Array.isArray(t)&&t.length>0&&!Number.isFinite(t[0])}var Us=`struct SolidPolygonUniforms {
+  extruded: f32,
+  isWireframe: f32,
+  elevationScale: f32,
+};
+
+@group(0) @binding(auto) var<uniform> solidPolygon: SolidPolygonUniforms;
+`;var ro=`layout(std140) uniform solidPolygonUniforms {
+  bool extruded;
+  bool isWireframe;
+  float elevationScale;
+} solidPolygon;
+`;var ao={name:`solidPolygon`,source:Us,vs:ro,fs:ro,uniformTypes:{extruded:`f32`,isWireframe:`f32`,elevationScale:`f32`}};var Xe=`in vec4 fillColors;
+in vec4 lineColors;
+in float rowIndexes;
+out vec4 vColor;
+struct PolygonProps {
+vec3 positions;
+vec3 positions64Low;
+vec3 normal;
+float elevations;
+};
+vec3 project_offset_normal(vec3 vector) {
+if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSETS) {
+return normalize(vector * project.commonUnitsPerWorldUnit);
+}
+return project_normal(vector);
+}
+void calculatePosition(PolygonProps props) {
+vec3 pos = props.positions;
+vec3 pos64Low = props.positions64Low;
+vec3 normal = props.normal;
+vec4 colors = solidPolygon.isWireframe ? lineColors : fillColors;
+geometry.worldPosition = props.positions;
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
+if (solidPolygon.extruded) {
+pos.z += props.elevations * solidPolygon.elevationScale;
+}
+gl_Position = project_position_to_clipspace(pos, pos64Low, vec3(0.), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+if (solidPolygon.extruded) {
+#ifdef IS_SIDE_VERTEX
+normal = project_offset_normal(normal);
+#else
+normal = project_normal(normal);
+#endif
+geometry.normal = normal;
+vec3 lightColor = lighting_getLightColor(colors.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+vColor = vec4(lightColor, colors.a * layer.opacity);
+} else {
+vColor = vec4(colors.rgb, colors.a * layer.opacity);
+}
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;var lo=`#version 300 es
+#define SHADER_NAME solid-polygon-layer-vertex-shader
+in vec3 vertexPositions;
+in vec3 vertexPositions64Low;
+in float elevations;
+${Xe}
+void main(void) {
+PolygonProps props;
+props.positions = vertexPositions;
+props.positions64Low = vertexPositions64Low;
+props.elevations = elevations;
+props.normal = vec3(0.0, 0.0, 1.0);
+calculatePosition(props);
+}
+`;var co=`#version 300 es
+#define SHADER_NAME solid-polygon-layer-vertex-shader-side
+#define IS_SIDE_VERTEX
+in vec2 positions;
+in vec3 vertexPositions;
+in vec3 nextVertexPositions;
+in vec3 vertexPositions64Low;
+in vec3 nextVertexPositions64Low;
+in float elevations;
+in float instanceVertexValid;
+${Xe}
+void main(void) {
+if(instanceVertexValid < 0.5){
+gl_Position = vec4(0.);
+return;
+}
+PolygonProps props;
+vec3 pos;
+vec3 pos64Low;
+vec3 nextPos;
+vec3 nextPos64Low;
+#if RING_WINDING_ORDER_CW == 1
+pos = vertexPositions;
+pos64Low = vertexPositions64Low;
+nextPos = nextVertexPositions;
+nextPos64Low = nextVertexPositions64Low;
+#else
+pos = nextVertexPositions;
+pos64Low = nextVertexPositions64Low;
+nextPos = vertexPositions;
+nextPos64Low = vertexPositions64Low;
+#endif
+props.positions = mix(pos, nextPos, positions.x);
+props.positions64Low = mix(pos64Low, nextPos64Low, positions.x);
+props.normal = vec3(
+pos.y - nextPos.y + (pos64Low.y - nextPos64Low.y),
+nextPos.x - pos.x + (nextPos64Low.x - pos64Low.x),
+0.0);
+props.elevations = elevations * positions.y;
+calculatePosition(props);
+}
+`;var fo=`#version 300 es
+#define SHADER_NAME solid-polygon-layer-fragment-shader
+precision highp float;
+in vec4 vColor;
+out vec4 fragColor;
+void main(void) {
+fragColor = vColor;
+geometry.uv = vec2(0.);
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;function uo(){return`fn project_offset_normal(vector: vec3<f32>) -> vec3<f32> {
+  if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
+      project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT_OFFSETS) {
+    return normalize(vector * project.commonUnitsPerWorldUnit);
+  }
+  return project_normal(vector);
+}
+
+fn apply_polygon_color(
+  colors: vec4<f32>,
+  normal: vec3<f32>,
+  position: vec4<f32>
+) -> vec4<f32> {
+  if (solidPolygon.extruded > 0.5) {
+    let lightColor = lighting_getLightColor2(
+      colors.rgb,
+      project.cameraPosition,
+      position.xyz,
+      normal
+    );
+    return vec4<f32>(lightColor, colors.a * layer.opacity);
+  }
+  return vec4<f32>(colors.rgb, colors.a * layer.opacity);
+}
+`}function po(){return`@fragment
+fn fragmentMain(inp: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = vec2<f32>(0.0, 0.0);
+
+  clip_filterColor(inp.clipCoordinates);
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(inp.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(inp.pickingColor, 1.0);
+  }
+
+  var fragColor = inp.vColor;
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(inp.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  return deckgl_premultiplied_alpha(fragColor);
+}
+`}function Vs(){return`${uo()}
+
+struct Attributes {
+  @location(0) vertexPositions: vec3<f32>,
+  @location(1) vertexPositions64Low: vec3<f32>,
+  @location(2) elevations: f32,
+  @location(3) fillColors: vec4<f32>,
+  @location(4) lineColors: vec4<f32>,
+  @location(5) rowIndexes: u32,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) pickingColor: vec3<f32>,
+  @location(2) clipCoordinates: vec2<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var outp: Varyings;
+
+  var pos = attributes.vertexPositions;
+  if (solidPolygon.extruded > 0.5) {
+    pos.z += attributes.elevations * solidPolygon.elevationScale;
+  }
+
+  geometry.worldPosition = attributes.vertexPositions;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.rowIndexes);
+
+  let projectedPosition = project_position_to_clipspace_and_commonspace(
+    pos,
+    attributes.vertexPositions64Low,
+    vec3<f32>(0.0)
+  );
+  geometry.position = projectedPosition.commonPosition;
+  outp.position = projectedPosition.clipPosition;
+
+  let normal = project_normal(vec3<f32>(0.0, 0.0, 1.0));
+  geometry.normal = normal;
+
+  let colors = select(
+    attributes.fillColors,
+    attributes.lineColors,
+    solidPolygon.isWireframe > 0.5
+  );
+  outp.vColor = apply_polygon_color(colors, normal, geometry.position);
+  outp.pickingColor = geometry.pickingColor;
+
+  outp.clipCoordinates = geometry.position.xy;
+  clip_filterPosition(&outp.position, geometry.worldPosition.xy);
+
+  return outp;
+}
+
+${po()}
+`}function Hs(t){return`const RING_WINDING_ORDER_CW: bool = ${t?`true`:`false`};
+
+${uo()}
+
+struct Attributes {
+  @location(0) positions: vec2<f32>,
+  @location(1) vertexPositions: vec3<f32>,
+  @location(2) vertexPositions64Low: vec3<f32>,
+  @location(3) nextVertexPositions: vec3<f32>,
+  @location(4) nextVertexPositions64Low: vec3<f32>,
+  @location(5) vertexValid: f32,
+  @location(6) elevations: f32,
+  @location(7) fillColors: vec4<f32>,
+  @location(8) lineColors: vec4<f32>,
+  @location(9) rowIndexes: u32,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) pickingColor: vec3<f32>,
+  @location(2) clipCoordinates: vec2<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var outp: Varyings;
+  outp.position = vec4<f32>(0.0);
+  outp.vColor = vec4<f32>(0.0);
+  outp.pickingColor = picking_getPickingColorFromIndex(attributes.rowIndexes);
+  outp.clipCoordinates = vec2<f32>(0.0);
+
+  if (attributes.vertexValid < 0.5) {
+    return outp;
+  }
+
+  let pos = select(attributes.nextVertexPositions, attributes.vertexPositions, RING_WINDING_ORDER_CW);
+  let pos64Low = select(
+    attributes.nextVertexPositions64Low,
+    attributes.vertexPositions64Low,
+    RING_WINDING_ORDER_CW
+  );
+  let nextPos = select(attributes.vertexPositions, attributes.nextVertexPositions, RING_WINDING_ORDER_CW);
+  let nextPos64Low = select(
+    attributes.vertexPositions64Low,
+    attributes.nextVertexPositions64Low,
+    RING_WINDING_ORDER_CW
+  );
+
+  let position = mix(pos, nextPos, attributes.positions.x);
+  let position64Low = mix(pos64Low, nextPos64Low, attributes.positions.x);
+
+  var worldPosition = position;
+  if (solidPolygon.extruded > 0.5) {
+    worldPosition.z += attributes.elevations * attributes.positions.y * solidPolygon.elevationScale;
+  }
+
+  geometry.worldPosition = position;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.rowIndexes);
+
+  let projectedPosition = project_position_to_clipspace_and_commonspace(
+    worldPosition,
+    position64Low,
+    vec3<f32>(0.0)
+  );
+  geometry.position = projectedPosition.commonPosition;
+  outp.position = projectedPosition.clipPosition;
+
+  let normal = project_offset_normal(vec3<f32>(
+    pos.y - nextPos.y + (pos64Low.y - nextPos64Low.y),
+    nextPos.x - pos.x + (nextPos64Low.x - pos64Low.x),
+    0.0
+  ));
+  geometry.normal = normal;
+
+  let colors = select(
+    attributes.fillColors,
+    attributes.lineColors,
+    solidPolygon.isWireframe > 0.5
+  );
+  outp.vColor = apply_polygon_color(colors, normal, geometry.position);
+  outp.pickingColor = geometry.pickingColor;
+
+  outp.clipCoordinates = geometry.position.xy;
+  clip_filterPosition(&outp.position, geometry.worldPosition.xy);
+
+  return outp;
+}
+
+${po()}
+`}function go(t,o){return t===`top`?Vs():Hs(o)}var Qe=[0,0,0,255];var Zs={filled:!0,extruded:!1,wireframe:!1,_normalize:!0,_windingOrder:`CW`,_full3d:!1,elevationScale:{type:`number`,min:0,value:1},getPolygon:{type:`accessor`,value:t=>t.polygon},getElevation:{type:`accessor`,value:1e3},getFillColor:{type:`accessor`,value:Qe},getLineColor:{type:`accessor`,value:Qe},material:!0};var qe={enter:(t,o)=>o.length?o.subarray(o.length-t.length):t};var we=(()=>{class t extends en$1{getShaders(e){let i=!this.props._normalize&&this.props._windingOrder===`CCW`?0:1;return super.getShaders({vs:e===`top`?lo:co,fs:fo,source:go(e,!!i),defines:{RING_WINDING_ORDER_CW:i},modules:[Wa,ma,Zo$1,Ka,ao,...this.context.device.type===`webgpu`?[ie]:[]]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds([`vertexPositions`])}initializeState(){let{viewport:e}=this.context,{coordinateSystem:i}=this.props,{_full3d:n}=this.props;e.isGeospatial&&i==="default"&&(i=`lnglat`);let s$6;i===`lnglat`&&(n?s$6=e.projectPosition.bind(e):s$6=e.projectFlat.bind(e)),this.setState({numInstances:0,polygonTesselator:new Ye({preproject:s$6,fp64:this.use64bitPositions(),IndexType:Uint32Array})});let r$7=this.getAttributeManager(),a=!0,l=this.context.device.type===`webgpu`;r$7.add(s(r({indices:{size:1,isIndexed:!0,update:this.calculateIndices,noAlloc:a},vertexPositions:r({size:3,type:`float64`,stepMode:`dynamic`,fp64:this.use64bitPositions(),transition:qe,accessor:`getPolygon`,update:this.calculatePositions,noAlloc:a},l?{}:{shaderAttributes:{nextVertexPositions:{vertexOffset:1}}})},l?{nextVertexPositions:{size:3,type:`float64`,stepMode:`dynamic`,fp64:this.use64bitPositions(),transition:!1,update:this.calculateNextPositions,noAlloc:a}}:{}),{[l?`vertexValid`:`instanceVertexValid`]:{size:1,type:l?`float32`:`uint16`,stepMode:`instance`,update:this.calculateVertexValid,noAlloc:a},elevations:{size:1,stepMode:`dynamic`,transition:qe,accessor:`getElevation`,bufferGroup:`solid-polygon-instance-data`},fillColors:{size:this.props.colorFormat.length,type:`unorm8`,stepMode:`dynamic`,transition:qe,accessor:`getFillColor`,defaultValue:Qe,bufferGroup:`solid-polygon-instance-data`},lineColors:{size:this.props.colorFormat.length,type:`unorm8`,stepMode:`dynamic`,transition:qe,accessor:`getLineColor`,defaultValue:Qe,bufferGroup:`solid-polygon-instance-data`},rowIndexes:{size:1,type:`uint32`,stepMode:`dynamic`,accessor:(c,{index:f})=>c&&c.__source?c.__source.index:f,bufferGroup:`solid-polygon-instance-data`}}))}getPickingInfo(e){let i=super.getPickingInfo(e),{index:n}=i,s=this.props.data;return s[0]&&s[0].__source&&(i.object=s.find(r=>r.__source.index===n)),i}disablePickingIndex(e){let i=this.props.data;if(i[0]&&i[0].__source)for(let n=0;n<i.length;n++)i[n].__source.index===e&&this._disablePickingIndex(n);else super.disablePickingIndex(e)}draw({uniforms:e}){let{extruded:i,filled:n,wireframe:s$7,elevationScale:r$8}=this.props,{topModel:a,sideModel:l,wireframeModel:c,polygonTesselator:f}=this.state,d={extruded:!!i,elevationScale:r$8,isWireframe:!1};c&&s$7&&(c.setInstanceCount(f.instanceCount-1),c.shaderInputs.setProps({solidPolygon:s(r({},d),{isWireframe:!0})}),c.draw(this.context.renderPass)),l&&n&&(l.setInstanceCount(f.instanceCount-1),l.shaderInputs.setProps({solidPolygon:d}),l.draw(this.context.renderPass)),a&&n&&(a.setVertexCount(f.vertexCount),a.shaderInputs.setProps({solidPolygon:d}),a.draw(this.context.renderPass))}updateState(e){super.updateState(e),this.updateGeometry(e);let{props:i,oldProps:n,changeFlags:s}=e,r=this.getAttributeManager();(s.extensionsChanged||i.filled!==n.filled||i.extruded!==n.extruded)&&(this.state.models?.forEach(l=>l.destroy()),this.setState(this._getModels()),r.invalidateAll())}updateGeometry({props:e,oldProps:i,changeFlags:n}){if(n.dataChanged||n.updateTriggersChanged&&(n.updateTriggersChanged.all||n.updateTriggersChanged.getPolygon)){let{polygonTesselator:r$9}=this.state,a=e.data.attributes||{};r$9.updateGeometry({data:e.data,normalize:e._normalize,geometryBuffer:a.getPolygon,buffers:this.context.device.type===`webgpu`?r({},a):a,getGeometry:e.getPolygon,positionFormat:e.positionFormat,wrapLongitude:e.wrapLongitude,resolution:this.context.viewport.resolution,fp64:this.use64bitPositions(),dataChanged:n.dataChanged,full3d:e._full3d}),this.setState({numInstances:r$9.instanceCount,startIndices:r$9.vertexStarts}),n.dataChanged||this.getAttributeManager().invalidateAll()}}_getModels(){let{id:e,filled:i,extruded:n}=this.props,s$8,r$10,a;if(i){let l=this.getShaders(`top`);l.defines=s(r({},l.defines),{NON_INSTANCED_MODEL:1});let c=this.getAttributeManager().getBufferLayouts({isInstanced:!1});this.context.device.type===`webgpu`&&(c=c.filter(f=>f.name!==`indices`&&f.name!==`vertexValid`&&f.name!==`instanceVertexValid`&&f.name!==`nextVertexPositions`)),s$8=new De$1(this.context.device,s(r({},l),{id:`${e}-top`,topology:`triangle-list`,bufferLayout:c,isIndexed:!0,userData:{excludeAttributes:{vertexValid:!0,instanceVertexValid:!0,nextVertexPositions:!0}}}))}if(n){let l=this.getAttributeManager().getBufferLayouts({isInstanced:!0});this.context.device.type===`webgpu`&&(l=l.filter(c=>c.name!==`indices`)),r$10=new De$1(this.context.device,s(r({},this.getShaders(`side`)),{id:`${e}-side`,bufferLayout:l,geometry:new ne$1({topology:`triangle-strip`,attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,1,1,0,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}})),a=new De$1(this.context.device,s(r({},this.getShaders(`side`)),{id:`${e}-wireframe`,bufferLayout:l,geometry:new ne$1({topology:`line-strip`,attributes:{positions:{size:2,value:new Float32Array([1,0,0,0,0,1,1,1])}}}),isInstanced:!0,userData:{excludeAttributes:{indices:!0}}}))}return{models:[r$10,a,s$8].filter(Boolean),topModel:s$8,sideModel:r$10,wireframeModel:a}}calculateIndices(e){let{polygonTesselator:i}=this.state;e.startIndices=i.indexStarts,e.value=i.get(`indices`)}calculatePositions(e){let{polygonTesselator:i}=this.state;e.startIndices=i.vertexStarts;let n=this.props.data.attributes?.getPolygon;if(this.context.device.type===`webgpu`&&ArrayBuffer.isView(n?.value)){let{value:s,size:r=3,offset:a=0,stride:l}=n,c=a/s.BYTES_PER_ELEMENT,f=l?l/s.BYTES_PER_ELEMENT:r,d=new Float64Array(i.instanceCount*3);for(let u=0;u<i.instanceCount;u++){let p=c+u*f,g=u*3;d[g]=s[p],d[g+1]=s[p+1],d[g+2]=r>2?s[p+2]:0}e.value=d;return}e.value=i.get(`positions`)}calculateVertexValid(e){let i=this.props.data.attributes?.instanceVertexValid?.value,n=this.context.device.type===`webgpu`&&i?i:this.state.polygonTesselator.get(`vertexValid`);e.value=this.context.device.type===`webgpu`&&n?Float32Array.from(n):n}calculateNextPositions(e){let{polygonTesselator:i}=this.state,n=this.getAttributeManager().getAttributes(),s=n.vertexPositions.value,r=this.props.data.attributes?.instanceVertexValid?.value||n.vertexValid?.value||i.get(`vertexValid`);if(e.startIndices=i.vertexStarts,!s){e.value=s;return}let a=s.length/3,l=new s.constructor(s.length);for(let c=0;c<a;c++){let f=c*3,d=r?.[c]&&c+1<a?f+3:f;for(let u=0;u<3;u++)l[f+u]=s[d+u]}e.value=l}}return t.defaultProps=Zs,t.layerName=`SolidPolygonLayer`,t})();function et({data:t,getIndex:o,dataRange:e,replace:i}){let{startRow:n=0,endRow:s=Infinity}=e,r=t.length,a=r,l=r;for(let u=0;u<r;u++){let p=o(t[u]);if(a>u&&p>=n&&(a=u),p>=s){l=u;break}}let c=a,d=l-a!==i.length?t.slice(l):void 0;for(let u=0;u<i.length;u++)t[c++]=i[u];if(d){for(let u=0;u<d.length;u++)t[c++]=d[u];t.length=c}return{startRow:a,endRow:a+i.length}}var ho=[0,0,0,255];var Js={stroked:!0,filled:!0,extruded:!1,elevationScale:1,wireframe:!1,_normalize:!0,_windingOrder:`CW`,lineWidthUnits:`meters`,lineWidthScale:1,lineWidthMinPixels:0,lineWidthMaxPixels:Number.MAX_SAFE_INTEGER,lineJointRounded:!1,lineMiterLimit:4,lineAntialiasing:!1,getPolygon:{type:`accessor`,value:t=>t.polygon},getFillColor:{type:`accessor`,value:[0,0,0,255]},getLineColor:{type:`accessor`,value:ho},getLineWidth:{type:`accessor`,value:1},getElevation:{type:`accessor`,value:1e3},material:!0};var Xs=(()=>{class t extends Dm{initializeState(){this.state={paths:[],pathsDiff:null},this.props.getLineDashArray&&A.removed(`getLineDashArray`,`PathStyleExtension`)()}updateState({changeFlags:e}){let i=e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPolygon);if(i&&Array.isArray(e.dataChanged)){let n=this.state.paths.slice(),s=e.dataChanged.map(r=>et({data:n,getIndex:a=>a.__source.index,dataRange:r,replace:this._getPaths(r)}));this.setState({paths:n,pathsDiff:s})}else i&&this.setState({paths:this._getPaths(),pathsDiff:null})}_getPaths(e={}){let{data:i,getPolygon:n,positionFormat:s,_normalize:r}=this.props,a=[],l=s===`XY`?2:3,{startRow:c,endRow:f}=e,{iterable:d,objectInfo:u}=Ar(i,c,f);for(let p of d){u.index++;let g=n(p,u);r&&(g=Je(g,l));let{holeIndices:h}=g,v=g.positions||g;if(h)for(let P=0;P<=h.length;P++){let C=v.slice(h[P-1]||0,h[P]||v.length);a.push(this.getSubLayerRow({path:C},p,u.index))}else a.push(this.getSubLayerRow({path:v},p,u.index))}return a}renderLayers(){let{data:e,_dataDiff:i,stroked:n,filled:s,extruded:r,wireframe:a,_normalize:l,_windingOrder:c,elevationScale:f,transitions:d,positionFormat:u}=this.props,{lineWidthUnits:p,lineWidthScale:g,lineWidthMinPixels:h,lineWidthMaxPixels:v,lineJointRounded:P,lineMiterLimit:C,lineAntialiasing:m,lineDashJustified:x}=this.props,{getFillColor:L,getLineColor:N,getLineWidth:G,getLineDashArray:j,getElevation:F,getPolygon:U,updateTriggers:D,material:V}=this.props,{paths:W,pathsDiff:H}=this.state,Q=this.getSubLayerClass(`fill`,we),lt=this.getSubLayerClass(`stroke`,_e),k=this.shouldRenderSubLayer(`fill`,W)&&new Q({_dataDiff:i,extruded:r,elevationScale:f,filled:s,wireframe:a,_normalize:l,_windingOrder:c,getElevation:F,getFillColor:L,getLineColor:r&&a?N:ho,material:V,transitions:d},this.getSubLayerProps({id:`fill`,updateTriggers:D&&{getPolygon:D.getPolygon,getElevation:D.getElevation,getFillColor:D.getFillColor,lineColors:r&&a,getLineColor:D.getLineColor}}),{data:e,positionFormat:u,getPolygon:U}),I=!r&&n&&this.shouldRenderSubLayer(`stroke`,W)&&new lt({_dataDiff:H&&(()=>H),widthUnits:p,widthScale:g,widthMinPixels:h,widthMaxPixels:v,jointRounded:P,miterLimit:C,antialiasing:m,dashJustified:x,_pathType:`loop`,transitions:d&&{getWidth:d.getLineWidth,getColor:d.getLineColor,getPath:d.getPolygon},getColor:this.getSubLayerAccessor(N),getWidth:this.getSubLayerAccessor(G),getDashArray:this.getSubLayerAccessor(j)},this.getSubLayerProps({id:`stroke`,updateTriggers:D&&{getWidth:D.getLineWidth,getColor:D.getLineColor,getDashArray:D.getLineDashArray}}),{data:W,positionFormat:u,getPath:ct=>ct.path});return[!r&&k,I,r&&k]}}return t.layerName=`PolygonLayer`,t.defaultProps=Js,t})();function xo(t,o){if(!t)return null;let e=`startIndices`in t?t.startIndices[o]:o,i=t.featureIds.value[e];return e!==-1?qs(t,i,e):null}function qs(t,o,e){let i={properties:r({},t.properties[o])};for(let n in t.numericProps)i.properties[n]=t.numericProps[n].value[e];return i}function vo(t){let o={points:null,lines:null,polygons:null};for(let e in o){let i=t[e].globalFeatureIds.value;o[e]=new Uint32Array(i)}return o}var mo=`layout(std140) uniform sdfUniforms {
+  float gamma;
+  bool enabled;
+  float buffer;
+  float outlineBuffer;
+  vec4 outlineColor;
+} sdf;
+`;var yo={name:`sdf`,vs:mo,fs:mo,uniformTypes:{gamma:`f32`,enabled:`f32`,buffer:`f32`,outlineBuffer:`f32`,outlineColor:`vec4<f32>`}};var Ie={none:0,start:1,center:2,end:3};var tt={name:`text`,vs:`layout(std140) uniform textUniforms {
+  highp vec2 cutoffPixels;
+  highp ivec2 align;
+  highp float fontSize;
+  bool flipY;
+} text;
+
+#define ALIGN_MODE_START ${Ie.start}
+#define ALIGN_MODE_CENTER ${Ie.center}
+#define ALIGN_MODE_END ${Ie.end}
+`,getUniforms:({contentCutoffPixels:t=[0,0],contentAlignHorizontal:o=`none`,contentAlignVertical:e=`none`,fontSize:i,viewport:n})=>({cutoffPixels:t,align:[Ie[o],Ie[e]],fontSize:i,flipY:n?.flipY??!1}),uniformTypes:{cutoffPixels:`vec2<f32>`,align:`vec2<i32>`,fontSize:`f32`,flipY:`f32`}};var Po=`#version 300 es
+#define SHADER_NAME multi-icon-layer-vertex-shader
+in vec2 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in float instanceSizes;
+in float instanceAngles;
+in vec4 instanceColors;
+in float rowIndexes;
+in vec4 instanceIconFrames;
+in float instanceColorModes;
+in vec2 instanceOffsets;
+in vec2 instancePixelOffset;
+in vec4 instanceClipRect;
+out float vColorMode;
+out vec4 vColor;
+out vec2 vTextureCoords;
+out vec2 uv;
+vec2 rotate_by_angle(vec2 vertex, float angle) {
+float angle_radian = angle * PI / 180.0;
+float cos_angle = cos(angle_radian);
+float sin_angle = sin(angle_radian);
+mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle);
+return rotationMatrix * vertex;
+}
+float getPixelOffsetFromAlignment(float anchor, float extent, float clipStart, float clipEnd, int mode) {
+if (clipEnd < clipStart) return 0.0;
+if (mode == ALIGN_MODE_START) {
+return max(- (anchor + clipStart), 0.0);
+}
+if (mode == ALIGN_MODE_CENTER) {
+float _min = max(0., anchor + clipStart);
+float _max = min(extent, anchor + clipEnd);
+return _min < _max ? (_min + _max) / 2.0 - anchor : 0.0;
+}
+if (mode == ALIGN_MODE_END) {
+return min(extent - (anchor + clipEnd), 0.);
+}
+return 0.0;
+}
+void main(void) {
+geometry.worldPosition = instancePositions;
+geometry.uv = positions;
+geometry.pickingColor = picking_getPickingColorFromIndex(rowIndexes);
+uv = positions;
+vec2 iconSize = instanceIconFrames.zw;
+float sizePixels = clamp(
+project_size_to_pixel(instanceSizes * icon.sizeScale, icon.sizeUnits),
+icon.sizeMinPixels, icon.sizeMaxPixels
+);
+float instanceScale = sizePixels / text.fontSize;
+vec2 pixelOffset = positions / 2.0 * iconSize + instanceOffsets;
+pixelOffset = rotate_by_angle(pixelOffset, instanceAngles) * instanceScale;
+pixelOffset += instancePixelOffset;
+pixelOffset.y *= -1.0;
+vec2 anchorPosScreen;
+if (icon.billboard)  {
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+anchorPosScreen = gl_Position.xy / gl_Position.w;
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vec3 offset = vec3(pixelOffset, 0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+} else {
+vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0);
+if (text.flipY) {
+offset_common.y *= -1.;
+}
+DECKGL_FILTER_SIZE(offset_common, geometry);
+vec4 anchorPos = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0));
+anchorPosScreen = anchorPos.xy / anchorPos.w;
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+anchorPosScreen = vec2(anchorPosScreen.x + 1.0, 1.0 - anchorPosScreen.y) / 2.0 * project.viewportSize / project.devicePixelRatio;
+vec2 xy = project_size_to_pixel(instanceClipRect.xy);
+vec2 wh = project_size_to_pixel(instanceClipRect.zw);
+if (text.flipY) {
+xy.y = -xy.y - wh.y;
+}
+if (text.align.x > 0 || text.align.y > 0) {
+vec2 viewportPixels = project.viewportSize / project.devicePixelRatio;
+vec2 scrollPixels = vec2(
+getPixelOffsetFromAlignment(anchorPosScreen.x, viewportPixels.x, xy.x, xy.x + wh.x, text.align.x),
+-getPixelOffsetFromAlignment(anchorPosScreen.y, viewportPixels.y, -xy.y - wh.y, -xy.y, text.align.y)
+);
+pixelOffset += scrollPixels;
+gl_Position.xy += project_pixel_size_to_clipspace(scrollPixels);
+}
+if (instanceClipRect.z >= 0.) {
+if (pixelOffset.x < xy.x || pixelOffset.x > xy.x + wh.x) {
+gl_Position = vec4(0.0);
+}
+else if (text.cutoffPixels.x > 0.) {
+float vpWidth = project.viewportSize.x / project.devicePixelRatio;
+float l = max(anchorPosScreen.x + xy.x, 0.0);
+float r = min(anchorPosScreen.x + xy.x + wh.x, vpWidth);
+if (r - l < text.cutoffPixels.x) {
+gl_Position = vec4(0.0);
+}
+}
+}
+if (instanceClipRect.w >= 0.) {
+if (pixelOffset.y < xy.y || pixelOffset.y > xy.y + wh.y) {
+gl_Position = vec4(0.0);
+}
+else if (text.cutoffPixels.y > 0.) {
+float vpHeight = project.viewportSize.y / project.devicePixelRatio;
+float t = max(anchorPosScreen.y - xy.y - wh.y, 0.0);
+float b = min(anchorPosScreen.y - xy.y, vpHeight);
+if (b - t < text.cutoffPixels.y) {
+gl_Position = vec4(0.0);
+}
+}
+}
+vTextureCoords = mix(
+instanceIconFrames.xy,
+instanceIconFrames.xy + iconSize,
+(positions.xy + 1.0) / 2.0
+) / icon.iconsTextureDim;
+vColor = instanceColors;
+DECKGL_FILTER_COLOR(vColor, geometry);
+vColorMode = instanceColorModes;
+}
+`;var _o=`#version 300 es
+#define SHADER_NAME multi-icon-layer-fragment-shader
+precision highp float;
+uniform sampler2D iconsTexture;
+in vec4 vColor;
+in vec2 vTextureCoords;
+in vec2 uv;
+out vec4 fragColor;
+void main(void) {
+geometry.uv = uv;
+if (!bool(picking.isActive)) {
+float alpha = texture(iconsTexture, vTextureCoords).a;
+vec4 color = vColor;
+if (sdf.enabled) {
+float distance = alpha;
+alpha = smoothstep(sdf.buffer - sdf.gamma, sdf.buffer + sdf.gamma, distance);
+if (sdf.outlineBuffer > 0.0) {
+float inFill = alpha;
+float inBorder = smoothstep(sdf.outlineBuffer - sdf.gamma, sdf.outlineBuffer + sdf.gamma, distance);
+color = mix(sdf.outlineColor, vColor, inFill);
+alpha = inBorder;
+}
+}
+float a = alpha * color.a;
+if (a < icon.alphaCutoff) {
+discard;
+}
+fragColor = vec4(color.rgb, a * layer.opacity);
+}
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;function er({collision:t=!1}={}){return`struct IconUniforms {
+  sizeScale: f32,
+  iconsTextureDim: vec2<f32>,
+  sizeBasis: f32,
+  sizeMinPixels: f32,
+  sizeMaxPixels: f32,
+  billboard: i32,
+  sizeUnits: i32,
+  alphaCutoff: f32
+};
+
+struct TextUniforms {
+  cutoffPixels: vec2<f32>,
+  align: vec2<i32>,
+  fontSize: f32,
+  flipY: f32
+};
+
+struct SdfUniforms {
+  gamma: f32,
+  enabled: f32,
+  buffer: f32,
+  outlineBuffer: f32,
+  outlineColor: vec4<f32>
+};
+
+${t?`struct CollisionUniforms {
+  sort: i32,
+  enabled: i32
+};
+`:``}
+
+const ALIGN_MODE_START: i32 = 1;
+const ALIGN_MODE_CENTER: i32 = 2;
+const ALIGN_MODE_END: i32 = 3;
+
+@group(0) @binding(auto) var<uniform> icon: IconUniforms;
+@group(0) @binding(auto) var<uniform> text: TextUniforms;
+@group(0) @binding(auto) var<uniform> sdf: SdfUniforms;
+${t?`@group(0) @binding(auto) var<uniform> collision: CollisionUniforms;`:``}
+@group(0) @binding(auto) var iconsTexture : texture_2d<f32>;
+@group(0) @binding(auto) var iconsTextureSampler : sampler;
+${t?`@group(0) @binding(auto) var collision_texture : texture_2d<f32>;
+`:``}
+
+fn rotate_by_angle(vertex: vec2<f32>, angle_deg: f32) -> vec2<f32> {
+  let angle_radian = angle_deg * PI / 180.0;
+  let c = cos(angle_radian);
+  let s = sin(angle_radian);
+  let rotation = mat2x2<f32>(vec2<f32>(c, -s), vec2<f32>(s, c));
+  return rotation * vertex;
+}
+
+fn get_pixel_offset_from_alignment(
+  anchor: f32,
+  extent: f32,
+  clipStart: f32,
+  clipEnd: f32,
+  mode: i32
+) -> f32 {
+  if (clipEnd < clipStart) {
+    return 0.0;
+  }
+  if (mode == ALIGN_MODE_START) {
+    return max(-(anchor + clipStart), 0.0);
+  }
+  if (mode == ALIGN_MODE_CENTER) {
+    let minValue = max(0.0, anchor + clipStart);
+    let maxValue = min(extent, anchor + clipEnd);
+    if (minValue < maxValue) {
+      return (minValue + maxValue) / 2.0 - anchor;
+    }
+    return 0.0;
+  }
+  if (mode == ALIGN_MODE_END) {
+    return min(extent - (anchor + clipEnd), 0.0);
+  }
+  return 0.0;
+}
+
+${t?`fn collision_match(texCoords: vec2<f32>, pickingColor: vec3<f32>) -> f32 {
+  let textureSize = vec2<i32>(textureDimensions(collision_texture));
+  let pixelCoords = clamp(
+    vec2<i32>(texCoords * vec2<f32>(textureSize)),
+    vec2<i32>(0),
+    textureSize - vec2<i32>(1)
+  );
+  let collisionPickingColor = textureLoad(collision_texture, pixelCoords, 0);
+  let delta = dot(abs(collisionPickingColor.rgb - pickingColor), vec3<f32>(1.0));
+  return step(delta, 0.001);
+}
+
+fn collision_is_visible(texCoords: vec2<f32>, pickingColor: vec3<f32>) -> f32 {
+  if (collision.enabled == 0) {
+    return 1.0;
+  }
+
+  var accumulator = 0.0;
+  let stepSize = vec2<f32>(1.0) / project.viewportSize;
+
+  for (var i: i32 = -2; i <= 2; i = i + 1) {
+    for (var j: i32 = -2; j <= 2; j = j + 1) {
+      let delta = vec2<f32>(f32(j), f32(i)) * stepSize;
+      accumulator = accumulator + collision_match(texCoords + delta, pickingColor);
+    }
+  }
+
+  return pow(accumulator / 25.0, 2.2);
+}
+`:``}
+
+struct Attributes {
+  @location(0) positions: vec2<f32>,
+
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceSizes: f32,
+  @location(4) instanceAngles: f32,
+  @location(5) instanceColors: vec4<f32>,
+  @location(6) instanceIconFrames: vec4<f32>,
+  @location(7) instanceColorModes: f32,
+  @location(8) instanceOffsets: vec2<f32>,
+  @location(9) instancePixelOffset: vec2<f32>,
+  @location(10) rowIndexes: u32,
+  @location(11) instanceClipRect: vec4<f32>,
+  ${t?`@location(12) collisionPriorities: f32,`:``}
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+
+  @location(0) vColorMode: f32,
+  @location(1) vColor: vec4<f32>,
+  @location(2) vTextureCoords: vec2<f32>,
+  @location(3) uv: vec2<f32>,
+  @location(4) pickingColor: vec3<f32>,
+};
+
+@vertex
+fn vertexMain(inp: Attributes) -> Varyings {
+  geometry.worldPosition = inp.instancePositions;
+  geometry.uv = inp.positions;
+  geometry.pickingColor = picking_getPickingColorFromIndex(inp.rowIndexes);
+
+  var outp: Varyings;
+  outp.uv = inp.positions;
+
+  let iconSize = inp.instanceIconFrames.zw;
+
+  let sizePixels = clamp(
+    project_unit_size_to_pixel(inp.instanceSizes * icon.sizeScale, icon.sizeUnits),
+    icon.sizeMinPixels, icon.sizeMaxPixels
+  );
+  let instanceScale = sizePixels / text.fontSize;
+
+  var pixelOffset = inp.positions / 2.0 * iconSize + inp.instanceOffsets;
+  pixelOffset = rotate_by_angle(pixelOffset, inp.instanceAngles) * instanceScale;
+  pixelOffset = pixelOffset + inp.instancePixelOffset;
+  pixelOffset.y = pixelOffset.y * -1.0;
+
+  var pos: vec4<f32>;
+  var anchorPosScreen: vec2<f32>;
+  if (icon.billboard != 0) {
+    pos = project_position_to_clipspace(inp.instancePositions, inp.instancePositions64Low, vec3<f32>(0.0));
+    anchorPosScreen = pos.xy / pos.w;
+
+    let clipOffset = project_pixel_size_to_clipspace(pixelOffset);
+    pos = vec4<f32>(pos.x + clipOffset.x, pos.y + clipOffset.y, pos.z, pos.w);
+  } else {
+    var offsetCommon = vec3<f32>(project_pixel_size_vec2(pixelOffset), 0.0);
+    if (text.flipY > 0.5) {
+      offsetCommon.y = offsetCommon.y * -1.0;
+    }
+    let anchorPos = project_position_to_clipspace(inp.instancePositions, inp.instancePositions64Low, vec3<f32>(0.0));
+    anchorPosScreen = anchorPos.xy / anchorPos.w;
+    pos = project_position_to_clipspace(inp.instancePositions, inp.instancePositions64Low, offsetCommon);
+  }
+
+  anchorPosScreen = vec2<f32>(anchorPosScreen.x + 1.0, 1.0 - anchorPosScreen.y) / 2.0 *
+    project.viewportSize / project.devicePixelRatio;
+  var xy = project_size_vec2(inp.instanceClipRect.xy) * project.scale;
+  var wh = project_size_vec2(inp.instanceClipRect.zw) * project.scale;
+
+  if (text.flipY > 0.5) {
+    xy.y = -xy.y - wh.y;
+  }
+  if (text.align.x > 0 || text.align.y > 0) {
+    let viewportPixels = project.viewportSize / project.devicePixelRatio;
+    let scrollPixels = vec2<f32>(
+      get_pixel_offset_from_alignment(anchorPosScreen.x, viewportPixels.x, xy.x, xy.x + wh.x, text.align.x),
+      -get_pixel_offset_from_alignment(anchorPosScreen.y, viewportPixels.y, -xy.y - wh.y, -xy.y, text.align.y)
+    );
+    pixelOffset = pixelOffset + scrollPixels;
+    let scrollClipOffset = project_pixel_size_to_clipspace(scrollPixels);
+    pos.x = pos.x + scrollClipOffset.x;
+    pos.y = pos.y + scrollClipOffset.y;
+  }
+
+  if (inp.instanceClipRect.z >= 0.0) {
+    if (pixelOffset.x < xy.x || pixelOffset.x > xy.x + wh.x) {
+      pos = vec4<f32>(0.0);
+    } else if (text.cutoffPixels.x > 0.0) {
+      let viewportWidth = project.viewportSize.x / project.devicePixelRatio;
+      let left = max(anchorPosScreen.x + xy.x, 0.0);
+      let right = min(anchorPosScreen.x + xy.x + wh.x, viewportWidth);
+      if (right - left < text.cutoffPixels.x) {
+        pos = vec4<f32>(0.0);
+      }
+    }
+  }
+  if (inp.instanceClipRect.w >= 0.0) {
+    if (pixelOffset.y < xy.y || pixelOffset.y > xy.y + wh.y) {
+      pos = vec4<f32>(0.0);
+    } else if (text.cutoffPixels.y > 0.0) {
+      let viewportHeight = project.viewportSize.y / project.devicePixelRatio;
+      let top = max(anchorPosScreen.y - xy.y - wh.y, 0.0);
+      let bottom = min(anchorPosScreen.y - xy.y, viewportHeight);
+      if (bottom - top < text.cutoffPixels.y) {
+        pos = vec4<f32>(0.0);
+      }
+    }
+  }
+
+  ${t?`  if (collision.sort != 0) {
+    pos.z = -0.001 * inp.collisionPriorities * pos.w;
+  }
+  `:``}
+
+  let uvMix = (inp.positions.xy + vec2<f32>(1.0, 1.0)) * 0.5;
+  outp.vTextureCoords = mix(inp.instanceIconFrames.xy, inp.instanceIconFrames.xy + iconSize, uvMix) / icon.iconsTextureDim;
+
+  outp.position = pos;
+  outp.vColor = inp.instanceColors;
+  outp.vColorMode = inp.instanceColorModes;
+  outp.pickingColor = picking_getPickingColorFromIndex(inp.rowIndexes);
+
+  return outp;
+}
+
+@fragment
+fn fragmentMain(inp: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = inp.uv;
+
+  let texColor = textureSample(iconsTexture, iconsTextureSampler, inp.vTextureCoords);
+  var alpha = texColor.a;
+  var color = inp.vColor;
+
+  if (sdf.enabled > 0.5) {
+    let distance = alpha;
+    alpha = smoothstep(sdf.buffer - sdf.gamma, sdf.buffer + sdf.gamma, distance);
+
+    if (sdf.outlineBuffer > 0.0) {
+      let inFill = alpha;
+      let inBorder = smoothstep(sdf.outlineBuffer - sdf.gamma, sdf.outlineBuffer + sdf.gamma, distance);
+      color = mix(sdf.outlineColor, inp.vColor, inFill);
+      alpha = inBorder;
+    }
+  } else if (inp.vColorMode == 0.0) {
+    color = texColor;
+  }
+
+  var a = alpha * color.a * layer.opacity;
+  if (a < icon.alphaCutoff) {
+    discard;
+  }
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(inp.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(inp.pickingColor, 1.0);
+  }
+
+  ${t?`  let collisionFade = collision_is_visible(inp.position.xy / project.viewportSize, inp.pickingColor);
+  a = a * collisionFade;
+  if (a <= 0.0001) {
+    discard;
+  }
+  `:``}
+
+  var fragColor = deckgl_premultiplied_alpha(vec4<f32>(color.rgb, a));
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(inp.pickingColor - highlightedObjectColor))) {
+      let highLightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highLightAlpha + fragColor.a * (1.0 - highLightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highLightRatio = highLightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highLightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  return fragColor;
+}
+`}var Co=er();var Lt=192/256;var tr={getIconOffsets:{type:`accessor`,value:t=>t.offsets},getContentBox:{type:`accessor`,value:[0,0,-1,-1]},fontSize:1,alphaCutoff:.001,smoothing:.1,outlineWidth:0,outlineColor:{type:`color`,value:[0,0,0,255]},contentCutoffPixels:{type:`array`,value:[0,0]},contentAlignHorizontal:`none`,contentAlignVertical:`none`};var St=(()=>{class t extends ce{getShaders(){let e=super.getShaders();return s(r({},e),{modules:[...e.modules,tt,yo],vs:Po,fs:_o,source:Co})}initializeState(){super.initializeState();let e=this.getAttributeManager(),i=e.attributes.instanceIconDefs;i.settings.update=this.calculateInstanceIconDefs,e.addInstanced({rowIndexes:{type:`uint32`,size:1,bufferGroup:`icon-instance-data`,accessor:(n,{index:s})=>s},instanceClipRect:{size:4,bufferGroup:`icon-instance-data`,accessor:`getContentBox`,defaultValue:[0,0,-1,-1]}})}updateState(e){super.updateState(e);let{props:i,oldProps:n,changeFlags:s}=e,{outlineColor:r}=i;if(s.extensionsChanged){this.state.fillModel?.destroy();let a=this.context.device.type===`webgpu`?this._getModel(`${this.props.id}-fill`):void 0;this.setState({fillModel:a,models:a?[this.state.model,a]:[this.state.model]})}if(s.updateTriggersChanged&&(s.updateTriggersChanged.getIcon||s.updateTriggersChanged.getIconOffsets)&&this.getAttributeManager().invalidate(`instanceIconDefs`),r!==n.outlineColor){let a=[r[0]/255,r[1]/255,r[2]/255,(r[3]??255)/255];this.setState({outlineColor:a})}!i.sdf&&i.outlineWidth&&A.warn(`${this.id}: fontSettings.sdf is required to render outline`)()}draw(e){let{sdf:i,smoothing:n,fontSize:s$9,outlineWidth:r$11,contentCutoffPixels:a,contentAlignHorizontal:l,contentAlignVertical:c}=this.props,{outlineColor:f}=this.state,d=r$11?Math.max(n,Lt*(1-r$11)):-1,u=this.state.model,p={buffer:Lt,outlineBuffer:d,gamma:n,enabled:!!i,outlineColor:f},g={contentCutoffPixels:a,contentAlignHorizontal:l,contentAlignVertical:c,fontSize:s$9,viewport:this.context.viewport};if(u.shaderInputs.setProps({sdf:p,text:g}),super.draw(e),i&&r$11){let{iconManager:h}=this.state;if(h.getTexture()){let P=this.state.fillModel||u;P.shaderInputs.setProps({sdf:s(r({},p),{outlineBuffer:Lt}),text:g}),this._drawModel(P)}}}calculateInstanceIconDefs(e,{startRow:i,endRow:n}){let{data:s,getIcon:r,getIconOffsets:a}=this.props,l=e.getVertexOffset(i),c=e.value,{iterable:f,objectInfo:d}=Ar(s,i,n);for(let u of f){d.index++;let p=r(u,d),g=a(u,d);if(p){let h=0;for(let v of Array.from(p)){let P=super.getInstanceIconDef(v);P[0]=g[h*2],P[1]+=g[h*2+1],P[6]=1,c.set(P,l),l+=e.size,h++}}}}}return t.defaultProps=tr,t.layerName=`MultiIconLayer`,t})();var bt=new Float64Array(256);for(let t=0;t<256;t++){let o=.5-Math.pow(t/255,.45454545454545453);bt[t]=o*Math.abs(o)}bt[255]=-0x56bc75e2d63100000;var it=class{constructor({fontSize:o=24,buffer:e=3,radius:i=8,cutoff:n=.25,fontFamily:s=`sans-serif`,fontWeight:r=`normal`,fontStyle:a=`normal`,lang:l=null}={}){this.buffer=e,this.radius=i,this.cutoff=n,this.lang=l;let c=this.size=o+e*4,f=this._createCanvas(c),d=this.ctx=f.getContext(`2d`,{willReadFrequently:!0});d.font=`${a} ${r} ${o}px ${s}`,d.textBaseline=`alphabetic`,d.textAlign=`left`,d.fillStyle=`black`,this.gridOuter=new Float64Array(c*c),this.gridInner=new Float64Array(c*c),this.f=new Float64Array(c),this.z=new Float64Array(c+1),this.v=new Uint16Array(c)}_createCanvas(o){if(typeof OffscreenCanvas<`u`)return new OffscreenCanvas(o,o);let e=document.createElement(`canvas`);return e.width=e.height=o,e}draw(o){let{width:e,actualBoundingBoxAscent:i,actualBoundingBoxDescent:n,actualBoundingBoxLeft:s,actualBoundingBoxRight:r}=this.ctx.measureText(o),a=Math.ceil(i),l=Math.floor(-s),c=Math.max(0,Math.min(this.size-this.buffer,Math.ceil(r)-l)),f=Math.max(0,Math.min(this.size-this.buffer,a+Math.ceil(n))),d=c+2*this.buffer,u=f+2*this.buffer,p=Math.max(d*u,0),g=new Uint8ClampedArray(p),h={data:g,width:d,height:u,glyphWidth:c,glyphHeight:f,glyphTop:a,glyphLeft:l,glyphAdvance:e};if(c===0||f===0)return h;let{ctx:v,buffer:P,gridInner:C,gridOuter:m}=this;this.lang&&(v.lang=this.lang),v.clearRect(P,P,c,f),v.fillText(o,P-l,P+a);let x=v.getImageData(P,P,c,f);m.fill(0x56bc75e2d63100000,0,p),C.fill(0,0,p);let L=3;for(let F=0;F<f;F++){let U=(F+P)*d+P;for(let D=0;D<c;D++,L+=4,U++){let V=x.data[L];if(V===0)continue;let W=bt[V];m[U]=Math.max(0,W),C[U]=Math.max(0,-W)}}Lo(m,0,0,d,u,d,this.f,this.v,this.z);let N=Math.min(P,1);Lo(C,P-N,P-N,c+2*N,f+2*N,d,this.f,this.v,this.z);let G=255/this.radius,j=255*(1-this.cutoff);for(let F=0;F<p;F++){let U=Math.sqrt(m[F])-Math.sqrt(C[F]);g[F]=Math.round(j-G*U)}return h}};function Lo(t,o,e,i,n,s,r,a,l){for(let c=o;c<o+i;c++)So(t,e*s+c,s,n,r,a,l);for(let c=e;c<e+n;c++)So(t,c*s+o,1,i,r,a,l)}function So(t,o,e,i,n,s,r){s[0]=0,r[0]=-0x56bc75e2d63100000,r[1]=0x56bc75e2d63100000,n[0]=t[o];for(let a=1,l=0,c=0;a<i;a++){n[a]=t[o+a*e];let f=a*a;do{let d=s[l];c=(n[a]-n[d]+f-d*d)/(a-d)/2}while(c<=r[l]&&--l>-1);l++,s[l]=a,r[l]=c,r[l+1]=0x56bc75e2d63100000}for(let a=0,l=0;a<i;a++){for(;r[l+1]<a;)l++;let c=s[l],f=a-c;t[o+a*e]=n[c]+f*f}}var or=32;var nr=[];function sr(t){return Math.pow(2,Math.ceil(Math.log2(t)))}function bo({characterSet:t,measureText:o,buffer:e,maxCanvasWidth:i,mapping:n={},xOffset:s=0,yOffsetMin:r=0,yOffsetMax:a=0}){let c=s,f=r,d=a;for(let u of t)if(!n[u]){let{advance:p,width:g,ascent:h,descent:v}=o(u),P=h+v;c+g+e*2>i&&(c=0,f=d),n[u]={x:c+e,y:f+e,width:g,height:P,advance:p,anchorX:g/2,anchorY:h},c+=g+e*2,d=Math.max(d,f+P+e*2)}return{mapping:n,xOffset:c,yOffsetMin:f,yOffsetMax:d,canvasHeight:sr(d)}}function wo(t,o,e,i){let n=0;for(let s=o;s<e;s++){let r=t[s];n+=i[r]?.advance||0}return n}function Io(t,o,e,i,n,s){let r=o,a=0;for(let l=o;l<e;l++){let c=wo(t,l,l+1,n);a+c>i&&(r<l&&s.push(l),r=l,a=0),a+=c}return a}function rr(t,o,e,i,n,s){let r=o,a=o,l=o,c=0;for(let f=o;f<e;f++)if((t[f]===` `||t[f+1]===` `||f+1===e)&&(l=f+1),l>a){let d=wo(t,a,l,n);c+d>i&&(r<a&&(s.push(a),r=a,c=0),d>i&&(d=Io(t,a,l,i,n,s),r=s[s.length-1])),a=l,c+=d}return c}function ar(t,o,e,i,n=0,s){s===void 0&&(s=t.length);let r=[];return o===`break-all`?Io(t,n,s,e,i,r):rr(t,n,s,e,i,r),r}function lr(t,o,e,i,n,s){let r=0,a=0;for(let l=o;l<e;l++){let f=i[t[l]];f&&(a=Math.max(a,f.height))}for(let l=o;l<e;l++){let c=t[l],f=i[c];f?(n[l]=r+f.anchorX,r+=f.advance):(A.warn(`Missing character: ${c} (${c.codePointAt(0)})`)(),n[l]=r,r+=or)}s[0]=r,s[1]=a}function Ao(t,o,e,i,n,s){let r=Array.from(t),a=r.length,l=new Array(a),c=new Array(a),f=new Array(a),d=(i===`break-word`||i===`break-all`)&&isFinite(n)&&n>0,u=[0,0],p=[0,0],g=0,h=o+e/2,v=0,P=0;for(let C=0;C<=a;C++){let m=r[C];if((m===`
+`||C===a)&&(P=C),P>v){let x=d?ar(r,i,n,s,v,P):nr;for(let L=0;L<=x.length;L++){let N=L===0?v:x[L-1],G=L<x.length?x[L]:P;lr(r,N,G,s,l,p);for(let j=N;j<G;j++)c[j]=h,f[j]=p[0];g++,h+=e,u[0]=Math.max(u[0],p[0])}v=P}m===`
+`&&(l[v]=0,c[v]=0,f[v]=0,v++)}return u[1]=g*e,{x:l,y:c,rowWidth:f,size:u}}function Eo({value:t,length:o,stride:e,offset:i,startIndices:n,characterSet:s}){let r=t.BYTES_PER_ELEMENT,a=e?e/r:1,l=i?i/r:0,c=n[o]||Math.ceil((t.length-l)/a),f=s&&new Set,d=new Array(o),u=t;if(a>1||l>0){let p=t.constructor;u=new p(c);for(let g=0;g<c;g++)u[g]=t[g*a+l]}for(let p=0;p<o;p++){let g=n[p],h=n[p+1]||c,v=u.subarray(g,h);d[p]=String.fromCodePoint.apply(null,v),f&&v.forEach(f.add,f)}if(f)for(let p of f)s.add(String.fromCodePoint(p));return{texts:d,characterCount:c}}var Ae=class{constructor(o=5){this._cache={},this._order=[],this.limit=o}get(o){let e=this._cache[o];return e&&(this._deleteOrder(o),this._appendOrder(o)),e}set(o,e){this._cache[o]?(this.delete(o),this._cache[o]=e,this._appendOrder(o)):(Object.keys(this._cache).length===this.limit&&this.delete(this._order[0]),this._cache[o]=e,this._appendOrder(o))}delete(o){this._cache[o]&&(delete this._cache[o],this._deleteOrder(o))}_deleteOrder(o){let e=this._order.indexOf(o);e>=0&&this._order.splice(e,1)}_appendOrder(o){this._order.push(o)}};function cr(){let t=[];for(let o=32;o<128;o++)t.push(String.fromCharCode(o));return t}var q={fontFamily:`Monaco, monospace`,fontWeight:`normal`,characterSet:cr(),fontSize:64,buffer:4,sdf:!1,cutoff:.25,radius:12,smoothing:.1};var To=1024;var Oo=.9;var Ro=.3;var zo=3;var ot=new Ae(zo);function fr(t,o){let e;typeof o==`string`?e=new Set(Array.from(o)):e=new Set(o);let i=ot.get(t);if(!i)return e;for(let n in i.mapping)e.has(n)&&e.delete(n);return e}function dr(t,o){for(let e=0;e<t.length;e++)o.data[4*e+3]=t[e]}function Mo(t,o,e,i){t.font=`${i} ${e}px ${o}`,t.fillStyle=`#000`,t.textBaseline=`alphabetic`,t.textAlign=`left`}function ur(t,o,e){if(e===void 0){let n=t.measureText(`A`);return n.fontBoundingBoxAscent?{advance:0,width:0,ascent:Math.ceil(n.fontBoundingBoxAscent),descent:Math.ceil(n.fontBoundingBoxDescent)}:{advance:0,width:0,ascent:o*Oo,descent:o*Ro}}let i=t.measureText(e);return i.actualBoundingBoxAscent?{advance:i.width,width:Math.ceil(i.actualBoundingBoxRight-i.actualBoundingBoxLeft),ascent:Math.ceil(i.actualBoundingBoxAscent),descent:Math.ceil(i.actualBoundingBoxDescent)}:{advance:i.width,width:i.width,ascent:o*Oo,descent:o*Ro}}function ko(t){A.assert(Number.isFinite(t)&&t>=zo,`Invalid cache limit`),ot=new Ae(t)}var nt=class{constructor(){this.props=r({},q)}get atlas(){return this._atlas}get mapping(){return this._atlas&&this._atlas.mapping}setProps(o={}){Object.assign(this.props,o),o._getFontRenderer&&(this._getFontRenderer=o._getFontRenderer),this._key=this._getKey();let e=fr(this._key,this.props.characterSet),i=ot.get(this._key);if(i&&e.size===0){this._atlas!==i&&(this._atlas=i);return}let n=this._generateFontAtlas(e,i);this._atlas=n,ot.set(this._key,n)}_generateFontAtlas(o,e){let{fontFamily:i,fontWeight:n,fontSize:s,buffer:r$12,sdf:a,radius:l,cutoff:c}=this.props,f=e&&e.data;f||(f=document.createElement(`canvas`),f.width=To);let d=f.getContext(`2d`,{willReadFrequently:!0});Mo(d,i,s,n);let u=x=>ur(d,s,x),p;this._getFontRenderer?p=this._getFontRenderer(this.props):a&&(p={measure:u,draw:pr(this.props)});let{mapping:g,canvasHeight:h,xOffset:v,yOffsetMin:P,yOffsetMax:C}=bo(r({measureText:x=>p?p.measure(x):u(x),buffer:r$12,characterSet:o,maxCanvasWidth:To},e&&{mapping:e.mapping,xOffset:e.xOffset,yOffsetMin:e.yOffsetMin,yOffsetMax:e.yOffsetMax}));if(f.height!==h){let x=f.height>0?d.getImageData(0,0,f.width,f.height):null;f.height=h,x&&d.putImageData(x,0,0)}if(Mo(d,i,s,n),p)for(let x of o){let L=g[x],N=L.width,{data:G,left:j=0,top:F=0}=p.draw(x),U=L.x-j,D=L.y-F,V=Math.max(0,Math.round(U)),W=Math.max(0,Math.round(D)),H=Math.min(G.width,f.width-V),Q=Math.min(G.height,f.height-W);d.putImageData(G,V,W,0,0,H,Q),L.x=V,L.y=W,L.width=H,L.height=Q,L.anchorX+=H/2-j-N/2,L.anchorY+=F}else for(let x of o){let L=g[x];d.fillText(x,L.x,L.y+L.anchorY)}let m=p?p.measure():u();return{baselineOffset:(m.ascent-m.descent)/2,xOffset:v,yOffsetMin:P,yOffsetMax:C,mapping:g,data:f,width:f.width,height:f.height}}_getKey(){let{fontFamily:o,fontWeight:e,fontSize:i,buffer:n,sdf:s,radius:r,cutoff:a}=this.props;return s?`${o} ${e} ${i} ${n} ${r} ${a}`:`${o} ${e} ${i} ${n}`}};function pr({fontSize:t,buffer:o,radius:e,cutoff:i,fontFamily:n,fontWeight:s}){let r=new it({fontSize:t,buffer:o,radius:e,cutoff:i,fontFamily:n,fontWeight:`${s}`});return a=>{let{data:l,width:c,height:f}=r.draw(a),d=new ImageData(c,f);return dr(l,d),{data:d,left:o,top:o}}}var gr=`struct TextBackgroundUniforms {
+  billboard: f32,
+  sizeScale: f32,
+  sizeMinPixels: f32,
+  sizeMaxPixels: f32,
+  borderRadius: vec4<f32>,
+  padding: vec4<f32>,
+  sizeUnits: i32,
+  stroked: f32,
+};
+
+@group(0) @binding(auto) var<uniform> textBackground: TextBackgroundUniforms;
+`;var Do=`layout(std140) uniform textBackgroundUniforms {
+  bool billboard;
+  float sizeScale;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  vec4 borderRadius;
+  vec4 padding;
+  highp int sizeUnits;
+  bool stroked;
+} textBackground;
+`;var Fo={name:`textBackground`,source:gr,vs:Do,fs:Do,uniformTypes:{billboard:`f32`,sizeScale:`f32`,sizeMinPixels:`f32`,sizeMaxPixels:`f32`,borderRadius:`vec4<f32>`,padding:`vec4<f32>`,sizeUnits:`i32`,stroked:`f32`}};var No=`#version 300 es
+#define SHADER_NAME text-background-layer-vertex-shader
+in vec2 positions;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in vec4 instanceRects;
+in vec4 instanceClipRect;
+in float instanceSizes;
+in float instanceAngles;
+in vec2 instancePixelOffsets;
+in float instanceLineWidths;
+in vec4 instanceFillColors;
+in vec4 instanceLineColors;
+out vec4 vFillColor;
+out vec4 vLineColor;
+out float vLineWidth;
+out vec2 uv;
+out vec2 dimensions;
+vec2 rotate_by_angle(vec2 vertex, float angle) {
+float angle_radian = radians(angle);
+float cos_angle = cos(angle_radian);
+float sin_angle = sin(angle_radian);
+mat2 rotationMatrix = mat2(cos_angle, -sin_angle, sin_angle, cos_angle);
+return rotationMatrix * vertex;
+}
+void main(void) {
+geometry.worldPosition = instancePositions;
+geometry.uv = positions;
+geometry.pickingColor = picking_getPickingColorFromInstanceID();
+uv = positions;
+vLineWidth = instanceLineWidths;
+float sizePixels = clamp(
+project_size_to_pixel(instanceSizes * textBackground.sizeScale, textBackground.sizeUnits),
+textBackground.sizeMinPixels, textBackground.sizeMaxPixels
+);
+float instanceScale = sizePixels / text.fontSize;
+dimensions = instanceRects.zw * instanceScale + textBackground.padding.xy + textBackground.padding.zw;
+vec2 pixelOffset = (positions * instanceRects.zw + instanceRects.xy) * instanceScale + mix(-textBackground.padding.xy, textBackground.padding.zw, positions);
+pixelOffset = rotate_by_angle(pixelOffset, instanceAngles);
+pixelOffset += instancePixelOffsets;
+pixelOffset.y *= -1.0;
+vec2 xy = project_size_to_pixel(instanceClipRect.xy);
+vec2 wh = project_size_to_pixel(instanceClipRect.zw);
+if (text.flipY) {
+xy.y = -xy.y - wh.y;
+}
+if (instanceClipRect.z >= 0.0) {
+dimensions.x = wh.x;
+pixelOffset.x = xy.x + uv.x * wh.x + mix(-textBackground.padding.x, textBackground.padding.z, uv.x);
+}
+if (instanceClipRect.w >= 0.0) {
+dimensions.y = wh.y;
+pixelOffset.y = xy.y + uv.y * wh.y + mix(-textBackground.padding.y, textBackground.padding.w, uv.y);
+}
+if (textBackground.billboard)  {
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, vec3(0.0), geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vec3 offset = vec3(pixelOffset, 0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+gl_Position.xy += project_pixel_size_to_clipspace(offset.xy);
+} else {
+vec3 offset_common = vec3(project_pixel_size(pixelOffset), 0.0);
+if (text.flipY) {
+offset_common.y *= -1.;
+}
+DECKGL_FILTER_SIZE(offset_common, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, offset_common, geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+}
+vFillColor = vec4(instanceFillColors.rgb, instanceFillColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vFillColor, geometry);
+vLineColor = vec4(instanceLineColors.rgb, instanceLineColors.a * layer.opacity);
+DECKGL_FILTER_COLOR(vLineColor, geometry);
+}
+`;var Go=`#version 300 es
+#define SHADER_NAME text-background-layer-fragment-shader
+precision highp float;
+in vec4 vFillColor;
+in vec4 vLineColor;
+in float vLineWidth;
+in vec2 uv;
+in vec2 dimensions;
+out vec4 fragColor;
+float round_rect(vec2 p, vec2 size, vec4 radii) {
+vec2 pixelPositionCB = (p - 0.5) * size;
+vec2 sizeCB = size * 0.5;
+float maxBorderRadius = min(size.x, size.y) * 0.5;
+vec4 borderRadius = vec4(min(radii, maxBorderRadius));
+borderRadius.xy =
+(pixelPositionCB.x > 0.0) ? borderRadius.xy : borderRadius.zw;
+borderRadius.x = (pixelPositionCB.y > 0.0) ? borderRadius.x : borderRadius.y;
+vec2 q = abs(pixelPositionCB) - sizeCB + borderRadius.x;
+return -(min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - borderRadius.x);
+}
+float rect(vec2 p, vec2 size) {
+vec2 pixelPosition = p * size;
+return min(min(pixelPosition.x, size.x - pixelPosition.x),
+min(pixelPosition.y, size.y - pixelPosition.y));
+}
+vec4 get_stroked_fragColor(float dist) {
+float isBorder = smoothedge(dist, vLineWidth);
+return mix(vFillColor, vLineColor, isBorder);
+}
+void main(void) {
+geometry.uv = uv;
+if (textBackground.borderRadius != vec4(0.0)) {
+float distToEdge = round_rect(uv, dimensions, textBackground.borderRadius);
+float shapeAlpha = smoothedge(-distToEdge, 0.0);
+if (shapeAlpha == 0.0) {
+discard;
+}
+if (textBackground.stroked) {
+fragColor = get_stroked_fragColor(distToEdge);
+} else {
+fragColor = vFillColor;
+}
+fragColor.a *= shapeAlpha;
+} else {
+if (textBackground.stroked) {
+float distToEdge = rect(uv, dimensions);
+fragColor = get_stroked_fragColor(distToEdge);
+} else {
+fragColor = vFillColor;
+}
+}
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;var Bo=`struct TextUniforms {
+  cutoffPixels: vec2<f32>,
+  align: vec2<i32>,
+  fontSize: f32,
+  flipY: f32,
+};
+
+@group(0) @binding(auto) var<uniform> text: TextUniforms;
+
+fn rotate_by_angle(vertex: vec2<f32>, angle: f32) -> vec2<f32> {
+  let angleRadian = radians(angle);
+  let cosine = cos(angleRadian);
+  let sine = sin(angleRadian);
+  let rotationMatrix = mat2x2<f32>(
+    vec2<f32>(cosine, -sine),
+    vec2<f32>(sine, cosine)
+  );
+  return rotationMatrix * vertex;
+}
+
+struct Attributes {
+  @builtin(instance_index) instanceIndex: u32,
+  @location(0) positions: vec2<f32>,
+  @location(1) instancePositions: vec3<f32>,
+  @location(2) instancePositions64Low: vec3<f32>,
+  @location(3) instanceSizes: f32,
+  @location(4) instanceAngles: f32,
+  @location(5) instanceRects: vec4<f32>,
+  @location(6) instanceClipRect: vec4<f32>,
+  @location(7) instancePixelOffsets: vec2<f32>,
+  @location(8) instanceFillColors: vec4<f32>,
+  @location(9) instanceLineColors: vec4<f32>,
+  @location(10) instanceLineWidths: f32,
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vFillColor: vec4<f32>,
+  @location(1) vLineColor: vec4<f32>,
+  @location(2) vLineWidth: f32,
+  @location(3) uv: vec2<f32>,
+  @location(4) dimensions: vec2<f32>,
+  @location(5) pickingColor: vec3<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  geometry.worldPosition = attributes.instancePositions;
+  geometry.uv = attributes.positions;
+  geometry.pickingColor = picking_getPickingColorFromIndex(attributes.instanceIndex);
+
+  var varyings: Varyings;
+  varyings.uv = attributes.positions;
+  varyings.vLineWidth = attributes.instanceLineWidths;
+
+  let sizePixels = clamp(
+    project_unit_size_to_pixel(
+      attributes.instanceSizes * textBackground.sizeScale,
+      textBackground.sizeUnits
+    ),
+    textBackground.sizeMinPixels,
+    textBackground.sizeMaxPixels
+  );
+  let instanceScale = sizePixels / text.fontSize;
+
+  varyings.dimensions = attributes.instanceRects.zw * instanceScale +
+    textBackground.padding.xy + textBackground.padding.zw;
+
+  var pixelOffset =
+    (attributes.positions * attributes.instanceRects.zw + attributes.instanceRects.xy) *
+      instanceScale +
+    mix(-textBackground.padding.xy, textBackground.padding.zw, attributes.positions);
+  pixelOffset = rotate_by_angle(pixelOffset, attributes.instanceAngles);
+  pixelOffset = pixelOffset + attributes.instancePixelOffsets;
+  pixelOffset.y = pixelOffset.y * -1.0;
+
+  var xy = project_size_vec2(attributes.instanceClipRect.xy) * project.scale;
+  let wh = project_size_vec2(attributes.instanceClipRect.zw) * project.scale;
+  if (text.flipY > 0.5) {
+    xy.y = -xy.y - wh.y;
+  }
+  if (attributes.instanceClipRect.z >= 0.0) {
+    varyings.dimensions.x = wh.x;
+    pixelOffset.x = xy.x + varyings.uv.x * wh.x + mix(
+      -textBackground.padding.x,
+      textBackground.padding.z,
+      varyings.uv.x
+    );
+  }
+  if (attributes.instanceClipRect.w >= 0.0) {
+    varyings.dimensions.y = wh.y;
+    pixelOffset.y = xy.y + varyings.uv.y * wh.y + mix(
+      -textBackground.padding.y,
+      textBackground.padding.w,
+      varyings.uv.y
+    );
+  }
+
+  if (textBackground.billboard > 0.5) {
+    var position = project_position_to_clipspace(
+      attributes.instancePositions,
+      attributes.instancePositions64Low,
+      vec3<f32>(0.0)
+    );
+    let clipOffset = project_pixel_size_to_clipspace(pixelOffset);
+    position = vec4<f32>(
+      position.x + clipOffset.x,
+      position.y + clipOffset.y,
+      position.z,
+      position.w
+    );
+    varyings.position = position;
+  } else {
+    var offsetCommon = vec3<f32>(project_pixel_size_vec2(pixelOffset), 0.0);
+    if (text.flipY > 0.5) {
+      offsetCommon.y = offsetCommon.y * -1.0;
+    }
+    varyings.position = project_position_to_clipspace(
+      attributes.instancePositions,
+      attributes.instancePositions64Low,
+      offsetCommon
+    );
+  }
+
+  varyings.vFillColor = vec4<f32>(
+    attributes.instanceFillColors.rgb,
+    attributes.instanceFillColors.a * layer.opacity
+  );
+  varyings.vLineColor = vec4<f32>(
+    attributes.instanceLineColors.rgb,
+    attributes.instanceLineColors.a * layer.opacity
+  );
+  varyings.pickingColor = geometry.pickingColor;
+  return varyings;
+}
+
+fn round_rect(point: vec2<f32>, size: vec2<f32>, radii: vec4<f32>) -> f32 {
+  let pixelPosition = (point - 0.5) * size;
+  let halfSize = size * 0.5;
+  let maxBorderRadius = min(size.x, size.y) * 0.5;
+  var borderRadius = min(radii, vec4<f32>(maxBorderRadius));
+
+  borderRadius = select(borderRadius.zwxy, borderRadius, pixelPosition.x > 0.0);
+  let radius = select(borderRadius.y, borderRadius.x, pixelPosition.y > 0.0);
+  let q = abs(pixelPosition) - halfSize + radius;
+  return -(min(max(q.x, q.y), 0.0) + length(max(q, vec2<f32>(0.0))) - radius);
+}
+
+fn rect(point: vec2<f32>, size: vec2<f32>) -> f32 {
+  let pixelPosition = point * size;
+  return min(
+    min(pixelPosition.x, size.x - pixelPosition.x),
+    min(pixelPosition.y, size.y - pixelPosition.y)
+  );
+}
+
+fn get_stroked_frag_color(
+  distanceToEdge: f32,
+  lineWidth: f32,
+  fillColor: vec4<f32>,
+  lineColor: vec4<f32>
+) -> vec4<f32> {
+  let isBorder = smoothedge(distanceToEdge, lineWidth);
+  return mix(fillColor, lineColor, isBorder);
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  geometry.uv = varyings.uv;
+  var fragColor: vec4<f32>;
+
+  if (any(textBackground.borderRadius != vec4<f32>(0.0))) {
+    let distanceToEdge = round_rect(
+      varyings.uv,
+      varyings.dimensions,
+      textBackground.borderRadius
+    );
+    let shapeAlpha = smoothedge(-distanceToEdge, 0.0);
+    if (shapeAlpha == 0.0) {
+      discard;
+    }
+    if (textBackground.stroked > 0.5) {
+      fragColor = get_stroked_frag_color(
+        distanceToEdge,
+        varyings.vLineWidth,
+        varyings.vFillColor,
+        varyings.vLineColor
+      );
+    } else {
+      fragColor = varyings.vFillColor;
+    }
+    fragColor.a = fragColor.a * shapeAlpha;
+  } else if (textBackground.stroked > 0.5) {
+    let distanceToEdge = rect(varyings.uv, varyings.dimensions);
+    fragColor = get_stroked_frag_color(
+      distanceToEdge,
+      varyings.vLineWidth,
+      varyings.vFillColor,
+      varyings.vLineColor
+    );
+  } else {
+    fragColor = varyings.vFillColor;
+  }
+
+  if (picking.isActive > 0.5) {
+    if (!picking_isColorValid(varyings.pickingColor)) {
+      discard;
+    }
+    return vec4<f32>(varyings.pickingColor, 1.0);
+  }
+
+  if (picking.isHighlightActive > 0.5) {
+    let highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+    if (picking_isColorZero(abs(varyings.pickingColor - highlightedObjectColor))) {
+      let highlightAlpha = picking.highlightColor.a;
+      let blendedAlpha = highlightAlpha + fragColor.a * (1.0 - highlightAlpha);
+      if (blendedAlpha > 0.0) {
+        let highlightRatio = highlightAlpha / blendedAlpha;
+        fragColor = vec4<f32>(
+          mix(fragColor.rgb, picking.highlightColor.rgb, highlightRatio),
+          blendedAlpha
+        );
+      } else {
+        fragColor = vec4<f32>(fragColor.rgb, 0.0);
+      }
+    }
+  }
+
+  return deckgl_premultiplied_alpha(fragColor);
+}
+`;var hr={billboard:!0,sizeScale:1,sizeUnits:`pixels`,sizeMinPixels:0,sizeMaxPixels:Number.MAX_SAFE_INTEGER,fontSize:1,borderRadius:{type:`object`,value:0},padding:{type:`array`,value:[0,0,0,0]},getPosition:{type:`accessor`,value:t=>t.position},getSize:{type:`accessor`,value:1},getAngle:{type:`accessor`,value:0},getPixelOffset:{type:`accessor`,value:[0,0]},getBoundingRect:{type:`accessor`,value:[0,0,0,0]},getClipRect:{type:`accessor`,value:[0,0,-1,-1]},getFillColor:{type:`accessor`,value:[0,0,0,255]},getLineColor:{type:`accessor`,value:[0,0,0,255]},getLineWidth:{type:`accessor`,value:1}};var wt=(()=>{class t extends en$1{getShaders(){return super.getShaders({vs:No,fs:Go,source:Bo,modules:[Wa,ma,Ka,Fo,tt]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceSizes:{size:1,transition:!0,bufferGroup:`text-background-instance-data`,accessor:`getSize`,defaultValue:1},instanceAngles:{size:1,transition:!0,bufferGroup:`text-background-instance-data`,accessor:`getAngle`},instanceRects:{size:4,bufferGroup:`text-background-instance-data`,accessor:`getBoundingRect`},instanceClipRect:{size:4,bufferGroup:`text-background-instance-data`,accessor:`getClipRect`,defaultValue:[0,0,-1,-1]},instancePixelOffsets:{size:2,transition:!0,bufferGroup:`text-background-instance-data`,accessor:`getPixelOffset`},instanceFillColors:{size:4,transition:!0,type:`unorm8`,accessor:`getFillColor`,defaultValue:[0,0,0,255]},instanceLineColors:{size:4,transition:!0,type:`unorm8`,accessor:`getLineColor`,defaultValue:[0,0,0,255]},instanceLineWidths:{size:1,transition:!0,bufferGroup:`text-background-instance-data`,accessor:`getLineWidth`,defaultValue:1}})}updateState(e){super.updateState(e);let{changeFlags:i}=e;i.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{billboard:i,sizeScale:n,sizeUnits:s,sizeMinPixels:r,sizeMaxPixels:a,getLineWidth:l,fontSize:c}=this.props,{padding:f,borderRadius:d}=this.props;f.length<4&&(f=[f[0],f[1],f[0],f[1]]),Array.isArray(d)||(d=[d,d,d,d]);let u=this.state.model,p={billboard:i,stroked:!!l,borderRadius:d,padding:f,sizeUnits:ee[s],sizeScale:n,sizeMinPixels:r,sizeMaxPixels:a},g={fontSize:c,viewport:this.context.viewport};u.shaderInputs.setProps({textBackground:p,text:g}),u.draw(this.context.renderPass)}_getModel(){return new De$1(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new ne$1({topology:`triangle-strip`,vertexCount:4,attributes:{positions:{size:2,value:new Float32Array([0,0,1,0,0,1,1,1])}}}),isInstanced:!0}))}}return t.defaultProps=hr,t.layerName=`TextBackgroundLayer`,t})();var jo={start:1,middle:0,end:-1};var Wo={top:1,center:0,bottom:-1};var It=[0,0,0,255];var mr={billboard:!0,sizeScale:1,sizeUnits:`pixels`,sizeMinPixels:0,sizeMaxPixels:Number.MAX_SAFE_INTEGER,background:!1,getBackgroundColor:{type:`accessor`,value:[255,255,255,255]},getBorderColor:{type:`accessor`,value:It},getBorderWidth:{type:`accessor`,value:0},backgroundBorderRadius:{type:`object`,value:0},backgroundPadding:{type:`array`,value:[0,0,0,0]},characterSet:{type:`object`,value:q.characterSet},fontFamily:q.fontFamily,fontWeight:q.fontWeight,lineHeight:1,outlineWidth:{type:`number`,value:0,min:0},outlineColor:{type:`color`,value:It},fontSettings:{type:`object`,value:{},compare:1},wordBreak:`break-word`,maxWidth:{type:`number`,value:-1},contentCutoffPixels:{type:`array`,value:[0,0]},contentAlignHorizontal:`none`,contentAlignVertical:`none`,getText:{type:`accessor`,value:t=>t.text},getPosition:{type:`accessor`,value:t=>t.position},getColor:{type:`accessor`,value:It},getSize:{type:`accessor`,value:32},getAngle:{type:`accessor`,value:0},getTextAnchor:{type:`accessor`,value:`middle`},getAlignmentBaseline:{type:`accessor`,value:`center`},getPixelOffset:{type:`accessor`,value:[0,0]},getContentBox:{type:`accessor`,value:[0,0,-1,-1]},backgroundColor:{deprecatedFor:[`background`,`getBackgroundColor`]}};var At=(()=>{class t extends Dm{constructor(){super(...arguments),this.getBoundingRect=(e,i)=>{let{size:[n,s]}=this.transformParagraph(e,i),{getTextAnchor:r,getAlignmentBaseline:a}=this.props,l=jo[typeof r==`function`?r(e,i):r],c=Wo[typeof a==`function`?a(e,i):a];return[(l-1)*n/2,(c-1)*s/2,n,s]},this.getIconOffsets=(e,i)=>{let{getTextAnchor:n,getAlignmentBaseline:s}=this.props,{x:r,y:a,rowWidth:l,size:[,c]}=this.transformParagraph(e,i),f=jo[typeof n==`function`?n(e,i):n],d=Wo[typeof s==`function`?s(e,i):s],u=r.length,p=new Array(u*2),g=0;for(let h=0;h<u;h++)p[g++]=(f-1)*l[h]/2+r[h],p[g++]=(d-1)*c/2+a[h];return p}}initializeState(){this.state={styleVersion:0,fontAtlasManager:new nt},this.props.maxWidth>0&&A.once(1,`v8.9 breaking change: TextLayer maxWidth is now relative to text size`)()}updateState(e){let{props:i,oldProps:n,changeFlags:s}=e;(s.dataChanged||s.updateTriggersChanged&&(s.updateTriggersChanged.all||s.updateTriggersChanged.getText))&&this._updateText(),(this._updateFontAtlas()||i.lineHeight!==n.lineHeight||i.wordBreak!==n.wordBreak||i.maxWidth!==n.maxWidth)&&this.setState({styleVersion:this.state.styleVersion+1})}getPickingInfo({info:e}){return e.object=e.index>=0?this.props.data[e.index]:null,e}_updateFontAtlas(){let{fontSettings:e,fontFamily:i,fontWeight:n,_getFontRenderer:s$10}=this.props,{fontAtlasManager:r$13,characterSet:a}=this.state,l=s(r({},e),{characterSet:a,fontFamily:i,fontWeight:n,_getFontRenderer:s$10});if(!r$13.mapping)return r$13.setProps(l),!0;for(let c in l)if(l[c]!==r$13.props[c])return r$13.setProps(l),!0;return!1}_updateText(){let{data:e,characterSet:i}=this.props,n=e.attributes?.getText,{getText:s$11}=this.props,r$14=e.startIndices,a,l=i===`auto`&&new Set;if(n&&r$14){let{texts:c,characterCount:f}=Eo(s(r({},ArrayBuffer.isView(n)?{value:n}:n),{length:e.length,startIndices:r$14,characterSet:l}));a=f,s$11=(d,{index:u})=>c[u]}else{let{iterable:c,objectInfo:f}=Ar(e);r$14=[0],a=0;for(let d of c){f.index++;let u=Array.from(s$11(d,f)||``);l&&u.forEach(l.add,l),a+=u.length,r$14.push(a)}}this.setState({getText:s$11,startIndices:r$14,numInstances:a,characterSet:l||i})}transformParagraph(e,i){let{fontAtlasManager:n}=this.state,s=n.mapping,{baselineOffset:r}=n.atlas,{fontSize:a}=n.props,l=this.state.getText,{wordBreak:c,lineHeight:f,maxWidth:d}=this.props;return Ao(l(e,i)||``,r,f*a,c,d*a,s)}renderLayers(){let{startIndices:e,numInstances:i,getText:n,fontAtlasManager:{atlas:s,mapping:r},styleVersion:a}=this.state,{data:l,_dataDiff:c,getPosition:f,getColor:d,getSize:u,getAngle:p,getPixelOffset:g,getBackgroundColor:h,getBorderColor:v,getBorderWidth:P,getContentBox:C,backgroundBorderRadius:m,backgroundPadding:x,background:L,billboard:N,fontSettings:G,outlineWidth:j,outlineColor:F,sizeScale:U,sizeUnits:D,sizeMinPixels:V,sizeMaxPixels:W,contentCutoffPixels:H,contentAlignHorizontal:Q,contentAlignVertical:lt,transitions:k,updateTriggers:I}=this.props,ct=this.getSubLayerClass(`characters`,St),$o=this.getSubLayerClass(`background`,wt),{fontSize:Tt}=this.state.fontAtlasManager.props;return[L&&new $o({getFillColor:h,getLineColor:v,getLineWidth:P,borderRadius:m,padding:x,getPosition:f,getSize:u,getAngle:p,getPixelOffset:g,getClipRect:C,billboard:N,sizeScale:U,sizeUnits:D,sizeMinPixels:V,sizeMaxPixels:W,fontSize:Tt,transitions:k&&{getPosition:k.getPosition,getAngle:k.getAngle,getSize:k.getSize,getFillColor:k.getBackgroundColor,getLineColor:k.getBorderColor,getLineWidth:k.getBorderWidth,getPixelOffset:k.getPixelOffset}},this.getSubLayerProps({id:`background`,updateTriggers:{getPosition:I.getPosition,getAngle:I.getAngle,getSize:I.getSize,getFillColor:I.getBackgroundColor,getLineColor:I.getBorderColor,getLineWidth:I.getBorderWidth,getPixelOffset:I.getPixelOffset,getBoundingRect:{getText:I.getText,getTextAnchor:I.getTextAnchor,getAlignmentBaseline:I.getAlignmentBaseline,styleVersion:a}}}),{data:l.attributes&&l.attributes.background?{length:l.length,attributes:l.attributes.background}:l,_dataDiff:c,autoHighlight:!1,getBoundingRect:this.getBoundingRect}),new ct({sdf:G.sdf,smoothing:Number.isFinite(G.smoothing)?G.smoothing:q.smoothing,outlineWidth:j/(G.radius||q.radius),outlineColor:F,iconAtlas:s,iconMapping:r,getPosition:f,getColor:d,getSize:u,getAngle:p,getPixelOffset:g,getContentBox:C,billboard:N,sizeScale:U,sizeUnits:D,sizeMinPixels:V,sizeMaxPixels:W,fontSize:Tt,contentCutoffPixels:H,contentAlignHorizontal:Q,contentAlignVertical:lt,transitions:k&&{getPosition:k.getPosition,getAngle:k.getAngle,getColor:k.getColor,getSize:k.getSize,getPixelOffset:k.getPixelOffset,getContentBox:k.getContentBox}},this.getSubLayerProps({id:`characters`,updateTriggers:{all:I.getText,getPosition:I.getPosition,getAngle:I.getAngle,getColor:I.getColor,getSize:I.getSize,getPixelOffset:I.getPixelOffset,getContentBox:I.getContentBox,getIconOffsets:{getTextAnchor:I.getTextAnchor,getAlignmentBaseline:I.getAlignmentBaseline,styleVersion:a}}}),{data:l,_dataDiff:c,startIndices:e,numInstances:i,getIconOffsets:this.getIconOffsets,getIcon:n})]}static set fontAtlasCacheLimit(e){ko(e)}}return t.defaultProps=mr,t.layerName=`TextLayer`,t})();var Ee={circle:{type:ut,props:{filled:`filled`,stroked:`stroked`,lineWidthMaxPixels:`lineWidthMaxPixels`,lineWidthMinPixels:`lineWidthMinPixels`,lineWidthScale:`lineWidthScale`,lineWidthUnits:`lineWidthUnits`,pointRadiusMaxPixels:`radiusMaxPixels`,pointRadiusMinPixels:`radiusMinPixels`,pointRadiusScale:`radiusScale`,pointRadiusUnits:`radiusUnits`,pointAntialiasing:`antialiasing`,pointBillboard:`billboard`,getFillColor:`getFillColor`,getLineColor:`getLineColor`,getLineWidth:`getLineWidth`,getPointRadius:`getRadius`}},icon:{type:ce,props:{iconAtlas:`iconAtlas`,iconMapping:`iconMapping`,iconSizeMaxPixels:`sizeMaxPixels`,iconSizeMinPixels:`sizeMinPixels`,iconSizeScale:`sizeScale`,iconSizeUnits:`sizeUnits`,iconAlphaCutoff:`alphaCutoff`,iconBillboard:`billboard`,getIcon:`getIcon`,getIconAngle:`getAngle`,getIconColor:`getColor`,getIconPixelOffset:`getPixelOffset`,getIconSize:`getSize`}},text:{type:At,props:{textSizeMaxPixels:`sizeMaxPixels`,textSizeMinPixels:`sizeMinPixels`,textSizeScale:`sizeScale`,textSizeUnits:`sizeUnits`,textBackground:`background`,textBackgroundPadding:`backgroundPadding`,textFontFamily:`fontFamily`,textFontWeight:`fontWeight`,textLineHeight:`lineHeight`,textMaxWidth:`maxWidth`,textOutlineColor:`outlineColor`,textOutlineWidth:`outlineWidth`,textWordBreak:`wordBreak`,textCharacterSet:`characterSet`,textBillboard:`billboard`,textFontSettings:`fontSettings`,getText:`getText`,getTextAngle:`getAngle`,getTextColor:`getColor`,getTextPixelOffset:`getPixelOffset`,getTextSize:`getSize`,getTextAnchor:`getTextAnchor`,getTextAlignmentBaseline:`getAlignmentBaseline`,getTextBackgroundColor:`getBackgroundColor`,getTextBorderColor:`getBorderColor`,getTextBorderWidth:`getBorderWidth`}}};var Te={type:_e,props:{lineWidthUnits:`widthUnits`,lineWidthScale:`widthScale`,lineWidthMinPixels:`widthMinPixels`,lineWidthMaxPixels:`widthMaxPixels`,lineJointRounded:`jointRounded`,lineCapRounded:`capRounded`,lineMiterLimit:`miterLimit`,lineBillboard:`billboard`,lineAntialiasing:`antialiasing`,getLineColor:`getColor`,getLineWidth:`getWidth`}};var st={type:we,props:{extruded:`extruded`,filled:`filled`,wireframe:`wireframe`,elevationScale:`elevationScale`,material:`material`,_full3d:`_full3d`,getElevation:`getElevation`,getFillColor:`getFillColor`,getLineColor:`getLineColor`}};function ae({type:t,props:o}){let e={};for(let i in o)e[i]=t.defaultProps[o[i]];return e}function rt(t,o){let{transitions:e,updateTriggers:i}=t.props,n={updateTriggers:{},transitions:e&&{getPosition:e.geometry}};for(let s in o){let r=o[s],a=t.props[s];s.startsWith(`get`)&&(a=t.getSubLayerAccessor(a),n.updateTriggers[r]=i[s],e&&(n.transitions[r]=e[s])),n[r]=a}return n}function Vo(t){if(Array.isArray(t))return t;switch(A.assert(t.type,`GeoJSON does not have type`),t.type){case`Feature`:return[t];case`FeatureCollection`:return A.assert(Array.isArray(t.features),`GeoJSON does not have features array`),t.features;default:return[{geometry:t}]}}function Et(t,o,e={}){let i={pointFeatures:[],lineFeatures:[],polygonFeatures:[],polygonOutlineFeatures:[]},{startRow:n=0,endRow:s=t.length}=e;for(let r=n;r<s;r++){let a=t[r],{geometry:l}=a;if(l)if(l.type===`GeometryCollection`){A.assert(Array.isArray(l.geometries),`GeoJSON does not have geometries array`);let{geometries:c}=l;for(let f=0;f<c.length;f++){let d=c[f];Uo(d,i,o,a,r)}}else Uo(l,i,o,a,r)}return i}function Uo(t,o,e,i,n){let{type:s,coordinates:r}=t,{pointFeatures:a,lineFeatures:l,polygonFeatures:c,polygonOutlineFeatures:f}=o;if(!_r(s,r)){A.warn(`${s} coordinates are malformed`)();return}switch(s){case`Point`:a.push(e({geometry:t},i,n));break;case`MultiPoint`:r.forEach(d=>{a.push(e({geometry:{type:`Point`,coordinates:d}},i,n))});break;case`LineString`:l.push(e({geometry:t},i,n));break;case`MultiLineString`:r.forEach(d=>{l.push(e({geometry:{type:`LineString`,coordinates:d}},i,n))});break;case`Polygon`:c.push(e({geometry:t},i,n)),r.forEach(d=>{f.push(e({geometry:{type:`LineString`,coordinates:d}},i,n))});break;case`MultiPolygon`:r.forEach(d=>{c.push(e({geometry:{type:`Polygon`,coordinates:d}},i,n)),d.forEach(u=>{f.push(e({geometry:{type:`LineString`,coordinates:u}},i,n))})});break;default:}}var Pr={Point:1,MultiPoint:2,LineString:2,MultiLineString:3,Polygon:3,MultiPolygon:4};function _r(t,o){let e=Pr[t];for(A.assert(e,`Unknown GeoJSON type ${t}`);o&&--e>0;)o=o[0];return o&&Number.isFinite(o[0])}function Ho(){return{points:{},lines:{},polygons:{},polygonsOutline:{}}}function at(t){return t.geometry.coordinates}function Zo(t,o){let e=Ho(),{pointFeatures:i,lineFeatures:n,polygonFeatures:s,polygonOutlineFeatures:r}=t;return e.points.data=i,e.points._dataDiff=o.pointFeatures&&(()=>o.pointFeatures),e.points.getPosition=at,e.lines.data=n,e.lines._dataDiff=o.lineFeatures&&(()=>o.lineFeatures),e.lines.getPath=at,e.polygons.data=s,e.polygons._dataDiff=o.polygonFeatures&&(()=>o.polygonFeatures),e.polygons.getPolygon=at,e.polygonsOutline.data=r,e.polygonsOutline._dataDiff=o.polygonOutlineFeatures&&(()=>o.polygonOutlineFeatures),e.polygonsOutline.getPath=at,e}function Ko(t){let o=Ho(),{points:e,lines:i,polygons:n}=t,s$12=vo(t);o.points.data={length:e.positions.value.length/e.positions.size,attributes:s(r({},e.attributes),{getPosition:e.positions,rowIndexes:{size:1,type:`uint32`,value:s$12.points}}),properties:e.properties,numericProps:e.numericProps,featureIds:e.featureIds},o.lines.data={length:i.pathIndices.value.length-1,startIndices:i.pathIndices.value,attributes:s(r({},i.attributes),{getPath:i.positions,rowIndexes:{size:1,type:`uint32`,value:s$12.lines}}),properties:i.properties,numericProps:i.numericProps,featureIds:i.featureIds},o.lines._pathType=`open`;let r$15=n.positions.value.length/n.positions.size,a=Array(r$15).fill(1);for(let l of n.primitivePolygonIndices.value)a[l-1]=0;return o.polygons.data={length:n.polygonIndices.value.length-1,startIndices:n.polygonIndices.value,attributes:s(r({},n.attributes),{getPolygon:n.positions,instanceVertexValid:{size:1,value:new Uint16Array(a)},rowIndexes:{size:1,type:`uint32`,value:s$12.polygons}}),properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},o.polygons._normalize=!1,n.triangles&&(o.polygons.data.attributes.indices=n.triangles.value),o.polygonsOutline.data={length:n.primitivePolygonIndices.value.length-1,startIndices:n.primitivePolygonIndices.value,attributes:s(r({},n.attributes),{getPath:n.positions,rowIndexes:{size:1,type:`uint32`,value:s$12.polygons}}),properties:n.properties,numericProps:n.numericProps,featureIds:n.featureIds},o.polygonsOutline._pathType=`open`,o}var Cr=[`points`,`linestrings`,`polygons`];var Lr=s(r(r(r(r(r({},ae(Ee.circle)),ae(Ee.icon)),ae(Ee.text)),ae(Te)),ae(st)),{stroked:!0,filled:!0,extruded:!1,wireframe:!1,_full3d:!1,iconAtlas:{type:`object`,value:null},iconMapping:{type:`object`,value:{}},getIcon:{type:`accessor`,value:t=>t.properties.icon},getText:{type:`accessor`,value:t=>t.properties.text},pointType:`circle`,getRadius:{deprecatedFor:`getPointRadius`}});var br=(()=>{class t extends Dm{initializeState(){this.state={layerProps:{},features:{},featuresDiff:{}}}updateState({props:e,changeFlags:i}){if(!i.dataChanged)return;let{data:n}=this.props,s=n&&`points`in n&&`polygons`in n&&`lines`in n;this.setState({binary:s}),s?this._updateStateBinary({props:e,changeFlags:i}):this._updateStateJSON({props:e,changeFlags:i})}_updateStateBinary({props:e,changeFlags:i}){let n=Ko(e.data);this.setState({layerProps:n})}_updateStateJSON({props:e,changeFlags:i}){let n=Vo(e.data),s=this.getSubLayerRow.bind(this),r={},a={};if(Array.isArray(i.dataChanged)){let c=this.state.features;for(let f in c)r[f]=c[f].slice(),a[f]=[];for(let f of i.dataChanged){let d=Et(n,s,f);for(let u in c)a[u].push(et({data:r[u],getIndex:p=>p.__source.index,dataRange:f,replace:d[u]}))}}else r=Et(n,s);let l=Zo(r,a);this.setState({features:r,featuresDiff:a,layerProps:l})}getPickingInfo(e){let i=super.getPickingInfo(e),{index:n,sourceLayer:s}=i;return i.featureType=Cr.find(r=>s.id.startsWith(`${this.id}-${r}-`)),n>=0&&s.id.startsWith(`${this.id}-points-text`)&&this.state.binary&&(i.index=this.props.data.points.globalFeatureIds.value[n]),i}_updateAutoHighlight(e){let i=`${this.id}-points-`,n=e.featureType===`points`;for(let s of this.getSubLayers())s.id.startsWith(i)===n&&s.updateAutoHighlight(e)}_renderPolygonLayer(){let{extruded:e,wireframe:i}=this.props,{layerProps:n}=this.state,s=`polygons-fill`,r=this.shouldRenderSubLayer(s,n.polygons?.data)&&this.getSubLayerClass(s,st.type);if(r){let a=rt(this,st.props),l=e&&i;return l||delete a.getLineColor,a.updateTriggers.lineColors=l,new r(a,this.getSubLayerProps({id:s,updateTriggers:a.updateTriggers}),n.polygons)}return null}_renderLineLayers(){let{extruded:e,stroked:i}=this.props,{layerProps:n}=this.state,s=`polygons-stroke`,r=`linestrings`,a=!e&&i&&this.shouldRenderSubLayer(s,n.polygonsOutline?.data)&&this.getSubLayerClass(s,Te.type),l=this.shouldRenderSubLayer(r,n.lines?.data)&&this.getSubLayerClass(r,Te.type);if(a||l){let c=rt(this,Te.props);return[a&&new a(c,this.getSubLayerProps({id:s,updateTriggers:c.updateTriggers}),n.polygonsOutline),l&&new l(c,this.getSubLayerProps({id:r,updateTriggers:c.updateTriggers}),n.lines)]}return null}_renderPointLayers(){let{pointType:e}=this.props,{layerProps:i,binary:n}=this.state,{highlightedObjectIndex:s$13}=this.props;!n&&Number.isFinite(s$13)&&(s$13=i.points.data.findIndex(c=>c.__source.index===s$13));let r$16=new Set(e.split(`+`)),a=[];for(let c of r$16){let f=`points-${c}`,d=Ee[c],u$1=d&&this.shouldRenderSubLayer(f,i.points?.data)&&this.getSubLayerClass(f,d.type);if(u$1){let p=rt(this,d.props),g=i.points;if(c===`text`&&n){let l=g.data.attributes,{rowIndexes:h}=l,v=u(l,[`rowIndexes`]);g=s(r({},g),{data:s(r({},g.data),{attributes:v})})}a.push(new u$1(p,this.getSubLayerProps({id:f,updateTriggers:p.updateTriggers,highlightedObjectIndex:s$13}),g))}}return a}renderLayers(){let{extruded:e}=this.props,i=this._renderPolygonLayer(),n=this._renderLineLayers(),s=this._renderPointLayers();return[!e&&i,n,s,e&&i]}getSubLayerAccessor(e){let{binary:i}=this.state;return!i||typeof e!=`function`?super.getSubLayerAccessor(e):(n,s)=>{let{data:r,index:a}=s;return e(xo(r,a),s)}}}return t.layerName=`GeoJsonLayer`,t.defaultProps=Lr,t})();export{xt as _,Xs as a,ce as c,fn as d,ut as f,xs as g,wt as h,Tn as i,de as l,wn as m,Nn as n,_e as o,we as p,St as r,br as s,At as t,en as u};
+//# debugId=19960610-36c8-5a0b-b972-26302dead612