@npm9912/v-map 0.1.0

package/dist/cjs/polygon-layer-B9PrN7vr.js

@@ -0,0 +1,1300 @@
+'use strict';
+
+var deckProvider = require('./deck-provider-Ctq3Q8a1.js');
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock$1 = `\
+uniform arcUniforms {
+  bool greatCircle;
+  bool useShortestPath;
+  float numSegments;
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  highp int widthUnits;
+} arc;
+`;
+const arcUniforms = {
+    name: 'arc',
+    vs: uniformBlock$1,
+    fs: uniformBlock$1,
+    uniformTypes: {
+        greatCircle: 'f32',
+        useShortestPath: 'f32',
+        numSegments: 'f32',
+        widthScale: 'f32',
+        widthMinPixels: 'f32',
+        widthMaxPixels: 'f32',
+        widthUnits: 'i32'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var vs$2 = `\
+#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 vec3 instancePickingColors;
+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 = instancePickingColors;
+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);
+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);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var fs$2 = `\
+#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) {
+if (isValid == 0.0) {
+discard;
+}
+fragColor = vColor;
+geometry.uv = uv;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_COLOR$2 = [0, 0, 0, 255];
+const defaultProps$3 = {
+    getSourcePosition: { type: 'accessor', value: (x) => x.sourcePosition },
+    getTargetPosition: { type: 'accessor', value: (x) => x.targetPosition },
+    getSourceColor: { type: 'accessor', value: DEFAULT_COLOR$2 },
+    getTargetColor: { type: 'accessor', value: DEFAULT_COLOR$2 },
+    getWidth: { type: 'accessor', value: 1 },
+    getHeight: { type: 'accessor', value: 1 },
+    getTilt: { type: 'accessor', value: 0 },
+    greatCircle: false,
+    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 }
+};
+/** Render raised arcs joining pairs of source and target coordinates. */
+class ArcLayer extends deckProvider.Layer {
+    getBounds() {
+        return this.getAttributeManager()?.getBounds([
+            'instanceSourcePositions',
+            'instanceTargetPositions'
+        ]);
+    }
+    getShaders() {
+        return super.getShaders({ vs: vs$2, fs: fs$2, modules: [deckProvider.project32, deckProvider.picking, arcUniforms] }); // 'project' module added by default.
+    }
+    // This layer has its own wrapLongitude logic
+    get wrapLongitude() {
+        return false;
+    }
+    initializeState() {
+        const attributeManager = this.getAttributeManager();
+        /* eslint-disable max-len */
+        attributeManager.addInstanced({
+            instanceSourcePositions: {
+                size: 3,
+                type: 'float64',
+                fp64: this.use64bitPositions(),
+                transition: true,
+                accessor: 'getSourcePosition'
+            },
+            instanceTargetPositions: {
+                size: 3,
+                type: 'float64',
+                fp64: this.use64bitPositions(),
+                transition: true,
+                accessor: 'getTargetPosition'
+            },
+            instanceSourceColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getSourceColor',
+                defaultValue: DEFAULT_COLOR$2
+            },
+            instanceTargetColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getTargetColor',
+                defaultValue: DEFAULT_COLOR$2
+            },
+            instanceWidths: {
+                size: 1,
+                transition: true,
+                accessor: 'getWidth',
+                defaultValue: 1
+            },
+            instanceHeights: {
+                size: 1,
+                transition: true,
+                accessor: 'getHeight',
+                defaultValue: 1
+            },
+            instanceTilts: {
+                size: 1,
+                transition: true,
+                accessor: 'getTilt',
+                defaultValue: 0
+            }
+        });
+        /* eslint-enable max-len */
+    }
+    updateState(params) {
+        super.updateState(params);
+        if (params.changeFlags.extensionsChanged) {
+            this.state.model?.destroy();
+            this.state.model = this._getModel();
+            this.getAttributeManager().invalidateAll();
+        }
+    }
+    draw({ uniforms }) {
+        const { widthUnits, widthScale, widthMinPixels, widthMaxPixels, greatCircle, wrapLongitude, numSegments } = this.props;
+        const arcProps = {
+            numSegments,
+            widthUnits: deckProvider.UNIT[widthUnits],
+            widthScale,
+            widthMinPixels,
+            widthMaxPixels,
+            greatCircle,
+            useShortestPath: wrapLongitude
+        };
+        const model = this.state.model;
+        model.shaderInputs.setProps({ arc: arcProps });
+        model.setVertexCount(numSegments * 2);
+        model.draw(this.context.renderPass);
+    }
+    _getModel() {
+        return new deckProvider.Model(this.context.device, {
+            ...this.getShaders(),
+            id: this.props.id,
+            bufferLayout: this.getAttributeManager().getBufferLayouts(),
+            topology: 'triangle-strip',
+            isInstanced: true
+        });
+    }
+}
+ArcLayer.layerName = 'ArcLayer';
+ArcLayer.defaultProps = defaultProps$3;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const wgslUniformBlock = /* wgsl */ `\
+struct PointCloudUniforms {
+  radiusPixels: f32,
+  sizeUnits: i32,
+};
+
+@group(0) @binding(3)
+var<uniform> pointCloud: PointCloudUniforms;
+`;
+const glslUniformBlock = `\
+uniform pointCloudUniforms {
+  float radiusPixels;
+  highp int sizeUnits;
+} pointCloud;
+`;
+const pointCloudUniforms = {
+    name: 'pointCloud',
+    source: wgslUniformBlock,
+    vs: glslUniformBlock,
+    fs: glslUniformBlock,
+    uniformTypes: {
+        radiusPixels: 'f32',
+        sizeUnits: 'i32'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var vs$1 = `\
+#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;
+in vec3 instancePickingColors;
+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 = instancePickingColors;
+vec3 offset = vec3(positions.xy * project_size_to_pixel(pointCloud.radiusPixels, pointCloud.sizeUnits), 0.0);
+DECKGL_FILTER_SIZE(offset, geometry);
+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);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var fs$1 = `\
+#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);
+if (distToCenter > 1.0) {
+discard;
+}
+fragColor = vColor;
+DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var source = /* wgsl */ `\
+struct ConstantAttributes {
+  instanceNormals: vec3<f32>,
+  instanceColors: vec4<f32>,
+  instancePositions: vec3<f32>,
+  instancePositions64Low: vec3<f32>,
+  instancePickingColors: vec3<f32>
+};
+
+const constants = ConstantAttributes(
+  vec3<f32>(1.0, 0.0, 0.0),
+  vec4<f32>(0.0, 0.0, 0.0, 1.0),
+  vec3<f32>(0.0),
+  vec3<f32>(0.0),
+  vec3<f32>(0.0)
+);
+
+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>,
+  @location(5) instancePickingColors: vec3<f32>
+};
+
+struct Varyings {
+  @builtin(position) position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) unitPosition: vec2<f32>,
+};
+
+@vertex
+fn vertexMain(attributes: Attributes) -> Varyings {
+  var varyings: Varyings;
+  
+  // var geometry: Geometry;
+  // geometry.worldPosition = instancePositions;
+  // geometry.normal = project_normal(instanceNormals);
+
+  // position on the containing square in [-1, 1] space
+  varyings.unitPosition = attributes.positions.xy;
+  geometry.uv = varyings.unitPosition;
+  geometry.pickingColor = attributes.instancePickingColors;
+
+  // Find the center of the point and add the current vertex
+  let offset = vec3<f32>(attributes.positions.xy * project_unit_size_to_pixel(pointCloud.radiusPixels, pointCloud.sizeUnits), 0.0);
+  // DECKGL_FILTER_SIZE(offset, geometry);
+
+  varyings.position = project_position_to_clipspace(attributes.instancePositions, attributes.instancePositions64Low, vec3<f32>(0.0)); // TODO , geometry.position);
+  // 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 * color.opacity);
+  // DECKGL_FILTER_COLOR(vColor, geometry);
+
+  return varyings;
+}
+
+@fragment
+fn fragmentMain(varyings: Varyings) -> @location(0) vec4<f32> {
+  // var geometry: Geometry;
+  // geometry.uv = unitPosition.xy;
+
+  let distToCenter = length(varyings.unitPosition);
+  if (distToCenter > 1.0) {
+    discard;
+  }
+
+  var fragColor: vec4<f32>;
+
+  fragColor = varyings.vColor;
+  // DECKGL_FILTER_COLOR(fragColor, geometry);
+
+  // Apply premultiplied alpha as required by transparent canvas
+  fragColor = deckgl_premultiplied_alpha(fragColor);
+
+  return fragColor;
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_COLOR$1 = [0, 0, 0, 255];
+const DEFAULT_NORMAL = [0, 0, 1];
+const defaultProps$2 = {
+    sizeUnits: 'pixels',
+    pointSize: { type: 'number', min: 0, value: 10 }, //  point radius in pixels
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    getNormal: { type: 'accessor', value: DEFAULT_NORMAL },
+    getColor: { type: 'accessor', value: DEFAULT_COLOR$1 },
+    material: true,
+    // Depreated
+    radiusPixels: { deprecatedFor: 'pointSize' }
+};
+// support loaders.gl point cloud format
+function normalizeData(data) {
+    const { header, attributes } = data;
+    if (!header || !attributes) {
+        return;
+    }
+    data.length = header.vertexCount;
+    if (attributes.POSITION) {
+        attributes.instancePositions = attributes.POSITION;
+    }
+    if (attributes.NORMAL) {
+        attributes.instanceNormals = attributes.NORMAL;
+    }
+    if (attributes.COLOR_0) {
+        const { size, value } = attributes.COLOR_0;
+        attributes.instanceColors = { size, type: 'unorm8', value };
+    }
+}
+/** Render a point cloud with 3D positions, normals and colors. */
+class PointCloudLayer extends deckProvider.Layer {
+    getShaders() {
+        return super.getShaders({
+            vs: vs$1,
+            fs: fs$1,
+            source,
+            modules: [deckProvider.project32, deckProvider.color, deckProvider.gouraudMaterial, deckProvider.picking, pointCloudUniforms]
+        });
+    }
+    initializeState() {
+        this.getAttributeManager().addInstanced({
+            instancePositions: {
+                size: 3,
+                type: 'float64',
+                fp64: this.use64bitPositions(),
+                transition: true,
+                accessor: 'getPosition'
+            },
+            instanceNormals: {
+                size: 3,
+                transition: true,
+                accessor: 'getNormal',
+                defaultValue: DEFAULT_NORMAL
+            },
+            instanceColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getColor',
+                defaultValue: DEFAULT_COLOR$1
+            }
+        });
+    }
+    updateState(params) {
+        const { changeFlags, props } = params;
+        super.updateState(params);
+        if (changeFlags.extensionsChanged) {
+            this.state.model?.destroy();
+            this.state.model = this._getModel();
+            this.getAttributeManager().invalidateAll();
+        }
+        if (changeFlags.dataChanged) {
+            normalizeData(props.data);
+        }
+    }
+    draw({ uniforms }) {
+        const { pointSize, sizeUnits } = this.props;
+        const model = this.state.model;
+        const pointCloudProps = {
+            sizeUnits: deckProvider.UNIT[sizeUnits],
+            radiusPixels: pointSize
+        };
+        model.shaderInputs.setProps({ pointCloud: pointCloudProps });
+        if (this.context.device.type === 'webgpu') {
+            // @ts-expect-error TODO - this line was needed during WebGPU port
+            model.instanceCount = this.props.data.length;
+        }
+        model.draw(this.context.renderPass);
+    }
+    _getModel() {
+        // TODO(ibgreen): WebGPU complication: Matching attachment state of the renderpass requires including a depth buffer
+        const parameters = this.context.device.type === 'webgpu'
+            ? {
+                depthWriteEnabled: true,
+                depthCompare: 'less-equal'
+            }
+            : undefined;
+        // a triangle that minimally cover the unit circle
+        const positions = [];
+        for (let i = 0; i < 3; i++) {
+            const angle = (i / 3) * Math.PI * 2;
+            positions.push(Math.cos(angle) * 2, Math.sin(angle) * 2, 0);
+        }
+        return new deckProvider.Model(this.context.device, {
+            ...this.getShaders(),
+            id: this.props.id,
+            bufferLayout: this.getAttributeManager().getBufferLayouts(),
+            geometry: new deckProvider.Geometry({
+                topology: 'triangle-list',
+                attributes: {
+                    positions: new Float32Array(positions)
+                }
+            }),
+            parameters,
+            isInstanced: true
+        });
+    }
+}
+PointCloudLayer.layerName = 'PointCloudLayer';
+PointCloudLayer.defaultProps = defaultProps$2;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class ColumnGeometry extends deckProvider.Geometry {
+    constructor(props) {
+        const { indices, attributes } = tesselateColumn(props);
+        super({
+            ...props,
+            indices,
+            // @ts-expect-error
+            attributes
+        });
+    }
+}
+/* eslint-disable max-statements, complexity */
+function tesselateColumn(props) {
+    const { radius, height = 1, nradial = 10 } = props;
+    let { vertices } = props;
+    if (vertices) {
+        deckProvider.defaultLogger.assert(vertices.length >= nradial); // `vertices` must contain at least `diskResolution` points
+        vertices = vertices.flatMap(v => [v[0], v[1]]);
+        deckProvider.modifyPolygonWindingDirection(vertices, deckProvider.WINDING.COUNTER_CLOCKWISE);
+    }
+    const isExtruded = height > 0;
+    const vertsAroundEdge = nradial + 1; // loop
+    const numVertices = isExtruded
+        ? vertsAroundEdge * 3 + 1 // top, side top edge, side bottom edge, one additional degenerage vertex
+        : nradial; // top
+    const stepAngle = (Math.PI * 2) / nradial;
+    // Used for wireframe
+    const indices = new Uint16Array(isExtruded ? nradial * 3 * 2 : 0); // top loop, side vertical, bottom loop
+    const positions = new Float32Array(numVertices * 3);
+    const normals = new Float32Array(numVertices * 3);
+    let i = 0;
+    // side tesselation: 0, 1, 2, 3, 4, 5, ...
+    //
+    // 0 - 2 - 4  ... top
+    // | / | / |
+    // 1 - 3 - 5  ... bottom
+    //
+    if (isExtruded) {
+        for (let j = 0; j < vertsAroundEdge; j++) {
+            const a = j * stepAngle;
+            const vertexIndex = j % nradial;
+            const sin = Math.sin(a);
+            const cos = Math.cos(a);
+            for (let k = 0; k < 2; k++) {
+                positions[i + 0] = vertices ? vertices[vertexIndex * 2] : cos * radius;
+                positions[i + 1] = vertices ? vertices[vertexIndex * 2 + 1] : sin * radius;
+                positions[i + 2] = (1 / 2 - k) * height;
+                normals[i + 0] = vertices ? vertices[vertexIndex * 2] : cos;
+                normals[i + 1] = vertices ? vertices[vertexIndex * 2 + 1] : sin;
+                i += 3;
+            }
+        }
+        // duplicate the last vertex to create proper degenerate triangle.
+        positions[i + 0] = positions[i - 3];
+        positions[i + 1] = positions[i - 2];
+        positions[i + 2] = positions[i - 1];
+        i += 3;
+    }
+    // The column geometry is rendered as a triangle strip, so
+    // in order to render sides and top in one go we need to use degenerate triangles.
+    // Duplicate last vertex of side trinagles and first vertex of the top cap to preserve winding order.
+    // top tesselation: 0, -1, 1, -2, 2, -3, 3, ...
+    //
+    //    0 -- 1
+    //   /      \
+    // -1        2
+    //  |        |
+    // -2        3
+    //   \      /
+    //   -3 -- 4
+    //
+    for (let j = isExtruded ? 0 : 1; j < vertsAroundEdge; j++) {
+        const v = Math.floor(j / 2) * Math.sign(0.5 - (j % 2));
+        const a = v * stepAngle;
+        const vertexIndex = (v + nradial) % nradial;
+        const sin = Math.sin(a);
+        const cos = Math.cos(a);
+        positions[i + 0] = vertices ? vertices[vertexIndex * 2] : cos * radius;
+        positions[i + 1] = vertices ? vertices[vertexIndex * 2 + 1] : sin * radius;
+        positions[i + 2] = height / 2;
+        normals[i + 2] = 1;
+        i += 3;
+    }
+    if (isExtruded) {
+        let index = 0;
+        for (let j = 0; j < nradial; j++) {
+            // top loop
+            indices[index++] = j * 2 + 0;
+            indices[index++] = j * 2 + 2;
+            // side vertical
+            indices[index++] = j * 2 + 0;
+            indices[index++] = j * 2 + 1;
+            // bottom loop
+            indices[index++] = j * 2 + 1;
+            indices[index++] = j * 2 + 3;
+        }
+    }
+    return {
+        indices,
+        attributes: {
+            POSITION: { size: 3, value: positions },
+            NORMAL: { size: 3, value: normals }
+        }
+    };
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = `\
+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;
+`;
+const columnUniforms = {
+    name: 'column',
+    vs: uniformBlock,
+    fs: uniformBlock,
+    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'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var vs = `#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;
+in vec3 instancePickingColors;
+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 = instancePickingColors;
+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);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var fs = `#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);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_COLOR = [0, 0, 0, 255];
+const defaultProps$1 = {
+    diskResolution: { type: 'number', min: 4, value: 20 },
+    vertices: null,
+    radius: { type: 'number', min: 0, value: 1000 },
+    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: true,
+    wireframe: false,
+    filled: true,
+    stroked: false,
+    flatShading: false,
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    getFillColor: { type: 'accessor', value: DEFAULT_COLOR },
+    getLineColor: { type: 'accessor', value: DEFAULT_COLOR },
+    getLineWidth: { type: 'accessor', value: 1 },
+    getElevation: { type: 'accessor', value: 1000 },
+    material: true,
+    getColor: { deprecatedFor: ['getFillColor', 'getLineColor'] }
+};
+/** Render extruded cylinders (tessellated regular polygons) at given coordinates. */
+class ColumnLayer extends deckProvider.Layer {
+    getShaders() {
+        const defines = {};
+        const { flatShading } = this.props;
+        if (flatShading) {
+            defines.FLAT_SHADING = 1;
+        }
+        return super.getShaders({
+            vs,
+            fs,
+            defines,
+            modules: [deckProvider.project32, flatShading ? deckProvider.phongMaterial : deckProvider.gouraudMaterial, deckProvider.picking, columnUniforms]
+        });
+    }
+    /**
+     * DeckGL calls initializeState when GL context is available
+     * Essentially a deferred constructor
+     */
+    initializeState() {
+        const attributeManager = this.getAttributeManager();
+        /* eslint-disable max-len */
+        attributeManager.addInstanced({
+            instancePositions: {
+                size: 3,
+                type: 'float64',
+                fp64: this.use64bitPositions(),
+                transition: true,
+                accessor: 'getPosition'
+            },
+            instanceElevations: {
+                size: 1,
+                transition: true,
+                accessor: 'getElevation'
+            },
+            instanceFillColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getFillColor',
+                defaultValue: DEFAULT_COLOR
+            },
+            instanceLineColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getLineColor',
+                defaultValue: DEFAULT_COLOR
+            },
+            instanceStrokeWidths: {
+                size: 1,
+                accessor: 'getLineWidth',
+                transition: true
+            }
+        });
+        /* eslint-enable max-len */
+    }
+    updateState(params) {
+        super.updateState(params);
+        const { props, oldProps, changeFlags } = params;
+        const regenerateModels = changeFlags.extensionsChanged || props.flatShading !== oldProps.flatShading;
+        if (regenerateModels) {
+            this.state.models?.forEach(model => model.destroy());
+            this.setState(this._getModels());
+            this.getAttributeManager().invalidateAll();
+        }
+        const instanceCount = this.getNumInstances();
+        this.state.fillModel.setInstanceCount(instanceCount);
+        this.state.wireframeModel.setInstanceCount(instanceCount);
+        if (regenerateModels ||
+            props.diskResolution !== oldProps.diskResolution ||
+            props.vertices !== oldProps.vertices ||
+            (props.extruded || props.stroked) !== (oldProps.extruded || oldProps.stroked)) {
+            this._updateGeometry(props);
+        }
+    }
+    getGeometry(diskResolution, vertices, hasThinkness) {
+        const geometry = new ColumnGeometry({
+            radius: 1,
+            height: hasThinkness ? 2 : 0,
+            vertices,
+            nradial: diskResolution
+        });
+        let meanVertexDistance = 0;
+        if (vertices) {
+            for (let i = 0; i < diskResolution; i++) {
+                const p = vertices[i];
+                const d = Math.sqrt(p[0] * p[0] + p[1] * p[1]);
+                meanVertexDistance += d / diskResolution;
+            }
+        }
+        else {
+            meanVertexDistance = 1;
+        }
+        this.setState({
+            edgeDistance: Math.cos(Math.PI / diskResolution) * meanVertexDistance
+        });
+        return geometry;
+    }
+    _getModels() {
+        const shaders = this.getShaders();
+        const bufferLayout = this.getAttributeManager().getBufferLayouts();
+        const fillModel = new deckProvider.Model(this.context.device, {
+            ...shaders,
+            id: `${this.props.id}-fill`,
+            bufferLayout,
+            isInstanced: true
+        });
+        const wireframeModel = new deckProvider.Model(this.context.device, {
+            ...shaders,
+            id: `${this.props.id}-wireframe`,
+            bufferLayout,
+            isInstanced: true
+        });
+        return {
+            fillModel,
+            wireframeModel,
+            models: [wireframeModel, fillModel]
+        };
+    }
+    _updateGeometry({ diskResolution, vertices, extruded, stroked }) {
+        const geometry = this.getGeometry(diskResolution, vertices, extruded || stroked);
+        this.setState({
+            fillVertexCount: geometry.attributes.POSITION.value.length / 3
+        });
+        const fillModel = this.state.fillModel;
+        const wireframeModel = this.state.wireframeModel;
+        fillModel.setGeometry(geometry);
+        fillModel.setTopology('triangle-strip');
+        // Disable indices
+        fillModel.setIndexBuffer(null);
+        wireframeModel.setGeometry(geometry);
+        wireframeModel.setTopology('line-list');
+    }
+    draw({ uniforms }) {
+        const { lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels, radiusUnits, elevationScale, extruded, filled, stroked, wireframe, offset, coverage, radius, angle } = this.props;
+        const fillModel = this.state.fillModel;
+        const wireframeModel = this.state.wireframeModel;
+        const { fillVertexCount, edgeDistance } = this.state;
+        const columnProps = {
+            radius,
+            angle: (angle / 180) * Math.PI,
+            offset,
+            extruded,
+            stroked,
+            coverage,
+            elevationScale,
+            edgeDistance,
+            radiusUnits: deckProvider.UNIT[radiusUnits],
+            widthUnits: deckProvider.UNIT[lineWidthUnits],
+            widthScale: lineWidthScale,
+            widthMinPixels: lineWidthMinPixels,
+            widthMaxPixels: lineWidthMaxPixels
+        };
+        // When drawing 3d: draw wireframe first so it doesn't get occluded by depth test
+        if (extruded && wireframe) {
+            wireframeModel.shaderInputs.setProps({
+                column: {
+                    ...columnProps,
+                    isStroke: true
+                }
+            });
+            wireframeModel.draw(this.context.renderPass);
+        }
+        if (filled) {
+            // model.setProps({isIndexed: false});
+            fillModel.setVertexCount(fillVertexCount);
+            fillModel.shaderInputs.setProps({
+                column: {
+                    ...columnProps,
+                    isStroke: false
+                }
+            });
+            fillModel.draw(this.context.renderPass);
+        }
+        // When drawing 2d: draw fill before stroke so that the outline is always on top
+        if (!extruded && stroked) {
+            // model.setProps({isIndexed: false});
+            // The width of the stroke is achieved by flattening the side of the cylinder.
+            // Skip the last 1/3 of the vertices which is the top.
+            fillModel.setVertexCount((fillVertexCount * 2) / 3);
+            fillModel.shaderInputs.setProps({
+                column: {
+                    ...columnProps,
+                    isStroke: true
+                }
+            });
+            fillModel.draw(this.context.renderPass);
+        }
+    }
+}
+ColumnLayer.layerName = 'ColumnLayer';
+ColumnLayer.defaultProps = defaultProps$1;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const defaultLineColor = [0, 0, 0, 255];
+const defaultFillColor = [0, 0, 0, 255];
+const defaultProps = {
+    stroked: true,
+    filled: true,
+    extruded: false,
+    elevationScale: 1,
+    wireframe: false,
+    _normalize: true,
+    _windingOrder: 'CW',
+    lineWidthUnits: 'meters',
+    lineWidthScale: 1,
+    lineWidthMinPixels: 0,
+    lineWidthMaxPixels: Number.MAX_SAFE_INTEGER,
+    lineJointRounded: false,
+    lineMiterLimit: 4,
+    getPolygon: { type: 'accessor', value: (f) => f.polygon },
+    // Polygon fill color
+    getFillColor: { type: 'accessor', value: defaultFillColor },
+    // Point, line and polygon outline color
+    getLineColor: { type: 'accessor', value: defaultLineColor },
+    // Line and polygon outline accessors
+    getLineWidth: { type: 'accessor', value: 1 },
+    // Polygon extrusion accessor
+    getElevation: { type: 'accessor', value: 1000 },
+    // Optional material for 'lighting' shader module
+    material: true
+};
+/** A composite layer that renders filled, stroked and/or extruded polygons. */
+class PolygonLayer extends deckProvider.CompositeLayer {
+    initializeState() {
+        this.state = {
+            paths: [],
+            pathsDiff: null
+        };
+        if (this.props.getLineDashArray) {
+            deckProvider.defaultLogger.removed('getLineDashArray', 'PathStyleExtension')();
+        }
+    }
+    updateState({ changeFlags }) {
+        const geometryChanged = changeFlags.dataChanged ||
+            (changeFlags.updateTriggersChanged &&
+                (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPolygon));
+        if (geometryChanged && Array.isArray(changeFlags.dataChanged)) {
+            const paths = this.state.paths.slice();
+            const pathsDiff = changeFlags.dataChanged.map(dataRange => deckProvider.replaceInRange({
+                data: paths,
+                getIndex: p => p.__source.index,
+                dataRange,
+                replace: this._getPaths(dataRange)
+            }));
+            this.setState({ paths, pathsDiff });
+        }
+        else if (geometryChanged) {
+            this.setState({
+                paths: this._getPaths(),
+                pathsDiff: null
+            });
+        }
+    }
+    _getPaths(dataRange = {}) {
+        const { data, getPolygon, positionFormat, _normalize } = this.props;
+        const paths = [];
+        const positionSize = positionFormat === 'XY' ? 2 : 3;
+        const { startRow, endRow } = dataRange;
+        const { iterable, objectInfo } = deckProvider.createIterable(data, startRow, endRow);
+        for (const object of iterable) {
+            objectInfo.index++;
+            let polygon = getPolygon(object, objectInfo);
+            if (_normalize) {
+                polygon = deckProvider.normalize(polygon, positionSize);
+            }
+            const { holeIndices } = polygon;
+            const positions = polygon.positions || polygon;
+            if (holeIndices) {
+                // split the positions array into `holeIndices.length + 1` rings
+                // holeIndices[-1] falls back to 0
+                // holeIndices[holeIndices.length] falls back to positions.length
+                for (let i = 0; i <= holeIndices.length; i++) {
+                    const path = positions.slice(holeIndices[i - 1] || 0, holeIndices[i] || positions.length);
+                    paths.push(this.getSubLayerRow({ path }, object, objectInfo.index));
+                }
+            }
+            else {
+                paths.push(this.getSubLayerRow({ path: positions }, object, objectInfo.index));
+            }
+        }
+        return paths;
+    }
+    /* eslint-disable complexity */
+    renderLayers() {
+        // Layer composition props
+        const { data, _dataDiff, stroked, filled, extruded, wireframe, _normalize, _windingOrder, elevationScale, transitions, positionFormat } = this.props;
+        // Rendering props underlying layer
+        const { lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels, lineJointRounded, lineMiterLimit, lineDashJustified } = this.props;
+        // Accessor props for underlying layers
+        const { getFillColor, getLineColor, getLineWidth, getLineDashArray, getElevation, getPolygon, updateTriggers, material } = this.props;
+        const { paths, pathsDiff } = this.state;
+        const FillLayer = this.getSubLayerClass('fill', deckProvider.SolidPolygonLayer);
+        const StrokeLayer = this.getSubLayerClass('stroke', deckProvider.PathLayer);
+        // Filled Polygon Layer
+        const polygonLayer = this.shouldRenderSubLayer('fill', paths) &&
+            new FillLayer({
+                _dataDiff,
+                extruded,
+                elevationScale,
+                filled,
+                wireframe,
+                _normalize,
+                _windingOrder,
+                getElevation,
+                getFillColor,
+                getLineColor: extruded && wireframe ? getLineColor : defaultLineColor,
+                material,
+                transitions
+            }, this.getSubLayerProps({
+                id: 'fill',
+                updateTriggers: updateTriggers && {
+                    getPolygon: updateTriggers.getPolygon,
+                    getElevation: updateTriggers.getElevation,
+                    getFillColor: updateTriggers.getFillColor,
+                    // using a legacy API to invalid lineColor attributes
+                    // if (extruded && wireframe) has changed
+                    lineColors: extruded && wireframe,
+                    getLineColor: updateTriggers.getLineColor
+                }
+            }), {
+                data,
+                positionFormat,
+                getPolygon
+            });
+        // Polygon line layer
+        const polygonLineLayer = !extruded &&
+            stroked &&
+            this.shouldRenderSubLayer('stroke', paths) &&
+            new StrokeLayer({
+                _dataDiff: pathsDiff && (() => pathsDiff),
+                widthUnits: lineWidthUnits,
+                widthScale: lineWidthScale,
+                widthMinPixels: lineWidthMinPixels,
+                widthMaxPixels: lineWidthMaxPixels,
+                jointRounded: lineJointRounded,
+                miterLimit: lineMiterLimit,
+                dashJustified: lineDashJustified,
+                // Already normalized
+                _pathType: 'loop',
+                transitions: transitions && {
+                    getWidth: transitions.getLineWidth,
+                    getColor: transitions.getLineColor,
+                    getPath: transitions.getPolygon
+                },
+                getColor: this.getSubLayerAccessor(getLineColor),
+                getWidth: this.getSubLayerAccessor(getLineWidth),
+                getDashArray: this.getSubLayerAccessor(getLineDashArray)
+            }, this.getSubLayerProps({
+                id: 'stroke',
+                updateTriggers: updateTriggers && {
+                    getWidth: updateTriggers.getLineWidth,
+                    getColor: updateTriggers.getLineColor,
+                    getDashArray: updateTriggers.getLineDashArray
+                }
+            }), {
+                data: paths,
+                positionFormat,
+                getPath: x => x.path
+            });
+        return [
+            // If not extruded: flat fill layer is drawn below outlines
+            !extruded && polygonLayer,
+            polygonLineLayer,
+            // If extruded: draw fill layer last for correct blending behavior
+            extruded && polygonLayer
+        ];
+    }
+}
+PolygonLayer.layerName = 'PolygonLayer';
+PolygonLayer.defaultProps = defaultProps;
+
+exports.ArcLayer = ArcLayer;
+exports.ColumnLayer = ColumnLayer;
+exports.PointCloudLayer = PointCloudLayer;
+exports.PolygonLayer = PolygonLayer;