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

package/dist/browser/chunk-BcTPI0Ei.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{$ as re$1,O as Zo$1,X as pt$1,Z as qr,h as Oi$1,l as Ko$1,n as De}from"./chunk-C7x5ioh5.js";import{C as Yr,L as ma,M as ie$1,O as ee,R as ne$1,T as ao,X as xs$1,Y as xe$1,f as Ka,v as S,w as _m,x as Wa,z as nt$1}from"./chunk-DIEcQ4a-.js";var po=v((vc,kt)=>{"use strict";kt.exports=ft;kt.exports.default=ft;function ft(i,e,t){t=t||2;var o=e&&e.length,n=o?e[0]*t:i.length,s=lo(i,0,n,t,!0),r=[];if(!s||s.next===s.prev)return r;var a,l,c,f,d,p,u;if(o&&(s=Rs(i,e,s,t)),i.length>80*t){a=c=i[0],l=f=i[1];for(var g=t;g<n;g+=t)d=i[g],p=i[g+1],d<a&&(a=d),p<l&&(l=p),d>c&&(c=d),p>f&&(f=p);u=Math.max(c-a,f-l),u=u!==0?32767/u:0}return ke(s,r,t,a,l,u,0),r}function lo(i,e,t,o,n){var s,r;if(n===zt(i,e,t,o)>0)for(s=e;s<t;s+=o)r=ao(s,i[s],i[s+1],r);else for(s=t-o;s>=e;s-=o)r=ao(s,i[s],i[s+1],r);return r&&dt(r,r.next)&&(Fe(r),r=r.next),r}function X(i,e){if(!i)return i;e||(e=i);var t=i,o;do if(o=!1,!t.steiner&&(dt(t,t.next)||w(t.prev,t,t.next)===0)){if(Fe(t),t=e=t.prev,t===t.next)break;o=!0}else t=t.next;while(o||t!==e);return e}function ke(i,e,t,o,n,s,r){if(i){!r&&s&&Fs(i,o,n,s);for(var a=i,l,c;i.prev!==i.next;){if(l=i.prev,c=i.next,s?Es(i,o,n,s):As(i)){e.push(l.i/t|0),e.push(i.i/t|0),e.push(c.i/t|0),Fe(i),i=c.next,a=c.next;continue}if(i=c,i===a){r?r===1?(i=Ts(X(i),e,t),ke(i,e,t,o,n,s,2)):r===2&&Os(i,e,t,o,n,s):ke(X(i),e,t,o,n,s,1);break}}}}function As(i){var e=i.prev,t=i,o=i.next;if(w(e,t,o)>=0)return!1;for(var n=e.x,s=t.x,r=o.x,a=e.y,l=t.y,c=o.y,f=n<s?n<r?n:r:s<r?s:r,d=a<l?a<c?a:c:l<c?l:c,p=n>s?n>r?n:r:s>r?s:r,u=a>l?a>c?a:c:l>c?l:c,g=o.next;g!==e;){if(g.x>=f&&g.x<=p&&g.y>=d&&g.y<=u&&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 Es(i,e,t,o){var n=i.prev,s=i,r=i.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,p=r.y,u=a<l?a<c?a:c:l<c?l:c,g=f<d?f<p?f:p:d<p?d:p,h=a>l?a>c?a:c:l>c?l:c,v=f>d?f>p?f:p:d>p?d:p,P=Rt(u,g,e,t,o),C=Rt(h,v,e,t,o),m=i.prevZ,x=i.nextZ;m&&m.z>=P&&x&&x.z<=C;){if(m.x>=u&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&se(a,f,l,d,c,p,m.x,m.y)&&w(m.prev,m,m.next)>=0||(m=m.prevZ,x.x>=u&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&se(a,f,l,d,c,p,x.x,x.y)&&w(x.prev,x,x.next)>=0))return!1;x=x.nextZ}for(;m&&m.z>=P;){if(m.x>=u&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&se(a,f,l,d,c,p,m.x,m.y)&&w(m.prev,m,m.next)>=0)return!1;m=m.prevZ}for(;x&&x.z<=C;){if(x.x>=u&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&se(a,f,l,d,c,p,x.x,x.y)&&w(x.prev,x,x.next)>=0)return!1;x=x.nextZ}return!0}function Ts(i,e,t){var o=i;do{var n=o.prev,s=o.next.next;!dt(n,s)&&co(n,o,o.next,s)&&De(n,s)&&De(s,n)&&(e.push(n.i/t|0),e.push(o.i/t|0),e.push(s.i/t|0),Fe(o),Fe(o.next),o=i=s),o=o.next}while(o!==i);return X(o)}function Os(i,e,t,o,n,s){var r=i;do{for(var a=r.next.next;a!==r.prev;){if(r.i!==a.i&&js(r,a)){var l=fo(r,a);r=X(r,r.next),l=X(l,l.next),ke(r,e,t,o,n,s,0),ke(l,e,t,o,n,s,0);return}a=a.next}r=r.next}while(r!==i)}function Rs(i,e,t,o){var n=[],s=0,r=e.length,a,l,c;for(;s<r;s++)a=e[s]*o,l=s<r-1?e[s+1]*o:i.length,c=lo(i,a,l,o,!1),c===c.next&&(c.steiner=!0),n.push(Gs(c));for(n.sort(Ms),s=0;s<n.length;s++)t=zs(n[s],t);return t}function Ms(i,e){return i.x-e.x}function zs(i,e){var t=ks(i,e);if(!t)return e;var o=fo(t,i);return X(o,o.next),X(t,t.next)}function ks(i,e){var t=e,o=i.x,n=i.y,s=-1/0,r;do{if(n<=t.y&&n>=t.next.y&&t.next.y!==t.y){var a=t.x+(n-t.y)*(t.next.x-t.x)/(t.next.y-t.y);if(a<=o&&a>s&&(s=a,r=t.x<t.next.x?t:t.next,a===o))return r}t=t.next}while(t!==e);if(!r)return null;var l=r,c=r.x,f=r.y,d=1/0,p;t=r;do o>=t.x&&t.x>=c&&o!==t.x&&se(n<f?o:s,n,c,f,n<f?s:o,n,t.x,t.y)&&(p=Math.abs(n-t.y)/(o-t.x),De(t,i)&&(p<d||p===d&&(t.x>r.x||t.x===r.x&&Ds(r,t)))&&(r=t,d=p)),t=t.next;while(t!==l);return r}function Ds(i,e){return w(i.prev,i,e.prev)<0&&w(e.next,i,i.next)<0}function Fs(i,e,t,o){var n=i;do n.z===0&&(n.z=Rt(n.x,n.y,e,t,o)),n.prevZ=n.prev,n.nextZ=n.next,n=n.next;while(n!==i);n.prevZ.nextZ=null,n.prevZ=null,Ns(n)}function Ns(i){var e,t,o,n,s,r,a,l,c=1;do{for(t=i,i=null,s=null,r=0;t;){for(r++,o=t,a=0,e=0;e<c&&(a++,o=o.nextZ,!!o);e++);for(l=c;a>0||l>0&&o;)a!==0&&(l===0||!o||t.z<=o.z)?(n=t,t=t.nextZ,a--):(n=o,o=o.nextZ,l--),s?s.nextZ=n:i=n,n.prevZ=s,s=n;t=o}s.nextZ=null,c*=2}while(r>1);return i}function Rt(i,e,t,o,n){return i=(i-t)*n|0,e=(e-o)*n|0,i=(i|i<<8)&16711935,i=(i|i<<4)&252645135,i=(i|i<<2)&858993459,i=(i|i<<1)&1431655765,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,i|e<<1}function Gs(i){var e=i,t=i;do(e.x<t.x||e.x===t.x&&e.y<t.y)&&(t=e),e=e.next;while(e!==i);return t}function se(i,e,t,o,n,s,r,a){return(n-r)*(e-a)>=(i-r)*(s-a)&&(i-r)*(o-a)>=(t-r)*(e-a)&&(t-r)*(s-a)>=(n-r)*(o-a)}function js(i,e){return i.next.i!==e.i&&i.prev.i!==e.i&&!Bs(i,e)&&(De(i,e)&&De(e,i)&&Ws(i,e)&&(w(i.prev,i,e.prev)||w(i,e.prev,e))||dt(i,e)&&w(i.prev,i,i.next)>0&&w(e.prev,e,e.next)>0)}function w(i,e,t){return(e.y-i.y)*(t.x-e.x)-(e.x-i.x)*(t.y-e.y)}function dt(i,e){return i.x===e.x&&i.y===e.y}function co(i,e,t,o){var n=ct(w(i,e,t)),s=ct(w(i,e,o)),r=ct(w(t,o,i)),a=ct(w(t,o,e));return!!(n!==s&&r!==a||n===0&&lt(i,t,e)||s===0&&lt(i,o,e)||r===0&&lt(t,i,o)||a===0&&lt(t,e,o))}function lt(i,e,t){return e.x<=Math.max(i.x,t.x)&&e.x>=Math.min(i.x,t.x)&&e.y<=Math.max(i.y,t.y)&&e.y>=Math.min(i.y,t.y)}function ct(i){return i>0?1:i<0?-1:0}function Bs(i,e){var t=i;do{if(t.i!==i.i&&t.next.i!==i.i&&t.i!==e.i&&t.next.i!==e.i&&co(t,t.next,i,e))return!0;t=t.next}while(t!==i);return!1}function De(i,e){return w(i.prev,i,i.next)<0?w(i,e,i.next)>=0&&w(i,i.prev,e)>=0:w(i,e,i.prev)<0||w(i,i.next,e)<0}function Ws(i,e){var t=i,o=!1,n=(i.x+e.x)/2,s=(i.y+e.y)/2;do t.y>s!=t.next.y>s&&t.next.y!==t.y&&n<(t.next.x-t.x)*(s-t.y)/(t.next.y-t.y)+t.x&&(o=!o),t=t.next;while(t!==i);return o}function fo(i,e){var t=new Mt(i.i,i.x,i.y),o=new Mt(e.i,e.x,e.y),n=i.next,s=e.prev;return i.next=e,e.prev=i,t.next=n,n.prev=t,o.next=t,t.prev=o,s.next=o,o.prev=s,o}function ao(i,e,t,o){var n=new Mt(i,e,t);return o?(n.next=o.next,n.prev=o,o.next.prev=n,o.next=n):(n.prev=n,n.next=n),n}function Fe(i){i.next.prev=i.prev,i.prev.next=i.next,i.prevZ&&(i.prevZ.nextZ=i.nextZ),i.nextZ&&(i.nextZ.prevZ=i.prevZ)}function Mt(i,e,t){this.i=i,this.x=e,this.y=t,this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1}ft.deviation=function(i,e,t,o){var n=e&&e.length,s=n?e[0]*t:i.length,r=Math.abs(zt(i,0,s,t));if(n)for(var a=0,l=e.length;a<l;a++){var c=e[a]*t,f=a<l-1?e[a+1]*t:i.length;r-=Math.abs(zt(i,c,f,t))}var d=0;for(a=0;a<o.length;a+=3){var p=o[a]*t,u=o[a+1]*t,g=o[a+2]*t;d+=Math.abs((i[p]-i[g])*(i[u+1]-i[p+1])-(i[p]-i[u])*(i[g+1]-i[p+1]))}return r===0&&d===0?0:Math.abs((d-r)/r)};function zt(i,e,t,o){for(var n=0,s=e,r=t-o;s<t;s+=o)n+=(i[r]-i[s])*(i[s+1]+i[r+1]),r=s;return n}ft.flatten=function(i){for(var e=i[0][0].length,t={vertices:[],holes:[],dimensions:e},o=0,n=0;n<i.length;n++){for(var s=0;s<i[n].length;s++)for(var r=0;r<e;r++)t.vertices.push(i[n][s][r]);n>0&&(o+=i[n-1].length,t.holes.push(o))}return t}});var pn=`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 Xt=`layout(std140) uniform arcUniforms {
+  bool greatCircle;
+  bool useShortestPath;
+  float numSegments;
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  highp int widthUnits;
+} arc;
+`;var qt={name:`arc`,source:pn,vs:Xt,fs:Xt,uniformTypes:{greatCircle:`f32`,useShortestPath:`f32`,numSegments:`f32`,widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,widthUnits:`i32`}};var Qt=`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 ei=`#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 ti=`#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 tt=[0,0,0,255];var un={getSourcePosition:{type:`accessor`,value:i=>i.sourcePosition},getTargetPosition:{type:`accessor`,value:i=>i.targetPosition},getSourceColor:{type:`accessor`,value:tt},getTargetColor:{type:`accessor`,value:tt},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 ce=class extends ao{getBounds(){return this.getAttributeManager()?.getBounds([`instanceSourcePositions`,`instanceTargetPositions`])}getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:ei,fs:ti,source:Qt,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,qt]})}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:tt},instanceTargetColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getTargetColor`,defaultValue:tt},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:t,oldProps:o,changeFlags:n}=e;(n.extensionsChanged||t.antialiasing!==o.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{widthUnits:t,widthScale:o,widthMinPixels:n,widthMaxPixels:s,greatCircle:r,wrapLongitude:a,numSegments:l}=this.props,c={numSegments:l,widthUnits:ee[t],widthScale:o,widthMinPixels:n,widthMaxPixels:s,greatCircle:r,useShortestPath:a},f=this.state.model;f.shaderInputs.setProps({arc:c}),f.setVertexCount(l*2),f.draw(this.context.renderPass)}_getModel(){return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),topology:`triangle-strip`,isInstanced:!0}))}};ce.layerName=`ArcLayer`;ce.defaultProps=un;var gn=ce;var hn=new Uint32Array([0,2,1,0,3,2]);var xn=new Float32Array([0,1,0,0,1,0,1,1]);function bt(i,e){if(!e)return vn(i);let t=Math.max(Math.abs(i[0][0]-i[3][0]),Math.abs(i[1][0]-i[2][0])),o=Math.max(Math.abs(i[1][1]-i[0][1]),Math.abs(i[2][1]-i[3][1])),n=Math.ceil(t/e)+1,s=Math.ceil(o/e)+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 p=0;p<n;p++){let u=p/(n-1);for(let g=0;g<s;g++){let h=g/(s-1),v=mn(i,u,h);c[f*3+0]=v[0],c[f*3+1]=v[1],c[f*3+2]=v[2]||0,l[f*2+0]=u,l[f*2+1]=1-h,p>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 vn(i){let e=new Float64Array(12);for(let t=0;t<i.length;t++)e[t*3+0]=i[t][0],e[t*3+1]=i[t][1],e[t*3+2]=i[t][2]||0;return{vertexCount:6,positions:e,indices:hn,texCoords:xn}}function mn(i,e,t){return Oi$1(Oi$1(i[0],i[1],t),Oi$1(i[3],i[2],t),e)}var yn=`
+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 ii=`layout(std140) uniform bitmapUniforms {
+  vec4 bounds;
+  float coordinateConversion;
+  float desaturate;
+  vec3 tintColor;
+  vec4 transparentColor;
+} bitmap;
+`;var oi={name:`bitmap`,source:yn,vs:ii,fs:ii,uniformTypes:{bounds:`vec4<f32>`,coordinateConversion:`f32`,desaturate:`f32`,tintColor:`vec3<f32>`,transparentColor:`vec4<f32>`}};var ni=`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 si=`#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 ri=`#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 _n={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 fe=class extends ao{getShaders(){return super.getShaders({vs:si,fs:ri,source:ni,modules:[ma,Wa,Ka,oi]})}initializeState(){let e=this.getAttributeManager(),t=!0;e.add({indices:{size:1,isIndexed:!0,update:o=>o.value=this.state.mesh.indices,noAlloc:t},positions:{size:3,type:`float64`,fp64:this.use64bitPositions(),update:o=>o.value=this.state.mesh.positions,noAlloc:t},texCoords:{size:2,update:o=>o.value=this.state.mesh.texCoords,noAlloc:t}})}updateState({props:e,oldProps:t,changeFlags:o}){let n=this.getAttributeManager();if(o.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),n.invalidateAll()),e.bounds!==t.bounds){let s=this.state.mesh,r$1=this._createMesh();this.state.model.setVertexCount(r$1.vertexCount);for(let a in r$1)s&&s[a]!==r$1[a]&&n.invalidate(a);this.setState(r({mesh:r$1},this._getCoordinateUniforms()))}else e._imageCoordinateSystem!==t._imageCoordinateSystem&&this.setState(this._getCoordinateUniforms())}getPickingInfo(e){let{image:t}=this.props,o=e.info;if(!o.color||!t)return o.bitmap=null,o;let{width:n,height:s}=t;o.index=0;let r=Sn(o.color);return o.bitmap={size:{width:n,height:s},uv:r,pixel:[Math.floor(r[0]*n),Math.floor(r[1]*s)]},o}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,t=e;return ai(e)&&(t=[[e[0],e[1]],[e[0],e[3]],[e[2],e[3]],[e[2],e[1]]]),bt(t,this.context.viewport.resolution)}_getModel(){let e=this.context.device.type===`webgpu`?this.getAttributeManager().getBufferLayouts({isInstanced:!1}).filter(t=>t.name!==`indices`):this.getAttributeManager().getBufferLayouts();return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:e,topology:`triangle-list`,isInstanced:!1}))}draw(e){let{shaderModuleProps:t}=e,{model:o,coordinateConversion:n,bounds:s,disablePicking:r}=this.state,{image:a,desaturate:l,transparentColor:c,tintColor:f}=this.props;if(!(t.picking.isActive&&r)&&a&&o){let d={bitmapTexture:a,bounds:s,coordinateConversion:n,desaturate:l,tintColor:f.slice(0,3).map(p=>p/255),transparentColor:c.map(p=>p/255)};o.shaderInputs.setProps({bitmap:d}),o.draw(this.context.renderPass)}}_getCoordinateUniforms(){let{_imageCoordinateSystem:e}=this.props;if(e!=="default"){let{bounds:t}=this.props;if(!ai(t))throw new Error(`_imageCoordinateSystem only supports rectangular bounds`);let o=this.context.viewport.resolution?`lnglat`:`cartesian`;if(e=e===`lnglat`?`lnglat`:`cartesian`,e===`lnglat`&&o===`cartesian`)return{coordinateConversion:-1,bounds:t};if(e===`cartesian`&&o===`lnglat`){let n=nt$1([t[0],t[1]]),s=nt$1([t[2],t[3]]);return{coordinateConversion:1,bounds:[n[0],n[1],s[0],s[1]]}}}return{coordinateConversion:0,bounds:[0,0,0,0]}}};fe.layerName=`BitmapLayer`;fe.defaultProps=_n;var Cn=fe;function Sn(i){let[e,t,o]=i,n=(o&240)/256;return[(e+(o&15)/16)/256,(t+n)/256]}function ai(i){return Number.isFinite(i[0])}var li=`layout(std140) uniform iconUniforms {
+  float sizeScale;
+  vec2 iconsTextureDim;
+  float sizeBasis;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  bool billboard;
+  highp int sizeUnits;
+  float alphaCutoff;
+} icon;
+`;var ci={name:`icon`,vs:li,fs:li,uniformTypes:{sizeScale:`f32`,iconsTextureDim:`vec2<f32>`,sizeBasis:`f32`,sizeMinPixels:`f32`,sizeMaxPixels:`f32`,billboard:`f32`,sizeUnits:`i32`,alphaCutoff:`f32`}};var fi=`#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 di=`#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 Ln=`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 pi(i){return Ln.replace(`PICKING_COLOR_ATTRIBUTE`,i?`@location(10) rowIndexes: u32,`:``).replace(`PICKING_COLOR_VALUE`,i?`picking_getPickingColorFromIndex(inp.rowIndexes)`:`picking_getPickingColorFromIndex(inp.instanceIndex)`)}var bn=1024;var wn=4;var ui=()=>{};var gi={minFilter:`linear`,mipmapFilter:`linear`,magFilter:`linear`,addressModeU:`clamp-to-edge`,addressModeV:`clamp-to-edge`};var In={x:0,y:0,width:0,height:0};function An(i){return Math.pow(2,Math.ceil(Math.log2(i)))}function En(i,e,t,o){let n=Math.min(t/e.width,o/e.height),s=Math.floor(e.width*n),r=Math.floor(e.height*n);return n===1?{image:e,width:s,height:r}:(i.canvas.height=r,i.canvas.width=s,i.clearRect(0,0,s,r),i.drawImage(e,0,0,e.width,e.height,0,0,s,r),{image:i.canvas,width:s,height:r})}function de(i){return i&&(i.id||i.url)}function xi(i){let{device:e}=i;e.type===`webgl`?i.generateMipmapsWebGL():e.type===`webgpu`&&e.generateMipmapsWebGPU(i)}function Tn(i,e,t,o){let{width:n,height:s,device:r}=i,a=r.createTexture({format:`rgba8unorm`,width:e,height:t,sampler:o,mipLevels:r.getMipLevelCount(e,t)}),l=r.createCommandEncoder();l.copyTextureToTexture({sourceTexture:i,destinationTexture:a,width:n,height:s});let c=l.finish();return r.submit(c),xi(a),i.destroy(),a}function hi(i,e,t){for(let o=0;o<e.length;o++){let{icon:n,xOffset:s$1}=e[o],r$2=de(n);i[r$2]=s(r({},n),{x:s$1,y:t})}}function On({icons:i,buffer:e,mapping:t={},xOffset:o=0,yOffset:n=0,rowHeight:s=0,canvasWidth:r}){let a=[];for(let l=0;l<i.length;l++){let c=i[l];if(!t[de(c)]){let{height:d,width:p}=c;o+p+e>r&&(hi(t,a,n),o=0,n=s+n+e,s=0,a=[]),a.push({icon:c,xOffset:o}),o=o+p+e,s=Math.max(s,d)}}return a.length>0&&hi(t,a,n),{mapping:t,rowHeight:s,xOffset:o,yOffset:n,canvasWidth:r,canvasHeight:An(s+n+e)}}function Rn(i,e,t){if(!i||!e)return null;t=t||{};let o={},{iterable:n,objectInfo:s$2}=Yr(i);for(let r$3 of n){s$2.index++;let a=e(r$3,s$2),l=de(a);if(!a)throw new Error(`Icon is missing.`);if(!a.url)throw new Error(`Icon url is missing.`);!o[l]&&(!t[l]||a.url!==t[l].url)&&(o[l]=s(r({},a),{source:r$3,sourceIndex:s$2.index}))}return o}var pe=class{constructor(e,{onUpdate:t=ui,onError:o=ui}){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=wn,this._canvasWidth=bn,this._canvasHeight=0,this._canvas=null,this.device=e,this.onUpdate=t,this.onError=o}finalize(){this._texture?.delete()}getTexture(){return this._texture||this._externalTexture}getIconMapping(e){let t=this._autoPacking?de(e):e;return this._mapping[t]||In}setProps({loadOptions:e,autoPacking:t,iconAtlas:o,iconMapping:n,textureParameters:s}){e&&(this._loadOptions=e),t!==void 0&&(this._autoPacking=t),n&&(this._mapping=n),o&&(this._texture?.delete(),this._texture=null,this._externalTexture=o),s&&(this._samplerParameters=s)}get isLoaded(){return this._pendingCount===0}packIcons(e,t){if(!this._autoPacking||typeof document>`u`)return;let o=Object.values(Rn(e,t,this._mapping)||{});if(o.length>0){let{mapping:n,xOffset:s,yOffset:r,rowHeight:a,canvasHeight:l}=On({icons:o,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||gi,mipLevels:this.device.getMipLevelCount(this._canvasWidth,this._canvasHeight)})),this._texture.height!==this._canvasHeight&&(this._texture=Tn(this._texture,this._canvasWidth,this._canvasHeight,this._samplerParameters||gi)),this.onUpdate(!0),this._canvas=this._canvas||document.createElement(`canvas`),this._loadIcons(o)}}_loadIcons(e){let t=this._canvas.getContext(`2d`,{willReadFrequently:!0});for(let o of e)this._pendingCount++,xe$1(o.url,this._loadOptions).then(n=>{let s=de(o),r=this._mapping[s],{x:a,y:l,width:c,height:f}=r,{image:d,width:p,height:u}=En(t,n,c,f),g=a+(c-p)/2,h=l+(f-u)/2;this._texture?.copyExternalImage({image:d,x:g,y:h,width:p,height:u}),r.x=g,r.y=h,r.width=p,r.height=u,this._texture&&xi(this._texture),this.onUpdate(p!==c||u!==f)}).catch(n=>{this.onError({url:o.url,source:o.source,sourceIndex:o.sourceIndex,loadOptions:this._loadOptions,error:n})}).finally(()=>{this._pendingCount--})}};var vi=[0,0,0,255];var Mn={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:i=>i.position},getIcon:{type:`accessor`,value:i=>i.icon},getColor:{type:`accessor`,value:vi},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 ue=class extends ao{getShaders(){let e=!!this.props.data?.attributes?.rowIndexes;return super.getShaders({vs:fi,fs:di,source:pi(e),defines:e?{USE_ROW_INDEXES:!0}:{},modules:[Wa,ma,Ka,ci]})}initializeState(){this.state={iconManager:new pe(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:vi},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:t,oldProps:o,changeFlags:n}=e,s=this.getAttributeManager(),{iconAtlas:r,iconMapping:a,data:l,getIcon:c,textureParameters:f}=t,{iconManager:d}=this.state;if(typeof r==`string`)return;let p=r||this.internalState.isAsyncPropLoading(`iconAtlas`);d.setProps({loadOptions:t.loadOptions,autoPacking:!p,iconAtlas:r,iconMapping:p?a:null,textureParameters:f}),p?o.iconMapping!==t.iconMapping&&s.invalidate(`getIcon`):(n.dataChanged||n.updateTriggersChanged&&(n.updateTriggersChanged.all||n.updateTriggersChanged.getIcon))&&d.packIcons(l,c),n.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),s.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:t,sizeBasis:o,sizeMinPixels:n,sizeMaxPixels:s,sizeUnits:r,billboard:a,alphaCutoff:l}=this.props,{iconManager:c}=this.state,f=c.getTexture();if(f){let d={iconsTexture:f,iconsTextureDim:[f.width,f.height],sizeUnits:ee[r],sizeScale:t,sizeBasis:o===`height`?1:0,sizeMinPixels:n,sizeMaxPixels:s,billboard:a,alphaCutoff:l};e.shaderInputs.setProps({icon:d}),e.draw(this.context.renderPass)}}_getModel(e=this.props.id){return new De(this.context.device,s(r({},this.getShaders()),{id:e,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$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 t=this.getCurrentLayer()?.props.onIconError;t?t(e):S.error(e.error.message)()}getInstanceIconDef(e){let{x:t,y:o,width:n,height:s,mask:r,anchorX:a=n/2,anchorY:l=s/2}=this.state.iconManager.getIconMapping(e);return[n/2-a,s/2-l,t,o,n,s,r?1:0]}};ue.defaultProps=Mn;ue.layerName=`IconLayer`;var ge=ue;var mi=`layout(std140) uniform lineUniforms {
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  float useShortestPath;
+  highp int widthUnits;
+} line;
+`;var yi={name:`line`,source:``,vs:mi,fs:mi,uniformTypes:{widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,useShortestPath:`f32`,widthUnits:`i32`}};var Pi=`// ---------- 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 _i=`#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 Ci=`#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 kn={getSourcePosition:{type:`accessor`,value:i=>i.sourcePosition},getTargetPosition:{type:`accessor`,value:i=>i.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 he=class extends ao{getBounds(){return this.getAttributeManager()?.getBounds([`instanceSourcePositions`,`instanceTargetPositions`])}getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:_i,fs:Ci,source:Pi,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,yi]})}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:t,oldProps:o,changeFlags:n}=e;(n.extensionsChanged||t.antialiasing!==o.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{widthUnits:t,widthScale:o,widthMinPixels:n,widthMaxPixels:s$3,wrapLongitude:r$4}=this.props,a=this.state.model,l={widthUnits:ee[t],widthScale:o,widthMinPixels:n,widthMaxPixels:s$3,useShortestPath:r$4?1:0};a.shaderInputs.setProps({line:l}),a.draw(this.context.renderPass),r$4&&(a.shaderInputs.setProps({line:s(r({},l),{useShortestPath:-1})}),a.draw(this.context.renderPass))}_getModel(){return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$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}))}};he.layerName=`LineLayer`;he.defaultProps=kn;var Dn=he;var Si=`layout(std140) uniform pointCloudUniforms {
+  float radiusPixels;
+  highp int sizeUnits;
+} pointCloud;
+`;var Li={name:`pointCloud`,source:``,vs:Si,fs:Si,uniformTypes:{radiusPixels:`f32`,sizeUnits:`i32`}};var bi=`#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 wi=`#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 Ii=`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 Ai=[0,0,0,255];var Ei=[0,0,1];var Fn={sizeUnits:`pixels`,pointSize:{type:`number`,min:0,value:10},antialiasing:!1,getPosition:{type:`accessor`,value:i=>i.position},getNormal:{type:`accessor`,value:Ei},getColor:{type:`accessor`,value:Ai},material:!0,radiusPixels:{deprecatedFor:`pointSize`}};function Nn(i){let{header:e,attributes:t}=i;if(!(!e||!t)&&(i.length=e.vertexCount,t.POSITION&&(t.instancePositions=t.POSITION),t.NORMAL&&(t.instanceNormals=t.NORMAL),t.COLOR_0)){let{size:o,value:n}=t.COLOR_0;t.instanceColors={size:o,type:`unorm8`,value:n}}}var xe=class extends ao{getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:bi,fs:wi,source:Ii,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Zo$1,Ka,Li]})}initializeState(){this.getAttributeManager().addInstanced({instancePositions:{size:3,type:`float64`,fp64:this.use64bitPositions(),transition:!0,accessor:`getPosition`},instanceNormals:{size:3,transition:!0,accessor:`getNormal`,defaultValue:Ei},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getColor`,defaultValue:Ai}})}updateState(e){let{changeFlags:t,props:o,oldProps:n}=e;super.updateState(e),(t.extensionsChanged||o.antialiasing!==n.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll()),t.dataChanged&&Nn(o.data)}draw({uniforms:e}){let{pointSize:t,sizeUnits:o}=this.props,n=this.state.model,s={sizeUnits:ee[o],radiusPixels:t};n.shaderInputs.setProps({pointCloud:s}),n.draw(this.context.renderPass)}_getModel(){let e=[];for(let t=0;t<3;t++){let o=t/3*Math.PI*2;e.push(Math.cos(o)*2,Math.sin(o)*2,0)}return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$1({topology:`triangle-list`,attributes:{positions:new Float32Array(e)}}),isInstanced:!0}))}};xe.layerName=`PointCloudLayer`;xe.defaultProps=Fn;var Gn=xe;var Ti=`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 Oi={name:`scatterplot`,vs:Ti,fs:Ti,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 Ri=`#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 Mi=`#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 jn=`// 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 zi(i){return jn.replace(`PICKING_COLOR_ATTRIBUTE`,i?`@location(8) rowIndexes: u32,`:``).replace(`PICKING_COLOR_VALUE`,i?`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(i={}){let e={};return i.enabled!==void 0&&(e.enabled=i.enabled?1:0),i.mode!==void 0&&(e.mode=i.mode===`instance`?1:0),i.bounds!==void 0&&(e.bounds=i.bounds),e}};var ki=[0,0,0,255];var Un={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:i=>i.position},getRadius:{type:`accessor`,value:1},getFillColor:{type:`accessor`,value:ki},getLineColor:{type:`accessor`,value:ki},getLineWidth:{type:`accessor`,value:1},getPixelOffset:{type:`accessor`,value:[0,0]},strokeWidth:{deprecatedFor:`getLineWidth`},outline:{deprecatedFor:`stroked`},getColor:{deprecatedFor:[`getFillColor`,`getLineColor`]}};var ve=class extends ao{getShaders(){let e=!!this.props.data?.attributes?.rowIndexes;return super.getShaders({vs:Ri,fs:Mi,source:zi(e),defines:e?{USE_ROW_INDEXES:!0}:{},modules:[Wa,ma,Ka,Oi,...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:t,radiusScale:o,radiusMinPixels:n,radiusMaxPixels:s,stroked:r,filled:a,billboard:l,antialiasing:c,lineWidthUnits:f,lineWidthScale:d,lineWidthMinPixels:p,lineWidthMaxPixels:u}=this.props,g={stroked:r,filled:a,billboard:l,antialiasing:c,radiusUnits:ee[t],radiusScale:o,radiusMinPixels:n,radiusMaxPixels:s,lineWidthUnits:ee[f],lineWidthScale:d,lineWidthMinPixels:p,lineWidthMaxPixels:u},h=this.state.model;h.shaderInputs.setProps({scatterplot:g}),h.draw(this.context.renderPass)}_getModel(){return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$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}))}};ve.defaultProps=Un;ve.layerName=`ScatterplotLayer`;var wt=ve;var oe={CLOCKWISE:1,COUNTER_CLOCKWISE:-1};function Y(i,e,t={}){return Di(i,t)!==e?(Vn(i,t),!0):!1}function Di(i,e={}){return Math.sign(ye(i,e))}var me={x:0,y:1,z:2};function ye(i,e={}){let{start:t=0,end:o=i.length,plane:n=`xy`}=e,s=e.size||2,r=0,a=me[n[0]],l=me[n[1]];for(let c=t,f=o-s;c<o;c+=s)r+=(i[c+a]-i[f+a])*(i[c+l]+i[f+l]),f=c;return r/2}function Vn(i,e){let{start:t=0,end:o=i.length,size:n=2}=e,s=(o-t)/n,r=Math.floor(s/2);for(let a=0;a<r;++a){let l=t+a*n,c=t+(s-1-a)*n;for(let f=0;f<n;++f){let d=i[l+f];i[l+f]=i[c+f],i[c+f]=d}}}function Zn(i,e,t=2,o,n=`xy`){let s=e&&e.length,r=s?e[0]*t:i.length,a=Ni(i,0,r,t,!0,o&&o[0],n),l=[];if(!a||a.next===a.prev)return l;let c,f,d,p,u,g,h;if(s&&(a=Xn(i,e,a,t,o,n)),i.length>80*t){p=f=i[0],u=d=i[1];for(let v=t;v<r;v+=t)g=i[v],h=i[v+1],g<p&&(p=g),h<u&&(u=h),g>f&&(f=g),h>d&&(d=h);c=Math.max(f-p,d-u),c=c!==0?32767/c:0}return Pe(a,l,t,p,u,c,0),l}function Ni(i,e,t,o,n,s,r){let a,l;s===void 0&&(s=ye(i,{start:e,end:t,size:o,plane:r}));let c=me[r[0]],f=me[r[1]];if(n===s<0)for(a=e;a<t;a+=o)l=Fi(a,i[a+c],i[a+f],l);else for(a=t-o;a>=e;a-=o)l=Fi(a,i[a+c],i[a+f],l);return l&&nt(l,l.next)&&(Ce(l),l=l.next),l}function J(i,e){if(!i)return i;e||(e=i);let t=i,o;do if(o=!1,!t.steiner&&(nt(t,t.next)||b(t.prev,t,t.next)===0)){if(Ce(t),t=e=t.prev,t===t.next)break;o=!0}else t=t.next;while(o||t!==e);return e}function Pe(i,e,t,o,n,s,r){if(!i)return;!r&&s&&is(i,o,n,s);let a=i,l,c;for(;i.prev!==i.next;){if(l=i.prev,c=i.next,s?$n(i,o,n,s):Kn(i)){e.push(l.i/t|0),e.push(i.i/t|0),e.push(c.i/t|0),Ce(i),i=c.next,a=c.next;continue}if(i=c,i===a){r?r===1?(i=Yn(J(i),e,t),Pe(i,e,t,o,n,s,2)):r===2&&Jn(i,e,t,o,n,s):Pe(J(i),e,t,o,n,s,1);break}}}function Kn(i){let e=i.prev,t=i,o=i.next;if(b(e,t,o)>=0)return!1;let n=e.x,s=t.x,r=o.x,a=e.y,l=t.y,c=o.y,f=n<s?n<r?n:r:s<r?s:r,d=a<l?a<c?a:c:l<c?l:c,p=n>s?n>r?n:r:s>r?s:r,u=a>l?a>c?a:c:l>c?l:c,g=o.next;for(;g!==e;){if(g.x>=f&&g.x<=p&&g.y>=d&&g.y<=u&&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 $n(i,e,t,o){let n=i.prev,s=i,r=i.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,p=r.y,u=a<l?a<c?a:c:l<c?l:c,g=f<d?f<p?f:p:d<p?d:p,h=a>l?a>c?a:c:l>c?l:c,v=f>d?f>p?f:p:d>p?d:p,P=It(u,g,e,t,o),C=It(h,v,e,t,o),m=i.prevZ,x=i.nextZ;for(;m&&m.z>=P&&x&&x.z<=C;){if(m.x>=u&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&ne(a,f,l,d,c,p,m.x,m.y)&&b(m.prev,m,m.next)>=0||(m=m.prevZ,x.x>=u&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&ne(a,f,l,d,c,p,x.x,x.y)&&b(x.prev,x,x.next)>=0))return!1;x=x.nextZ}for(;m&&m.z>=P;){if(m.x>=u&&m.x<=h&&m.y>=g&&m.y<=v&&m!==n&&m!==r&&ne(a,f,l,d,c,p,m.x,m.y)&&b(m.prev,m,m.next)>=0)return!1;m=m.prevZ}for(;x&&x.z<=C;){if(x.x>=u&&x.x<=h&&x.y>=g&&x.y<=v&&x!==n&&x!==r&&ne(a,f,l,d,c,p,x.x,x.y)&&b(x.prev,x,x.next)>=0)return!1;x=x.nextZ}return!0}function Yn(i,e,t){let o=i;do{let n=o.prev,s=o.next.next;!nt(n,s)&&Gi(n,o,o.next,s)&&_e(n,s)&&_e(s,n)&&(e.push(n.i/t|0),e.push(o.i/t|0),e.push(s.i/t|0),Ce(o),Ce(o.next),o=i=s),o=o.next}while(o!==i);return J(o)}function Jn(i,e,t,o,n,s){let r=i;do{let a=r.next.next;for(;a!==r.prev;){if(r.i!==a.i&&ss(r,a)){let l=ji(r,a);r=J(r,r.next),l=J(l,l.next),Pe(r,e,t,o,n,s,0),Pe(l,e,t,o,n,s,0);return}a=a.next}r=r.next}while(r!==i)}function Xn(i,e,t,o,n,s){let r=[],a,l,c,f,d;for(a=0,l=e.length;a<l;a++)c=e[a]*o,f=a<l-1?e[a+1]*o:i.length,d=Ni(i,c,f,o,!1,n&&n[a+1],s),d===d.next&&(d.steiner=!0),r.push(ns(d));for(r.sort(qn),a=0;a<r.length;a++)t=Qn(r[a],t);return t}function qn(i,e){return i.x-e.x}function Qn(i,e){let t=es(i,e);if(!t)return e;let o=ji(t,i);return J(o,o.next),J(t,t.next)}function es(i,e){let t=e,o=i.x,n=i.y,s=-1/0,r;do{if(n<=t.y&&n>=t.next.y&&t.next.y!==t.y){let p=t.x+(n-t.y)*(t.next.x-t.x)/(t.next.y-t.y);if(p<=o&&p>s&&(s=p,r=t.x<t.next.x?t:t.next,p===o))return r}t=t.next}while(t!==e);if(!r)return null;let a=r,l=r.x,c=r.y,f=1/0,d;t=r;do o>=t.x&&t.x>=l&&o!==t.x&&ne(n<c?o:s,n,l,c,n<c?s:o,n,t.x,t.y)&&(d=Math.abs(n-t.y)/(o-t.x),_e(t,i)&&(d<f||d===f&&(t.x>r.x||t.x===r.x&&ts(r,t)))&&(r=t,f=d)),t=t.next;while(t!==a);return r}function ts(i,e){return b(i.prev,i,e.prev)<0&&b(e.next,i,i.next)<0}function is(i,e,t,o){let n=i;do n.z===0&&(n.z=It(n.x,n.y,e,t,o)),n.prevZ=n.prev,n.nextZ=n.next,n=n.next;while(n!==i);n.prevZ.nextZ=null,n.prevZ=null,os(n)}function os(i){let e,t,o=1,n,s,r,a,l,c;do{for(s=i,i=null,c=null,n=0;s;){for(n++,a=s,r=0,t=0;t<o&&(r++,a=a.nextZ,!!a);t++);for(l=o;r>0||l>0&&a;)r!==0&&(l===0||!a||s.z<=a.z)?(e=s,s=s.nextZ,r--):(e=a,a=a.nextZ,l--),c?c.nextZ=e:i=e,e.prevZ=c,c=e;s=a}c.nextZ=null,o*=2}while(n>1);return i}function It(i,e,t,o,n){return i=(i-t)*n|0,e=(e-o)*n|0,i=(i|i<<8)&16711935,i=(i|i<<4)&252645135,i=(i|i<<2)&858993459,i=(i|i<<1)&1431655765,e=(e|e<<8)&16711935,e=(e|e<<4)&252645135,e=(e|e<<2)&858993459,e=(e|e<<1)&1431655765,i|e<<1}function ns(i){let e=i,t=i;do(e.x<t.x||e.x===t.x&&e.y<t.y)&&(t=e),e=e.next;while(e!==i);return t}function ne(i,e,t,o,n,s,r,a){return(n-r)*(e-a)>=(i-r)*(s-a)&&(i-r)*(o-a)>=(t-r)*(e-a)&&(t-r)*(s-a)>=(n-r)*(o-a)}function ss(i,e){return i.next.i!==e.i&&i.prev.i!==e.i&&!rs(i,e)&&(_e(i,e)&&_e(e,i)&&as(i,e)&&(b(i.prev,i,e.prev)||b(i,e.prev,e))||nt(i,e)&&b(i.prev,i,i.next)>0&&b(e.prev,e,e.next)>0)}function b(i,e,t){return(e.y-i.y)*(t.x-e.x)-(e.x-i.x)*(t.y-e.y)}function nt(i,e){return i.x===e.x&&i.y===e.y}function Gi(i,e,t,o){let n=ot(b(i,e,t)),s=ot(b(i,e,o)),r=ot(b(t,o,i)),a=ot(b(t,o,e));return!!(n!==s&&r!==a||n===0&&it(i,t,e)||s===0&&it(i,o,e)||r===0&&it(t,i,o)||a===0&&it(t,e,o))}function it(i,e,t){return e.x<=Math.max(i.x,t.x)&&e.x>=Math.min(i.x,t.x)&&e.y<=Math.max(i.y,t.y)&&e.y>=Math.min(i.y,t.y)}function ot(i){return i>0?1:i<0?-1:0}function rs(i,e){let t=i;do{if(t.i!==i.i&&t.next.i!==i.i&&t.i!==e.i&&t.next.i!==e.i&&Gi(t,t.next,i,e))return!0;t=t.next}while(t!==i);return!1}function _e(i,e){return b(i.prev,i,i.next)<0?b(i,e,i.next)>=0&&b(i,i.prev,e)>=0:b(i,e,i.prev)<0||b(i,i.next,e)<0}function as(i,e){let t=i,o=!1,n=(i.x+e.x)/2,s=(i.y+e.y)/2;do t.y>s!=t.next.y>s&&t.next.y!==t.y&&n<(t.next.x-t.x)*(s-t.y)/(t.next.y-t.y)+t.x&&(o=!o),t=t.next;while(t!==i);return o}function ji(i,e){let t=new Se(i.i,i.x,i.y),o=new Se(e.i,e.x,e.y),n=i.next,s=e.prev;return i.next=e,e.prev=i,t.next=n,n.prev=t,o.next=t,t.prev=o,s.next=o,o.prev=s,o}function Fi(i,e,t,o){let n=new Se(i,e,t);return o?(n.next=o.next,n.prev=o,o.next.prev=n,o.next=n):(n.prev=n,n.next=n),n}function Ce(i){i.next.prev=i.prev,i.prev.next=i.next,i.prevZ&&(i.prevZ.nextZ=i.nextZ),i.nextZ&&(i.nextZ.prevZ=i.prevZ)}var Se=class{constructor(e,t,o){this.prev=null,this.next=null,this.z=0,this.prevZ=null,this.nextZ=null,this.steiner=!1,this.i=e,this.x=t,this.y=o}};function G(i,e){let t=e.length,o=i.length;if(o>0){let n=!0;for(let s=0;s<t;s++)if(i[o-t+s]!==e[s]){n=!1;break}if(n)return!1}for(let n=0;n<t;n++)i[o+n]=e[n];return!0}function Le(i,e){let t=e.length;for(let o=0;o<t;o++)i[o]=e[o]}function Z(i,e,t,o,n=[]){let s=o+e*t;for(let r=0;r<t;r++)n[r]=i[s+r];return n}function st(i,e,t,o,n=[]){let s,r;if(t&8)s=(o[3]-i[1])/(e[1]-i[1]),r=3;else if(t&4)s=(o[1]-i[1])/(e[1]-i[1]),r=1;else if(t&2)s=(o[2]-i[0])/(e[0]-i[0]),r=2;else if(t&1)s=(o[0]-i[0])/(e[0]-i[0]),r=0;else return null;for(let a=0;a<i.length;a++)n[a]=(r&1)===a?o[r]:s*(e[a]-i[a])+i[a];return n}function be(i,e){let t=0;return i[0]<e[0]?t|=1:i[0]>e[2]&&(t|=2),i[1]<e[1]?t|=4:i[1]>e[3]&&(t|=8),t}function we(i,e){let{size:t=2,broken:o=!1,gridResolution:n=10,gridOffset:s=[0,0],startIndex:r=0,endIndex:a=i.length}=e||{},l=(a-r)/t,c=[],f=[c],d=Z(i,0,t,r),p,u,g=Ui(d,n,s,[]),h=[];G(c,d);for(let v=1;v<l;v++){for(p=Z(i,v,t,r,p),u=be(p,g);u;){st(d,p,u,g,h);let P=be(h,g);P&&(st(d,h,P,g,h),u=P),G(c,h),Le(d,h),cs(g,n,u),o&&c.length>t&&(c=[],f.push(c),G(c,d)),u=be(p,g)}G(c,p),Le(d,p)}return o?f:f[0]}var Bi=0;var ls=1;function Ie(i,e=null,t){if(!i.length)return[];let{size:o=2,gridResolution:n=10,gridOffset:s=[0,0],edgeTypes:r=!1}=t||{},a=[],l=[{pos:i,types:r?new Array(i.length/o).fill(ls):null,holes:e||[]}],c=[[],[]],f=[];for(;l.length;){let{pos:d,types:p,holes:u}=l.shift();fs(d,o,u[0]||d.length,c),f=Ui(c[0],n,s,f);let g=be(c[1],f);if(g){let h=Wi(d,p,o,0,u[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<u.length;C++)h=Wi(d,p,o,u[C],u[C+1]||d.length,f,g),h[0]&&(v.holes.push(v.pos.length),v.pos=rt(v.pos,h[0].pos),r&&(v.types=rt(v.types,h[0].types))),h[1]&&(P.holes.push(P.pos.length),P.pos=rt(P.pos,h[1].pos),r&&(P.types=rt(P.types,h[1].types)))}else{let h={positions:d};r&&(h.edgeTypes=p),u.length&&(h.holeIndices=u),a.push(h)}}return a}function Wi(i,e,t,o,n,s,r){let a=(n-o)/t,l=[],c=[],f=[],d=[],p=[],u,g,h,v=Z(i,a-1,t,o),P=Math.sign(r&8?v[1]-s[3]:v[0]-s[2]),C=e&&e[a-1],m=0,x=0;for(let S=0;S<a;S++)u=Z(i,S,t,o,u),g=Math.sign(r&8?u[1]-s[3]:u[0]-s[2]),h=e&&e[o/t+S],g&&P&&P!==g&&(st(v,u,r,s,p),G(l,p)&&f.push(C),G(c,p)&&d.push(C)),g<=0?(G(l,u)&&f.push(h),m-=g):f.length&&(f[f.length-1]=Bi),g>=0?(G(c,u)&&d.push(h),x+=g):d.length&&(d[d.length-1]=Bi),Le(v,u),P=g,C=h;return[m?{pos:l,types:e&&f}:null,x?{pos:c,types:e&&d}:null]}function Ui(i,e,t,o){let n=Math.floor((i[0]-t[0])/e)*e+t[0],s=Math.floor((i[1]-t[1])/e)*e+t[1];return o[0]=n,o[1]=s,o[2]=n+e,o[3]=s+e,o}function cs(i,e,t){t&8?(i[1]+=e,i[3]+=e):t&4?(i[1]-=e,i[3]-=e):t&2?(i[0]+=e,i[2]+=e):t&1&&(i[0]-=e,i[2]-=e)}function fs(i,e,t,o){let n=1/0,s=-1/0,r=1/0,a=-1/0;for(let l=0;l<t;l+=e){let c=i[l],f=i[l+1];n=c<n?c:n,s=c>s?c:s,r=f<r?f:r,a=f>a?f:a}return o[0][0]=n,o[0][1]=r,o[1][0]=s,o[1][1]=a,o}function rt(i,e){for(let t=0;t<e.length;t++)i.push(e[t]);return i}var ds=85.051129;function At(i,e){let{size:t=2,startIndex:o=0,endIndex:n=i.length,normalize:s=!0}=e||{},r=i.slice(o,n);Vi(r,t,0,n-o);let a=we(r,{size:t,broken:!0,gridResolution:360,gridOffset:[-180,-180]});if(s)for(let l of a)Hi(l,t);return a}function Et(i,e=null,t){let{size:o=2,normalize:n=!0,edgeTypes:s=!1}=t||{};e=e||[];let r=[],a=[],l=0,c=0;for(let d=0;d<=e.length;d++){let p=e[d]||i.length,u=c,g=ps(i,o,l,p);for(let h=g;h<p;h++)r[c++]=i[h];for(let h=l;h<g;h++)r[c++]=i[h];Vi(r,o,u,c),us(r,o,u,c,t?.maxLatitude),l=p,a[d]=c}a.pop();let f=Ie(r,a,{size:o,gridResolution:360,gridOffset:[-180,-180],edgeTypes:s});if(n)for(let d of f)Hi(d.positions,o);return f}function ps(i,e,t,o){let n=-1,s=-1;for(let r=t+1;r<o;r+=e){let a=Math.abs(i[r]);a>n&&(n=a,s=r-1)}return s}function us(i,e,t,o,n=ds){let s=i[t],r=i[o-e];if(Math.abs(s-r)>180){let a=Z(i,0,e,t);a[0]+=Math.round((r-s)/360)*360,G(i,a),a[1]=Math.sign(a[1])*n,G(i,a),a[0]=s,G(i,a)}}function Vi(i,e,t,o){let n=i[0],s;for(let r=t;r<o;r+=e){s=i[r];let a=s-n;(a>180||a<-180)&&(s-=Math.round(a/360)*360),i[r]=n=s}}function Hi(i,e){let t,o=i.length/e;for(let s=0;s<o&&(t=i[s*e],(t+180)%360===0);s++);let n=-Math.round(t/360)*360;if(n!==0)for(let s=0;s<o;s++)i[s*e]+=n}var Ae=class extends re$1{constructor(e){let{indices:t,attributes:o}=hs(e);super(s(r({},e),{topology:`line-list`,indices:t,attributes:o}))}};function hs(i){let{radius:e,height:t=1,nradial:o=10}=i,{vertices:n}=i;n&&(S.assert(n.length>=o),n=n.flatMap(u=>[u[0],u[1]]),Y(n,oe.COUNTER_CLOCKWISE));let s=t>0,r=o+1,a=s?r*3+1:o,l=Math.PI*2/o,c=new Uint16Array(s?o*3*2:0),f=new Float32Array(a*3),d=new Float32Array(a*3),p=0;if(s){for(let u=0;u<r;u++){let g=u*l,h=u%o,v=Math.sin(g),P=Math.cos(g);for(let C=0;C<2;C++)f[p+0]=n?n[h*2]:P*e,f[p+1]=n?n[h*2+1]:v*e,f[p+2]=(1/2-C)*t,d[p+0]=n?n[h*2]:P,d[p+1]=n?n[h*2+1]:v,p+=3}f[p+0]=f[p-3],f[p+1]=f[p-2],f[p+2]=f[p-1],p+=3}for(let u=s?0:1;u<r;u++){let g=Math.floor(u/2)*Math.sign(.5-u%2),h=g*l,v=(g+o)%o,P=Math.sin(h),C=Math.cos(h);f[p+0]=n?n[v*2]:C*e,f[p+1]=n?n[v*2+1]:P*e,f[p+2]=t/2,d[p+2]=1,p+=3}if(s){let u=0;for(let g=0;g<o;g++)c[u++]=g*2+0,c[u++]=g*2+2,c[u++]=g*2+0,c[u++]=g*2+1,c[u++]=g*2+1,c[u++]=g*2+3}return{indices:c,attributes:{POSITION:{size:3,value:f},NORMAL:{size:3,value:d}}}}var xs=`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 Zi=`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 Ki={name:`column`,source:xs,vs:Zi,fs:Zi,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 $i=`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 vs=`${$i}
+
+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 ms=`${$i}
+
+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 Yi(i){return i?ms:vs}var Ji=`#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 Xi=`#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 at=[0,0,0,255];var ys={name:`geometry`,stepMode:`vertex`,byteStride:24,attributes:[{attribute:`positions`,format:`float32x3`,byteOffset:0},{attribute:`normals`,format:`float32x3`,byteOffset:12}]};var Ps={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:i=>i.position},getFillColor:{type:`accessor`,value:at},getLineColor:{type:`accessor`,value:at},getLineWidth:{type:`accessor`,value:1},getElevation:{type:`accessor`,value:1e3},material:!0,getColor:{deprecatedFor:[`getFillColor`,`getLineColor`]}};var Ee=class extends ao{getShaders(){let e={},{flatShading:t}=this.props;return t&&(e.FLAT_SHADING=1),super.getShaders({vs:Ji,fs:Xi,source:Yi(t),defines:e,modules:[Wa,ma,t?Ko$1:Zo$1,Ka,Ki]})}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:at},instanceLineColors:{size:this.props.colorFormat.length,type:`unorm8`,transition:!0,accessor:`getLineColor`,defaultValue:at},instanceStrokeWidths:{size:1,accessor:`getLineWidth`,transition:!0}})}updateState(e){super.updateState(e);let{props:t,oldProps:o,changeFlags:n}=e,s=n.extensionsChanged||t.flatShading!==o.flatShading;s&&(this.state.models?.forEach(a=>a.destroy()),this.setState(this._getModels()),this.getAttributeManager().invalidateAll());let r=this.getNumInstances();this.state.fillModel.setInstanceCount(r),this.state.strokeModel.setInstanceCount(r),this.state.wireframeModel.setInstanceCount(r),(s||t.diskResolution!==o.diskResolution||t.vertices!==o.vertices||t.extruded!==o.extruded||t.stroked!==o.stroked)&&this._updateGeometry(t)}getGeometry(e,t,o){let n=new Ae({radius:1,height:o?2:0,vertices:t,nradial:e}),s=0;if(t)for(let r=0;r<e;r++){let a=t[r],l=Math.sqrt(a[0]*a[0]+a[1]*a[1]);s+=l/e}else s=1;return this.setState({edgeDistance:Math.cos(Math.PI/e)*s}),n}_getModels(){let e=this.getShaders(),t=[...this.getAttributeManager().getBufferLayouts(),ys],o=new De(this.context.device,s(r({},e),{id:`${this.props.id}-fill`,bufferLayout:t,isInstanced:!0})),n=new De(this.context.device,s(r({},e),{id:`${this.props.id}-stroke`,bufferLayout:t,isInstanced:!0})),s$4=new De(this.context.device,s(r({},e),{id:`${this.props.id}-wireframe`,bufferLayout:t,isInstanced:!0}));return{fillModel:o,strokeModel:n,wireframeModel:s$4,models:[s$4,o,n]}}_updateGeometry({diskResolution:e,vertices:t,extruded:o,stroked:n}){let s=this.getGeometry(e,t,o||n),r=s.attributes.POSITION,a=s.attributes.NORMAL;if(this._setFillGeometry(new re$1({topology:`triangle-strip`,attributes:{POSITION:r,NORMAL:a}})),!o&&n){let l=r.value.length/3;this._setStrokeGeometry(new re$1({topology:`triangle-strip`,vertexCount:l-e-1,attributes:{POSITION:r,NORMAL:a}}))}o&&this._setWireframeGeometry(s)}_setFillGeometry(e){let t=pt$1(e,{attributes:[`POSITION`,`NORMAL`]});this.state.fillModel.setGeometry(t)}_setStrokeGeometry(e){let t=pt$1(e,{attributes:[`POSITION`,`NORMAL`]});this.state.strokeModel.setGeometry(t)}_setWireframeGeometry(e){let t=pt$1(e,{attributes:[`POSITION`,`NORMAL`]}),o=this.state.wireframeModel;o.setGeometry(t),o.setTopology(`line-list`)}draw({uniforms:e}){let{lineWidthUnits:t,lineWidthScale:o,lineWidthMinPixels:n,lineWidthMaxPixels:s$5,radiusUnits:r$5,elevationScale:a,extruded:l,filled:c,stroked:f,wireframe:d,offset:p,coverage:u,radius:g,angle:h}=this.props,v=this.state.fillModel,P=this.state.strokeModel,C=this.state.wireframeModel,{edgeDistance:m}=this.state,x={radius:g,angle:h/180*Math.PI,offset:p,extruded:l,stroked:f,coverage:u,elevationScale:a,edgeDistance:m,radiusUnits:ee[r$5],widthUnits:ee[t],widthScale:o,widthMinPixels:n,widthMaxPixels:s$5};l&&d&&(C.shaderInputs.setProps({column:s(r({},x),{isStroke:!0})}),C.draw(this.context.renderPass)),c&&(v.shaderInputs.setProps({column:s(r({},x),{isStroke:!1})}),v.draw(this.context.renderPass)),!l&&f&&(P.shaderInputs.setProps({column:s(r({},x),{isStroke:!0})}),P.draw(this.context.renderPass))}};Ee.layerName=`ColumnLayer`;Ee.defaultProps=Ps;var Tt=Ee;var _s={cellSize:{type:`number`,min:0,value:1e3},offset:{type:`array`,value:[1,1]}};var Te=class extends Tt{_updateGeometry(){let e=new qr;this._setFillGeometry(e)}draw({uniforms:e}){let{elevationScale:t,extruded:o,offset:n,coverage:s,cellSize:r,angle:a,radiusUnits:l}=this.props,c=this.state.fillModel,f={radius:r/2,radiusUnits:ee[l],angle:a,offset:n,extruded:o,stroked:!1,coverage:s,elevationScale:t,edgeDistance:1,isStroke:!1,widthUnits:0,widthScale:0,widthMinPixels:0,widthMaxPixels:0};c.shaderInputs.setProps({column:f}),c.draw(this.context.renderPass)}};Te.layerName=`GridCellLayer`;Te.defaultProps=_s;var Cs=Te;function qi(i,e,t,o){let n;if(Array.isArray(i[0])){let s=i.length*e;n=new Array(s);for(let r=0;r<i.length;r++)for(let a=0;a<e;a++)n[r*e+a]=i[r][a]||0}else n=i;return t?we(n,{size:e,gridResolution:t}):o?At(n,{size:e}):n}var Ss=1;var Ls=2;var Oe=4;var Re=class extends xs$1{constructor(e){super(s(r({},e),{attributes:{positions:{size:3,padding:18,initialize:!0,type:e.fp64?Float64Array:Float32Array},segmentTypes:{size:1,type:e.isWebGPU?Float32Array:Uint8ClampedArray}}}))}get(e){return this.attributes[e]}getPathSegmentIndices(e){let t=this.attributes.segmentTypes,o=this.vertexStarts[e],n=Math.min(this.vertexStarts[e+1]??this.instanceCount,this.instanceCount),s=[];for(let r=o;r<n-1;r++)(t[r]&Oe)===0&&s.push(r);return s.length&&(t[o]&Oe)!==0&&s.unshift(s.pop()),s}getGeometryFromBuffer(e){return this.normalize||this.opts.isWebGPU?super.getGeometryFromBuffer(e):null}normalizeGeometry(e){return this.normalize?qi(e,this.positionSize,this.opts.resolution,this.opts.wrapLongitude):e}getGeometrySize(e){if(Qi(e)){let o=0;for(let n of e)o+=this.getGeometrySize(n);return o}let t=this.getPathLength(e);return t<2?0:this.isClosed(e)?t<3?0:t+2:t}updateGeometryAttributes(e,t){if(t.geometrySize!==0)if(e&&Qi(e))for(let o of e){let n=this.getGeometrySize(o);t.geometrySize=n,this.updateGeometryAttributes(o,t),t.vertexStart+=n}else this._updateSegmentTypes(e,t),this._updatePositions(e,t)}_updateSegmentTypes(e,t){let o=this.attributes.segmentTypes,n=e?this.isClosed(e):!1,{vertexStart:s,geometrySize:r}=t;o.fill(0,s,s+r),n?(o[s]=Oe,o[s+r-2]=Oe):(o[s]+=Ss,o[s+r-2]+=Ls),o[s+r-1]=Oe}_updatePositions(e,t){let{positions:o}=this.attributes;if(!o||!e)return;let{vertexStart:n,geometrySize:s}=t,r=new Array(3);for(let a=n,l=0;l<s;a++,l++)this.getPointOnPath(e,l,r),o[a*3]=r[0],o[a*3+1]=r[1],o[a*3+2]=r[2]}getPathLength(e){return e.length/this.positionSize}getPointOnPath(e,t,o=[]){let{positionSize:n}=this;t*n>=e.length&&(t+=1-e.length/n);let s=t*n;return o[0]=e[s],o[1]=e[s+1],o[2]=n===3&&e[s+2]||0,o}isClosed(e){if(!this.normalize)return!!this.opts.loop;let{positionSize:t}=this,o=e.length-t;return e[0]===e[o]&&e[1]===e[o+1]&&(t===2||e[2]===e[o+2])}};function Qi(i){return Array.isArray(i[0])}var bs=`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 eo=`layout(std140) uniform pathUniforms {
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  float jointType;
+  float capType;
+  float miterLimit;
+  bool billboard;
+  highp int widthUnits;
+} path;
+`;var to={name:`path`,source:bs,vs:eo,fs:eo,uniformTypes:{widthScale:`f32`,widthMinPixels:`f32`,widthMaxPixels:`f32`,jointType:`f32`,capType:`f32`,miterLimit:`f32`,billboard:`f32`,widthUnits:`i32`}};var io=`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 oo=`#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 no=`#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 ro=[0,0,0,255];var ws={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:i=>i.path},getColor:{type:`accessor`,value:ro},getWidth:{type:`accessor`,value:1},rounded:{deprecatedFor:[`jointRounded`,`capRounded`]}};var Ot={enter:(i,e)=>e.length?e.subarray(e.length-i.length):i};function Is(i){if(i.isGeospatial)return null;let{unitsPerMeter:e}=i.distanceScales;return[e[0],e[1],e[2]]}function so(i,e){return i===e||!!(i&&e&&i.length===e.length&&i.every((t,o)=>t===e[o]))}var Me=class extends ao{getShaders(){let{antialiasing:e}=this.props;return super.getShaders({vs:oo,fs:no,source:io,defines:e?{ANTIALIASING:1}:{},modules:[Wa,ma,Ka,to,...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 t=this.props.coordinateSystem;if(!!!this.getAttributeManager()?.getAttributes().instanceDashOffsets)return null;if(e instanceof ne$1&&e.zoom>=12&&(t==="default"||t===`lnglat`||t===`cartesian`)){let r=ie$1.getUniforms({viewport:e,coordinateSystem:t,coordinateOrigin:this.props.coordinateOrigin,autoWrapLongitude:this.wrapLongitude});return[e.projectionMode,r.coordinateOrigin[1],r.commonOrigin[1],...r.commonUnitsPerWorldUnit,...r.commonUnitsPerWorldUnit2,r.commonUnitsPerMeter[2]]}let s=Is(e);return s?[e.projectionMode,...s]:[e.projectionMode]}shouldUpdateState(e){let{viewport:t}=this.context;return super.shouldUpdateState(e)||this.state?.tessellationResolution!==t.resolution||!so(this.state?.pathProjectionScale,this.getPathProjectionScale(t))}initializeState(){let t=this.context.device.type===`webgpu`;this.getAttributeManager().addInstanced(s(r({},t?{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:Ot,accessor:`getPath`,update:this.calculatePositions,noAlloc:!0,shaderAttributes:{instanceLeftPositions:{vertexOffset:0},instanceStartPositions:{vertexOffset:1},instanceEndPositions:{vertexOffset:2},instanceRightPositions:{vertexOffset:3}}}}),{instanceTypes:{size:1,type:t?`float32`:`uint8`,update:this.calculateSegmentTypes,noAlloc:!0},instanceStrokeWidths:{size:1,accessor:`getWidth`,transition:t?!1:Ot,defaultValue:1,bufferGroup:`path-instance-data`},instanceColors:{size:this.props.colorFormat.length,type:`unorm8`,accessor:`getColor`,transition:t?!1:Ot,defaultValue:ro,bufferGroup:`path-instance-data`},rowIndexes:{size:1,type:`uint32`,accessor:(n,{index:s})=>n&&n.__source?n.__source.index:s,bufferGroup:`path-instance-data`}})),this.setState({pathTesselator:new Re({fp64:this.use64bitPositions(),isWebGPU:t}),tessellationResolution:this.context.viewport.resolution,pathProjectionScale:this.getPathProjectionScale(this.context.viewport)})}updateState(e){super.updateState(e);let{props:t,oldProps:o,changeFlags:n}=e,s=this.getAttributeManager(),{viewport:r}=this.context,a=this.state.tessellationResolution!==r.resolution,l=this.getPathProjectionScale(r),c=!so(this.state.pathProjectionScale,l),d=n.updateTriggersChanged&&(n.updateTriggersChanged.all||n.updateTriggersChanged.getPath)||t._pathType!==o._pathType||t.positionFormat!==o.positionFormat||t.wrapLongitude!==o.wrapLongitude||a;if(n.dataChanged||d){let{pathTesselator:u}=this.state,g=t.data.attributes||{};u.updateGeometry({data:t.data,geometryBuffer:g.getPath,buffers:g,normalize:!t._pathType,loop:t._pathType===`loop`,getGeometry:t.getPath,positionFormat:t.positionFormat,wrapLongitude:t.wrapLongitude,resolution:r.resolution,dataChanged:d?void 0:n.dataChanged}),this.setState({numInstances:u.instanceCount,startIndices:u.vertexStarts,tessellationResolution:r.resolution,pathProjectionScale:l}),!n.dataChanged||d?s.invalidateAll():c&&s.invalidate(`instanceDashOffsets`)}else c&&(this.setState({pathProjectionScale:l}),s.invalidate(`instanceDashOffsets`));(n.extensionsChanged||t.antialiasing!==o.antialiasing)&&(this.state.model?.destroy(),this.state.model=this._getModel(),s.invalidateAll())}getPickingInfo(e){let t=super.getPickingInfo(e),{index:o}=t,n=this.props.data;return n[0]&&n[0].__source&&(t.object=n.find(s=>s.__source.index===o)),t}disablePickingIndex(e){let t=this.props.data;if(t[0]&&t[0].__source)for(let o=0;o<t.length;o++)t[o].__source.index===e&&this._disablePickingIndex(o);else super.disablePickingIndex(e)}draw({uniforms:e}){let{jointRounded:t,capRounded:o,billboard:n,miterLimit:s,widthUnits:r,widthScale:a,widthMinPixels:l,widthMaxPixels:c}=this.props,f=this.state.model,d={jointType:Number(t),capType:Number(o),billboard:n,widthUnits:ee[r],widthScale:a,miterLimit:s,widthMinPixels:l,widthMaxPixels:c};f.shaderInputs.setProps({path:d}),f.draw(this.context.renderPass)}_getModel(){return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$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:t}=this.state;e.startIndices=t.vertexStarts,e.value=t.get(`positions`)}calculateSegmentTypes(e){let{pathTesselator:t}=this.state;e.startIndices=t.vertexStarts,e.value=t.get(`segmentTypes`)}calculateWebGPUPositions(e){let{pathTesselator:t}=this.state,o=t.get(`positions`);if(!o){e.value=null;return}let n=t.instanceCount,s=new Float32Array(n*24),r=[-1,0,1,2];for(let a=0;a<n;a++){let l=a*24;for(let c=0;c<4;c++){let f=a+r[c],d=l+c*3;for(let p=0;p<3;p++){let u=f>=0&&f<n?o[f*3+p]:0,g=Math.fround(u);s[d+p]=g,s[d+p+12]=u-g}}}e.startIndices=t.vertexStarts,e.value=s}};Me.defaultProps=ws;Me.layerName=`PathLayer`;var ze=Me;var vo=x(po(),1);var pt=oe.CLOCKWISE;var uo=oe.COUNTER_CLOCKWISE;var K={isClosed:!0};function Us(i){if(i=i&&i.positions||i,!Array.isArray(i)&&!ArrayBuffer.isView(i))throw new Error(`invalid polygon`)}function re(i){return`positions`in i?i.positions:i}function Ne(i){return`holeIndices`in i?i.holeIndices:null}function Vs(i){return Array.isArray(i[0])}function Hs(i){return i.length>=1&&i[0].length>=2&&Number.isFinite(i[0][0])}function Zs(i){let e=i[0],t=i[i.length-1];return e[0]===t[0]&&e[1]===t[1]&&e[2]===t[2]}function Ks(i,e,t,o){for(let n=0;n<e;n++)if(i[t+n]!==i[o-e+n])return!1;return!0}function go(i,e,t,o,n){let s=e,r=t.length;for(let a=0;a<r;a++)for(let l=0;l<o;l++)i[s++]=t[a][l]||0;if(!Zs(t))for(let a=0;a<o;a++)i[s++]=t[0][a]||0;return K.start=e,K.end=s,K.size=o,Y(i,n,K),s}function ho(i,e,t,o,n=0,s,r){s=s||t.length;let a=s-n;if(a<=0)return e;let l=e;for(let c=0;c<a;c++)i[l++]=t[n+c];if(!Ks(t,o,n,s))for(let c=0;c<o;c++)i[l++]=t[n+c];return K.start=e,K.end=l,K.size=o,Y(i,r,K),l}function ut(i,e){Us(i);let t=[],o=[];if(`positions`in i){let{positions:n,holeIndices:s}=i;if(s){let r=0;for(let a=0;a<=s.length;a++)r=ho(t,r,n,e,s[a-1],s[a],a===0?pt:uo),o.push(r);return o.pop(),{positions:t,holeIndices:o}}i=n}if(!Vs(i))return ho(t,0,i,e,0,t.length,pt),t;if(!Hs(i)){let n=0;for(let[s,r]of i.entries())n=go(t,n,r,e,s===0?pt:uo),o.push(n);return o.pop(),{positions:t,holeIndices:o}}return go(t,0,i,e,pt),t}function Dt(i,e,t){let o=i.length/3,n=0;for(let s=0;s<o;s++){let r=(s+1)%o;n+=i[s*3+e]*i[r*3+t],n-=i[r*3+e]*i[s*3+t]}return Math.abs(n/2)}function xo(i,e,t,o){let n=i.length/3;for(let s=0;s<n;s++){let r=s*3,a=i[r+0],l=i[r+1],c=i[r+2];i[r+e]=a,i[r+t]=l,i[r+o]=c}}function mo(i,e,t,o){let n=Ne(i);n&&(n=n.map(a=>a/e));let s=re(i),r=o&&e===3;if(t){let a=s.length;s=s.slice();let l=[];for(let c=0;c<a;c+=e){l[0]=s[c],l[1]=s[c+1],r&&(l[2]=s[c+2]);let f=t(l);s[c]=f[0],s[c+1]=f[1],r&&(s[c+2]=f[2])}}if(r){let a=Dt(s,0,1),l=Dt(s,0,2),c=Dt(s,1,2);if(!a&&!l&&!c)return[];a>l&&a>c||(l>c?(t||(s=s.slice()),xo(s,0,2,1)):(t||(s=s.slice()),xo(s,2,0,1)))}return(0,vo.default)(s,n,e)}var Ge=class extends xs$1{constructor(e){let{fp64:t,IndexType:o=Uint32Array}=e;super(s(r({},e),{attributes:{positions:{size:3,type:t?Float64Array:Float32Array},vertexValid:{type:Uint16Array,size:1},indices:{type:o,size:1}}}))}get(e){let{attributes:t}=this;return e===`indices`?t.indices&&t.indices.subarray(0,this.vertexCount):t[e]}updateGeometry(e){super.updateGeometry(e);let t=this.buffers.indices;if(t)this.vertexCount=(t.value||t).length;else if(this.data&&!this.getGeometry)throw new Error(`missing indices buffer`)}normalizeGeometry(e){if(this.normalize){let t=ut(e,this.positionSize);return this.opts.resolution?Ie(re(t),Ne(t),{size:this.positionSize,gridResolution:this.opts.resolution,edgeTypes:!0}):this.opts.wrapLongitude?Et(re(t),Ne(t),{size:this.positionSize,maxLatitude:86,edgeTypes:!0}):t}return e}getGeometrySize(e){if(Po(e)){let t=0;for(let o of e)t+=this.getGeometrySize(o);return t}return re(e).length/this.positionSize}getGeometryFromBuffer(e){return this.normalize||!this.buffers.indices?super.getGeometryFromBuffer(e):null}updateGeometryAttributes(e,t){if(e&&Po(e))for(let o of e){let n=this.getGeometrySize(o);t.geometrySize=n,this.updateGeometryAttributes(o,t),t.vertexStart+=n,t.indexStart=this.indexStarts[t.geometryIndex+1]}else{let o=e;this._updateIndices(o,t),this._updatePositions(o,t),this._updateVertexValid(o,t)}}_updateIndices(e,{geometryIndex:t,vertexStart:o,indexStart:n}){let{attributes:s,indexStarts:r,typedArrayManager:a}=this,l=s.indices;if(!l||!e)return;let c=n,f=mo(e,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]+o;r[t+1]=n+f.length,s.indices=l}_updatePositions(e,{vertexStart:t,geometrySize:o}){let{attributes:{positions:n},positionSize:s}=this;if(!n||!e)return;let r=re(e);for(let a=t,l=0;l<o;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(e,{vertexStart:t,geometrySize:o}){let{positionSize:n}=this,s=this.attributes.vertexValid,r=e&&Ne(e);if(e&&e.edgeTypes?s.set(e.edgeTypes,t):s.fill(1,t,t+o),r)for(let a=0;a<r.length;a++)s[t+r[a]/n-1]=0;s[t+o-1]=0}};function Po(i){return Array.isArray(i)&&i.length>0&&!Number.isFinite(i[0])}var $s=`struct SolidPolygonUniforms {
+  extruded: f32,
+  isWireframe: f32,
+  elevationScale: f32,
+};
+
+@group(0) @binding(auto) var<uniform> solidPolygon: SolidPolygonUniforms;
+`;var _o=`layout(std140) uniform solidPolygonUniforms {
+  bool extruded;
+  bool isWireframe;
+  float elevationScale;
+} solidPolygon;
+`;var Co={name:`solidPolygon`,source:$s,vs:_o,fs:_o,uniformTypes:{extruded:`f32`,isWireframe:`f32`,elevationScale:`f32`}};var gt=`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 So=`#version 300 es
+#define SHADER_NAME solid-polygon-layer-vertex-shader
+in vec3 vertexPositions;
+in vec3 vertexPositions64Low;
+in float elevations;
+${gt}
+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 Lo=`#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;
+${gt}
+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 bo=`#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 wo(){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 Io(){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 Ys(){return`${wo()}
+
+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;
+}
+
+${Io()}
+`}function Js(i){return`const RING_WINDING_ORDER_CW: bool = ${i?`true`:`false`};
+
+${wo()}
+
+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;
+}
+
+${Io()}
+`}function Ao(i,e){return i===`top`?Ys():Js(e)}var xt=[0,0,0,255];var Xs={filled:!0,extruded:!1,wireframe:!1,_normalize:!0,_windingOrder:`CW`,_full3d:!1,elevationScale:{type:`number`,min:0,value:1},getPolygon:{type:`accessor`,value:i=>i.polygon},getElevation:{type:`accessor`,value:1e3},getFillColor:{type:`accessor`,value:xt},getLineColor:{type:`accessor`,value:xt},material:!0};var ht={enter:(i,e)=>e.length?e.subarray(e.length-i.length):i};var je=class extends ao{getShaders(e){let t=!this.props._normalize&&this.props._windingOrder===`CCW`?0:1;return super.getShaders({vs:e===`top`?So:Lo,fs:bo,source:Ao(e,!!t),defines:{RING_WINDING_ORDER_CW:t},modules:[Wa,ma,Zo$1,Ka,Co,...this.context.device.type===`webgpu`?[ie]:[]]})}get wrapLongitude(){return!1}getBounds(){return this.getAttributeManager()?.getBounds([`vertexPositions`])}initializeState(){let{viewport:e}=this.context,{coordinateSystem:t}=this.props,{_full3d:o}=this.props;e.isGeospatial&&t==="default"&&(t=`lnglat`);let n;t===`lnglat`&&(o?n=e.projectPosition.bind(e):n=e.projectFlat.bind(e)),this.setState({numInstances:0,polygonTesselator:new Ge({preproject:n,fp64:this.use64bitPositions(),IndexType:Uint32Array})});let s$6=this.getAttributeManager(),r$6=!0,a=this.context.device.type===`webgpu`;s$6.add(s(r({indices:{size:1,isIndexed:!0,update:this.calculateIndices,noAlloc:r$6},vertexPositions:r({size:3,type:`float64`,stepMode:`dynamic`,fp64:this.use64bitPositions(),transition:ht,accessor:`getPolygon`,update:this.calculatePositions,noAlloc:r$6},a?{}:{shaderAttributes:{nextVertexPositions:{vertexOffset:1}}})},a?{nextVertexPositions:{size:3,type:`float64`,stepMode:`dynamic`,fp64:this.use64bitPositions(),transition:!1,update:this.calculateNextPositions,noAlloc:r$6}}:{}),{[a?`vertexValid`:`instanceVertexValid`]:{size:1,type:a?`float32`:`uint16`,stepMode:`instance`,update:this.calculateVertexValid,noAlloc:r$6},elevations:{size:1,stepMode:`dynamic`,transition:ht,accessor:`getElevation`,bufferGroup:`solid-polygon-instance-data`},fillColors:{size:this.props.colorFormat.length,type:`unorm8`,stepMode:`dynamic`,transition:ht,accessor:`getFillColor`,defaultValue:xt,bufferGroup:`solid-polygon-instance-data`},lineColors:{size:this.props.colorFormat.length,type:`unorm8`,stepMode:`dynamic`,transition:ht,accessor:`getLineColor`,defaultValue:xt,bufferGroup:`solid-polygon-instance-data`},rowIndexes:{size:1,type:`uint32`,stepMode:`dynamic`,accessor:(l,{index:c})=>l&&l.__source?l.__source.index:c,bufferGroup:`solid-polygon-instance-data`}}))}getPickingInfo(e){let t=super.getPickingInfo(e),{index:o}=t,n=this.props.data;return n[0]&&n[0].__source&&(t.object=n.find(s=>s.__source.index===o)),t}disablePickingIndex(e){let t=this.props.data;if(t[0]&&t[0].__source)for(let o=0;o<t.length;o++)t[o].__source.index===e&&this._disablePickingIndex(o);else super.disablePickingIndex(e)}draw({uniforms:e}){let{extruded:t,filled:o,wireframe:n,elevationScale:s$7}=this.props,{topModel:r$7,sideModel:a,wireframeModel:l,polygonTesselator:c}=this.state,f={extruded:!!t,elevationScale:s$7,isWireframe:!1};l&&n&&(l.setInstanceCount(c.instanceCount-1),l.shaderInputs.setProps({solidPolygon:s(r({},f),{isWireframe:!0})}),l.draw(this.context.renderPass)),a&&o&&(a.setInstanceCount(c.instanceCount-1),a.shaderInputs.setProps({solidPolygon:f}),a.draw(this.context.renderPass)),r$7&&o&&(r$7.setVertexCount(c.vertexCount),r$7.shaderInputs.setProps({solidPolygon:f}),r$7.draw(this.context.renderPass))}updateState(e){super.updateState(e),this.updateGeometry(e);let{props:t,oldProps:o,changeFlags:n}=e,s=this.getAttributeManager();(n.extensionsChanged||t.filled!==o.filled||t.extruded!==o.extruded)&&(this.state.models?.forEach(a=>a.destroy()),this.setState(this._getModels()),s.invalidateAll())}updateGeometry({props:e,oldProps:t,changeFlags:o}){if(o.dataChanged||o.updateTriggersChanged&&(o.updateTriggersChanged.all||o.updateTriggersChanged.getPolygon)){let{polygonTesselator:s}=this.state,r$8=e.data.attributes||{};s.updateGeometry({data:e.data,normalize:e._normalize,geometryBuffer:r$8.getPolygon,buffers:this.context.device.type===`webgpu`?r({},r$8):r$8,getGeometry:e.getPolygon,positionFormat:e.positionFormat,wrapLongitude:e.wrapLongitude,resolution:this.context.viewport.resolution,fp64:this.use64bitPositions(),dataChanged:o.dataChanged,full3d:e._full3d}),this.setState({numInstances:s.instanceCount,startIndices:s.vertexStarts}),o.dataChanged||this.getAttributeManager().invalidateAll()}}_getModels(){let{id:e,filled:t,extruded:o}=this.props,n,s$8,r$9;if(t){let a=this.getShaders(`top`);a.defines=s(r({},a.defines),{NON_INSTANCED_MODEL:1});let l=this.getAttributeManager().getBufferLayouts({isInstanced:!1});this.context.device.type===`webgpu`&&(l=l.filter(c=>c.name!==`indices`&&c.name!==`vertexValid`&&c.name!==`instanceVertexValid`&&c.name!==`nextVertexPositions`)),n=new De(this.context.device,s(r({},a),{id:`${e}-top`,topology:`triangle-list`,bufferLayout:l,isIndexed:!0,userData:{excludeAttributes:{vertexValid:!0,instanceVertexValid:!0,nextVertexPositions:!0}}}))}if(o){let a=this.getAttributeManager().getBufferLayouts({isInstanced:!0});this.context.device.type===`webgpu`&&(a=a.filter(l=>l.name!==`indices`)),s$8=new De(this.context.device,s(r({},this.getShaders(`side`)),{id:`${e}-side`,bufferLayout:a,geometry:new re$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}}})),r$9=new De(this.context.device,s(r({},this.getShaders(`side`)),{id:`${e}-wireframe`,bufferLayout:a,geometry:new re$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:[s$8,r$9,n].filter(Boolean),topModel:n,sideModel:s$8,wireframeModel:r$9}}calculateIndices(e){let{polygonTesselator:t}=this.state;e.startIndices=t.indexStarts,e.value=t.get(`indices`)}calculatePositions(e){let{polygonTesselator:t}=this.state;e.startIndices=t.vertexStarts;let o=this.props.data.attributes?.getPolygon;if(this.context.device.type===`webgpu`&&ArrayBuffer.isView(o?.value)){let{value:n,size:s=3,offset:r=0,stride:a}=o,l=r/n.BYTES_PER_ELEMENT,c=a?a/n.BYTES_PER_ELEMENT:s,f=new Float64Array(t.instanceCount*3);for(let d=0;d<t.instanceCount;d++){let p=l+d*c,u=d*3;f[u]=n[p],f[u+1]=n[p+1],f[u+2]=s>2?n[p+2]:0}e.value=f;return}e.value=t.get(`positions`)}calculateVertexValid(e){let t=this.props.data.attributes?.instanceVertexValid?.value,o=this.context.device.type===`webgpu`&&t?t:this.state.polygonTesselator.get(`vertexValid`);e.value=this.context.device.type===`webgpu`&&o?Float32Array.from(o):o}calculateNextPositions(e){let{polygonTesselator:t}=this.state,o=this.getAttributeManager().getAttributes(),n=o.vertexPositions.value,s=this.props.data.attributes?.instanceVertexValid?.value||o.vertexValid?.value||t.get(`vertexValid`);if(e.startIndices=t.vertexStarts,!n){e.value=n;return}let r=n.length/3,a=new n.constructor(n.length);for(let l=0;l<r;l++){let c=l*3,f=s?.[l]&&l+1<r?c+3:c;for(let d=0;d<3;d++)a[c+d]=n[f+d]}e.value=a}};je.defaultProps=Xs;je.layerName=`SolidPolygonLayer`;var Be=je;function vt({data:i,getIndex:e,dataRange:t,replace:o}){let{startRow:n=0,endRow:s=1/0}=t,r=i.length,a=r,l=r;for(let p=0;p<r;p++){let u=e(i[p]);if(a>p&&u>=n&&(a=p),u>=s){l=p;break}}let c=a,d=l-a!==o.length?i.slice(l):void 0;for(let p=0;p<o.length;p++)i[c++]=o[p];if(d){for(let p=0;p<d.length;p++)i[c++]=d[p];i.length=c}return{startRow:a,endRow:a+o.length}}var Eo=[0,0,0,255];var Qs={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:i=>i.polygon},getFillColor:{type:`accessor`,value:[0,0,0,255]},getLineColor:{type:`accessor`,value:Eo},getLineWidth:{type:`accessor`,value:1},getElevation:{type:`accessor`,value:1e3},material:!0};var We=class extends _m{initializeState(){this.state={paths:[],pathsDiff:null},this.props.getLineDashArray&&S.removed(`getLineDashArray`,`PathStyleExtension`)()}updateState({changeFlags:e}){let t=e.dataChanged||e.updateTriggersChanged&&(e.updateTriggersChanged.all||e.updateTriggersChanged.getPolygon);if(t&&Array.isArray(e.dataChanged)){let o=this.state.paths.slice(),n=e.dataChanged.map(s=>vt({data:o,getIndex:r=>r.__source.index,dataRange:s,replace:this._getPaths(s)}));this.setState({paths:o,pathsDiff:n})}else t&&this.setState({paths:this._getPaths(),pathsDiff:null})}_getPaths(e={}){let{data:t,getPolygon:o,positionFormat:n,_normalize:s}=this.props,r=[],a=n===`XY`?2:3,{startRow:l,endRow:c}=e,{iterable:f,objectInfo:d}=Yr(t,l,c);for(let p of f){d.index++;let u=o(p,d);s&&(u=ut(u,a));let{holeIndices:g}=u,h=u.positions||u;if(g)for(let v=0;v<=g.length;v++){let P=h.slice(g[v-1]||0,g[v]||h.length);r.push(this.getSubLayerRow({path:P},p,d.index))}else r.push(this.getSubLayerRow({path:h},p,d.index))}return r}renderLayers(){let{data:e,_dataDiff:t,stroked:o,filled:n,extruded:s,wireframe:r,_normalize:a,_windingOrder:l,elevationScale:c,transitions:f,positionFormat:d}=this.props,{lineWidthUnits:p,lineWidthScale:u,lineWidthMinPixels:g,lineWidthMaxPixels:h,lineJointRounded:v,lineMiterLimit:P,lineAntialiasing:C,lineDashJustified:m}=this.props,{getFillColor:x,getLineColor:S,getLineWidth:N,getLineDashArray:W,getElevation:j,getPolygon:F,updateTriggers:A,material:V}=this.props,{paths:B,pathsDiff:U}=this.state,$=this.getSubLayerClass(`fill`,Be),Q=this.getSubLayerClass(`stroke`,ze),D=this.shouldRenderSubLayer(`fill`,B)&&new $({_dataDiff:t,extruded:s,elevationScale:c,filled:n,wireframe:r,_normalize:a,_windingOrder:l,getElevation:j,getFillColor:x,getLineColor:s&&r?S:Eo,material:V,transitions:f},this.getSubLayerProps({id:`fill`,updateTriggers:A&&{getPolygon:A.getPolygon,getElevation:A.getElevation,getFillColor:A.getFillColor,lineColors:s&&r,getLineColor:A.getLineColor}}),{data:e,positionFormat:d,getPolygon:F}),I=!s&&o&&this.shouldRenderSubLayer(`stroke`,B)&&new Q({_dataDiff:U&&(()=>U),widthUnits:p,widthScale:u,widthMinPixels:g,widthMaxPixels:h,jointRounded:v,miterLimit:P,antialiasing:C,dashJustified:m,_pathType:`loop`,transitions:f&&{getWidth:f.getLineWidth,getColor:f.getLineColor,getPath:f.getPolygon},getColor:this.getSubLayerAccessor(S),getWidth:this.getSubLayerAccessor(N),getDashArray:this.getSubLayerAccessor(W)},this.getSubLayerProps({id:`stroke`,updateTriggers:A&&{getWidth:A.getLineWidth,getColor:A.getLineColor,getDashArray:A.getLineDashArray}}),{data:B,positionFormat:d,getPath:St=>St.path});return[!s&&D,I,s&&D]}};We.layerName=`PolygonLayer`;We.defaultProps=Qs;var er=We;function To(i,e){if(!i)return null;let t=`startIndices`in i?i.startIndices[e]:e,o=i.featureIds.value[t];return t!==-1?tr(i,o,t):null}function tr(i,e,t){let o={properties:r({},i.properties[e])};for(let n in i.numericProps)o.properties[n]=i.numericProps[n].value[t];return o}function Oo(i){let e={points:null,lines:null,polygons:null};for(let t in e){let o=i[t].globalFeatureIds.value;e[t]=new Uint32Array(o)}return e}var Ro=`layout(std140) uniform sdfUniforms {
+  float gamma;
+  bool enabled;
+  float buffer;
+  float outlineBuffer;
+  vec4 outlineColor;
+} sdf;
+`;var Mo={name:`sdf`,vs:Ro,fs:Ro,uniformTypes:{gamma:`f32`,enabled:`f32`,buffer:`f32`,outlineBuffer:`f32`,outlineColor:`vec4<f32>`}};var Ue={none:0,start:1,center:2,end:3};var mt={name:`text`,vs:`layout(std140) uniform textUniforms {
+  highp vec2 cutoffPixels;
+  highp ivec2 align;
+  highp float fontSize;
+  bool flipY;
+} text;
+
+#define ALIGN_MODE_START ${Ue.start}
+#define ALIGN_MODE_CENTER ${Ue.center}
+#define ALIGN_MODE_END ${Ue.end}
+`,getUniforms:({contentCutoffPixels:i=[0,0],contentAlignHorizontal:e=`none`,contentAlignVertical:t=`none`,fontSize:o,viewport:n})=>({cutoffPixels:i,align:[Ue[e],Ue[t]],fontSize:o,flipY:n?.flipY??!1}),uniformTypes:{cutoffPixels:`vec2<f32>`,align:`vec2<i32>`,fontSize:`f32`,flipY:`f32`}};var zo=`#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 ko=`#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 or({collision:i=!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>
+};
+
+${i?`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;
+${i?`@group(0) @binding(auto) var<uniform> collision: CollisionUniforms;`:``}
+@group(0) @binding(auto) var iconsTexture : texture_2d<f32>;
+@group(0) @binding(auto) var iconsTextureSampler : sampler;
+${i?`@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;
+}
+
+${i?`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>,
+  ${i?`@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);
+      }
+    }
+  }
+
+  ${i?`  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);
+  }
+
+  ${i?`  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 Do=or();var Ft=192/256;var nr={getIconOffsets:{type:`accessor`,value:i=>i.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 Ve=class extends ge{getShaders(){let e=super.getShaders();return s(r({},e),{modules:[...e.modules,mt,Mo],vs:zo,fs:ko,source:Do})}initializeState(){super.initializeState();let e=this.getAttributeManager(),t=e.attributes.instanceIconDefs;t.settings.update=this.calculateInstanceIconDefs,e.addInstanced({rowIndexes:{type:`uint32`,size:1,bufferGroup:`icon-instance-data`,accessor:(o,{index:n})=>n},instanceClipRect:{size:4,bufferGroup:`icon-instance-data`,accessor:`getContentBox`,defaultValue:[0,0,-1,-1]}})}updateState(e){super.updateState(e);let{props:t,oldProps:o,changeFlags:n}=e,{outlineColor:s}=t;if(n.extensionsChanged){this.state.fillModel?.destroy();let r=this.context.device.type===`webgpu`?this._getModel(`${this.props.id}-fill`):void 0;this.setState({fillModel:r,models:r?[this.state.model,r]:[this.state.model]})}if(n.updateTriggersChanged&&(n.updateTriggersChanged.getIcon||n.updateTriggersChanged.getIconOffsets)&&this.getAttributeManager().invalidate(`instanceIconDefs`),s!==o.outlineColor){let r=[s[0]/255,s[1]/255,s[2]/255,(s[3]??255)/255];this.setState({outlineColor:r})}!t.sdf&&t.outlineWidth&&S.warn(`${this.id}: fontSettings.sdf is required to render outline`)()}draw(e){let{sdf:t,smoothing:o,fontSize:n,outlineWidth:s$9,contentCutoffPixels:r$10,contentAlignHorizontal:a,contentAlignVertical:l}=this.props,{outlineColor:c}=this.state,f=s$9?Math.max(o,Ft*(1-s$9)):-1,d=this.state.model,p={buffer:Ft,outlineBuffer:f,gamma:o,enabled:!!t,outlineColor:c},u={contentCutoffPixels:r$10,contentAlignHorizontal:a,contentAlignVertical:l,fontSize:n,viewport:this.context.viewport};if(d.shaderInputs.setProps({sdf:p,text:u}),super.draw(e),t&&s$9){let{iconManager:g}=this.state;if(g.getTexture()){let v=this.state.fillModel||d;v.shaderInputs.setProps({sdf:s(r({},p),{outlineBuffer:Ft}),text:u}),this._drawModel(v)}}}calculateInstanceIconDefs(e,{startRow:t,endRow:o}){let{data:n,getIcon:s,getIconOffsets:r}=this.props,a=e.getVertexOffset(t),l=e.value,{iterable:c,objectInfo:f}=Yr(n,t,o);for(let d of c){f.index++;let p=s(d,f),u=r(d,f);if(p){let g=0;for(let h of Array.from(p)){let v=super.getInstanceIconDef(h);v[0]=u[g*2],v[1]+=u[g*2+1],v[6]=1,l.set(v,a),a+=e.size,g++}}}}};Ve.defaultProps=nr;Ve.layerName=`MultiIconLayer`;var Nt=Ve;var Gt=new Float64Array(256);for(let i=0;i<256;i++){let e=.5-Math.pow(i/255,.45454545454545453);Gt[i]=e*Math.abs(e)}Gt[255]=-0x56bc75e2d63100000;var He=class{constructor({fontSize:e=24,buffer:t=3,radius:o=8,cutoff:n=.25,fontFamily:s=`sans-serif`,fontWeight:r=`normal`,fontStyle:a=`normal`,lang:l=null}={}){t=this.buffer=Math.round(t),this.radius=o,this.cutoff=n,this.lang=l;let c=this.size=Math.ceil(e)+t*4,f=this._createCanvas(c),d=this.ctx=f.getContext(`2d`,{willReadFrequently:!0});d.font=`${a} ${r} ${e}px ${s}`,d.textBaseline=`alphabetic`,d.textAlign=`left`,d.fillStyle=`black`,l&&(d.lang=l);let u=(this.maxGlyphDim=c-t)+2*t;this.gridOuter=new Float64Array(u*u),this.gridInner=new Float64Array(u*u),this.f=new Float64Array(u),this.z=new Float64Array(u+1),this.v=new Uint16Array(u)}_createCanvas(e){if(typeof OffscreenCanvas<`u`)return new OffscreenCanvas(e,e);let t=document.createElement(`canvas`);return t.width=t.height=e,t}draw(e){let{width:t,actualBoundingBoxAscent:o,actualBoundingBoxDescent:n,actualBoundingBoxLeft:s,actualBoundingBoxRight:r}=this.ctx.measureText(e),a=Math.ceil(o),l=Math.floor(-s),c=Math.max(0,Math.min(this.maxGlyphDim,Math.ceil(r)-l)),f=Math.max(0,Math.min(this.maxGlyphDim,a+Math.ceil(n))),d=c+2*this.buffer,p=f+2*this.buffer,u=d*p,g=new Uint8ClampedArray(u),h={data:g,width:d,height:p,glyphWidth:c,glyphHeight:f,glyphTop:a,glyphLeft:l,glyphAdvance:t};if(c===0||f===0)return h;let{ctx:v,buffer:P,gridInner:C,gridOuter:m}=this;v.clearRect(P,P,c,f),v.fillText(e,P-l,P+a);let x=v.getImageData(P,P,c,f);m.fill(0x56bc75e2d63100000,0,u),C.fill(0,0,u);let S=3;for(let F=0;F<f;F++){let A=(F+P)*d+P;for(let V=0;V<c;V++,S+=4,A++){let B=x.data[S];if(B===0)continue;let U=Gt[B];m[A]=Math.max(0,U),C[A]=Math.max(0,-U)}}Fo(m,0,0,d,p,d,this.f,this.v,this.z,P);let N=Math.min(P,1);Fo(C,P-N,P-N,c+2*N,f+2*N,d,this.f,this.v,this.z);let W=255/this.radius,j=255*(1-this.cutoff);for(let F=0;F<u;F++){let A=Math.sqrt(m[F])-Math.sqrt(C[F]);g[F]=j-W*A}return h}};function Fo(i,e,t,o,n,s,r,a,l,c=0){for(let f=e+c;f<e+o-c;f++)No(i,t*s+f,s,n,r,a,l);for(let f=t;f<t+n;f++)No(i,f*s+e,1,o,r,a,l)}function No(i,e,t,o,n,s,r){s[0]=0,r[0]=-0x56bc75e2d63100000,r[1]=0x56bc75e2d63100000,n[0]=i[e];for(let a=1,l=0;a<o;a++){let c=n[a]=i[e+a*t],f=a*a,d;do{let p=s[l];d=(c-n[p]+f-p*p)/(a-p)/2}while(d<=r[l]&&--l>-1);l++,s[l]=a,r[l]=d,r[l+1]=0x56bc75e2d63100000}for(let a=0,l=0;a<o;a++){for(;r[l+1]<a;)l++;let c=s[l],f=a-c;i[e+a*t]=n[c]+f*f}}var sr=32;var rr=[];function ar(i){return Math.pow(2,Math.ceil(Math.log2(i)))}function Go({characterSet:i,measureText:e,buffer:t,maxCanvasWidth:o,mapping:n={},xOffset:s=0,yOffsetMin:r=0,yOffsetMax:a=0}){let c=s,f=r,d=a;for(let p of i)if(!n[p]){let{advance:u,width:g,ascent:h,descent:v}=e(p),P=h+v;c+g+t*2>o&&(c=0,f=d),n[p]={x:c+t,y:f+t,width:g,height:P,advance:u,anchorX:g/2,anchorY:h},c+=g+t*2,d=Math.max(d,f+P+t*2)}return{mapping:n,xOffset:c,yOffsetMin:f,yOffsetMax:d,canvasHeight:ar(d)}}function jo(i,e,t,o){let n=0;for(let s=e;s<t;s++){let r=i[s];n+=o[r]?.advance||0}return n}function Bo(i,e,t,o,n,s){let r=e,a=0;for(let l=e;l<t;l++){let c=jo(i,l,l+1,n);a+c>o&&(r<l&&s.push(l),r=l,a=0),a+=c}return a}function lr(i,e,t,o,n,s){let r=e,a=e,l=e,c=0;for(let f=e;f<t;f++)if((i[f]===` `||i[f+1]===` `||f+1===t)&&(l=f+1),l>a){let d=jo(i,a,l,n);c+d>o&&(r<a&&(s.push(a),r=a,c=0),d>o&&(d=Bo(i,a,l,o,n,s),r=s[s.length-1])),a=l,c+=d}return c}function cr(i,e,t,o,n=0,s){s===void 0&&(s=i.length);let r=[];return e===`break-all`?Bo(i,n,s,t,o,r):lr(i,n,s,t,o,r),r}function fr(i,e,t,o,n,s){let r=0,a=0;for(let l=e;l<t;l++){let f=o[i[l]];f&&(a=Math.max(a,f.height))}for(let l=e;l<t;l++){let c=i[l],f=o[c];f?(n[l]=r+f.anchorX,r+=f.advance):(S.warn(`Missing character: ${c} (${c.codePointAt(0)})`)(),n[l]=r,r+=sr)}s[0]=r,s[1]=a}function Wo(i,e,t,o,n,s){let r=Array.from(i),a=r.length,l=new Array(a),c=new Array(a),f=new Array(a),d=(o===`break-word`||o===`break-all`)&&isFinite(n)&&n>0,p=[0,0],u=[0,0],g=0,h=e+t/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?cr(r,o,n,s,v,P):rr;for(let S=0;S<=x.length;S++){let N=S===0?v:x[S-1],W=S<x.length?x[S]:P;fr(r,N,W,s,l,u);for(let j=N;j<W;j++)c[j]=h,f[j]=u[0];g++,h+=t,p[0]=Math.max(p[0],u[0])}v=P}m===`
+`&&(l[v]=0,c[v]=0,f[v]=0,v++)}return p[1]=g*t,{x:l,y:c,rowWidth:f,size:p}}function Uo({value:i,length:e,stride:t,offset:o,startIndices:n,characterSet:s}){let r=i.BYTES_PER_ELEMENT,a=t?t/r:1,l=o?o/r:0,c=n[e]||Math.ceil((i.length-l)/a),f=s&&new Set,d=new Array(e),p=i;if(a>1||l>0){let u=i.constructor;p=new u(c);for(let g=0;g<c;g++)p[g]=i[g*a+l]}for(let u=0;u<e;u++){let g=n[u],h=n[u+1]||c,v=p.subarray(g,h);d[u]=String.fromCodePoint.apply(null,v),f&&v.forEach(f.add,f)}if(f)for(let u of f)s.add(String.fromCodePoint(u));return{texts:d,characterCount:c}}var ae=class{constructor(e=5){this._cache={},this._order=[],this.limit=e}get(e){let t=this._cache[e];return t&&(this._deleteOrder(e),this._appendOrder(e)),t}set(e,t){this._cache[e]?(this.delete(e),this._cache[e]=t,this._appendOrder(e)):(Object.keys(this._cache).length===this.limit&&this.delete(this._order[0]),this._cache[e]=t,this._appendOrder(e))}delete(e){this._cache[e]&&(delete this._cache[e],this._deleteOrder(e))}_deleteOrder(e){let t=this._order.indexOf(e);t>=0&&this._order.splice(t,1)}_appendOrder(e){this._order.push(e)}};function dr(){let i=[];for(let e=32;e<128;e++)i.push(String.fromCharCode(e));return i}var q={fontFamily:`Monaco, monospace`,fontWeight:`normal`,characterSet:dr(),fontSize:64,buffer:4,sdf:!1,cutoff:.25,radius:12,smoothing:.1};var Vo=1024;var Ho=.9;var Zo=.3;var $o=3;var yt=new ae($o);function pr(i,e){let t;typeof e==`string`?t=new Set(Array.from(e)):t=new Set(e);let o=yt.get(i);if(!o)return t;for(let n in o.mapping)t.has(n)&&t.delete(n);return t}function ur(i,e){for(let t=0;t<i.length;t++)e.data[4*t+3]=i[t]}function Ko(i,e,t,o){i.font=`${o} ${t}px ${e}`,i.fillStyle=`#000`,i.textBaseline=`alphabetic`,i.textAlign=`left`}function gr(i,e,t){if(t===void 0){let n=i.measureText(`A`);return n.fontBoundingBoxAscent?{advance:0,width:0,ascent:Math.ceil(n.fontBoundingBoxAscent),descent:Math.ceil(n.fontBoundingBoxDescent)}:{advance:0,width:0,ascent:e*Ho,descent:e*Zo}}let o=i.measureText(t);return o.actualBoundingBoxAscent?{advance:o.width,width:Math.ceil(o.actualBoundingBoxRight-o.actualBoundingBoxLeft),ascent:Math.ceil(o.actualBoundingBoxAscent),descent:Math.ceil(o.actualBoundingBoxDescent)}:{advance:o.width,width:o.width,ascent:e*Ho,descent:e*Zo}}function Yo(i){S.assert(Number.isFinite(i)&&i>=$o,`Invalid cache limit`),yt=new ae(i)}var Ze=class{constructor(){this.props=r({},q)}get atlas(){return this._atlas}get mapping(){return this._atlas&&this._atlas.mapping}setProps(e={}){Object.assign(this.props,e),e._getFontRenderer&&(this._getFontRenderer=e._getFontRenderer),this._key=this._getKey();let t=pr(this._key,this.props.characterSet),o=yt.get(this._key);if(o&&t.size===0){this._atlas!==o&&(this._atlas=o);return}let n=this._generateFontAtlas(t,o);this._atlas=n,yt.set(this._key,n)}_generateFontAtlas(e,t){let{fontFamily:o,fontWeight:n,fontSize:s,buffer:r$11,sdf:a,radius:l,cutoff:c}=this.props,f=t&&t.data;f||(f=document.createElement(`canvas`),f.width=Vo);let d=f.getContext(`2d`,{willReadFrequently:!0});Ko(d,o,s,n);let p=x=>gr(d,s,x),u;this._getFontRenderer?u=this._getFontRenderer(this.props):a&&(u={measure:p,draw:hr(this.props)});let{mapping:g,canvasHeight:h,xOffset:v,yOffsetMin:P,yOffsetMax:C}=Go(r({measureText:x=>u?u.measure(x):p(x),buffer:r$11,characterSet:e,maxCanvasWidth:Vo},t&&{mapping:t.mapping,xOffset:t.xOffset,yOffsetMin:t.yOffsetMin,yOffsetMax:t.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(Ko(d,o,s,n),u)for(let x of e){let S=g[x],N=S.width,{data:W,left:j=0,top:F=0}=u.draw(x),A=S.x-j,V=S.y-F,B=Math.max(0,Math.round(A)),U=Math.max(0,Math.round(V)),$=Math.min(W.width,f.width-B),Q=Math.min(W.height,f.height-U);d.putImageData(W,B,U,0,0,$,Q),S.x=B,S.y=U,S.width=$,S.height=Q,S.anchorX+=$/2-j-N/2,S.anchorY+=F}else for(let x of e){let S=g[x];d.fillText(x,S.x,S.y+S.anchorY)}let m=u?u.measure():p();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:e,fontWeight:t,fontSize:o,buffer:n,sdf:s,radius:r,cutoff:a}=this.props;return s?`${e} ${t} ${o} ${n} ${r} ${a}`:`${e} ${t} ${o} ${n}`}};function hr({fontSize:i,buffer:e,radius:t,cutoff:o,fontFamily:n,fontWeight:s}){let r=new He({fontSize:i,buffer:e,radius:t,cutoff:o,fontFamily:n,fontWeight:`${s}`});return a=>{let{data:l,width:c,height:f}=r.draw(a),d=new ImageData(c,f);return ur(l,d),{data:d,left:e,top:e}}}var xr=`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 Jo=`layout(std140) uniform textBackgroundUniforms {
+  bool billboard;
+  float sizeScale;
+  float sizeMinPixels;
+  float sizeMaxPixels;
+  vec4 borderRadius;
+  vec4 padding;
+  highp int sizeUnits;
+  bool stroked;
+} textBackground;
+`;var Xo={name:`textBackground`,source:xr,vs:Jo,fs:Jo,uniformTypes:{billboard:`f32`,sizeScale:`f32`,sizeMinPixels:`f32`,sizeMaxPixels:`f32`,borderRadius:`vec4<f32>`,padding:`vec4<f32>`,sizeUnits:`i32`,stroked:`f32`}};var qo=`#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 Qo=`#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 en=`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 vr={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:i=>i.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 Ke=class extends ao{getShaders(){return super.getShaders({vs:qo,fs:Qo,source:en,modules:[Wa,ma,Ka,Xo,mt]})}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:t}=e;t.extensionsChanged&&(this.state.model?.destroy(),this.state.model=this._getModel(),this.getAttributeManager().invalidateAll())}draw({uniforms:e}){let{billboard:t,sizeScale:o,sizeUnits:n,sizeMinPixels:s,sizeMaxPixels:r,getLineWidth:a,fontSize:l}=this.props,{padding:c,borderRadius:f}=this.props;c.length<4&&(c=[c[0],c[1],c[0],c[1]]),Array.isArray(f)||(f=[f,f,f,f]);let d=this.state.model,p={billboard:t,stroked:!!a,borderRadius:f,padding:c,sizeUnits:ee[n],sizeScale:o,sizeMinPixels:s,sizeMaxPixels:r},u={fontSize:l,viewport:this.context.viewport};d.shaderInputs.setProps({textBackground:p,text:u}),d.draw(this.context.renderPass)}_getModel(){return new De(this.context.device,s(r({},this.getShaders()),{id:this.props.id,bufferLayout:this.getAttributeManager().getBufferLayouts(),geometry:new re$1({topology:`triangle-strip`,vertexCount:4,attributes:{positions:{size:2,value:new Float32Array([0,0,1,0,0,1,1,1])}}}),isInstanced:!0}))}};Ke.defaultProps=vr;Ke.layerName=`TextBackgroundLayer`;var jt=Ke;var tn={start:1,middle:0,end:-1};var on={top:1,center:0,bottom:-1};var Bt=[0,0,0,255];var yr={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:Bt},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:Bt},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:i=>i.text},getPosition:{type:`accessor`,value:i=>i.position},getColor:{type:`accessor`,value:Bt},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 $e=class extends _m{constructor(){super(...arguments),this.getBoundingRect=(e,t)=>{let{size:[o,n]}=this.transformParagraph(e,t),{getTextAnchor:s,getAlignmentBaseline:r}=this.props,a=tn[typeof s==`function`?s(e,t):s],l=on[typeof r==`function`?r(e,t):r];return[(a-1)*o/2,(l-1)*n/2,o,n]},this.getIconOffsets=(e,t)=>{let{getTextAnchor:o,getAlignmentBaseline:n}=this.props,{x:s,y:r,rowWidth:a,size:[,l]}=this.transformParagraph(e,t),c=tn[typeof o==`function`?o(e,t):o],f=on[typeof n==`function`?n(e,t):n],d=s.length,p=new Array(d*2),u=0;for(let g=0;g<d;g++)p[u++]=(c-1)*a[g]/2+s[g],p[u++]=(f-1)*l/2+r[g];return p}}initializeState(){this.state={styleVersion:0,fontAtlasManager:new Ze},this.props.maxWidth>0&&S.once(1,`v8.9 breaking change: TextLayer maxWidth is now relative to text size`)()}updateState(e){let{props:t,oldProps:o,changeFlags:n}=e;(n.dataChanged||n.updateTriggersChanged&&(n.updateTriggersChanged.all||n.updateTriggersChanged.getText))&&this._updateText(),(this._updateFontAtlas()||t.lineHeight!==o.lineHeight||t.wordBreak!==o.wordBreak||t.maxWidth!==o.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:t,fontWeight:o,_getFontRenderer:n}=this.props,{fontAtlasManager:s$10,characterSet:r$12}=this.state,a=s(r({},e),{characterSet:r$12,fontFamily:t,fontWeight:o,_getFontRenderer:n});if(!s$10.mapping)return s$10.setProps(a),!0;for(let l in a)if(a[l]!==s$10.props[l])return s$10.setProps(a),!0;return!1}_updateText(){let{data:e,characterSet:t}=this.props,o=e.attributes?.getText,{getText:n}=this.props,s$11=e.startIndices,r$13,a=t===`auto`&&new Set;if(o&&s$11){let{texts:l,characterCount:c}=Uo(s(r({},ArrayBuffer.isView(o)?{value:o}:o),{length:e.length,startIndices:s$11,characterSet:a}));r$13=c,n=(f,{index:d})=>l[d]}else{let{iterable:l,objectInfo:c}=Yr(e);s$11=[0],r$13=0;for(let f of l){c.index++;let d=Array.from(n(f,c)||``);a&&d.forEach(a.add,a),r$13+=d.length,s$11.push(r$13)}}this.setState({getText:n,startIndices:s$11,numInstances:r$13,characterSet:a||t})}transformParagraph(e,t){let{fontAtlasManager:o}=this.state,n=o.mapping,{baselineOffset:s}=o.atlas,{fontSize:r}=o.props,a=this.state.getText,{wordBreak:l,lineHeight:c,maxWidth:f}=this.props;return Wo(a(e,t)||``,s,c*r,l,f*r,n)}renderLayers(){let{startIndices:e,numInstances:t,getText:o,fontAtlasManager:{atlas:n,mapping:s},styleVersion:r}=this.state,{data:a,_dataDiff:l,getPosition:c,getColor:f,getSize:d,getAngle:p,getPixelOffset:u,getBackgroundColor:g,getBorderColor:h,getBorderWidth:v,getContentBox:P,backgroundBorderRadius:C,backgroundPadding:m,background:x,billboard:S,fontSettings:N,outlineWidth:W,outlineColor:j,sizeScale:F,sizeUnits:A,sizeMinPixels:V,sizeMaxPixels:B,contentCutoffPixels:U,contentAlignHorizontal:$,contentAlignVertical:Q,transitions:D,updateTriggers:I}=this.props,St=this.getSubLayerClass(`characters`,Nt),cn=this.getSubLayerClass(`background`,jt),{fontSize:Vt}=this.state.fontAtlasManager.props;return[x&&new cn({getFillColor:g,getLineColor:h,getLineWidth:v,borderRadius:C,padding:m,getPosition:c,getSize:d,getAngle:p,getPixelOffset:u,getClipRect:P,billboard:S,sizeScale:F,sizeUnits:A,sizeMinPixels:V,sizeMaxPixels:B,fontSize:Vt,transitions:D&&{getPosition:D.getPosition,getAngle:D.getAngle,getSize:D.getSize,getFillColor:D.getBackgroundColor,getLineColor:D.getBorderColor,getLineWidth:D.getBorderWidth,getPixelOffset:D.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:r}}}),{data:a.attributes&&a.attributes.background?{length:a.length,attributes:a.attributes.background}:a,_dataDiff:l,autoHighlight:!1,getBoundingRect:this.getBoundingRect}),new St({sdf:N.sdf,smoothing:Number.isFinite(N.smoothing)?N.smoothing:q.smoothing,outlineWidth:W/(N.radius||q.radius),outlineColor:j,iconAtlas:n,iconMapping:s,getPosition:c,getColor:f,getSize:d,getAngle:p,getPixelOffset:u,getContentBox:P,billboard:S,sizeScale:F,sizeUnits:A,sizeMinPixels:V,sizeMaxPixels:B,fontSize:Vt,contentCutoffPixels:U,contentAlignHorizontal:$,contentAlignVertical:Q,transitions:D&&{getPosition:D.getPosition,getAngle:D.getAngle,getColor:D.getColor,getSize:D.getSize,getPixelOffset:D.getPixelOffset,getContentBox:D.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:r}}}),{data:a,_dataDiff:l,startIndices:e,numInstances:t,getIconOffsets:this.getIconOffsets,getIcon:o})]}static set fontAtlasCacheLimit(e){Yo(e)}};$e.defaultProps=yr;$e.layerName=`TextLayer`;var Wt=$e;var Ye={circle:{type:wt,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:ge,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:Wt,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 Je={type:ze,props:{lineWidthUnits:`widthUnits`,lineWidthScale:`widthScale`,lineWidthMinPixels:`widthMinPixels`,lineWidthMaxPixels:`widthMaxPixels`,lineJointRounded:`jointRounded`,lineCapRounded:`capRounded`,lineMiterLimit:`miterLimit`,lineBillboard:`billboard`,lineAntialiasing:`antialiasing`,getLineColor:`getColor`,getLineWidth:`getWidth`}};var Pt={type:Be,props:{extruded:`extruded`,filled:`filled`,wireframe:`wireframe`,elevationScale:`elevationScale`,material:`material`,_full3d:`_full3d`,getElevation:`getElevation`,getFillColor:`getFillColor`,getLineColor:`getLineColor`}};function le({type:i,props:e}){let t={};for(let o in e)t[o]=i.defaultProps[e[o]];return t}function _t(i,e){let{transitions:t,updateTriggers:o}=i.props,n={updateTriggers:{},transitions:t&&{getPosition:t.geometry}};for(let s in e){let r=e[s],a=i.props[s];s.startsWith(`get`)&&(a=i.getSubLayerAccessor(a),n.updateTriggers[r]=o[s],t&&(n.transitions[r]=t[s])),n[r]=a}return n}function sn(i){if(Array.isArray(i))return i;switch(S.assert(i.type,`GeoJSON does not have type`),i.type){case`Feature`:return[i];case`FeatureCollection`:return S.assert(Array.isArray(i.features),`GeoJSON does not have features array`),i.features;default:return[{geometry:i}]}}function Ut(i,e,t={}){let o={pointFeatures:[],lineFeatures:[],polygonFeatures:[],polygonOutlineFeatures:[]},{startRow:n=0,endRow:s=i.length}=t;for(let r=n;r<s;r++){let a=i[r],{geometry:l}=a;if(l)if(l.type===`GeometryCollection`){S.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];nn(d,o,e,a,r)}}else nn(l,o,e,a,r)}return o}function nn(i,e,t,o,n){let{type:s,coordinates:r}=i,{pointFeatures:a,lineFeatures:l,polygonFeatures:c,polygonOutlineFeatures:f}=e;if(!_r(s,r)){S.warn(`${s} coordinates are malformed`)();return}switch(s){case`Point`:a.push(t({geometry:i},o,n));break;case`MultiPoint`:r.forEach(d=>{a.push(t({geometry:{type:`Point`,coordinates:d}},o,n))});break;case`LineString`:l.push(t({geometry:i},o,n));break;case`MultiLineString`:r.forEach(d=>{l.push(t({geometry:{type:`LineString`,coordinates:d}},o,n))});break;case`Polygon`:c.push(t({geometry:i},o,n)),r.forEach(d=>{f.push(t({geometry:{type:`LineString`,coordinates:d}},o,n))});break;case`MultiPolygon`:r.forEach(d=>{c.push(t({geometry:{type:`Polygon`,coordinates:d}},o,n)),d.forEach(p=>{f.push(t({geometry:{type:`LineString`,coordinates:p}},o,n))})})}}var Pr={Point:1,MultiPoint:2,LineString:2,MultiLineString:3,Polygon:3,MultiPolygon:4};function _r(i,e){let t=Pr[i];for(S.assert(t,`Unknown GeoJSON type ${i}`);e&&--t>0;)e=e[0];return e&&Number.isFinite(e[0])}function rn(){return{points:{},lines:{},polygons:{},polygonsOutline:{}}}function Ct(i){return i.geometry.coordinates}function an(i,e){let t=rn(),{pointFeatures:o,lineFeatures:n,polygonFeatures:s,polygonOutlineFeatures:r}=i;return t.points.data=o,t.points._dataDiff=e.pointFeatures&&(()=>e.pointFeatures),t.points.getPosition=Ct,t.lines.data=n,t.lines._dataDiff=e.lineFeatures&&(()=>e.lineFeatures),t.lines.getPath=Ct,t.polygons.data=s,t.polygons._dataDiff=e.polygonFeatures&&(()=>e.polygonFeatures),t.polygons.getPolygon=Ct,t.polygonsOutline.data=r,t.polygonsOutline._dataDiff=e.polygonOutlineFeatures&&(()=>e.polygonOutlineFeatures),t.polygonsOutline.getPath=Ct,t}function ln(i){let e=rn(),{points:t,lines:o,polygons:n}=i,s$12=Oo(i);e.points.data={length:t.positions.value.length/t.positions.size,attributes:s(r({},t.attributes),{getPosition:t.positions,rowIndexes:{size:1,type:`uint32`,value:s$12.points}}),properties:t.properties,numericProps:t.numericProps,featureIds:t.featureIds},e.lines.data={length:o.pathIndices.value.length-1,startIndices:o.pathIndices.value,attributes:s(r({},o.attributes),{getPath:o.positions,rowIndexes:{size:1,type:`uint32`,value:s$12.lines}}),properties:o.properties,numericProps:o.numericProps,featureIds:o.featureIds},e.lines._pathType=`open`;let r$14=n.positions.value.length/n.positions.size,a=Array(r$14).fill(1);for(let l of n.primitivePolygonIndices.value)a[l-1]=0;return e.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},e.polygons._normalize=!1,n.triangles&&(e.polygons.data.attributes.indices=n.triangles.value),e.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},e.polygonsOutline._pathType=`open`,e}var Cr=[`points`,`linestrings`,`polygons`];var Sr=s(r(r(r(r(r({},le(Ye.circle)),le(Ye.icon)),le(Ye.text)),le(Je)),le(Pt)),{stroked:!0,filled:!0,extruded:!1,wireframe:!1,_full3d:!1,iconAtlas:{type:`object`,value:null},iconMapping:{type:`object`,value:{}},getIcon:{type:`accessor`,value:i=>i.properties.icon},getText:{type:`accessor`,value:i=>i.properties.text},pointType:`circle`,getRadius:{deprecatedFor:`getPointRadius`}});var Xe=class extends _m{initializeState(){this.state={layerProps:{},features:{},featuresDiff:{}}}updateState({props:e,changeFlags:t}){if(!t.dataChanged)return;let{data:o}=this.props,n=o&&`points`in o&&`polygons`in o&&`lines`in o;this.setState({binary:n}),n?this._updateStateBinary({props:e,changeFlags:t}):this._updateStateJSON({props:e,changeFlags:t})}_updateStateBinary({props:e,changeFlags:t}){let o=ln(e.data);this.setState({layerProps:o})}_updateStateJSON({props:e,changeFlags:t}){let o=sn(e.data),n=this.getSubLayerRow.bind(this),s={},r={};if(Array.isArray(t.dataChanged)){let l=this.state.features;for(let c in l)s[c]=l[c].slice(),r[c]=[];for(let c of t.dataChanged){let f=Ut(o,n,c);for(let d in l)r[d].push(vt({data:s[d],getIndex:p=>p.__source.index,dataRange:c,replace:f[d]}))}}else s=Ut(o,n);let a=an(s,r);this.setState({features:s,featuresDiff:r,layerProps:a})}getPickingInfo(e){let t=super.getPickingInfo(e),{index:o,sourceLayer:n}=t;return t.featureType=Cr.find(s=>n.id.startsWith(`${this.id}-${s}-`)),o>=0&&n.id.startsWith(`${this.id}-points-text`)&&this.state.binary&&(t.index=this.props.data.points.globalFeatureIds.value[o]),t}_updateAutoHighlight(e){let t=`${this.id}-points-`,o=e.featureType===`points`;for(let n of this.getSubLayers())n.id.startsWith(t)===o&&n.updateAutoHighlight(e)}_renderPolygonLayer(){let{extruded:e,wireframe:t}=this.props,{layerProps:o}=this.state,n=`polygons-fill`,s=this.shouldRenderSubLayer(n,o.polygons?.data)&&this.getSubLayerClass(n,Pt.type);if(s){let r=_t(this,Pt.props),a=e&&t;return a||delete r.getLineColor,r.updateTriggers.lineColors=a,new s(r,this.getSubLayerProps({id:n,updateTriggers:r.updateTriggers}),o.polygons)}return null}_renderLineLayers(){let{extruded:e,stroked:t}=this.props,{layerProps:o}=this.state,n=`polygons-stroke`,s=`linestrings`,r=!e&&t&&this.shouldRenderSubLayer(n,o.polygonsOutline?.data)&&this.getSubLayerClass(n,Je.type),a=this.shouldRenderSubLayer(s,o.lines?.data)&&this.getSubLayerClass(s,Je.type);if(r||a){let l=_t(this,Je.props);return[r&&new r(l,this.getSubLayerProps({id:n,updateTriggers:l.updateTriggers}),o.polygonsOutline),a&&new a(l,this.getSubLayerProps({id:s,updateTriggers:l.updateTriggers}),o.lines)]}return null}_renderPointLayers(){let{pointType:e}=this.props,{layerProps:t,binary:o}=this.state,{highlightedObjectIndex:n}=this.props;!o&&Number.isFinite(n)&&(n=t.points.data.findIndex(l=>l.__source.index===n));let s$13=new Set(e.split(`+`)),r$15=[];for(let l of s$13){let c=`points-${l}`,f=Ye[l],d=f&&this.shouldRenderSubLayer(c,t.points?.data)&&this.getSubLayerClass(c,f.type);if(d){let p=_t(this,f.props),u$1=t.points;if(l===`text`&&o){let a=u$1.data.attributes,{rowIndexes:g}=a,h=u(a,[`rowIndexes`]);u$1=s(r({},u$1),{data:s(r({},u$1.data),{attributes:h})})}r$15.push(new d(p,this.getSubLayerProps({id:c,updateTriggers:p.updateTriggers,highlightedObjectIndex:n}),u$1))}}return r$15}renderLayers(){let{extruded:e}=this.props,t=this._renderPolygonLayer(),o=this._renderLineLayers(),n=this._renderPointLayers();return[!e&&t,o,n,e&&t]}getSubLayerAccessor(e){let{binary:t}=this.state;return!t||typeof e!=`function`?super.getSubLayerAccessor(e):(o,n)=>{let{data:s,index:r}=n;return e(To(s,r),n)}}};Xe.layerName=`GeoJsonLayer`;Xe.defaultProps=Sr;var Lr=Xe;export{ze as _,Gn as a,Tt as c,er as d,ge as f,ye as g,wt as h,Dn as i,Wt as l,jt as m,Cn as n,Lr as o,gn as p,Cs as r,Nt as s,Be as t,Zn as u};
+//# debugId=7fec4dc7-70a9-597d-a1ca-61760d4e356b