@tangram.gl/basemap-layers 0.0.0-stage → 0.0.0

package/dist/types/fill-extrusion-lighting-extension.d.ts

@@ -0,0 +1,49 @@
+import { LayerExtension } from '@deck.gl/core';
+import type { Layer } from '@deck.gl/core';
+/** A style's `light`, evaluated at one zoom. */
+export type FillExtrusionLight = {
+    /** Whether the light turns with the map (`map`) or stays fixed on the screen (`viewport`). */
+    anchor: 'map' | 'viewport';
+    /** Radial coordinate, azimuthal angle and polar angle, in degrees, as in the style spec. */
+    position: [number, number, number];
+    /** RGB in 0-1. */
+    color: [number, number, number];
+    /** 0-1. */
+    intensity: number;
+};
+/** The style spec's default `light`. */
+export declare const DEFAULT_FILL_EXTRUSION_LIGHT: FillExtrusionLight;
+/**
+ * Returns the light vector that deck.gl's normals, in common space (x east, y north, z up), are
+ * shaded against, as MapLibre GL JS shades its own. MapLibre takes the light's spherical position
+ * in tile coordinates (y south) and turns it by the map's bearing when the light is anchored to
+ * the viewport. It keeps the light's radial length, which it does not normalize. Its wall normals
+ * point into the buildings: `_generateSideFaces` takes the perpendicular `(-y, x)` of each edge
+ * of a ring that is clockwise in tile coordinates. deck.gl's point out, so the horizontal part of
+ * the light is reversed for them: x is negated, and y, negated from tile to common space, is
+ * negated back.
+ */
+export declare function getFillExtrusionLightDirection(light: FillExtrusionLight, bearing: number): [number, number, number];
+/**
+ * Shades the extruded `SolidPolygonLayer`s of a layer as MapLibre GL JS shades `fill-extrusion`,
+ * from the style's `light` (`fillExtrusionLight`) and `fill-extrusion-vertical-gradient`
+ * (`fillExtrusionVerticalGradient`), instead of with deck.gl's lights, which it turns off for the
+ * layer at every draw. A light anchored to the viewport turns with the viewport's bearing, which is
+ * read at every draw. On a globe, the light is placed relative to
+ * the ground under each building. Polygons must lie at `fill-extrusion-base` and be extruded by
+ * the rest of the height. WebGL only: on WebGPU the extension adds no shader code, and buildings
+ * keep deck.gl's lights.
+ */
+export declare class FillExtrusionLightingExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        fillExtrusionLight: {
+            type: string;
+            value: FillExtrusionLight;
+        };
+        fillExtrusionVerticalGradient: boolean;
+    };
+    isEnabled(layer: Layer): boolean;
+    getShaders(this: Layer, extension: this): any;
+    draw(this: Layer<any>, params: any, extension: this): void;
+}

package/dist/types/fill-outline-extension.d.ts

@@ -0,0 +1,22 @@
+import { LayerExtension } from '@deck.gl/core';
+import type { Layer } from '@deck.gl/core';
+import type { ShaderModule } from '@luma.gl/shadertools';
+/**
+ * Draws the `PathLayer`s of a fill's outline (`fill-outline-color`) as MapLibre GL JS draws it: as
+ * `gl.LINES`, which draw each segment on its own, one pixel across the axis it crosses most
+ * steeply. deck.gl's 1 pixel stroke covers more pixels than that on diagonals, and its joins draw
+ * past the corners of short segments, so outlines came out darker and wider than MapLibre's. The
+ * stroke, drawn without antialiasing, is cut to the pixels a line draws: those within half a pixel
+ * of the segment along that axis, and not in the joins. MapLibre's shader also fades each pixel
+ * with its distance from the line (`fill_outline.fragment.glsl`); its outlines in Chrome have the
+ * colors of unfaded pixels, and so do these. Other sublayers are left unchanged. WebGL only; on
+ * WebGPU the outline draws as a stroke.
+ */
+export declare class FillOutlineExtension extends LayerExtension {
+    static extensionName: string;
+    getShaders(this: Layer): {
+        modules?: undefined;
+    } | {
+        modules: ShaderModule[];
+    };
+}

