@npm9912/v-map 0.1.0

package/dist/cjs/index-B8LHqjyg.js

@@ -0,0 +1,1765 @@
+'use strict';
+
+var deckProvider = require('./deck-provider-Ctq3Q8a1.js');
+var layerExtension = require('./layer-extension-B_olS0rc.js');
+require('./styleconfig-CVRqArk-.js');
+require('./index.browser-DQhD8Jwl.js');
+require('./index-BIL4VsgP.js');
+require('./_commonjsHelpers-B83fTs8d.js');
+require('./messages-D7h4m8Tx.js');
+require('./geotiff-source-RaNzzWkC.js');
+require('@loaders.gl/core');
+require('@loaders.gl/images');
+require('@loaders.gl/loader-utils');
+require('@loaders.gl/terrain');
+require('@loaders.gl/schema');
+
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Copyright (c) 2017 Uber Technologies, Inc.
+// TODO - import epsilon
+const EPSILON$1 = 0.000001;
+const EARTH_RADIUS_METERS = 6371000;
+/**
+ * The poles (phi) are at the positive and negative y axis.
+ * The equator starts at positive z.
+ * @link https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ */
+class SphericalCoordinates {
+    // bearing: number;
+    // pitch: number;
+    // altitude: number;
+    // lnglatZ coordinates
+    // longitude: number;
+    // latitude: number;
+    // lng: number;
+    // lat: number;
+    // z: number;
+    /**
+     * Creates a new SphericalCoordinates object
+     * @param options
+     * @param [options.phi] =0 - rotation around X (latitude)
+     * @param [options.theta] =0 - rotation around Y (longitude)
+     * @param [options.radius] =1 - Distance from center
+     * @param [options.bearing]
+     * @param [options.pitch]
+     * @param [options.altitude]
+     * @param [options.radiusScale] =1
+     */
+    // eslint-disable-next-line complexity
+    constructor({ phi = 0, theta = 0, radius = 1, bearing, pitch, altitude, radiusScale = EARTH_RADIUS_METERS } = {}) {
+        this.phi = phi;
+        this.theta = theta;
+        // TODO - silently accepts illegal 0
+        this.radius = radius || altitude || 1; // radial distance from center
+        this.radiusScale = radiusScale || 1; // Used by lngLatZ
+        if (bearing !== undefined) {
+            this.bearing = bearing; // up / down towards top and bottom pole
+        }
+        if (pitch !== undefined) {
+            this.pitch = pitch; // around the equator of the sphere
+        }
+        this.check();
+    }
+    toString() {
+        return this.formatString(deckProvider.config);
+    }
+    formatString({ printTypes = false }) {
+        const f = deckProvider.formatValue;
+        return `${printTypes ? 'Spherical' : ''}\
+[rho:${f(this.radius)},theta:${f(this.theta)},phi:${f(this.phi)}]`;
+    }
+    equals(other) {
+        return (deckProvider.equals(this.radius, other.radius) &&
+            deckProvider.equals(this.theta, other.theta) &&
+            deckProvider.equals(this.phi, other.phi));
+    }
+    exactEquals(other) {
+        return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;
+    }
+    /* eslint-disable brace-style */
+    // Cartographic (bearing 0 north, pitch 0 look from above)
+    get bearing() {
+        return 180 - deckProvider.degrees(this.phi);
+    }
+    set bearing(v) {
+        this.phi = Math.PI - deckProvider.radians(v);
+    }
+    get pitch() {
+        return deckProvider.degrees(this.theta);
+    }
+    set pitch(v) {
+        this.theta = deckProvider.radians(v);
+    }
+    // get pitch() { return 90 - degrees(this.phi); }
+    // set pitch(v) { this.phi = radians(v) + Math.PI / 2; }
+    // get altitude() { return this.radius - 1; } // relative altitude
+    // lnglatZ coordinates
+    get longitude() {
+        return deckProvider.degrees(this.phi);
+    }
+    get latitude() {
+        return deckProvider.degrees(this.theta);
+    }
+    get lng() {
+        return deckProvider.degrees(this.phi);
+    }
+    get lat() {
+        return deckProvider.degrees(this.theta);
+    }
+    get z() {
+        return (this.radius - 1) * this.radiusScale;
+    }
+    /* eslint-enable brace-style */
+    set(radius, phi, theta) {
+        this.radius = radius;
+        this.phi = phi;
+        this.theta = theta;
+        return this.check();
+    }
+    clone() {
+        return new SphericalCoordinates().copy(this);
+    }
+    copy(other) {
+        this.radius = other.radius;
+        this.phi = other.phi;
+        this.theta = other.theta;
+        return this.check();
+    }
+    fromLngLatZ([lng, lat, z]) {
+        this.radius = 1 + z / this.radiusScale;
+        this.phi = deckProvider.radians(lat);
+        this.theta = deckProvider.radians(lng);
+        return this.check();
+    }
+    fromVector3(v) {
+        this.radius = deckProvider.length(v);
+        if (this.radius > 0) {
+            this.theta = Math.atan2(v[0], v[1]); // equator angle around y-up axis
+            this.phi = Math.acos(deckProvider.clamp(v[2] / this.radius, -1, 1)); // polar angle
+        }
+        return this.check();
+    }
+    toVector3() {
+        return new deckProvider.Vector3(0, 0, this.radius)
+            .rotateX({ radians: this.theta })
+            .rotateZ({ radians: this.phi });
+    }
+    // restrict phi to be betwee EPS and PI-EPS
+    makeSafe() {
+        this.phi = Math.max(EPSILON$1, Math.min(Math.PI - EPSILON$1, this.phi));
+        return this;
+    }
+    check() {
+        // this.makeSafe();
+        if (!Number.isFinite(this.phi) || !Number.isFinite(this.theta) || !(this.radius > 0)) {
+            throw new Error('SphericalCoordinates: some fields set to invalid numbers');
+        }
+        return this;
+    }
+}
+
+const EPSILON = 0.01;
+const VIEWPORT_TRANSITION_PROPS = ['longitude', 'latitude', 'zoom'];
+const DEFAULT_OPTS$1 = {
+    curve: 1.414,
+    speed: 1.2
+    // screenSpeed and maxDuration are used only if specified
+};
+/**
+ * mapbox-gl-js flyTo : https://www.mapbox.com/mapbox-gl-js/api/#map#flyto.
+ * It implements “Smooth and efficient zooming and panning.” algorithm by
+ * "Jarke J. van Wijk and Wim A.A. Nuij"
+ */
+function flyToViewport(startProps, endProps, t, options) {
+    // Equations from above paper are referred where needed.
+    const { startZoom, startCenterXY, uDelta, w0, u1, S, rho, rho2, r0 } = getFlyToTransitionParams(startProps, endProps, options);
+    // If change in center is too small, do linear interpolaiton.
+    if (u1 < EPSILON) {
+        const viewport = {};
+        for (const key of VIEWPORT_TRANSITION_PROPS) {
+            const startValue = startProps[key];
+            const endValue = endProps[key];
+            // @ts-ignore-error properties are populated dynamically
+            viewport[key] = deckProvider.lerp(startValue, endValue, t);
+        }
+        // @ts-expect-error properties are populated dynamically
+        return viewport;
+    }
+    const s = t * S;
+    const w = Math.cosh(r0) / Math.cosh(r0 + rho * s);
+    const u = (w0 * ((Math.cosh(r0) * Math.tanh(r0 + rho * s) - Math.sinh(r0)) / rho2)) / u1;
+    const scaleIncrement = 1 / w; // Using w method for scaling.
+    const newZoom = startZoom + deckProvider.scaleToZoom(scaleIncrement);
+    const newCenterWorld = deckProvider.scale([], uDelta, u);
+    deckProvider.add(newCenterWorld, newCenterWorld, startCenterXY);
+    const newCenter = deckProvider.worldToLngLat(newCenterWorld);
+    return {
+        longitude: newCenter[0],
+        latitude: newCenter[1],
+        zoom: newZoom
+    };
+}
+// returns transition duration in milliseconds
+function getFlyToDuration(startProps, endProps, options) {
+    const opts = { ...DEFAULT_OPTS$1, ...options };
+    const { screenSpeed, speed, maxDuration } = opts;
+    const { S, rho } = getFlyToTransitionParams(startProps, endProps, opts);
+    const length = 1000 * S;
+    let duration;
+    if (Number.isFinite(screenSpeed)) {
+        duration = length / (screenSpeed / rho);
+    }
+    else {
+        duration = length / speed;
+    }
+    return Number.isFinite(maxDuration) && duration > maxDuration ? 0 : duration;
+}
+// Private Methods
+// Calculate all parameters that are static for given startProps and endProps
+function getFlyToTransitionParams(startProps, endProps, opts) {
+    opts = Object.assign({}, DEFAULT_OPTS$1, opts);
+    const rho = opts.curve;
+    const startZoom = startProps.zoom;
+    const startCenter = [startProps.longitude, startProps.latitude];
+    const startScale = deckProvider.zoomToScale(startZoom);
+    const endZoom = endProps.zoom;
+    const endCenter = [endProps.longitude, endProps.latitude];
+    const scale = deckProvider.zoomToScale(endZoom - startZoom);
+    const startCenterXY = deckProvider.lngLatToWorld(startCenter);
+    const endCenterXY = deckProvider.lngLatToWorld(endCenter);
+    const uDelta = deckProvider.sub([], endCenterXY, startCenterXY);
+    const w0 = Math.max(startProps.width, startProps.height);
+    const w1 = w0 / scale;
+    const u1 = deckProvider.length$1(uDelta) * startScale;
+    // u0 is treated as '0' in Eq (9).
+    // If u1 is too small, will generate invalid number
+    const _u1 = Math.max(u1, EPSILON);
+    // Implement Equation (9) from above algorithm.
+    const rho2 = rho * rho;
+    const b0 = (w1 * w1 - w0 * w0 + rho2 * rho2 * _u1 * _u1) / (2 * w0 * rho2 * _u1);
+    const b1 = (w1 * w1 - w0 * w0 - rho2 * rho2 * _u1 * _u1) / (2 * w1 * rho2 * _u1);
+    const r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0);
+    const r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1);
+    const S = (r1 - r0) / rho;
+    return { startZoom, startCenterXY, uDelta, w0, u1, S, rho, rho2, r0, r1 };
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_LIGHT_COLOR = [255, 255, 255];
+const DEFAULT_LIGHT_INTENSITY = 1.0;
+const DEFAULT_ATTENUATION = [1, 0, 0];
+const DEFAULT_LIGHT_POSITION = [0.0, 0.0, 1.0];
+let idCount = 0;
+class PointLight {
+    constructor(props = {}) {
+        this.type = 'point';
+        const { color = DEFAULT_LIGHT_COLOR } = props;
+        const { intensity = DEFAULT_LIGHT_INTENSITY } = props;
+        const { position = DEFAULT_LIGHT_POSITION } = props;
+        this.id = props.id || `point-${idCount++}`;
+        this.color = color;
+        this.intensity = intensity;
+        this.type = 'point';
+        this.position = position;
+        this.attenuation = getAttenuation(props);
+        this.projectedLight = { ...this };
+    }
+    getProjectedLight({ layer }) {
+        const { projectedLight } = this;
+        const viewport = layer.context.viewport;
+        const { coordinateSystem, coordinateOrigin } = layer.props;
+        const position = deckProvider.projectPosition(this.position, {
+            viewport,
+            coordinateSystem,
+            coordinateOrigin,
+            fromCoordinateSystem: viewport.isGeospatial
+                ? deckProvider.COORDINATE_SYSTEM.LNGLAT
+                : deckProvider.COORDINATE_SYSTEM.CARTESIAN,
+            fromCoordinateOrigin: [0, 0, 0]
+        });
+        projectedLight.color = this.color;
+        projectedLight.intensity = this.intensity;
+        projectedLight.position = position;
+        return projectedLight;
+    }
+}
+function getAttenuation(props) {
+    if (props.attenuation) {
+        return props.attenuation;
+    }
+    return DEFAULT_ATTENUATION;
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class CameraLight extends PointLight {
+    getProjectedLight({ layer }) {
+        const { projectedLight } = this;
+        const viewport = layer.context.viewport;
+        const { coordinateSystem, coordinateOrigin, modelMatrix } = layer.props;
+        const { cameraPosition } = deckProvider.getUniformsFromViewport({
+            viewport,
+            modelMatrix: modelMatrix,
+            coordinateSystem,
+            coordinateOrigin
+        });
+        projectedLight.color = this.color;
+        projectedLight.intensity = this.intensity;
+        projectedLight.position = cameraPosition;
+        return projectedLight;
+    }
+}
+
+const DEGREES_TO_RADIANS$1 = Math.PI / 180;
+const DAY_IN_MS = 1000 * 60 * 60 * 24;
+const JD1970 = 2440588; // Julian Day year 1970
+const JD2000 = 2451545; // Julian Day year 2000
+// This angle ε [epsilon] is called the obliquity of the ecliptic and its value at the beginning of 2000 was 23.4397°
+const e = DEGREES_TO_RADIANS$1 * 23.4397; // obliquity of the Earth
+// Refer https://www.aa.quae.nl/en/reken/zonpositie.html
+// "The Mean Anomaly" section for explanation
+const M0 = 357.5291; // Earth mean anomaly on start day
+const M1 = 0.98560028; // Earth angle traverses on average per day seen from the sun
+const THETA0 = 280.147; // The sidereal time (in degrees) at longitude 0° at the instant defined by JD2000
+const THETA1 = 360.9856235; // The rate of change of the sidereal time, in degrees per day.
+/**
+ * Calculate sun position
+ * based on https://www.aa.quae.nl/en/reken/zonpositie.html
+ * inspired by https://github.com/mourner/suncalc/blob/master/suncalc.js
+ */
+function getSunPosition(timestamp, latitude, longitude) {
+    const longitudeWestInRadians = DEGREES_TO_RADIANS$1 * -longitude;
+    const phi = DEGREES_TO_RADIANS$1 * latitude;
+    const d = toDays(timestamp);
+    const c = getSunCoords(d);
+    // hour angle
+    const H = getSiderealTime(d, longitudeWestInRadians) - c.rightAscension;
+    return {
+        azimuth: getAzimuth(H, phi, c.declination),
+        altitude: getAltitude(H, phi, c.declination)
+    };
+}
+function getSunDirection(timestamp, latitude, longitude) {
+    const { azimuth, altitude } = getSunPosition(timestamp, latitude, longitude);
+    // solar position to light direction
+    return [
+        Math.sin(azimuth) * Math.cos(altitude),
+        Math.cos(azimuth) * Math.cos(altitude),
+        -Math.sin(altitude)
+    ];
+}
+function toJulianDay(timestamp) {
+    const ts = typeof timestamp === 'number' ? timestamp : timestamp.getTime();
+    return ts / DAY_IN_MS - 0.5 + JD1970;
+}
+function toDays(timestamp) {
+    return toJulianDay(timestamp) - JD2000;
+}
+function getRightAscension(eclipticLongitude, b) {
+    const lambda = eclipticLongitude;
+    return Math.atan2(Math.sin(lambda) * Math.cos(e) - Math.tan(b) * Math.sin(e), Math.cos(lambda));
+}
+function getDeclination(eclipticLongitude, b) {
+    const lambda = eclipticLongitude;
+    return Math.asin(Math.sin(b) * Math.cos(e) + Math.cos(b) * Math.sin(e) * Math.sin(lambda));
+}
+function getAzimuth(hourAngle, latitudeInRadians, declination) {
+    const H = hourAngle;
+    const phi = latitudeInRadians;
+    const delta = declination;
+    return Math.atan2(Math.sin(H), Math.cos(H) * Math.sin(phi) - Math.tan(delta) * Math.cos(phi));
+}
+function getAltitude(hourAngle, latitudeInRadians, declination) {
+    const H = hourAngle;
+    const phi = latitudeInRadians;
+    const delta = declination;
+    return Math.asin(Math.sin(phi) * Math.sin(delta) + Math.cos(phi) * Math.cos(delta) * Math.cos(H));
+}
+// https://www.aa.quae.nl/en/reken/zonpositie.html
+// "The Observer section"
+function getSiderealTime(dates, longitudeWestInRadians) {
+    return DEGREES_TO_RADIANS$1 * (THETA0 + THETA1 * dates) - longitudeWestInRadians;
+}
+function getSolarMeanAnomaly(days) {
+    return DEGREES_TO_RADIANS$1 * (M0 + M1 * days);
+}
+function getEclipticLongitude(meanAnomaly) {
+    const M = meanAnomaly;
+    // equation of center
+    const C = DEGREES_TO_RADIANS$1 * (1.9148 * Math.sin(M) + 0.02 * Math.sin(2 * M) + 0.0003 * Math.sin(3 * M));
+    // perihelion of the Earth
+    const P = DEGREES_TO_RADIANS$1 * 102.9372;
+    return M + C + P + Math.PI;
+}
+function getSunCoords(dates) {
+    const M = getSolarMeanAnomaly(dates);
+    const L = getEclipticLongitude(M);
+    return {
+        declination: getDeclination(L, 0),
+        rightAscension: getRightAscension(L, 0)
+    };
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class SunLight extends deckProvider.DirectionalLight {
+    constructor(opts) {
+        super(opts);
+        this.timestamp = opts.timestamp;
+    }
+    getProjectedLight({ layer }) {
+        const { viewport } = layer.context;
+        const isGlobe = viewport.resolution && viewport.resolution > 0;
+        if (isGlobe) {
+            // Rotate vector to align with the direction of the globe projection (up at lon:0,lat:0 is [0, -1, 0])
+            const [x, y, z] = getSunDirection(this.timestamp, 0, 0);
+            this.direction = [x, -z, y];
+        }
+        else {
+            // @ts-expect-error longitude and latitude are not defined on all viewports
+            const { latitude, longitude } = viewport;
+            this.direction = getSunDirection(this.timestamp, latitude, longitude);
+        }
+        return this;
+    }
+}
+
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const CLIPSPACE_VERTEX_SHADER_WGSL = /* wgsl */ `\
+struct VertexInputs {
+  @location(0) clipSpacePosition: vec2<f32>,
+  @location(1) texCoord: vec2<f32>,
+  @location(2) coordinate: vec2<f32>  
+}
+
+struct FragmentInputs {
+  @builtin(position) Position : vec4<f32>,
+  @location(0) position : vec2<f32>,
+  @location(1) coordinate : vec2<f32>,
+  @location(2) uv : vec2<f32>
+};
+
+@vertex
+fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
+  var outputs: FragmentInputs;
+  outputs.Position = vec4(inputs.clipSpacePosition, 0., 1.);
+  outputs.position = inputs.clipSpacePosition;
+  outputs.coordinate = inputs.coordinate;
+  outputs.uv = inputs.texCoord;
+  return outputs;
+}
+`;
+const CLIPSPACE_VERTEX_SHADER = /* glsl */ `\
+#version 300 es
+in vec2 clipSpacePositions;
+in vec2 texCoords;
+in vec2 coordinates;
+
+out vec2 position;
+out vec2 coordinate;
+out vec2 uv;
+
+void main(void) {
+  gl_Position = vec4(clipSpacePositions, 0., 1.);
+  position = clipSpacePositions;
+  coordinate = coordinates;
+  uv = texCoords;
+}
+`;
+/* eslint-disable indent, no-multi-spaces */
+const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+class ClipSpace extends deckProvider.Model {
+    constructor(device, props) {
+        const TEX_COORDS = POSITIONS.map(coord => (coord === -1 ? 0 : coord));
+        // For WGSL we need to append the supplied fragment shader to the default vertex shader source
+        if (props.source) {
+            props = { ...props, source: `${CLIPSPACE_VERTEX_SHADER_WGSL}\n${props.source}` };
+        }
+        super(device, {
+            id: props.id || deckProvider.uid('clip-space'),
+            ...props,
+            vs: CLIPSPACE_VERTEX_SHADER,
+            vertexCount: 4,
+            geometry: new deckProvider.Geometry({
+                topology: 'triangle-strip',
+                vertexCount: 4,
+                attributes: {
+                    clipSpacePositions: { size: 2, value: new Float32Array(POSITIONS) },
+                    texCoords: { size: 2, value: new Float32Array(TEX_COORDS) },
+                    coordinates: { size: 2, value: new Float32Array(TEX_COORDS) }
+                }
+            })
+        });
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = `\
+uniform screenUniforms {
+  vec2 texSize;
+} screen;
+`;
+const screenUniforms = {
+    name: 'screen',
+    fs: uniformBlock,
+    uniformTypes: {
+        texSize: 'vec2<f32>'
+    }
+};
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** A base render pass. */
+class ScreenPass extends deckProvider.Pass {
+    constructor(device, props) {
+        super(device, props);
+        const { module, fs, id } = props;
+        const parameters = {
+            depthWriteEnabled: false,
+            depthCompare: 'always',
+            depthBias: 0,
+            blend: true,
+            blendColorSrcFactor: 'one',
+            blendColorDstFactor: 'one-minus-src-alpha',
+            blendAlphaSrcFactor: 'one',
+            blendAlphaDstFactor: 'one-minus-src-alpha',
+            blendColorOperation: 'add',
+            blendAlphaOperation: 'add'
+        };
+        this.model = new ClipSpace(device, { id, fs, modules: [module, screenUniforms], parameters });
+    }
+    render(params) {
+        this._renderPass(this.device, params);
+    }
+    delete() {
+        this.model.destroy();
+        this.model = null;
+    }
+    // Private methods
+    /**
+     * Renders the pass.
+     * This is an abstract method that should be overridden.
+     * @param inputBuffer - Frame buffer that contains the result of the previous pass
+     * @param outputBuffer - Frame buffer that serves as the output render target
+     */
+    _renderPass(device, options) {
+        const { clearCanvas, inputBuffer, outputBuffer } = options;
+        const texSize = [inputBuffer.width, inputBuffer.height];
+        const screenProps = {
+            texSrc: inputBuffer.colorAttachments[0],
+            texSize
+        };
+        this.model.shaderInputs.setProps({
+            screen: screenProps,
+            ...options.moduleProps
+        });
+        const renderPass = this.device.beginRenderPass({
+            framebuffer: outputBuffer,
+            parameters: { viewport: [0, 0, ...texSize] },
+            clearColor: clearCanvas ? [0, 0, 0, 0] : false,
+            clearDepth: 1,
+            clearStencil: false
+        });
+        this.model.draw(renderPass);
+        renderPass.end();
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class PostProcessEffect {
+    constructor(module, props) {
+        this.id = `${module.name}-pass`;
+        this.props = props;
+        deckProvider.initializeShaderModule(module);
+        this.module = module;
+    }
+    setup({ device }) {
+        this.passes = createPasses(device, this.module, this.id);
+    }
+    setProps(props) {
+        this.props = props;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    preRender() { }
+    postRender(params) {
+        const passes = this.passes;
+        const { target } = params;
+        let inputBuffer = params.inputBuffer;
+        let outputBuffer = params.swapBuffer;
+        for (let index = 0; index < passes.length; index++) {
+            const isLastPass = index === passes.length - 1;
+            const renderToTarget = target !== undefined && isLastPass;
+            if (renderToTarget) {
+                outputBuffer = target;
+            }
+            const clearCanvas = !renderToTarget || Boolean(params.clearCanvas);
+            const moduleProps = {};
+            const uniforms = this.module.passes[index].uniforms;
+            moduleProps[this.module.name] = { ...this.props, ...uniforms };
+            passes[index].render({ clearCanvas, inputBuffer, outputBuffer, moduleProps });
+            const switchBuffer = outputBuffer;
+            outputBuffer = inputBuffer;
+            inputBuffer = switchBuffer;
+        }
+        return inputBuffer;
+    }
+    cleanup() {
+        if (this.passes) {
+            for (const pass of this.passes) {
+                pass.delete();
+            }
+            this.passes = undefined;
+        }
+    }
+}
+function createPasses(device, module, id) {
+    return module.passes.map((pass, index) => {
+        const fs = getFragmentShaderForRenderPass(module, pass);
+        const idn = `${id}-${index}`;
+        return new ScreenPass(device, { id: idn, module, fs });
+    });
+}
+const FS_TEMPLATE_INPUTS = `\
+#version 300 es
+uniform sampler2D texSrc;
+
+in vec2 position;
+in vec2 coordinate;
+in vec2 uv;
+
+out vec4 fragColor;
+`;
+const FILTER_FS_TEMPLATE = (func) => `\
+${FS_TEMPLATE_INPUTS}
+void main() {
+  fragColor = texture(texSrc, coordinate);
+  fragColor = ${func}(fragColor, screen.texSize, coordinate);
+}
+`;
+const SAMPLER_FS_TEMPLATE = (func) => `\
+${FS_TEMPLATE_INPUTS}
+void main() {
+  fragColor = ${func}(texSrc, screen.texSize, coordinate);
+}
+`;
+function getFragmentShaderForRenderPass(module, pass) {
+    if (pass.filter) {
+        const func = typeof pass.filter === 'string' ? pass.filter : `${module.name}_filterColor_ext`;
+        return FILTER_FS_TEMPLATE(func);
+    }
+    if (pass.sampler) {
+        const func = typeof pass.sampler === 'string' ? pass.sampler : `${module.name}_sampleColor`;
+        return SAMPLER_FS_TEMPLATE(func);
+    }
+    // console.error(`${module.name} no fragment shader generated`);
+    return '';
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEGREES_TO_RADIANS = Math.PI / 180;
+function getViewMatrix({ height, focalDistance, orbitAxis, rotationX, rotationOrbit, zoom }) {
+    // We position the camera so that one common space unit (world space unit scaled by zoom)
+    // at the target maps to one screen pixel.
+    // This is a similar technique to that used in web mercator projection
+    // By doing so we are able to convert between common space and screen space sizes efficiently
+    // in the vertex shader.
+    const up = orbitAxis === 'Z' ? [0, 0, 1] : [0, 1, 0];
+    const eye = orbitAxis === 'Z' ? [0, -focalDistance, 0] : [0, 0, focalDistance];
+    const viewMatrix = new deckProvider.Matrix4().lookAt({ eye, up });
+    viewMatrix.rotateX(rotationX * DEGREES_TO_RADIANS);
+    if (orbitAxis === 'Z') {
+        viewMatrix.rotateZ(rotationOrbit * DEGREES_TO_RADIANS);
+    }
+    else {
+        viewMatrix.rotateY(rotationOrbit * DEGREES_TO_RADIANS);
+    }
+    // When height increases, we need to increase the distance from the camera to the target to
+    // keep the 1:1 mapping. However, this also changes the projected depth of each position by
+    // moving them further away between the near/far plane.
+    // Without modifying the default near/far planes, we instead scale down the common space to
+    // remove the distortion to the depth field.
+    const projectionScale = Math.pow(2, zoom) / height;
+    viewMatrix.scale(projectionScale);
+    return viewMatrix;
+}
+class OrbitViewport extends deckProvider.Viewport {
+    constructor(props) {
+        const { height, projectionMatrix, fovy = 50, // For setting camera position
+        orbitAxis = 'Z', // Orbit axis with 360 degrees rotating freedom, can only be 'Y' or 'Z'
+        target = [0, 0, 0], // Which point is camera looking at, default origin
+        rotationX = 0, // Rotating angle around X axis
+        rotationOrbit = 0, // Rotating angle around orbit axis
+        zoom = 0 } = props;
+        const focalDistance = projectionMatrix ? projectionMatrix[5] / 2 : deckProvider.fovyToAltitude(fovy);
+        super({
+            ...props,
+            // in case viewState contains longitude/latitude values,
+            // make sure that the base Viewport class does not treat this as a geospatial viewport
+            longitude: undefined,
+            viewMatrix: getViewMatrix({
+                height: height || 1,
+                focalDistance,
+                orbitAxis,
+                rotationX,
+                rotationOrbit,
+                zoom
+            }),
+            fovy,
+            focalDistance,
+            position: target,
+            zoom
+        });
+        this.target = target;
+        this.orbitAxis = orbitAxis;
+        this.rotationX = rotationX;
+        this.rotationOrbit = rotationOrbit;
+        this.fovy = fovy;
+        this.projectedCenter = this.project(this.center);
+    }
+    unproject(xyz, { topLeft = true } = {}) {
+        const [x, y, z = this.projectedCenter[2]] = xyz;
+        const y2 = topLeft ? y : this.height - y;
+        const [X, Y, Z] = deckProvider.pixelsToWorld([x, y2, z], this.pixelUnprojectionMatrix);
+        return [X, Y, Z];
+    }
+    panByPosition(coords, pixel, startPixel) {
+        const p0 = this.project(coords);
+        const nextCenter = [
+            this.width / 2 + p0[0] - pixel[0],
+            this.height / 2 + p0[1] - pixel[1],
+            this.projectedCenter[2]
+        ];
+        return {
+            target: this.unproject(nextCenter)
+        };
+    }
+}
+OrbitViewport.displayName = 'OrbitViewport';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const viewMatrix = new deckProvider.Matrix4().lookAt({ eye: [0, 0, 1] });
+function getProjectionMatrix({ width, height, near, far, padding }) {
+    let left = -width / 2;
+    let right = width / 2;
+    let bottom = -height / 2;
+    let top = height / 2;
+    if (padding) {
+        const { left: l = 0, right: r = 0, top: t = 0, bottom: b = 0 } = padding;
+        const offsetX = deckProvider.clamp((l + width - r) / 2, 0, width) - width / 2;
+        const offsetY = deckProvider.clamp((t + height - b) / 2, 0, height) - height / 2;
+        left -= offsetX;
+        right -= offsetX;
+        bottom += offsetY;
+        top += offsetY;
+    }
+    return new deckProvider.Matrix4().ortho({
+        left,
+        right,
+        bottom,
+        top,
+        near,
+        far
+    });
+}
+class OrthographicViewport extends deckProvider.Viewport {
+    constructor(props) {
+        const { width, height, near = 0.1, far = 1000, zoom = 0, target = [0, 0, 0], padding = null, flipY = true } = props;
+        const zoomX = props.zoomX ?? (Array.isArray(zoom) ? zoom[0] : zoom);
+        const zoomY = props.zoomY ?? (Array.isArray(zoom) ? zoom[1] : zoom);
+        const zoom_ = Math.min(zoomX, zoomY);
+        const scale = Math.pow(2, zoom_);
+        let distanceScales;
+        if (zoomX !== zoomY) {
+            const scaleX = Math.pow(2, zoomX);
+            const scaleY = Math.pow(2, zoomY);
+            distanceScales = {
+                unitsPerMeter: [scaleX / scale, scaleY / scale, 1],
+                metersPerUnit: [scale / scaleX, scale / scaleY, 1]
+            };
+        }
+        super({
+            ...props,
+            // in case viewState contains longitude/latitude values,
+            // make sure that the base Viewport class does not treat this as a geospatial viewport
+            longitude: undefined,
+            position: target,
+            viewMatrix: viewMatrix.clone().scale([scale, scale * (flipY ? -1 : 1), scale]),
+            projectionMatrix: getProjectionMatrix({
+                width: width || 1,
+                height: height || 1,
+                padding,
+                near,
+                far
+            }),
+            zoom: zoom_,
+            distanceScales
+        });
+        this.target = target;
+        this.zoomX = zoomX;
+        this.zoomY = zoomY;
+        this.flipY = flipY;
+    }
+    projectFlat([X, Y]) {
+        const { unitsPerMeter } = this.distanceScales;
+        return [X * unitsPerMeter[0], Y * unitsPerMeter[1]];
+    }
+    unprojectFlat([x, y]) {
+        const { metersPerUnit } = this.distanceScales;
+        return [x * metersPerUnit[0], y * metersPerUnit[1]];
+    }
+    /* Needed by LinearInterpolator */
+    panByPosition(coords, pixel, startPixel) {
+        const fromLocation = deckProvider.pixelsToWorld(pixel, this.pixelUnprojectionMatrix);
+        const toLocation = this.projectFlat(coords);
+        const translate = deckProvider.add([], toLocation, deckProvider.negate([], fromLocation));
+        const newCenter = deckProvider.add([], this.center, translate);
+        return { target: this.unprojectFlat(newCenter) };
+    }
+}
+OrthographicViewport.displayName = 'OrthographicViewport';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class FirstPersonViewport extends deckProvider.Viewport {
+    constructor(props) {
+        // TODO - push direction handling into Matrix4.lookAt
+        const { longitude, latitude, modelMatrix, bearing = 0, pitch = 0, up = [0, 0, 1] } = props;
+        // Always calculate direction from bearing and pitch
+        const spherical = new SphericalCoordinates({
+            bearing,
+            // Avoid "pixel project matrix not invertible" error
+            pitch: pitch === -90 ? 0.0001 : 90 + pitch
+        });
+        const dir = spherical.toVector3().normalize();
+        // Direction is relative to model coordinates, of course
+        const center = modelMatrix ? new deckProvider.Matrix4(modelMatrix).transformAsVector(dir) : dir;
+        // Just the direction. All the positioning is done in viewport.js
+        const zoom = Number.isFinite(latitude) ? deckProvider.getMeterZoom({ latitude: latitude }) : 0;
+        const scale = Math.pow(2, zoom);
+        const viewMatrix = new deckProvider.Matrix4().lookAt({ eye: [0, 0, 0], center, up }).scale(scale);
+        super({
+            ...props,
+            zoom,
+            viewMatrix
+        });
+        this.latitude = latitude;
+        this.longitude = longitude;
+        this.pitch = pitch;
+        this.bearing = bearing;
+        this.up = up;
+    }
+}
+FirstPersonViewport.displayName = 'FirstPersonViewport';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const MOVEMENT_SPEED = 20;
+const PAN_SPEED = 500;
+class FirstPersonState extends deckProvider.ViewState {
+    constructor(options) {
+        const { 
+        /* Viewport arguments */
+        width, // Width of viewport
+        height, // Height of viewport
+        // Position and orientation
+        position = [0, 0, 0], // typically in meters from anchor point
+        bearing = 0, // Rotation around y axis
+        pitch = 0, // Rotation around x axis
+        // Geospatial anchor
+        longitude = null, latitude = null, maxPitch = 90, minPitch = -90, 
+        // Model state when the rotate operation first started
+        startRotatePos, startBearing, startPitch, startZoomPosition, startPanPos, startPanPosition } = options;
+        super({
+            width,
+            height,
+            position,
+            bearing,
+            pitch,
+            longitude,
+            latitude,
+            maxPitch,
+            minPitch
+        }, {
+            startRotatePos,
+            startBearing,
+            startPitch,
+            startZoomPosition,
+            startPanPos,
+            startPanPosition
+        });
+        this.makeViewport = options.makeViewport;
+    }
+    /* Public API */
+    /**
+     * Start panning
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    panStart({ pos }) {
+        const { position } = this.getViewportProps();
+        return this._getUpdatedState({
+            startPanPos: pos,
+            startPanPosition: position
+        });
+    }
+    /**
+     * Pan
+     * @param {[Number, Number]} pos - position on screen where the pointer is
+     */
+    pan({ pos }) {
+        if (!pos) {
+            return this;
+        }
+        const { startPanPos = [0, 0], startPanPosition = [0, 0] } = this.getState();
+        const { width, height, bearing, pitch } = this.getViewportProps();
+        const deltaScaleX = (PAN_SPEED * (pos[0] - startPanPos[0])) / width;
+        const deltaScaleY = (PAN_SPEED * (pos[1] - startPanPos[1])) / height;
+        const up = new SphericalCoordinates({ bearing, pitch });
+        const forward = new SphericalCoordinates({ bearing, pitch: -90 });
+        const yDirection = up.toVector3().normalize();
+        const xDirection = forward.toVector3().cross(yDirection).normalize();
+        return this._getUpdatedState({
+            position: new deckProvider.Vector3(startPanPosition)
+                .add(xDirection.scale(deltaScaleX))
+                .add(yDirection.scale(deltaScaleY))
+        });
+    }
+    /**
+     * End panning
+     * Must call if `panStart()` was called
+     */
+    panEnd() {
+        return this._getUpdatedState({
+            startPanPos: null,
+            startPanPosition: null
+        });
+    }
+    /**
+     * Start rotating
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    rotateStart({ pos }) {
+        return this._getUpdatedState({
+            startRotatePos: pos,
+            startBearing: this.getViewportProps().bearing,
+            startPitch: this.getViewportProps().pitch
+        });
+    }
+    /**
+     * Rotate
+     * @param {[Number, Number]} pos - position on screen where the pointer is
+     */
+    rotate({ pos, deltaAngleX = 0, deltaAngleY = 0 }) {
+        const { startRotatePos, startBearing, startPitch } = this.getState();
+        const { width, height } = this.getViewportProps();
+        if (!startRotatePos || startBearing === undefined || startPitch === undefined) {
+            return this;
+        }
+        let newRotation;
+        if (pos) {
+            const deltaScaleX = (pos[0] - startRotatePos[0]) / width;
+            const deltaScaleY = (pos[1] - startRotatePos[1]) / height;
+            newRotation = {
+                bearing: startBearing - deltaScaleX * 180,
+                pitch: startPitch - deltaScaleY * 90
+            };
+        }
+        else {
+            newRotation = {
+                bearing: startBearing - deltaAngleX,
+                pitch: startPitch - deltaAngleY
+            };
+        }
+        return this._getUpdatedState(newRotation);
+    }
+    /**
+     * End rotating
+     * Must call if `rotateStart()` was called
+     */
+    rotateEnd() {
+        return this._getUpdatedState({
+            startRotatePos: null,
+            startBearing: null,
+            startPitch: null
+        });
+    }
+    /**
+     * Start zooming
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    zoomStart() {
+        return this._getUpdatedState({
+            startZoomPosition: this.getViewportProps().position
+        });
+    }
+    /**
+     * Zoom
+     * @param {[Number, Number]} pos - position on screen where the current center is
+     * @param {[Number, Number]} startPos - the center position at
+     *   the start of the operation. Must be supplied of `zoomStart()` was not called
+     * @param {Number} scale - a number between [0, 1] specifying the accumulated
+     *   relative scale.
+     */
+    zoom({ pos, scale }) {
+        const viewportProps = this.getViewportProps();
+        const startZoomPosition = this.getState().startZoomPosition || viewportProps.position;
+        const viewport = this.makeViewport(viewportProps);
+        const { projectionMatrix, width } = viewport;
+        const fovxRadians = 2.0 * Math.atan(1.0 / projectionMatrix[0]);
+        const angle = fovxRadians * (pos[0] / width - 0.5);
+        const direction = this.getDirection(true);
+        return this._move(direction.rotateZ({ radians: -angle }), Math.log2(scale) * MOVEMENT_SPEED, startZoomPosition);
+    }
+    /**
+     * End zooming
+     * Must call if `zoomStart()` was called
+     */
+    zoomEnd() {
+        return this._getUpdatedState({
+            startZoomPosition: null
+        });
+    }
+    moveLeft(speed = MOVEMENT_SPEED) {
+        const direction = this.getDirection(true);
+        return this._move(direction.rotateZ({ radians: Math.PI / 2 }), speed);
+    }
+    moveRight(speed = MOVEMENT_SPEED) {
+        const direction = this.getDirection(true);
+        return this._move(direction.rotateZ({ radians: -Math.PI / 2 }), speed);
+    }
+    // forward
+    moveUp(speed = MOVEMENT_SPEED) {
+        const direction = this.getDirection(true);
+        return this._move(direction, speed);
+    }
+    // backward
+    moveDown(speed = MOVEMENT_SPEED) {
+        const direction = this.getDirection(true);
+        return this._move(direction.negate(), speed);
+    }
+    rotateLeft(speed = 15) {
+        return this._getUpdatedState({
+            bearing: this.getViewportProps().bearing - speed
+        });
+    }
+    rotateRight(speed = 15) {
+        return this._getUpdatedState({
+            bearing: this.getViewportProps().bearing + speed
+        });
+    }
+    rotateUp(speed = 10) {
+        return this._getUpdatedState({
+            pitch: this.getViewportProps().pitch + speed
+        });
+    }
+    rotateDown(speed = 10) {
+        return this._getUpdatedState({
+            pitch: this.getViewportProps().pitch - speed
+        });
+    }
+    zoomIn(speed = MOVEMENT_SPEED) {
+        return this._move(new deckProvider.Vector3(0, 0, 1), speed);
+    }
+    zoomOut(speed = MOVEMENT_SPEED) {
+        return this._move(new deckProvider.Vector3(0, 0, -1), speed);
+    }
+    // shortest path between two view states
+    shortestPathFrom(viewState) {
+        const fromProps = viewState.getViewportProps();
+        const props = { ...this.getViewportProps() };
+        const { bearing, longitude } = props;
+        if (Math.abs(bearing - fromProps.bearing) > 180) {
+            props.bearing = bearing < 0 ? bearing + 360 : bearing - 360;
+        }
+        if (longitude !== null &&
+            fromProps.longitude !== null &&
+            Math.abs(longitude - fromProps.longitude) > 180) {
+            props.longitude = longitude < 0 ? longitude + 360 : longitude - 360;
+        }
+        return props;
+    }
+    /* Private methods */
+    _move(direction, speed, fromPosition = this.getViewportProps().position) {
+        const delta = direction.scale(speed);
+        return this._getUpdatedState({
+            position: new deckProvider.Vector3(fromPosition).add(delta)
+        });
+    }
+    getDirection(use2D = false) {
+        const spherical = new SphericalCoordinates({
+            bearing: this.getViewportProps().bearing,
+            pitch: use2D ? 90 : 90 + this.getViewportProps().pitch
+        });
+        const direction = spherical.toVector3().normalize();
+        return direction;
+    }
+    _getUpdatedState(newProps) {
+        // Update _viewportProps
+        return new FirstPersonState({
+            makeViewport: this.makeViewport,
+            ...this.getViewportProps(),
+            ...this.getState(),
+            ...newProps
+        });
+    }
+    // Apply any constraints (mathematical or defined by _viewportProps) to map state
+    applyConstraints(props) {
+        // Ensure pitch and zoom are within specified range
+        const { pitch, maxPitch, minPitch, longitude, bearing } = props;
+        props.pitch = deckProvider.clamp(pitch, minPitch, maxPitch);
+        // Normalize degrees
+        if (longitude !== null && (longitude < -180 || longitude > 180)) {
+            props.longitude = deckProvider.mod(longitude + 180, 360) - 180;
+        }
+        if (bearing < -180 || bearing > 180) {
+            props.bearing = deckProvider.mod(bearing + 180, 360) - 180;
+        }
+        return props;
+    }
+}
+class FirstPersonController extends deckProvider.Controller {
+    constructor() {
+        super(...arguments);
+        this.ControllerState = FirstPersonState;
+        this.transition = {
+            transitionDuration: 300,
+            transitionInterpolator: new deckProvider.LinearInterpolator(['position', 'pitch', 'bearing'])
+        };
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class FirstPersonView extends deckProvider.View {
+    constructor(props = {}) {
+        super(props);
+    }
+    getViewportType() {
+        return FirstPersonViewport;
+    }
+    get ControllerType() {
+        return FirstPersonController;
+    }
+}
+FirstPersonView.displayName = 'FirstPersonView';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class OrbitState extends deckProvider.ViewState {
+    constructor(options) {
+        const { 
+        /* Viewport arguments */
+        width, // Width of viewport
+        height, // Height of viewport
+        rotationX = 0, // Rotation around x axis
+        rotationOrbit = 0, // Rotation around orbit axis
+        target = [0, 0, 0], zoom = 0, 
+        /* Viewport constraints */
+        minRotationX = -90, maxRotationX = 90, minZoom = -Infinity, maxZoom = Infinity, 
+        /** Interaction states, required to calculate change during transform */
+        // Model state when the pan operation first started
+        startPanPosition, 
+        // Model state when the rotate operation first started
+        startRotatePos, startRotationX, startRotationOrbit, 
+        // Model state when the zoom operation first started
+        startZoomPosition, startZoom } = options;
+        super({
+            width,
+            height,
+            rotationX,
+            rotationOrbit,
+            target,
+            zoom,
+            minRotationX,
+            maxRotationX,
+            minZoom,
+            maxZoom
+        }, {
+            startPanPosition,
+            startRotatePos,
+            startRotationX,
+            startRotationOrbit,
+            startZoomPosition,
+            startZoom
+        });
+        this.makeViewport = options.makeViewport;
+    }
+    /**
+     * Start panning
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    panStart({ pos }) {
+        return this._getUpdatedState({
+            startPanPosition: this._unproject(pos)
+        });
+    }
+    /**
+     * Pan
+     * @param {[Number, Number]} pos - position on screen where the pointer is
+     */
+    pan({ pos, startPosition }) {
+        const startPanPosition = this.getState().startPanPosition || startPosition;
+        if (!startPanPosition) {
+            return this;
+        }
+        const viewport = this.makeViewport(this.getViewportProps());
+        const newProps = viewport.panByPosition(startPanPosition, pos);
+        return this._getUpdatedState(newProps);
+    }
+    /**
+     * End panning
+     * Must call if `panStart()` was called
+     */
+    panEnd() {
+        return this._getUpdatedState({
+            startPanPosition: null
+        });
+    }
+    /**
+     * Start rotating
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    rotateStart({ pos }) {
+        return this._getUpdatedState({
+            startRotatePos: pos,
+            startRotationX: this.getViewportProps().rotationX,
+            startRotationOrbit: this.getViewportProps().rotationOrbit
+        });
+    }
+    /**
+     * Rotate
+     * @param {[Number, Number]} pos - position on screen where the pointer is
+     */
+    rotate({ pos, deltaAngleX = 0, deltaAngleY = 0 }) {
+        const { startRotatePos, startRotationX, startRotationOrbit } = this.getState();
+        const { width, height } = this.getViewportProps();
+        if (!startRotatePos || startRotationX === undefined || startRotationOrbit === undefined) {
+            return this;
+        }
+        let newRotation;
+        if (pos) {
+            let deltaScaleX = (pos[0] - startRotatePos[0]) / width;
+            const deltaScaleY = (pos[1] - startRotatePos[1]) / height;
+            if (startRotationX < -90 || startRotationX > 90) {
+                // When looking at the "back" side of the scene, invert horizontal drag
+                // so that the camera movement follows user input
+                deltaScaleX *= -1;
+            }
+            newRotation = {
+                rotationX: startRotationX + deltaScaleY * 180,
+                rotationOrbit: startRotationOrbit + deltaScaleX * 180
+            };
+        }
+        else {
+            newRotation = {
+                rotationX: startRotationX + deltaAngleY,
+                rotationOrbit: startRotationOrbit + deltaAngleX
+            };
+        }
+        return this._getUpdatedState(newRotation);
+    }
+    /**
+     * End rotating
+     * Must call if `rotateStart()` was called
+     */
+    rotateEnd() {
+        return this._getUpdatedState({
+            startRotationX: null,
+            startRotationOrbit: null
+        });
+    }
+    // shortest path between two view states
+    shortestPathFrom(viewState) {
+        const fromProps = viewState.getViewportProps();
+        const props = { ...this.getViewportProps() };
+        const { rotationOrbit } = props;
+        if (Math.abs(rotationOrbit - fromProps.rotationOrbit) > 180) {
+            props.rotationOrbit = rotationOrbit < 0 ? rotationOrbit + 360 : rotationOrbit - 360;
+        }
+        return props;
+    }
+    /**
+     * Start zooming
+     * @param {[Number, Number]} pos - position on screen where the pointer grabs
+     */
+    zoomStart({ pos }) {
+        return this._getUpdatedState({
+            startZoomPosition: this._unproject(pos),
+            startZoom: this.getViewportProps().zoom
+        });
+    }
+    /**
+     * Zoom
+     * @param {[Number, Number]} pos - position on screen where the current target is
+     * @param {[Number, Number]} startPos - the target position at
+     *   the start of the operation. Must be supplied of `zoomStart()` was not called
+     * @param {Number} scale - a number between [0, 1] specifying the accumulated
+     *   relative scale.
+     */
+    zoom({ pos, startPos, scale }) {
+        let { startZoom, startZoomPosition } = this.getState();
+        if (!startZoomPosition) {
+            // We have two modes of zoom:
+            // scroll zoom that are discrete events (transform from the current zoom level),
+            // and pinch zoom that are continuous events (transform from the zoom level when
+            // pinch started).
+            // If startZoom state is defined, then use the startZoom state;
+            // otherwise assume discrete zooming
+            startZoom = this.getViewportProps().zoom;
+            startZoomPosition = this._unproject(startPos || pos);
+        }
+        if (!startZoomPosition) {
+            return this;
+        }
+        const newZoom = this._calculateNewZoom({ scale, startZoom });
+        const zoomedViewport = this.makeViewport({ ...this.getViewportProps(), zoom: newZoom });
+        return this._getUpdatedState({
+            zoom: newZoom,
+            ...zoomedViewport.panByPosition(startZoomPosition, pos)
+        });
+    }
+    /**
+     * End zooming
+     * Must call if `zoomStart()` was called
+     */
+    zoomEnd() {
+        return this._getUpdatedState({
+            startZoomPosition: null,
+            startZoom: null
+        });
+    }
+    zoomIn(speed = 2) {
+        return this._getUpdatedState({
+            zoom: this._calculateNewZoom({ scale: speed })
+        });
+    }
+    zoomOut(speed = 2) {
+        return this._getUpdatedState({
+            zoom: this._calculateNewZoom({ scale: 1 / speed })
+        });
+    }
+    moveLeft(speed = 50) {
+        return this._panFromCenter([-speed, 0]);
+    }
+    moveRight(speed = 50) {
+        return this._panFromCenter([speed, 0]);
+    }
+    moveUp(speed = 50) {
+        return this._panFromCenter([0, -speed]);
+    }
+    moveDown(speed = 50) {
+        return this._panFromCenter([0, speed]);
+    }
+    rotateLeft(speed = 15) {
+        return this._getUpdatedState({
+            rotationOrbit: this.getViewportProps().rotationOrbit - speed
+        });
+    }
+    rotateRight(speed = 15) {
+        return this._getUpdatedState({
+            rotationOrbit: this.getViewportProps().rotationOrbit + speed
+        });
+    }
+    rotateUp(speed = 10) {
+        return this._getUpdatedState({
+            rotationX: this.getViewportProps().rotationX - speed
+        });
+    }
+    rotateDown(speed = 10) {
+        return this._getUpdatedState({
+            rotationX: this.getViewportProps().rotationX + speed
+        });
+    }
+    /* Private methods */
+    _project(pos) {
+        const viewport = this.makeViewport(this.getViewportProps());
+        return viewport.project(pos);
+    }
+    _unproject(pos) {
+        const viewport = this.makeViewport(this.getViewportProps());
+        return viewport.unproject(pos);
+    }
+    // Calculates new zoom
+    _calculateNewZoom({ scale, startZoom }) {
+        const { maxZoom, minZoom } = this.getViewportProps();
+        if (startZoom === undefined) {
+            startZoom = this.getViewportProps().zoom;
+        }
+        const zoom = startZoom + Math.log2(scale);
+        return deckProvider.clamp(zoom, minZoom, maxZoom);
+    }
+    _panFromCenter(offset) {
+        const { target } = this.getViewportProps();
+        const center = this._project(target);
+        return this.pan({
+            startPosition: target,
+            pos: [center[0] + offset[0], center[1] + offset[1]]
+        });
+    }
+    _getUpdatedState(newProps) {
+        // @ts-ignore
+        return new this.constructor({
+            makeViewport: this.makeViewport,
+            ...this.getViewportProps(),
+            ...this.getState(),
+            ...newProps
+        });
+    }
+    // Apply any constraints (mathematical or defined by _viewportProps) to map state
+    applyConstraints(props) {
+        // Ensure zoom is within specified range
+        const { maxZoom, minZoom, zoom, maxRotationX, minRotationX, rotationOrbit } = props;
+        props.zoom = Array.isArray(zoom)
+            ? [deckProvider.clamp(zoom[0], minZoom, maxZoom), deckProvider.clamp(zoom[1], minZoom, maxZoom)]
+            : deckProvider.clamp(zoom, minZoom, maxZoom);
+        props.rotationX = deckProvider.clamp(props.rotationX, minRotationX, maxRotationX);
+        if (rotationOrbit < -180 || rotationOrbit > 180) {
+            props.rotationOrbit = deckProvider.mod(rotationOrbit + 180, 360) - 180;
+        }
+        return props;
+    }
+}
+class OrbitController extends deckProvider.Controller {
+    constructor() {
+        super(...arguments);
+        this.ControllerState = OrbitState;
+        this.transition = {
+            transitionDuration: 300,
+            transitionInterpolator: new deckProvider.LinearInterpolator({
+                transitionProps: {
+                    compare: ['target', 'zoom', 'rotationX', 'rotationOrbit'],
+                    required: ['target', 'zoom']
+                }
+            })
+        };
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class OrbitView extends deckProvider.View {
+    constructor(props = {}) {
+        super(props);
+        this.props.orbitAxis = props.orbitAxis || 'Z';
+    }
+    getViewportType() {
+        return OrbitViewport;
+    }
+    get ControllerType() {
+        return OrbitController;
+    }
+}
+OrbitView.displayName = 'OrbitView';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class OrthographicState extends OrbitState {
+    constructor(props) {
+        super(props);
+        this.zoomAxis = props.zoomAxis || 'all';
+    }
+    _calculateNewZoom({ scale, startZoom }) {
+        const { maxZoom, minZoom } = this.getViewportProps();
+        if (startZoom === undefined) {
+            startZoom = this.getViewportProps().zoom;
+        }
+        let deltaZoom = Math.log2(scale);
+        if (Array.isArray(startZoom)) {
+            let [newZoomX, newZoomY] = startZoom;
+            switch (this.zoomAxis) {
+                case 'X':
+                    // Scale x only
+                    newZoomX = deckProvider.clamp(newZoomX + deltaZoom, minZoom, maxZoom);
+                    break;
+                case 'Y':
+                    // Scale y only
+                    newZoomY = deckProvider.clamp(newZoomY + deltaZoom, minZoom, maxZoom);
+                    break;
+                default:
+                    // Lock aspect ratio
+                    let z = Math.min(newZoomX + deltaZoom, newZoomY + deltaZoom);
+                    if (z < minZoom) {
+                        deltaZoom += minZoom - z;
+                    }
+                    z = Math.max(newZoomX + deltaZoom, newZoomY + deltaZoom);
+                    if (z > maxZoom) {
+                        deltaZoom += maxZoom - z;
+                    }
+                    newZoomX += deltaZoom;
+                    newZoomY += deltaZoom;
+            }
+            return [newZoomX, newZoomY];
+        }
+        // Ignore `zoomAxis`
+        // `LinearTransitionInterpolator` does not support interpolation between a number and an array
+        // So if zoom is a number (legacy use case), new zoom still has to be a number
+        return deckProvider.clamp(startZoom + deltaZoom, minZoom, maxZoom);
+    }
+}
+class OrthographicController extends deckProvider.Controller {
+    constructor() {
+        super(...arguments);
+        this.ControllerState = OrthographicState;
+        this.transition = {
+            transitionDuration: 300,
+            transitionInterpolator: new deckProvider.LinearInterpolator(['target', 'zoom'])
+        };
+        this.dragMode = 'pan';
+    }
+    _onPanRotate() {
+        // No rotation in orthographic view
+        return false;
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class OrthographicView extends deckProvider.View {
+    constructor(props = {}) {
+        super(props);
+    }
+    getViewportType() {
+        return OrthographicViewport;
+    }
+    get ControllerType() {
+        return OrthographicController;
+    }
+}
+OrthographicView.displayName = 'OrthographicView';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class GlobeState extends deckProvider.MapState {
+    constructor(options) {
+        const { startPanPos, ...mapStateOptions } = options;
+        super(mapStateOptions);
+        if (startPanPos !== undefined) {
+            this._state.startPanPos = startPanPos;
+        }
+    }
+    panStart({ pos }) {
+        const { latitude, longitude, zoom } = this.getViewportProps();
+        return this._getUpdatedState({
+            startPanLngLat: [longitude, latitude],
+            startPanPos: pos,
+            startZoom: zoom
+        });
+    }
+    pan({ pos, startPos }) {
+        const state = this.getState();
+        const startPanLngLat = state.startPanLngLat || this._unproject(startPos);
+        if (!startPanLngLat)
+            return this;
+        const startZoom = state.startZoom ?? this.getViewportProps().zoom;
+        const startPanPos = state.startPanPos || startPos;
+        const coords = [startPanLngLat[0], startPanLngLat[1], startZoom];
+        const viewport = this.makeViewport(this.getViewportProps());
+        const newProps = viewport.panByPosition(coords, pos, startPanPos);
+        return this._getUpdatedState(newProps);
+    }
+    panEnd() {
+        return this._getUpdatedState({
+            startPanLngLat: null,
+            startPanPos: null,
+            startZoom: null
+        });
+    }
+    zoom({ scale }) {
+        // In Globe view zoom does not take into account the mouse position
+        const startZoom = this.getState().startZoom || this.getViewportProps().zoom;
+        const zoom = startZoom + Math.log2(scale);
+        return this._getUpdatedState({ zoom });
+    }
+    applyConstraints(props) {
+        // Ensure zoom is within specified range
+        const { longitude, latitude, maxZoom, minZoom, zoom } = props;
+        const ZOOM0 = deckProvider.zoomAdjust(0);
+        const zoomAdjustment = deckProvider.zoomAdjust(latitude) - ZOOM0;
+        props.zoom = deckProvider.clamp(zoom, minZoom + zoomAdjustment, maxZoom + zoomAdjustment);
+        if (longitude < -180 || longitude > 180) {
+            props.longitude = deckProvider.mod(longitude + 180, 360) - 180;
+        }
+        props.latitude = deckProvider.clamp(latitude, -deckProvider.MAX_LATITUDE, deckProvider.MAX_LATITUDE);
+        return props;
+    }
+}
+class GlobeController extends deckProvider.Controller {
+    constructor() {
+        super(...arguments);
+        this.ControllerState = GlobeState;
+        this.transition = {
+            transitionDuration: 300,
+            transitionInterpolator: new deckProvider.LinearInterpolator(['longitude', 'latitude', 'zoom'])
+        };
+        this.dragMode = 'pan';
+    }
+    setProps(props) {
+        super.setProps(props);
+        // TODO - support pitching?
+        this.dragRotate = false;
+        this.touchRotate = false;
+    }
+}
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+class GlobeView extends deckProvider.View {
+    constructor(props = {}) {
+        super(props);
+    }
+    getViewportType(viewState) {
+        return viewState.zoom > 12 ? deckProvider.WebMercatorViewport : deckProvider.GlobeViewport;
+    }
+    get ControllerType() {
+        return GlobeController;
+    }
+}
+GlobeView.displayName = 'GlobeView';
+
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const LINEARLY_INTERPOLATED_PROPS = {
+    bearing: 0,
+    pitch: 0,
+    position: [0, 0, 0]
+};
+const DEFAULT_OPTS = {
+    speed: 1.2,
+    curve: 1.414
+};
+/**
+ * This class adapts mapbox-gl-js Map#flyTo animation so it can be used in
+ * react/redux architecture.
+ * mapbox-gl-js flyTo : https://www.mapbox.com/mapbox-gl-js/api/#map#flyto.
+ * It implements “Smooth and efficient zooming and panning.” algorithm by
+ * "Jarke J. van Wijk and Wim A.A. Nuij"
+ */
+class FlyToInterpolator extends deckProvider.TransitionInterpolator {
+    constructor(opts = {}) {
+        super({
+            compare: ['longitude', 'latitude', 'zoom', 'bearing', 'pitch', 'position'],
+            extract: ['width', 'height', 'longitude', 'latitude', 'zoom', 'bearing', 'pitch', 'position'],
+            required: ['width', 'height', 'latitude', 'longitude', 'zoom']
+        });
+        this.opts = { ...DEFAULT_OPTS, ...opts };
+    }
+    interpolateProps(startProps, endProps, t) {
+        const viewport = flyToViewport(startProps, endProps, t, this.opts);
+        // Linearly interpolate 'bearing', 'pitch' and 'position'.
+        // If they are not supplied, they are interpreted as zeros in viewport calculation
+        // (fallback defined in WebMercatorViewport)
+        // Because there is no guarantee that the current controller's ViewState normalizes
+        // these props, safe guard is needed to avoid generating NaNs
+        for (const key in LINEARLY_INTERPOLATED_PROPS) {
+            viewport[key] = deckProvider.lerp$1(startProps[key] || LINEARLY_INTERPOLATED_PROPS[key], endProps[key] || LINEARLY_INTERPOLATED_PROPS[key], t);
+        }
+        return viewport;
+    }
+    // computes the transition duration
+    getDuration(startProps, endProps) {
+        let { transitionDuration } = endProps;
+        if (transitionDuration === 'auto') {
+            // auto calculate duration based on start and end props
+            transitionDuration = getFlyToDuration(startProps, endProps, this.opts);
+        }
+        return transitionDuration;
+    }
+}
+
+exports.AmbientLight = deckProvider.AmbientLight;
+exports.Attribute = deckProvider.Attribute;
+exports.AttributeManager = deckProvider.AttributeManager;
+exports.COORDINATE_SYSTEM = deckProvider.COORDINATE_SYSTEM;
+exports.CompositeLayer = deckProvider.CompositeLayer;
+exports.Controller = deckProvider.Controller;
+exports.Deck = deckProvider.Deck;
+exports.DeckRenderer = deckProvider.DeckRenderer;
+exports.DirectionalLight = deckProvider.DirectionalLight;
+exports.Layer = deckProvider.Layer;
+exports.LayerManager = deckProvider.LayerManager;
+exports.LightingEffect = deckProvider.LightingEffect;
+exports.LinearInterpolator = deckProvider.LinearInterpolator;
+exports.MapController = deckProvider.MapController;
+exports.MapView = deckProvider.MapView;
+exports.OPERATION = deckProvider.OPERATION;
+exports.TRANSITION_EVENTS = deckProvider.TRANSITION_EVENTS;
+exports.Tesselator = deckProvider.Tesselator;
+exports.TransitionInterpolator = deckProvider.TransitionInterpolator;
+exports.UNIT = deckProvider.UNIT;
+exports.VERSION = deckProvider.VERSION;
+exports.View = deckProvider.View;
+exports.Viewport = deckProvider.Viewport;
+exports.WebMercatorViewport = deckProvider.WebMercatorViewport;
+exports.Widget = deckProvider.Widget;
+exports._Component = deckProvider.Component;
+exports._ComponentState = deckProvider.ComponentState;
+exports._GlobeViewport = deckProvider.GlobeViewport;
+exports._LayersPass = deckProvider.LayersPass;
+exports._PickLayersPass = deckProvider.PickLayersPass;
+exports._applyStyles = deckProvider.applyStyles;
+exports._compareProps = deckProvider.compareProps;
+exports._count = deckProvider.count;
+exports._deepEqual = deckProvider.deepEqual;
+exports._fillArray = deckProvider.fillArray;
+exports._flatten = deckProvider.flatten;
+exports._memoize = deckProvider.memoize;
+exports._mergeShaders = deckProvider.mergeShaders;
+exports._removeStyles = deckProvider.removeStyles;
+exports.assert = deckProvider.assert;
+exports.color = deckProvider.color;
+exports.createIterable = deckProvider.createIterable;
+exports.fp64LowPart = deckProvider.fp64LowPart;
+exports.getShaderAssembler = deckProvider.getShaderAssembler;
+exports.gouraudMaterial = deckProvider.gouraudMaterial;
+exports.log = deckProvider.defaultLogger;
+exports.phongMaterial = deckProvider.phongMaterial;
+exports.picking = deckProvider.picking;
+exports.project = deckProvider.project;
+exports.project32 = deckProvider.project32;
+exports.shadow = deckProvider.shadow;
+exports.LayerExtension = layerExtension.LayerExtension;
+exports.FirstPersonController = FirstPersonController;
+exports.FirstPersonView = FirstPersonView;
+exports.FirstPersonViewport = FirstPersonViewport;
+exports.FlyToInterpolator = FlyToInterpolator;
+exports.OrbitController = OrbitController;
+exports.OrbitView = OrbitView;
+exports.OrbitViewport = OrbitViewport;
+exports.OrthographicController = OrthographicController;
+exports.OrthographicView = OrthographicView;
+exports.OrthographicViewport = OrthographicViewport;
+exports.PointLight = PointLight;
+exports.PostProcessEffect = PostProcessEffect;
+exports._CameraLight = CameraLight;
+exports._GlobeController = GlobeController;
+exports._GlobeView = GlobeView;
+exports._SunLight = SunLight;