@npm9912/v-map 0.1.0

package/dist/esm/index-B1zwA4IC.js

@@ -0,0 +1,685 @@
+import { C as ColumnLayer } from './polygon-layer-ByhxGhWC.js';
+export { A as ArcLayer, P as PointCloudLayer, a as PolygonLayer } from './polygon-layer-ByhxGhWC.js';
+import { G as Geometry, u as uid, L as Layer, p as project32, c as color, a as picking, U as UNIT, M as Model } from './deck-provider-C7U9VDEq.js';
+export { B as BitmapLayer, e as GeoJsonLayer, I as IconLayer, P as PathLayer, b as ScatterplotLayer, f as SolidPolygonLayer, T as TextLayer, g as _MultiIconLayer, h as _TextBackgroundLayer } from './deck-provider-C7U9VDEq.js';
+import './styleconfig-B-bAcABs.js';
+import './index.browser-DhQAXuA7.js';
+import './index-BUHa4Jj0.js';
+import './_commonjsHelpers-E-ZsRS8r.js';
+import './messages-CMKJzsgL.js';
+import './geotiff-source-esnDnC-u.js';
+import '@loaders.gl/core';
+import '@loaders.gl/images';
+import '@loaders.gl/loader-utils';
+import '@loaders.gl/terrain';
+import '@loaders.gl/schema';
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class CubeGeometry extends Geometry {
+    constructor(props = {}) {
+        const { id = uid('cube-geometry'), indices = true } = props;
+        super(indices
+            ? {
+                ...props,
+                id,
+                topology: 'triangle-list',
+                indices: { size: 1, value: CUBE_INDICES },
+                attributes: { ...ATTRIBUTES, ...props.attributes }
+            }
+            : {
+                ...props,
+                id,
+                topology: 'triangle-list',
+                indices: undefined,
+                attributes: { ...NON_INDEXED_ATTRIBUTES, ...props.attributes }
+            });
+    }
+}
+// prettier-ignore
+const CUBE_INDICES = new Uint16Array([
+    0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13,
+    14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23
+]);
+// prettier-ignore
+const CUBE_POSITIONS = new Float32Array([
+    -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1,
+    -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, -1,
+    -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1,
+    -1, -1, -1, 1, -1, -1, 1, -1, 1, -1, -1, 1,
+    1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1,
+    -1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1
+]);
+// TODO - could be Uint8
+// prettier-ignore
+const CUBE_NORMALS = new Float32Array([
+    // Front face
+    0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+    // Back face
+    0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
+    // Top face
+    0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+    // Bottom face
+    0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,
+    // Right face
+    1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,
+    // Left face
+    -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0
+]);
+// prettier-ignore
+const CUBE_TEX_COORDS = new Float32Array([
+    // Front face
+    0, 0, 1, 0, 1, 1, 0, 1,
+    // Back face
+    1, 0, 1, 1, 0, 1, 0, 0,
+    // Top face
+    0, 1, 0, 0, 1, 0, 1, 1,
+    // Bottom face
+    1, 1, 0, 1, 0, 0, 1, 0,
+    // Right face
+    1, 0, 1, 1, 0, 1, 0, 0,
+    // Left face
+    0, 0, 1, 0, 1, 1, 0, 1
+]);
+// float4 position
+// prettier-ignore
+const CUBE_NON_INDEXED_POSITIONS = new Float32Array([
+    1, -1, 1,
+    -1, -1, 1,
+    -1, -1, -1,
+    1, -1, -1,
+    1, -1, 1,
+    -1, -1, -1,
+    1, 1, 1,
+    1, -1, 1,
+    1, -1, -1,
+    1, 1, -1,
+    1, 1, 1,
+    1, -1, -1,
+    -1, 1, 1,
+    1, 1, 1,
+    1, 1, -1,
+    -1, 1, -1,
+    -1, 1, 1,
+    1, 1, -1,
+    -1, -1, 1,
+    -1, 1, 1,
+    -1, 1, -1,
+    -1, -1, -1,
+    -1, -1, 1,
+    -1, 1, -1,
+    1, 1, 1,
+    -1, 1, 1,
+    -1, -1, 1,
+    -1, -1, 1,
+    1, -1, 1,
+    1, 1, 1,
+    1, -1, -1,
+    -1, -1, -1,
+    -1, 1, -1,
+    1, 1, -1,
+    1, -1, -1,
+    -1, 1, -1,
+]);
+// float2 uv,
+// prettier-ignore
+const CUBE_NON_INDEXED_TEX_COORDS = new Float32Array([
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 0,
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 0,
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 0,
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 0,
+    1, 1,
+    0, 1,
+    0, 0,
+    0, 0,
+    1, 0,
+    1, 1,
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 0,
+]);
+// float4 color
+// prettier-ignore
+const CUBE_NON_INDEXED_COLORS = new Float32Array([
+    1, 0, 1, 1,
+    0, 0, 1, 1,
+    0, 0, 0, 1,
+    1, 0, 0, 1,
+    1, 0, 1, 1,
+    0, 0, 0, 1,
+    1, 1, 1, 1,
+    1, 0, 1, 1,
+    1, 0, 0, 1,
+    1, 1, 0, 1,
+    1, 1, 1, 1,
+    1, 0, 0, 1,
+    0, 1, 1, 1,
+    1, 1, 1, 1,
+    1, 1, 0, 1,
+    0, 1, 0, 1,
+    0, 1, 1, 1,
+    1, 1, 0, 1,
+    0, 0, 1, 1,
+    0, 1, 1, 1,
+    0, 1, 0, 1,
+    0, 0, 0, 1,
+    0, 0, 1, 1,
+    0, 1, 0, 1,
+    1, 1, 1, 1,
+    0, 1, 1, 1,
+    0, 0, 1, 1,
+    0, 0, 1, 1,
+    1, 0, 1, 1,
+    1, 1, 1, 1,
+    1, 0, 0, 1,
+    0, 0, 0, 1,
+    0, 1, 0, 1,
+    1, 1, 0, 1,
+    1, 0, 0, 1,
+    0, 1, 0, 1,
+]);
+const ATTRIBUTES = {
+    POSITION: { size: 3, value: CUBE_POSITIONS },
+    NORMAL: { size: 3, value: CUBE_NORMALS },
+    TEXCOORD_0: { size: 2, value: CUBE_TEX_COORDS }
+};
+const NON_INDEXED_ATTRIBUTES = {
+    POSITION: { size: 3, value: CUBE_NON_INDEXED_POSITIONS },
+    // NORMAL: {size: 3, value: CUBE_NON_INDEXED_NORMALS},
+    TEXCOORD_0: { size: 2, value: CUBE_NON_INDEXED_TEX_COORDS },
+    COLOR_0: { size: 3, value: CUBE_NON_INDEXED_COLORS }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlockWGSL = /* wgsl */ `\
+struct LineUniforms {
+  widthScale: f32,
+  widthMinPixels: f32,
+  widthMaxPixels: f32,
+  useShortestPath: f32,
+  widthUnits: i32,
+};
+
+@group(0) @binding(1)
+var<uniform> line: LineUniforms;
+`;
+const uniformBlockGLSL = /* glsl */ `\
+uniform lineUniforms {
+  float widthScale;
+  float widthMinPixels;
+  float widthMaxPixels;
+  float useShortestPath;
+  highp int widthUnits;
+} line;
+`;
+const lineUniforms = {
+    name: 'line',
+    source: uniformBlockWGSL,
+    vs: uniformBlockGLSL,
+    fs: uniformBlockGLSL,
+    uniformTypes: {
+        widthScale: 'f32',
+        widthMinPixels: 'f32',
+        widthMaxPixels: 'f32',
+        useShortestPath: 'f32',
+        widthUnits: 'i32'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const shaderWGSL = /* wgsl */ `\
+// ---------- 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> {
+  return p;
+}
+fn deckgl_filter_color(color: vec4<f32>, geometry: Geometry) -> vec4<f32> {
+  return color;
+}
+
+// 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°: (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 ----------
+
+// Uniforms for line, color, and project are assumed to be defined elsewhere.
+// For example:
+//
+// @group(0) @binding(0)
+// var<uniform> line: LineUniform;
+//
+// struct ColorUniform {
+//   opacity: f32,
+// };
+// @group(0) @binding(1)
+// var<uniform> color: ColorUniform;
+//
+// struct ProjectUniform {
+//   viewportSize: vec2<f32>,
+// };
+// @group(0) @binding(2)
+// var<uniform> project: ProjectUniform;
+
+
+
+// ---------- Vertex Output Structure ----------
+
+struct Varyings {
+  @builtin(position) gl_Position: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) uv: vec2<f32>,
+};
+
+// ---------- Vertex Shader Entry Point ----------
+
+@vertex
+fn vertexMain(
+  @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) instancePickingColors: vec3<f32>,
+  @location(7) instanceWidths: f32
+) -> Varyings {
+  var geometry: Geometry;
+  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);
+  let uv: vec2<f32> = positions.xy;
+  geometry.uv = uv;
+  geometry.pickingColor = instancePickingColors;
+
+  // 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.
+  let filteredOffset = deckgl_filter_size(offset, geometry);
+  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 * color.opacity);
+  // vColor = deckgl_filter_color(vColor, geometry);
+
+  var output: Varyings;
+  output.gl_Position = finalPosition;
+  output.vColor = vColor;
+  output.uv = uv;
+  return output;
+}
+
+@fragment
+fn fragmentMain(
+  @location(0) vColor: vec4<f32>,
+  @location(1) uv: vec2<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;
+
+  // Apply the deck.gl filter to the color.
+  fragColor = 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
+var vs = `\
+#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 vec3 instancePickingColors;
+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 = instancePickingColors;
+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);
+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);
+}
+`;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+var fs = `\
+#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;
+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 = {
+    getSourcePosition: { type: 'accessor', value: (x) => x.sourcePosition },
+    getTargetPosition: { type: 'accessor', value: (x) => x.targetPosition },
+    getColor: { type: 'accessor', value: DEFAULT_COLOR },
+    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 }
+};
+/**
+ * A layer that renders straight lines joining pairs of source and target coordinates.
+ */
+class LineLayer extends Layer {
+    getBounds() {
+        return this.getAttributeManager()?.getBounds([
+            'instanceSourcePositions',
+            'instanceTargetPositions'
+        ]);
+    }
+    getShaders() {
+        return super.getShaders({ vs, fs, source: shaderWGSL, modules: [project32, color, picking, lineUniforms] });
+    }
+    // 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'
+            },
+            instanceColors: {
+                size: this.props.colorFormat.length,
+                type: 'unorm8',
+                transition: true,
+                accessor: 'getColor',
+                defaultValue: [0, 0, 0, 255]
+            },
+            instanceWidths: {
+                size: 1,
+                transition: true,
+                accessor: 'getWidth',
+                defaultValue: 1
+            }
+        });
+        /* 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, wrapLongitude } = this.props;
+        const model = this.state.model;
+        const lineProps = {
+            widthUnits: UNIT[widthUnits],
+            widthScale,
+            widthMinPixels,
+            widthMaxPixels,
+            useShortestPath: wrapLongitude ? 1 : 0
+        };
+        model.shaderInputs.setProps({ line: lineProps });
+        model.draw(this.context.renderPass);
+        if (wrapLongitude) {
+            // Render a second copy for the clipped lines at the 180th meridian
+            model.shaderInputs.setProps({ line: { ...lineProps, useShortestPath: -1 } });
+            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;
+        /*
+         *  (0, -1)-------------_(1, -1)
+         *       |          _,-"  |
+         *       o      _,-"      o
+         *       |  _,-"          |
+         *   (0, 1)"-------------(1, 1)
+         */
+        const positions = [0, -1, 0, 0, 1, 0, 1, -1, 0, 1, 1, 0];
+        return new Model(this.context.device, {
+            ...this.getShaders(),
+            id: this.props.id,
+            bufferLayout: this.getAttributeManager().getBufferLayouts(),
+            geometry: new Geometry({
+                topology: 'triangle-strip',
+                attributes: {
+                    positions: { size: 3, value: new Float32Array(positions) }
+                }
+            }),
+            parameters,
+            isInstanced: true
+        });
+    }
+}
+LineLayer.layerName = 'LineLayer';
+LineLayer.defaultProps = defaultProps$1;
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const defaultProps = {
+    cellSize: { type: 'number', min: 0, value: 1000 },
+    offset: { type: 'array', value: [1, 1] }
+};
+class GridCellLayer extends ColumnLayer {
+    _updateGeometry() {
+        const geometry = new CubeGeometry();
+        this.state.fillModel.setGeometry(geometry);
+    }
+    draw({ uniforms }) {
+        const { elevationScale, extruded, offset, coverage, cellSize, angle, radiusUnits } = this.props;
+        const fillModel = this.state.fillModel;
+        const columnProps = {
+            radius: cellSize / 2,
+            radiusUnits: UNIT[radiusUnits],
+            angle,
+            offset,
+            extruded,
+            stroked: false,
+            coverage,
+            elevationScale,
+            edgeDistance: 1,
+            isStroke: false,
+            widthUnits: 0,
+            widthScale: 0,
+            widthMinPixels: 0,
+            widthMaxPixels: 0
+        };
+        fillModel.shaderInputs.setProps({ column: columnProps });
+        fillModel.draw(this.context.renderPass);
+    }
+}
+GridCellLayer.layerName = 'GridCellLayer';
+GridCellLayer.defaultProps = defaultProps;
+
+export { ColumnLayer, GridCellLayer, LineLayer };