package/dist/types/fill-pattern.d.ts

@@ -0,0 +1,99 @@
+import { type StyleFeature } from "./style-expression.js";
+import { type SpriteAtlas, type SpriteIconMappingEntry } from "./sprite.js";
+type StyleLayerLike = {
+    paint?: Record<string, unknown>;
+    layout?: Record<string, unknown>;
+};
+/** The features of a patterned fill whose images come from one sprite. */
+export type FillPatternGroup = {
+    atlas: SpriteAtlas;
+    /** The atlas's index in the style's sprite list, unique per group. */
+    atlasIndex: number;
+    features: any[];
+    /** The image name in the atlas's mapping, for every feature or per feature. */
+    getFillPattern: string | ((feature: StyleFeature) => string);
+    /** The image's pixel ratio, device pixels per CSS pixel, for every feature or per feature. */
+    getPixelRatio: number | ((feature: StyleFeature) => number);
+    /** The names of the group's images, sorted. */
+    names: string[];
+    /** The group's pattern atlas, made on first use and released with the group. */
+    patternAtlas?: PatternAtlas;
+};
+/**
+ * Splits a patterned fill's features by the sprite their `fill-pattern` image is in. Features
+ * whose image is in no loaded sprite draw nothing, as in MapLibre GL JS. `fill-pattern` is
+ * evaluated at the integer zoom, as the style spec does for cross-faded properties.
+ *
+ * Returns no groups while the sprites load (`null`) or when the layer has no `fill-pattern`. A
+ * pattern that does not depend on feature data keeps the tile's feature array, so deck.gl does not
+ * re-tessellate the features at a new zoom step; per-feature groups are cached per tile, style
+ * layer, sprite list and zoom.
+ */
+export declare function getFillPatternGroups(features: any[], styleLayer: StyleLayerLike, zoom: number, spriteAtlases: SpriteAtlas[] | null | undefined): FillPatternGroup[];
+type PatternAtlas = {
+    image: SpriteAtlas['image'] | OffscreenCanvas | HTMLCanvasElement | ImageData;
+    mapping: Record<string, SpriteIconMappingEntry>;
+};
+/**
+ * An atlas of the named sprite images for a pattern, each with a 1 pixel border copied from its
+ * opposite edge, as MapLibre GL JS pads its pattern atlas. A sprite packs its images edge to edge,
+ * so a linear filter at an image's edge would blend in the next image and draw a seam between the
+ * repeats; with the border, it blends in the image's own wrapped pixels. The atlas holds only
+ * these images, so each fill uploads a small texture instead of the whole sprite. Where the
+ * sprite image is a URL, or no canvas is available, it returns the sprite itself.
+ */
+export declare function getPatternAtlas(atlas: SpriteAtlas, names: string[]): PatternAtlas;
+/**
+ * The largest width and height of a pattern atlas. WebGL 2 guarantees textures of 2048 pixels; in
+ * practice every device that runs it supports 4096, as MapLibre GL JS also assumes for its atlases.
+ */
+export declare const MAX_PATTERN_ATLAS_SIZE = 4096;
+/**
+ * Places images with a 1 pixel border on each side in rows no wider than `maxSize`: shelf packing,
+ * tallest images first. Returns each image's top left corner, inside its border, and the atlas
+ * size, or `null` when the images do not fit in `maxSize` by `maxSize`.
+ */
+export declare function packPatternImages(sizes: {
+    width: number;
+    height: number;
+}[], maxSize?: number): {
+    positions: [number, number][];
+    width: number;
+    height: number;
+} | null;
+/**
+ * Gives each fully transparent pixel of the rectangle `[left, top, right, bottom)` (the whole
+ * image by default) next to a visible one the alpha-weighted average color of its neighbors in
+ * the rectangle, keeping it transparent. MapLibre GL JS samples its pattern atlas, which is
+ * premultiplied, with a linear filter, so a pattern's edges blend toward transparent in its own
+ * color. A canvas uploads unpremultiplied, with transparent pixels black: the filter would blend
+ * the edges toward black, and draw light patterns with dark outlines. The image is read back from
+ * the canvas so that these colors survive (a canvas keeps none for transparent pixels). It is
+ * changed in place, with no copy: only transparent pixels change, and their alpha, which weighs
+ * every neighbor's color, stays 0, so no pixel's new color depends on another's.
+ */
+export declare function bleedIntoTransparentPixels({ data, width, height }: ImageData, [left, top, right, bottom]?: number[]): void;
+/**
+ * The features of a patterned fill that no group draws, because no loaded sprite has their image.
+ * MapLibre GL JS draws no fill for them, but still draws their `fill-outline-color` outline.
+ * Cached per list of groups, which `getFillPatternGroups` reuses while its inputs are unchanged.
+ */
+export declare function getFeaturesWithoutPattern(features: any[], groups: FillPatternGroup[]): any[];
+/**
+ * `FillPatternExtension` props for a group: the sprite atlas and mapping, and each image repeated
+ * at its CSS-pixel size at the integer zoom, as MapLibre GL JS sizes patterns. Between integer
+ * zooms the pattern scales with the map, and it steps back at the next integer zoom. The image
+ * supplies the colors, so the fill color is only the opacity.
+ */
+export declare function getFillPatternProps(group: FillPatternGroup, zoom: number): {
+    fillPatternAtlas: string | OffscreenCanvas | ImageBitmap | HTMLCanvasElement | ImageData;
+    fillPatternMapping: Record<string, SpriteIconMappingEntry>;
+    fillPatternMask: boolean;
+    textureParameters: {
+        readonly mipmapFilter: "none";
+    };
+    fillPatternSizeUnits: "common";
+    getFillPattern: string | ((feature: StyleFeature) => string);
+    getFillPatternScale: number | ((feature: StyleFeature) => number);
+};
+export {};

package/dist/types/fill-style-extensions.d.ts

@@ -0,0 +1,100 @@
+import { LayerExtension } from '@deck.gl/core';
+import type { CompositeLayer, Layer } from '@deck.gl/core';
+import { FillStyleExtension } from '@deck.gl/extensions';
+/** The anchor of `fill-translate`. */
+export type FillTranslateAnchor = 'map' | 'viewport';
+type FillTranslateExtensionProps = {
+    /** `fill-translate`: the offset in pixels, x right and y down. */
+    fillTranslate?: [number, number];
+    /** `fill-translate-anchor`: `'map'` turns the offset with the map, `'viewport'` keeps it on screen. */
+    fillTranslateAnchor?: FillTranslateAnchor;
+};
+/**
+ * Returns the ground offset of `fill-translate` in pixels, x east and y south, at a map bearing in
+ * degrees. A `'viewport'` offset is turned by the bearing, so it keeps its direction on screen,
+ * as in MapLibre GL JS.
+ */
+export declare function getFillTranslateOffset(translate: readonly [number, number], anchor: FillTranslateAnchor, bearing: number): [number, number];
+/**
+ * Offsets a fill and its outline by `fill-translate` pixels, anchored to the map or to the
+ * viewport by `fill-translate-anchor`. WebGL only; on WebGPU fills draw untranslated.
+ *
+ * Added to a `GeoJsonLayer`, it reaches the polygon fill and outline sublayers.
+ */
+export declare class FillTranslateExtension extends LayerExtension {
+    static extensionName: string;
+    static defaultProps: {
+        fillTranslate: {
+            type: string;
+            value: number[];
+            compare: boolean;
+        };
+        fillTranslateAnchor: string;
+    };
+    getShaders(this: Layer): {
+        modules?: undefined;
+    } | {
+        modules: {
+            readonly name: "fillTranslate";
+            readonly dependencies: readonly [{
+                readonly name: "project";
+                readonly dependencies: [{
+                    name: string;
+                    source: string;
+                    vs: string;
+                }, {
+                    readonly name: "geometry";
+                    readonly source: "const SMOOTH_EDGE_RADIUS: f32 = 0.5;\n\nstruct VertexGeometry {\n  position: vec4<f32>,\n  worldPosition: vec3<f32>,\n  worldPositionAlt: vec3<f32>,\n  normal: vec3<f32>,\n  uv: vec2<f32>,\n  pickingColor: vec3<f32>,\n};\n\nvar<private> geometry_: VertexGeometry = VertexGeometry(\n  vec4<f32>(0.0, 0.0, 1.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec2<f32>(0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0)\n);\n\nstruct FragmentGeometry {\n  uv: vec2<f32>,\n};\n\nvar<private> fragmentGeometry: FragmentGeometry;\n\nfn smoothedge(edge: f32, x: f32) -> f32 {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
+                    readonly vs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct VertexGeometry {\n  vec4 position;\n  vec3 worldPosition;\n  vec3 worldPositionAlt;\n  vec3 normal;\n  vec2 uv;\n  vec3 pickingColor;\n} geometry = VertexGeometry(\n  vec4(0.0, 0.0, 1.0, 0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec2(0.0),\n  vec3(0.0)\n);\n";
+                    readonly fs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct FragmentGeometry {\n  vec2 uv;\n};\nFragmentGeometry geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
+                }];
+                readonly source: string;
+                readonly vs: string;
+                readonly getUniforms: (opts?: import("@deck.gl/core").ProjectProps | {}) => {};
+                readonly uniformTypes: {
+                    readonly wrapLongitude: "f32";
+                    readonly coordinateSystem: "i32";
+                    readonly commonUnitsPerMeter: "vec3<f32>";
+                    readonly projectionMode: "i32";
+                    readonly scale: "f32";
+                    readonly commonUnitsPerWorldUnit: "vec3<f32>";
+                    readonly commonUnitsPerWorldUnit2: "vec3<f32>";
+                    readonly center: "vec4<f32>";
+                    readonly modelMatrix: "mat4x4<f32>";
+                    readonly viewProjectionMatrix: "mat4x4<f32>";
+                    readonly viewportSize: "vec2<f32>";
+                    readonly devicePixelRatio: "f32";
+                    readonly focalDistance: "f32";
+                    readonly cameraPosition: "vec3<f32>";
+                    readonly coordinateOrigin: "vec3<f32>";
+                    readonly commonOrigin: "vec3<f32>";
+                    readonly pseudoMeters: "f32";
+                };
+            }];
+            readonly vs: "layout(std140) uniform fillTranslateUniforms {\n  vec2 offset;\n} fillTranslate;\n";
+            readonly uniformTypes: {
+                readonly offset: "vec2<f32>";
+            };
+            readonly inject: {
+                readonly 'vs:DECKGL_FILTER_GL_POSITION': {
+                    readonly order: -1;
+                    readonly injection: "\n  if (fillTranslate.offset != vec2(0.0)) {\n    vec2 fillTranslate_pixels = vec2(fillTranslate.offset.x, -fillTranslate.offset.y);\n    if (project.projectionMode == PROJECTION_MODE_GLOBE) {\n      // The globe is centred at the origin with its axis along z.\n      vec3 fillTranslate_up = normalize(geometry.position.xyz);\n      vec3 fillTranslate_east = vec3(-fillTranslate_up.y, fillTranslate_up.x, 0.0);\n      fillTranslate_east = length(fillTranslate_east) > 0.0\n        ? normalize(fillTranslate_east)\n        : vec3(1.0, 0.0, 0.0);\n      vec3 fillTranslate_north = cross(fillTranslate_up, fillTranslate_east);\n      geometry.position.xyz +=\n        (fillTranslate_east * fillTranslate_pixels.x + fillTranslate_north * fillTranslate_pixels.y) /\n        project.scale;\n    } else {\n      geometry.position.xy += fillTranslate_pixels / project.scale;\n    }\n    position = project_common_position_to_clipspace(geometry.position);\n  }\n";
+                };
+            };
+        }[];
+    };
+    draw(this: Layer<FillTranslateExtensionProps>): void;
+}
+/**
+ * `FillStyleExtension` with image patterns, run only where its GLSL shader runs. On WebGPU it adds
+ * no shader code, and the fills it is added to draw nothing, as before patterns were supported:
+ * their fill color is only the pattern's opacity.
+ */
+export declare class FillPatternExtension extends FillStyleExtension {
+    static extensionName: string;
+    constructor();
+    getShaders(this: Layer, extension: this): any;
+    isEnabled(layer: Layer): boolean;
+    getSubLayerProps(this: CompositeLayer, extension: this): any;
+}
+export {};

package/dist/types/geojson-source.d.ts

@@ -0,0 +1,29 @@
+import type { GeoJSONVTOptions } from '@maplibre/geojson-vt';
+import type { BasemapSource } from "./style-resolver.js";
+/** Whether a source is a GeoJSON source whose data has been resolved to a GeoJSON object. */
+export declare function isGeoJsonSource(source: BasemapSource | undefined): boolean;
+/** The deepest zoom a GeoJSON source is tiled at; deeper views overzoom its tiles. */
+export declare function getGeoJsonMaxZoom(source: BasemapSource): number;
+/**
+ * geojson-vt options for a GeoJSON source, as MapLibre GL JS 6 sets them: `buffer` and
+ * `tolerance` are given in pixels of a 512 pixel tile, and the source's `maxzoom` is the deepest
+ * zoom tiled. Clustering is supported without `clusterProperties`.
+ */
+export declare function getGeoJsonVtOptions(source: BasemapSource): GeoJSONVTOptions;
+/**
+ * Whether tiles requested from now on are cut in a worker, where one can start (`true`, the
+ * default), or on the main thread. For tests.
+ */
+export declare function setGeoJsonWorkerEnabled(enabled: boolean): void;
+/**
+ * The features of one tile of a GeoJSON source, cut by geojson-vt as MapLibre GL JS cuts them, in
+ * the normalized tile-local coordinates of decoded vector tiles: the existing vector tile path
+ * then draws them as it draws vector tiles. The source is indexed, and its tiles cut, in a worker
+ * where one can start, and on the main thread otherwise. Rejects if the source's data is not
+ * valid GeoJSON.
+ */
+export declare function getGeoJsonTileFeatures(source: BasemapSource, index: {
+    x: number;
+    y: number;
+    z: number;
+}): Promise<Record<string, unknown>[]>;

package/dist/types/geojson-tiler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Cutting GeoJSON into vector tiles with `@maplibre/geojson-vt`, and the transferable form a
+ * tile's features take between the worker that cuts them and the main thread that draws them.
+ * This module runs in both: it holds no state and imports nothing from the rest of the module.
+ */
+import { GeoJSONVT, type GeoJSONVTOptions } from '@maplibre/geojson-vt';
+/** The extent of MapLibre GL JS's tiles, in tile units: GeoJSON is tiled at this precision. */
+export declare const GEOJSON_TILE_EXTENT = 8192;
+/** The geometry types of a tile's features, by how deep their coordinates nest. */
+declare const GEOMETRY_DEPTHS: {
+    readonly Point: 0;
+    readonly MultiPoint: 1;
+    readonly LineString: 1;
+    readonly MultiLineString: 2;
+    readonly Polygon: 2;
+    readonly MultiPolygon: 3;
+};
+type GeometryType = keyof typeof GEOMETRY_DEPTHS;
+/** One feature of an encoded tile: its coordinates are in the tile's typed arrays. */
+type EncodedFeature = {
+    type: GeometryType;
+    properties: Record<string, unknown>;
+    id?: unknown;
+};
+/**
+ * A tile's features in a form whose bulk can be transferred between threads: each feature's
+ * coordinates, in tile units, follow one another in `positions` (x, y pairs), and `lengths` holds,
+ * depth first, the length of each array above a position (the polygons of a multipolygon, the
+ * rings of a polygon, the points of a ring). Tile units are integers: geojson-vt rounds them.
+ */
+export type EncodedTile = {
+    features: EncodedFeature[];
+    positions: Int32Array;
+    lengths: Uint32Array;
+};
+/** Builds the tile index of a GeoJSON source's data. Throws if the data is not valid GeoJSON. */
+export declare function createTileIndex(data: unknown, options: GeoJSONVTOptions): GeoJSONVT;
+/**
+ * Cuts one tile from a tile index, as MapLibre GL JS cuts it, and encodes its features. Its typed
+ * arrays' buffers can be transferred.
+ */
+export declare function cutTile(index: GeoJSONVT, z: number, x: number, y: number): EncodedTile;
+/**
+ * The GeoJSON features of an encoded tile, in the normalized tile-local coordinates of decoded
+ * vector tiles: the vector tile path then draws them as it draws vector tiles.
+ */
+export declare function decodeTile(tile: EncodedTile): Record<string, unknown>[];
+export {};

package/dist/types/geojson-worker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The worker that indexes GeoJSON sources and cuts their tiles, as MapLibre GL JS's
+ * `GeoJSONWorkerSource` does, so that a large source does not hold the main thread. See
+ * `geojson-source.ts` for the other end of each message.
+ */
+import type { GeoJSONVTOptions } from '@maplibre/geojson-vt';
+import { cutTile } from "./geojson-tiler.js";
+/** A message from the main thread. Messages of one source arrive in the order they are sent. */
+export type GeoJsonWorkerRequest = 
+/** Features of a FeatureCollection, sent in batches before its `index` message. */
+{
+    type: 'features';
+    source: number;
+    features: unknown[];
+}
+/** Builds a source's index from `data`, or from the features sent before it. */
+ | {
+    type: 'index';
+    source: number;
+    data?: unknown;
+    options: GeoJSONVTOptions;
+} | {
+    type: 'tile';
+    source: number;
+    request: number;
+    z: number;
+    x: number;
+    y: number;
+} | {
+    type: 'remove';
+    source: number;
+};
+/** The answer to a `tile` request: the encoded tile, or why the source cannot be tiled. */
+export type GeoJsonWorkerResponse = {
+    request: number;
+} & ({
+    tile: ReturnType<typeof cutTile>;
+} | {
+    error: string;
+});

package/dist/types/globe-horizon-extension.d.ts

@@ -0,0 +1,61 @@
+import { LayerExtension } from '@deck.gl/core';
+import type { Layer } from '@deck.gl/core';
+/**
+ * Hides labels and icons whose anchor is on the far side of the globe in a `GlobeView`, in the
+ * screen pass and in the collision filter's pass. In other views the shader does nothing. WebGL
+ * only: on WebGPU the extension adds no shader code.
+ *
+ * Added to a composite layer such as `TextLayer`, it reaches the character and background
+ * sublayers.
+ */
+export declare class GlobeHorizonExtension extends LayerExtension {
+    static extensionName: string;
+    getShaders(this: Layer): {
+        modules?: undefined;
+    } | {
+        modules: {
+            readonly name: "globeHorizon";
+            readonly dependencies: readonly [{
+                readonly name: "project";
+                readonly dependencies: [{
+                    name: string;
+                    source: string;
+                    vs: string;
+                }, {
+                    readonly name: "geometry";
+                    readonly source: "const SMOOTH_EDGE_RADIUS: f32 = 0.5;\n\nstruct VertexGeometry {\n  position: vec4<f32>,\n  worldPosition: vec3<f32>,\n  worldPositionAlt: vec3<f32>,\n  normal: vec3<f32>,\n  uv: vec2<f32>,\n  pickingColor: vec3<f32>,\n};\n\nvar<private> geometry_: VertexGeometry = VertexGeometry(\n  vec4<f32>(0.0, 0.0, 1.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0),\n  vec2<f32>(0.0, 0.0),\n  vec3<f32>(0.0, 0.0, 0.0)\n);\n\nstruct FragmentGeometry {\n  uv: vec2<f32>,\n};\n\nvar<private> fragmentGeometry: FragmentGeometry;\n\nfn smoothedge(edge: f32, x: f32) -> f32 {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
+                    readonly vs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct VertexGeometry {\n  vec4 position;\n  vec3 worldPosition;\n  vec3 worldPositionAlt;\n  vec3 normal;\n  vec2 uv;\n  vec3 pickingColor;\n} geometry = VertexGeometry(\n  vec4(0.0, 0.0, 1.0, 0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec3(0.0),\n  vec2(0.0),\n  vec3(0.0)\n);\n";
+                    readonly fs: "#define SMOOTH_EDGE_RADIUS 0.5\n\nstruct FragmentGeometry {\n  vec2 uv;\n};\nFragmentGeometry geometry;\n\nfloat smoothedge(float edge, float x) {\n  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);\n}\n";
+                }];
+                readonly source: string;
+                readonly vs: string;
+                readonly getUniforms: (opts?: import("@deck.gl/core").ProjectProps | {}) => {};
+                readonly uniformTypes: {
+                    readonly wrapLongitude: "f32";
+                    readonly coordinateSystem: "i32";
+                    readonly commonUnitsPerMeter: "vec3<f32>";
+                    readonly projectionMode: "i32";
+                    readonly scale: "f32";
+                    readonly commonUnitsPerWorldUnit: "vec3<f32>";
+                    readonly commonUnitsPerWorldUnit2: "vec3<f32>";
+                    readonly center: "vec4<f32>";
+                    readonly modelMatrix: "mat4x4<f32>";
+                    readonly viewProjectionMatrix: "mat4x4<f32>";
+                    readonly viewportSize: "vec2<f32>";
+                    readonly devicePixelRatio: "f32";
+                    readonly focalDistance: "f32";
+                    readonly cameraPosition: "vec3<f32>";
+                    readonly coordinateOrigin: "vec3<f32>";
+                    readonly commonOrigin: "vec3<f32>";
+                    readonly pseudoMeters: "f32";
+                };
+            }];
+            readonly inject: {
+                readonly 'vs:DECKGL_FILTER_GL_POSITION': {
+                    readonly order: 1;
+                    readonly injection: "\n  if (project.projectionMode == PROJECTION_MODE_GLOBE) {\n    vec3 globeHorizon_normal = normalize(project_position(geometry.worldPosition));\n    mat4 globeHorizon_m = project.viewProjectionMatrix;\n    vec3 globeHorizon_wRow = vec3(globeHorizon_m[0][3], globeHorizon_m[1][3], globeHorizon_m[2][3]);\n    bool globeHorizon_hidden = dot(globeHorizon_wRow, globeHorizon_wRow) == 0.0\n      ? dot(globeHorizon_normal, vec3(globeHorizon_m[0][2], globeHorizon_m[1][2], globeHorizon_m[2][2])) > 0.0\n      : dot(globeHorizon_normal, project.cameraPosition) < GLOBE_RADIUS;\n    if (globeHorizon_hidden) {\n      // Every vertex of the quad lands beyond the far plane, so it is clipped. In the collision\n      // pass this keeps a hidden label out of the collision map.\n      position = vec4(0.0, 0.0, 2.0, 1.0);\n    }\n  }\n";
+                };
+            };
+        }[];
+    };
+}