@deck.gl/extensions 9.4.0-beta.3 → 9.4.0-beta.4

package/dist/index.cjs

@@ -1,4 +1,3 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -15,7 +14,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
 var index_exports = {};
@@ -33,2640 +32,11 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../core/src/utils/log.ts
-var import_log = require("@probe.gl/log");
-var defaultLogger = new import_log.Log({ id: "deck" });
-var log_default = defaultLogger;
-
-// ../core/src/shaderlib/index.ts
-var import_shadertools2 = require("@luma.gl/shadertools");
-
-// ../core/src/shaderlib/misc/geometry.ts
-var source = (
-  /* wgsl */
-  `const SMOOTH_EDGE_RADIUS: f32 = 0.5;
-
-struct VertexGeometry {
-  position: vec4<f32>,
-  worldPosition: vec3<f32>,
-  worldPositionAlt: vec3<f32>,
-  normal: vec3<f32>,
-  uv: vec2<f32>,
-  pickingColor: vec3<f32>,
-};
-
-var<private> geometry_: VertexGeometry = VertexGeometry(
-  vec4<f32>(0.0, 0.0, 1.0, 0.0),
-  vec3<f32>(0.0, 0.0, 0.0),
-  vec3<f32>(0.0, 0.0, 0.0),
-  vec3<f32>(0.0, 0.0, 0.0),
-  vec2<f32>(0.0, 0.0),
-  vec3<f32>(0.0, 0.0, 0.0)
-);
-
-struct FragmentGeometry {
-  uv: vec2<f32>,
-};
-
-var<private> fragmentGeometry: FragmentGeometry;
-
-fn smoothedge(edge: f32, x: f32) -> f32 {
-  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);
-}
-`
-);
-var defines = "#define SMOOTH_EDGE_RADIUS 0.5";
-var vs = (
-  /* glsl */
-  `${defines}
-
-struct VertexGeometry {
-  vec4 position;
-  vec3 worldPosition;
-  vec3 worldPositionAlt;
-  vec3 normal;
-  vec2 uv;
-  vec3 pickingColor;
-} geometry = VertexGeometry(
-  vec4(0.0, 0.0, 1.0, 0.0),
-  vec3(0.0),
-  vec3(0.0),
-  vec3(0.0),
-  vec2(0.0),
-  vec3(0.0)
-);
-`
-);
-var fs = (
-  /* glsl */
-  `${defines}
-
-struct FragmentGeometry {
-  vec2 uv;
-};
-FragmentGeometry geometry;
-
-float smoothedge(float edge, float x) {
-  return smoothstep(edge - SMOOTH_EDGE_RADIUS, edge + SMOOTH_EDGE_RADIUS, x);
-}
-`
-);
-var geometry_default = {
-  name: "geometry",
-  source,
-  vs,
-  fs
-};
-
-// ../core/src/shaderlib/project/project.ts
-var import_shadertools = require("@luma.gl/shadertools");
-
-// ../core/src/shaderlib/project/viewport-uniforms.ts
-var import_core = require("@math.gl/core");
-
-// ../core/src/lib/constants.ts
-var import_mjolnir = require("mjolnir.js");
-var COORDINATE_SYSTEM = {
-  /**
-   * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
-   */
-  DEFAULT: "default",
-  /**
-   * Positions are interpreted as [longitude, latitude, elevation]
-   * longitude/latitude are in degrees, elevation is in meters.
-   * Dimensions are in meters.
-   */
-  LNGLAT: "lnglat",
-  /**
-   * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin.
-   * Dimensions are in meters.
-   */
-  METER_OFFSETS: "meter-offsets",
-  /**
-   * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin.
-   * deltaLng/deltaLat are in degrees, elevation is in meters.
-   * Dimensions are in meters.
-   */
-  LNGLAT_OFFSETS: "lnglat-offsets",
-  /**
-   * Positions and dimensions are in the common units of the viewport.
-   */
-  CARTESIAN: "cartesian"
-};
-Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", {
-  get: () => {
-    log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")();
-    return COORDINATE_SYSTEM.CARTESIAN;
-  }
-});
-var PROJECTION_MODE = {
-  /**
-   * Render geospatial data in Web Mercator projection
-   */
-  WEB_MERCATOR: 1,
-  /**
-   * Render geospatial data as a 3D globe
-   */
-  GLOBE: 2,
-  /**
-   * (Internal use only) Web Mercator projection at high zoom
-   */
-  WEB_MERCATOR_AUTO_OFFSET: 4,
-  /**
-   * No transformation
-   */
-  IDENTITY: 0
-};
-var UNIT = {
-  common: 0,
-  meters: 1,
-  pixels: 2
-};
-
-// ../core/src/utils/memoize.ts
-function isEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (Array.isArray(a)) {
-    const len = a.length;
-    if (!b || b.length !== len) {
-      return false;
-    }
-    for (let i = 0; i < len; i++) {
-      if (a[i] !== b[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-function memoize(compute) {
-  let cachedArgs = {};
-  let cachedResult;
-  return (args) => {
-    for (const key in args) {
-      if (!isEqual(args[key], cachedArgs[key])) {
-        cachedResult = compute(args);
-        cachedArgs = args;
-        break;
-      }
-    }
-    return cachedResult;
-  };
-}
-
-// ../core/src/shaderlib/project/viewport-uniforms.ts
-var ZERO_VECTOR = [0, 0, 0, 0];
-var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
-var IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];
-var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];
-var COORDINATE_SYSTEM_NUMBERS = {
-  default: -1,
-  cartesian: 0,
-  lnglat: 1,
-  "meter-offsets": 2,
-  "lnglat-offsets": 3
-};
-function getShaderCoordinateSystem(coordinateSystem) {
-  const shaderCoordinateSystem = COORDINATE_SYSTEM_NUMBERS[coordinateSystem];
-  if (shaderCoordinateSystem === void 0) {
-    throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
-  }
-  return shaderCoordinateSystem;
-}
-var getMemoizedViewportUniforms = memoize(calculateViewportUniforms);
-function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) {
-  if (coordinateOrigin.length < 3) {
-    coordinateOrigin = [coordinateOrigin[0], coordinateOrigin[1], 0];
-  }
-  let shaderCoordinateOrigin = coordinateOrigin;
-  let geospatialOrigin;
-  let offsetMode = true;
-  if (coordinateSystem === "lnglat-offsets" || coordinateSystem === "meter-offsets") {
-    geospatialOrigin = coordinateOrigin;
-  } else {
-    geospatialOrigin = viewport.isGeospatial ? (
-      // @ts-expect-error longitude and latitude are not defined on the base Viewport, but is expected on geospatial viewports
-      [Math.fround(viewport.longitude), Math.fround(viewport.latitude), 0]
-    ) : null;
-  }
-  switch (viewport.projectionMode) {
-    case PROJECTION_MODE.WEB_MERCATOR:
-      if (coordinateSystem === "lnglat" || coordinateSystem === "cartesian") {
-        geospatialOrigin = [0, 0, 0];
-        offsetMode = false;
-      }
-      break;
-    case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:
-      if (coordinateSystem === "lnglat") {
-        shaderCoordinateOrigin = geospatialOrigin;
-      } else if (coordinateSystem === "cartesian") {
-        shaderCoordinateOrigin = [
-          Math.fround(viewport.center[0]),
-          Math.fround(viewport.center[1]),
-          0
-        ];
-        geospatialOrigin = viewport.unprojectPosition(shaderCoordinateOrigin);
-        shaderCoordinateOrigin[0] -= coordinateOrigin[0];
-        shaderCoordinateOrigin[1] -= coordinateOrigin[1];
-        shaderCoordinateOrigin[2] -= coordinateOrigin[2];
-      }
-      break;
-    case PROJECTION_MODE.IDENTITY:
-      shaderCoordinateOrigin = viewport.position.map(Math.fround);
-      shaderCoordinateOrigin[2] = shaderCoordinateOrigin[2] || 0;
-      break;
-    case PROJECTION_MODE.GLOBE:
-      offsetMode = false;
-      geospatialOrigin = null;
-      break;
-    default:
-      offsetMode = false;
-  }
-  return { geospatialOrigin, shaderCoordinateOrigin, offsetMode };
-}
-function calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin) {
-  const { viewMatrixUncentered, projectionMatrix } = viewport;
-  let { viewMatrix: viewMatrix2, viewProjectionMatrix } = viewport;
-  let projectionCenter = ZERO_VECTOR;
-  let originCommon = ZERO_VECTOR;
-  let cameraPosCommon = viewport.cameraPosition;
-  const { geospatialOrigin, shaderCoordinateOrigin, offsetMode } = getOffsetOrigin(
-    viewport,
-    coordinateSystem,
-    coordinateOrigin
-  );
-  if (offsetMode) {
-    originCommon = viewport.projectPosition(geospatialOrigin || shaderCoordinateOrigin);
-    cameraPosCommon = [
-      cameraPosCommon[0] - originCommon[0],
-      cameraPosCommon[1] - originCommon[1],
-      cameraPosCommon[2] - originCommon[2]
-    ];
-    originCommon[3] = 1;
-    projectionCenter = import_core.vec4.transformMat4([], originCommon, viewProjectionMatrix);
-    viewMatrix2 = viewMatrixUncentered || viewMatrix2;
-    viewProjectionMatrix = import_core.mat4.multiply([], projectionMatrix, viewMatrix2);
-    viewProjectionMatrix = import_core.mat4.multiply([], viewProjectionMatrix, VECTOR_TO_POINT_MATRIX);
-  }
-  return {
-    viewMatrix: viewMatrix2,
-    viewProjectionMatrix,
-    projectionCenter,
-    originCommon,
-    cameraPosCommon,
-    shaderCoordinateOrigin,
-    geospatialOrigin
-  };
-}
-function getUniformsFromViewport({
-  viewport,
-  devicePixelRatio = 1,
-  modelMatrix = null,
-  // Match Layer.defaultProps
-  coordinateSystem = "default",
-  coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
-  autoWrapLongitude = false
-}) {
-  if (coordinateSystem === "default") {
-    coordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
-  }
-  const uniforms = getMemoizedViewportUniforms({
-    viewport,
-    devicePixelRatio,
-    coordinateSystem,
-    coordinateOrigin
-  });
-  uniforms.wrapLongitude = autoWrapLongitude;
-  uniforms.modelMatrix = modelMatrix || IDENTITY_MATRIX;
-  return uniforms;
-}
-function calculateViewportUniforms({
-  viewport,
-  devicePixelRatio,
-  coordinateSystem,
-  coordinateOrigin
-}) {
-  const {
-    projectionCenter,
-    viewProjectionMatrix,
-    originCommon,
-    cameraPosCommon,
-    shaderCoordinateOrigin,
-    geospatialOrigin
-  } = calculateMatrixAndOffset(viewport, coordinateSystem, coordinateOrigin);
-  const distanceScales = viewport.getDistanceScales();
-  const viewportSize = [
-    viewport.width * devicePixelRatio,
-    viewport.height * devicePixelRatio
-  ];
-  const focalDistance = import_core.vec4.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1;
-  const uniforms = {
-    // Projection mode values
-    coordinateSystem: getShaderCoordinateSystem(coordinateSystem),
-    projectionMode: viewport.projectionMode,
-    coordinateOrigin: shaderCoordinateOrigin,
-    commonOrigin: originCommon.slice(0, 3),
-    center: projectionCenter,
-    // Backward compatibility
-    // TODO: remove in v9
-    // @ts-expect-error _pseudoMeters is only defined on WebMercator viewport
-    pseudoMeters: Boolean(viewport._pseudoMeters),
-    // Screen size
-    viewportSize,
-    devicePixelRatio,
-    focalDistance,
-    commonUnitsPerMeter: distanceScales.unitsPerMeter,
-    commonUnitsPerWorldUnit: distanceScales.unitsPerMeter,
-    commonUnitsPerWorldUnit2: DEFAULT_PIXELS_PER_UNIT2,
-    scale: viewport.scale,
-    // This is the mercator scale (2 ** zoom)
-    wrapLongitude: false,
-    viewProjectionMatrix,
-    modelMatrix: IDENTITY_MATRIX,
-    // This is for lighting calculations
-    cameraPosition: cameraPosCommon
-  };
-  if (geospatialOrigin) {
-    const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);
-    switch (coordinateSystem) {
-      case "meter-offsets":
-        uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;
-        uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;
-        break;
-      case "lnglat":
-      case "lnglat-offsets":
-        if (!viewport._pseudoMeters) {
-          uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;
-        }
-        uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;
-        uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;
-        break;
-      // a.k.a "preprojected" positions
-      case "cartesian":
-        uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];
-        uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];
-        break;
-      default:
-        break;
-    }
-  }
-  if (viewport.projectionMode === PROJECTION_MODE.GLOBE && coordinateSystem === "meter-offsets") {
-    const EARTH_RADIUS2 = 6370972;
-    const GLOBE_RADIUS2 = 256;
-    const lambda = coordinateOrigin[0] * Math.PI / 180;
-    const phi = coordinateOrigin[1] * Math.PI / 180;
-    const cosPhi = Math.cos(phi);
-    const D = ((coordinateOrigin[2] || 0) / EARTH_RADIUS2 + 1) * GLOBE_RADIUS2;
-    uniforms.commonOrigin = [
-      Math.sin(lambda) * cosPhi * D,
-      -Math.cos(lambda) * cosPhi * D,
-      Math.sin(phi) * D
-    ];
-  }
-  return uniforms;
-}
-
-// ../core/src/shaderlib/project/project.wgsl.ts
-var SHADER_COORDINATE_SYSTEMS = [
-  "default",
-  "lnglat",
-  "meter-offsets",
-  "lnglat-offsets",
-  "cartesian"
-];
-var COORDINATE_SYSTEM_WGSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS.map(
-  (coordinateSystem) => `const COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")}: i32 = ${getShaderCoordinateSystem(coordinateSystem)};`
-).join("");
-var PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`).join("");
-var UNIT_WGSL_CONSTANTS = Object.keys(UNIT).map((key) => `const UNIT_${key.toUpperCase()}: i32 = ${UNIT[key]};`).join("");
-var projectWGSLHeader = (
-  /* wgsl */
-  `${COORDINATE_SYSTEM_WGSL_CONSTANTS}
-${PROJECTION_MODE_WGSL_CONSTANTS}
-${UNIT_WGSL_CONSTANTS}
-
-const TILE_SIZE: f32 = 512.0;
-const PI: f32 = 3.1415926536;
-const WORLD_SCALE: f32 = TILE_SIZE / (PI * 2.0);
-const ZERO_64_LOW: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
-const EARTH_RADIUS: f32 = 6370972.0; // meters
-const GLOBE_RADIUS: f32 = 256.0;
-
-// -----------------------------------------------------------------------------
-// Uniform block (converted from GLSL uniform block)
-// -----------------------------------------------------------------------------
-struct ProjectUniforms {
-  wrapLongitude: i32,
-  coordinateSystem: i32,
-  commonUnitsPerMeter: vec3<f32>,
-  projectionMode: i32,
-  scale: f32,
-  commonUnitsPerWorldUnit: vec3<f32>,
-  commonUnitsPerWorldUnit2: vec3<f32>,
-  center: vec4<f32>,
-  modelMatrix: mat4x4<f32>,
-  viewProjectionMatrix: mat4x4<f32>,
-  viewportSize: vec2<f32>,
-  devicePixelRatio: f32,
-  focalDistance: f32,
-  cameraPosition: vec3<f32>,
-  coordinateOrigin: vec3<f32>,
-  commonOrigin: vec3<f32>,
-  pseudoMeters: i32,
-};
-
-@group(0) @binding(auto)
-var<uniform> project: ProjectUniforms;
-
-// -----------------------------------------------------------------------------
-// Geometry data shared across the project helpers.
-// The active layer shader is responsible for populating this private module
-// state before calling the project functions below.
-// -----------------------------------------------------------------------------
-
-// Structure to carry additional geometry data used by deck.gl filters.
-struct Geometry {
-  worldPosition: vec3<f32>,
-  worldPositionAlt: vec3<f32>,
-  position: vec4<f32>,
-  normal: vec3<f32>,
-  uv: vec2<f32>,
-  pickingColor: vec3<f32>,
-};
-
-var<private> geometry: Geometry;
-`
-);
-var projectWGSL = (
-  /* wgsl */
-  `${projectWGSLHeader}
-
-// -----------------------------------------------------------------------------
-// Functions
-// -----------------------------------------------------------------------------
-
-// Returns an adjustment factor for commonUnitsPerMeter
-fn _project_size_at_latitude(lat: f32) -> f32 {
-  let y = clamp(lat, -89.9, 89.9);
-  return 1.0 / cos(radians(y));
-}
-
-// Overloaded version: scales a value in meters at a given latitude.
-fn _project_size_at_latitude_m(meters: f32, lat: f32) -> f32 {
-  return meters * project.commonUnitsPerMeter.z * _project_size_at_latitude(lat);
-}
-
-// Computes a non-linear scale factor based on geometry.
-// (Note: This function relies on "geometry" being provided.)
-fn project_size() -> f32 {
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&
-      project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
-      project.pseudoMeters == 0) {
-    if (geometry.position.w == 0.0) {
-      return _project_size_at_latitude(geometry.worldPosition.y);
-    }
-    let y: f32 = geometry.position.y / TILE_SIZE * 2.0 - 1.0;
-    let y2 = y * y;
-    let y4 = y2 * y2;
-    let y6 = y4 * y2;
-    return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;
-  }
-  return 1.0;
-}
-
-// Overloads to scale offsets (meters to world units)
-fn project_size_float(meters: f32) -> f32 {
-  return meters * project.commonUnitsPerMeter.z * project_size();
-}
-
-fn project_size_vec2(meters: vec2<f32>) -> vec2<f32> {
-  return meters * project.commonUnitsPerMeter.xy * project_size();
-}
-
-fn project_size_vec3(meters: vec3<f32>) -> vec3<f32> {
-  return meters * project.commonUnitsPerMeter * project_size();
-}
-
-fn project_size_vec4(meters: vec4<f32>) -> vec4<f32> {
-  return vec4<f32>(meters.xyz * project.commonUnitsPerMeter, meters.w);
-}
-
-// Returns a rotation matrix aligning the z\u2011axis with the given up vector.
-fn project_get_orientation_matrix(up: vec3<f32>) -> mat3x3<f32> {
-  let uz = normalize(up);
-  let ux = select(
-    vec3<f32>(1.0, 0.0, 0.0),
-    normalize(vec3<f32>(uz.y, -uz.x, 0.0)),
-    abs(uz.z) == 1.0
-  );
-  let uy = cross(uz, ux);
-  return mat3x3<f32>(ux, uy, uz);
-}
-
-// Since WGSL does not support "out" parameters, we return a struct.
-struct RotationResult {
-  needsRotation: bool,
-  transform: mat3x3<f32>,
-};
-
-fn project_needs_rotation(commonPosition: vec3<f32>) -> RotationResult {
-  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
-    return RotationResult(true, project_get_orientation_matrix(commonPosition));
-  } else {
-    return RotationResult(false, mat3x3<f32>());  // identity alternative if needed
-  };
-}
-
-// Projects a normal vector from the current coordinate system to world space.
-fn project_normal(vector: vec3<f32>) -> vec3<f32> {
-  let normal_modelspace = project.modelMatrix * vec4<f32>(vector, 0.0);
-  var n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);
-  let rotResult = project_needs_rotation(geometry.position.xyz);
-  if (rotResult.needsRotation) {
-    n = rotResult.transform * n;
-  }
-  return n;
-}
-
-// Applies a scale offset based on y-offset (dy)
-fn project_offset_(offset: vec4<f32>) -> vec4<f32> {
-  let dy: f32 = offset.y;
-  let commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;
-  return vec4<f32>(offset.xyz * commonUnitsPerWorldUnit, offset.w);
-}
-
-// Projects lng/lat coordinates to a unit tile [0,1]
-fn project_mercator_(lnglat: vec2<f32>) -> vec2<f32> {
-  var x = lnglat.x;
-  if (project.wrapLongitude != 0) {
-    x = ((x + 180.0) % 360.0) - 180.0;
-  }
-  let y = clamp(lnglat.y, -89.9, 89.9);
-  return vec2<f32>(
-    radians(x) + PI,
-    PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))
-  ) * WORLD_SCALE;
-}
-
-// Projects lng/lat/z coordinates for a globe projection.
-fn project_globe_(lnglatz: vec3<f32>) -> vec3<f32> {
-  let lambda = radians(lnglatz.x);
-  let phi = radians(lnglatz.y);
-  let cosPhi = cos(phi);
-  let D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;
-  return vec3<f32>(
-    sin(lambda) * cosPhi,
-    -cos(lambda) * cosPhi,
-    sin(phi)
-  ) * D;
-}
-
-// Projects positions (with an optional 64-bit low part) from the input
-// coordinate system to the common space.
-fn project_position_vec4_f64(position: vec4<f32>, position64Low: vec3<f32>) -> vec4<f32> {
-  var position_world = project.modelMatrix * position;
-
-  // Work around for a Mac+NVIDIA bug:
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      return vec4<f32>(
-        project_mercator_(position_world.xy),
-        _project_size_at_latitude_m(position_world.z, position_world.y),
-        position_world.w
-      );
-    }
-    if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
-      position_world = vec4f(position_world.xyz + project.coordinateOrigin, position_world.w);
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      return vec4<f32>(
-        project_globe_(position_world.xyz),
-        position_world.w
-      );
-    }
-    if (project.coordinateSystem == COORDINATE_SYSTEM_METER_OFFSETS) {
-      let enuMatrix = project_get_orientation_matrix(project.commonOrigin);
-      let metersToCommon = GLOBE_RADIUS / EARTH_RADIUS;
-      let offsetCommon = (enuMatrix * vec3<f32>(-position_world.x, -position_world.y, position_world.z)) * metersToCommon;
-      return vec4<f32>(project.commonOrigin + offsetCommon, position_world.w);
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {
-        return vec4<f32>(
-          project_mercator_(position_world.xy) - project.commonOrigin.xy,
-          project_size_float(position_world.z),
-          position_world.w
-        );
-      }
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_IDENTITY ||
-      (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
-       (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
-        project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
-    position_world = vec4f(position_world.xyz - project.coordinateOrigin, position_world.w);
-  }
-
-  return project_offset_(position_world) +
-         project_offset_(project.modelMatrix * vec4<f32>(position64Low, 0.0));
-}
-
-// Overloaded versions for different input types.
-fn project_position_vec4_f32(position: vec4<f32>) -> vec4<f32> {
-  return project_position_vec4_f64(position, ZERO_64_LOW);
-}
-
-fn project_position_vec3_f64(position: vec3<f32>, position64Low: vec3<f32>) -> vec3<f32> {
-  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), position64Low);
-  return projected_position.xyz;
-}
-
-fn project_position_vec3_f32(position: vec3<f32>) -> vec3<f32> {
-  let projected_position = project_position_vec4_f64(vec4<f32>(position, 1.0), ZERO_64_LOW);
-  return projected_position.xyz;
-}
-
-fn project_position_vec2_f32(position: vec2<f32>) -> vec2<f32> {
-  let projected_position = project_position_vec4_f64(vec4<f32>(position, 0.0, 1.0), ZERO_64_LOW);
-  return projected_position.xy;
-}
-
-// Transforms a common space position to clip space.
-fn project_common_position_to_clipspace_with_projection(position: vec4<f32>, viewProjectionMatrix: mat4x4<f32>, center: vec4<f32>) -> vec4<f32> {
-  var clipPosition = viewProjectionMatrix * position + center;
-  // deck.gl projection matrices use WebGL's [-w, w] depth range; WebGPU clips z to [0, w].
-  clipPosition.z = (clipPosition.z + clipPosition.w) * 0.5;
-  return clipPosition;
-}
-
-// Uses the project viewProjectionMatrix and center.
-fn project_common_position_to_clipspace(position: vec4<f32>) -> vec4<f32> {
-  return project_common_position_to_clipspace_with_projection(position, project.viewProjectionMatrix, project.center);
-}
-
-// Returns a clip space offset corresponding to a given number of screen pixels.
-fn project_pixel_size_to_clipspace(pixels: vec2<f32>) -> vec2<f32> {
-  let offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;
-  return offset * project.focalDistance;
-}
-
-fn project_meter_size_to_pixel(meters: f32) -> f32 {
-  return project_size_float(meters) * project.scale;
-}
-
-fn project_unit_size_to_pixel(size: f32, unit: i32) -> f32 {
-  if (unit == UNIT_METERS) {
-    return project_meter_size_to_pixel(size);
-  } else if (unit == UNIT_COMMON) {
-    return size * project.scale;
-  }
-  // UNIT_PIXELS: no scaling applied.
-  return size;
-}
-
-fn project_pixel_size_float(pixels: f32) -> f32 {
-  return pixels / project.scale;
-}
-
-fn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {
-  return pixels / project.scale;
-}
-`
-);
-
-// ../core/src/shaderlib/project/project.glsl.ts
-var SHADER_COORDINATE_SYSTEMS2 = [
-  "default",
-  "lnglat",
-  "meter-offsets",
-  "lnglat-offsets",
-  "cartesian"
-];
-var COORDINATE_SYSTEM_GLSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS2.map(
-  (coordinateSystem) => `const int COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")} = ${getShaderCoordinateSystem(coordinateSystem)};`
-).join("");
-var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join("");
-var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join("");
-var projectGLSL = (
-  /* glsl */
-  `${COORDINATE_SYSTEM_GLSL_CONSTANTS}
-${PROJECTION_MODE_GLSL_CONSTANTS}
-${UNIT_GLSL_CONSTANTS}
-
-layout(std140) uniform projectUniforms {
-  bool wrapLongitude;
-  int coordinateSystem;
-  vec3 commonUnitsPerMeter;
-  int projectionMode;
-  float scale;
-  vec3 commonUnitsPerWorldUnit;
-  vec3 commonUnitsPerWorldUnit2;
-  vec4 center;
-  mat4 modelMatrix;
-  mat4 viewProjectionMatrix;
-  vec2 viewportSize;
-  float devicePixelRatio;
-  float focalDistance;
-  vec3 cameraPosition;
-  vec3 coordinateOrigin;
-  vec3 commonOrigin;
-  bool pseudoMeters;
-} project;
-
-
-const float TILE_SIZE = 512.0;
-const float PI = 3.1415926536;
-const float WORLD_SCALE = TILE_SIZE / (PI * 2.0);
-const vec3 ZERO_64_LOW = vec3(0.0);
-const float EARTH_RADIUS = 6370972.0; // meters
-const float GLOBE_RADIUS = 256.0;
-
-// returns an adjustment factor for uCommonUnitsPerMeter
-float project_size_at_latitude(float lat) {
-  float y = clamp(lat, -89.9, 89.9);
-  return 1.0 / cos(radians(y));
-}
-
-float project_size() {
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR &&
-    project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT &&
-    project.pseudoMeters == false) {
-
-    // uCommonUnitsPerMeter in low-zoom Web Mercator is non-linear
-    // Adjust by 1 / cos(latitude)
-    // If geometry.position (vertex in common space) is populated, use it
-    // Otherwise use geometry.worldPosition (anchor in world space)
-
-    if (geometry.position.w == 0.0) {
-      return project_size_at_latitude(geometry.worldPosition.y);
-    }
-
-    // latitude from common y: 2.0 * (atan(exp(y / TILE_SIZE * 2.0 * PI - PI)) - PI / 4.0)
-    // Taylor series of 1 / cos(latitude)
-    // Max error < 0.003
-
-    float y = geometry.position.y / TILE_SIZE * 2.0 - 1.0;
-    float y2 = y * y;
-    float y4 = y2 * y2;
-    float y6 = y4 * y2;
-    return 1.0 + 4.9348 * y2 + 4.0587 * y4 + 1.5642 * y6;
-  }
-  return 1.0;
-}
-
-float project_size_at_latitude(float meters, float lat) {
-  return meters * project.commonUnitsPerMeter.z * project_size_at_latitude(lat);
-}
-
-//
-// Scaling offsets - scales meters to "world distance"
-// Note the scalar version of project_size is for scaling the z component only
-//
-float project_size(float meters) {
-  // For scatter relevant
-  return meters * project.commonUnitsPerMeter.z * project_size();
-}
-
-vec2 project_size(vec2 meters) {
-  return meters * project.commonUnitsPerMeter.xy * project_size();
-}
-
-vec3 project_size(vec3 meters) {
-  return meters * project.commonUnitsPerMeter * project_size();
-}
-
-vec4 project_size(vec4 meters) {
-  return vec4(meters.xyz * project.commonUnitsPerMeter, meters.w);
-}
-
-// Get rotation matrix that aligns the z axis with the given up vector
-// Find 3 unit vectors ux, uy, uz that are perpendicular to each other and uz == up
-mat3 project_get_orientation_matrix(vec3 up) {
-  vec3 uz = normalize(up);
-  // Tangent on XY plane
-  vec3 ux = abs(uz.z) == 1.0 ? vec3(1.0, 0.0, 0.0) : normalize(vec3(uz.y, -uz.x, 0));
-  vec3 uy = cross(uz, ux);
-  return mat3(ux, uy, uz);
-}
-
-bool project_needs_rotation(vec3 commonPosition, out mat3 transform) {
-  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
-    transform = project_get_orientation_matrix(commonPosition);
-    return true;
-  }
-  return false;
-}
-
-//
-// Projecting normal - transform deltas from current coordinate system to
-// normals in the worldspace
-//
-vec3 project_normal(vec3 vector) {
-  // Apply model matrix
-  vec4 normal_modelspace = project.modelMatrix * vec4(vector, 0.0);
-  vec3 n = normalize(normal_modelspace.xyz * project.commonUnitsPerMeter);
-  mat3 rotation;
-  if (project_needs_rotation(geometry.position.xyz, rotation)) {
-    n = rotation * n;
-  }
-  return n;
-}
-
-vec4 project_offset_(vec4 offset) {
-  float dy = offset.y;
-  vec3 commonUnitsPerWorldUnit = project.commonUnitsPerWorldUnit + project.commonUnitsPerWorldUnit2 * dy;
-  return vec4(offset.xyz * commonUnitsPerWorldUnit, offset.w);
-}
-
-//
-// Projecting positions - non-linear projection: lnglats => unit tile [0-1, 0-1]
-//
-vec2 project_mercator_(vec2 lnglat) {
-  float x = lnglat.x;
-  if (project.wrapLongitude) {
-    x = mod(x + 180., 360.0) - 180.;
-  }
-  float y = clamp(lnglat.y, -89.9, 89.9);
-  return vec2(
-    radians(x) + PI,
-    PI + log(tan_fp32(PI * 0.25 + radians(y) * 0.5))
-  ) * WORLD_SCALE;
-}
-
-vec3 project_globe_(vec3 lnglatz) {
-  float lambda = radians(lnglatz.x);
-  float phi = radians(lnglatz.y);
-  float cosPhi = cos(phi);
-  float D = (lnglatz.z / EARTH_RADIUS + 1.0) * GLOBE_RADIUS;
-
-  return vec3(
-    sin(lambda) * cosPhi,
-    -cos(lambda) * cosPhi,
-    sin(phi)
-  ) * D;
-}
-
-//
-// Projects positions (defined by project.coordinateSystem) to common space (defined by project.projectionMode)
-//
-vec4 project_position(vec4 position, vec3 position64Low) {
-  vec4 position_world = project.modelMatrix * position;
-
-  // Work around for a Mac+NVIDIA bug https://github.com/visgl/deck.gl/issues/4145
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      return vec4(
-        project_mercator_(position_world.xy),
-        project_size_at_latitude(position_world.z, position_world.y),
-        position_world.w
-      );
-    }
-    if (project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN) {
-      position_world.xyz += project.coordinateOrigin;
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_GLOBE) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      return vec4(
-        project_globe_(position_world.xyz),
-        position_world.w
-      );
-    }
-    if (project.coordinateSystem == COORDINATE_SYSTEM_METER_OFFSETS) {
-      mat3 enuMatrix = project_get_orientation_matrix(project.commonOrigin);
-      float metersToCommon = GLOBE_RADIUS / EARTH_RADIUS;
-      vec3 offsetCommon = (enuMatrix * vec3(-position_world.xy, position_world.z)) * metersToCommon;
-      return vec4(project.commonOrigin + offsetCommon, position_world.w);
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET) {
-    if (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT) {
-      if (abs(position_world.y - project.coordinateOrigin.y) > 0.25) {
-        // Too far from the projection center for offset mode to be accurate
-        // Only use high parts
-        return vec4(
-          project_mercator_(position_world.xy) - project.commonOrigin.xy,
-          project_size(position_world.z),
-          position_world.w
-        );
-      }
-    }
-  }
-  if (project.projectionMode == PROJECTION_MODE_IDENTITY ||
-    (project.projectionMode == PROJECTION_MODE_WEB_MERCATOR_AUTO_OFFSET &&
-    (project.coordinateSystem == COORDINATE_SYSTEM_LNGLAT ||
-     project.coordinateSystem == COORDINATE_SYSTEM_CARTESIAN))) {
-    // Subtract high part of 64 bit value. Convert remainder to float32, preserving precision.
-    position_world.xyz -= project.coordinateOrigin;
-  }
-
-  // Translation is already added to the high parts
-  return project_offset_(position_world) + project_offset_(project.modelMatrix * vec4(position64Low, 0.0));
-}
-
-vec4 project_position(vec4 position) {
-  return project_position(position, ZERO_64_LOW);
-}
-
-vec3 project_position(vec3 position, vec3 position64Low) {
-  vec4 projected_position = project_position(vec4(position, 1.0), position64Low);
-  return projected_position.xyz;
-}
-
-vec3 project_position(vec3 position) {
-  vec4 projected_position = project_position(vec4(position, 1.0), ZERO_64_LOW);
-  return projected_position.xyz;
-}
-
-vec2 project_position(vec2 position) {
-  vec4 projected_position = project_position(vec4(position, 0.0, 1.0), ZERO_64_LOW);
-  return projected_position.xy;
-}
-
-vec4 project_common_position_to_clipspace(vec4 position, mat4 viewProjectionMatrix, vec4 center) {
-  return viewProjectionMatrix * position + center;
-}
-
-//
-// Projects from common space coordinates to clip space.
-// Uses project.viewProjectionMatrix
-//
-vec4 project_common_position_to_clipspace(vec4 position) {
-  return project_common_position_to_clipspace(position, project.viewProjectionMatrix, project.center);
-}
-
-// Returns a clip space offset that corresponds to a given number of screen pixels
-vec2 project_pixel_size_to_clipspace(vec2 pixels) {
-  vec2 offset = pixels / project.viewportSize * project.devicePixelRatio * 2.0;
-  return offset * project.focalDistance;
-}
-
-float project_size_to_pixel(float meters) {
-  return project_size(meters) * project.scale;
-}
-vec2 project_size_to_pixel(vec2 meters) {
-  return project_size(meters) * project.scale;
-}
-float project_size_to_pixel(float size, int unit) {
-  if (unit == UNIT_METERS) return project_size_to_pixel(size);
-  if (unit == UNIT_COMMON) return size * project.scale;
-  // UNIT_PIXELS
-  return size;
-}
-float project_pixel_size(float pixels) {
-  return pixels / project.scale;
-}
-vec2 project_pixel_size(vec2 pixels) {
-  return pixels / project.scale;
-}
-`
-);
-
-// ../core/src/shaderlib/project/project.ts
-var INITIAL_MODULE_OPTIONS = {};
-function getUniforms(opts = INITIAL_MODULE_OPTIONS) {
-  if ("viewport" in opts) {
-    return getUniformsFromViewport(opts);
-  }
-  return {};
-}
-var project_default = {
-  name: "project",
-  dependencies: [import_shadertools.fp32, geometry_default],
-  source: projectWGSL,
-  vs: projectGLSL,
-  getUniforms,
-  uniformTypes: {
-    wrapLongitude: "f32",
-    coordinateSystem: "i32",
-    commonUnitsPerMeter: "vec3<f32>",
-    projectionMode: "i32",
-    scale: "f32",
-    commonUnitsPerWorldUnit: "vec3<f32>",
-    commonUnitsPerWorldUnit2: "vec3<f32>",
-    center: "vec4<f32>",
-    modelMatrix: "mat4x4<f32>",
-    viewProjectionMatrix: "mat4x4<f32>",
-    viewportSize: "vec2<f32>",
-    devicePixelRatio: "f32",
-    focalDistance: "f32",
-    cameraPosition: "vec3<f32>",
-    coordinateOrigin: "vec3<f32>",
-    commonOrigin: "vec3<f32>",
-    pseudoMeters: "f32"
-  }
-  // @ts-ignore TODO v9.1
-};
-
-// ../core/src/passes/pass.ts
-var Pass = class {
-  /** Create a new Pass instance */
-  constructor(device, props = { id: "pass" }) {
-    const { id } = props;
-    this.id = id;
-    this.device = device;
-    this.props = { ...props };
-  }
-  setProps(props) {
-    Object.assign(this.props, props);
-  }
-  render(params) {
-  }
-  // eslint-disable-line @typescript-eslint/no-empty-function
-  cleanup() {
-  }
-  // eslint-disable-line @typescript-eslint/no-empty-function
-};
-
-// ../core/src/passes/layers-pass.ts
-var WEBGPU_DEFAULT_DRAW_PARAMETERS = {
-  depthWriteEnabled: true,
-  depthCompare: "less-equal",
-  blendColorOperation: "add",
-  blendColorSrcFactor: "one",
-  blendColorDstFactor: "one-minus-src-alpha",
-  blendAlphaOperation: "add",
-  blendAlphaSrcFactor: "one",
-  blendAlphaDstFactor: "one-minus-src-alpha"
-};
-var LayersPass = class extends Pass {
-  constructor() {
-    super(...arguments);
-    this._lastRenderIndex = -1;
-  }
-  render(options) {
-    this._render(options);
-  }
-  _render(options) {
-    const { canvasContext = this.device.canvasContext } = options;
-    const framebuffer = options.target ?? canvasContext.getCurrentFramebuffer();
-    const [width, height] = canvasContext.getDrawingBufferSize();
-    const clearCanvas = options.clearCanvas ?? true;
-    let clearColor = options.clearColor ?? (clearCanvas ? [0, 0, 0, 0] : false);
-    let clearDepth = clearCanvas ? 1 : false;
-    let clearStencil = clearCanvas ? 0 : false;
-    const colorMask = options.colorMask ?? 15;
-    const parameters2 = { viewport: [0, 0, width, height] };
-    if (options.colorMask) {
-      parameters2.colorMask = colorMask;
-    }
-    if (options.scissorRect) {
-      parameters2.scissorRect = options.scissorRect;
-    }
-    const { shaderModuleProps, viewports, views, onViewportActive, clearStack = true } = options;
-    const pass = options.pass || "unknown";
-    const submitEachRenderPass = this.device.type === "webgpu";
-    if (clearStack) {
-      this._lastRenderIndex = -1;
-    }
-    const renderStats = [];
-    if (!viewports.length) {
-      const renderPass = this.device.beginRenderPass({
-        framebuffer,
-        parameters: parameters2,
-        clearColor,
-        clearDepth,
-        clearStencil
-      });
-      renderPass.end();
-      this.device.submit();
-      return renderStats;
-    }
-    try {
-      for (const viewport of viewports) {
-        onViewportActive == null ? void 0 : onViewportActive(viewport);
-        const drawLayerParams = this._getDrawLayerParams(viewport, options);
-        const view = views && views[viewport.id];
-        const subViewports = viewport.subViewports || [viewport];
-        const renderGroups = submitEachRenderPass ? subViewports.map((subViewport) => [subViewport]) : [subViewports];
-        for (const renderGroup of renderGroups) {
-          const renderPass = this.device.beginRenderPass({
-            framebuffer,
-            parameters: parameters2,
-            clearColor,
-            clearDepth,
-            clearStencil
-          });
-          try {
-            for (const subViewport of renderGroup) {
-              const stats = this._drawLayersInViewport(
-                renderPass,
-                {
-                  target: framebuffer,
-                  canvasContext,
-                  shaderModuleProps,
-                  viewport: subViewport,
-                  view,
-                  pass,
-                  layers: options.layers,
-                  isPicking: options.isPicking
-                },
-                drawLayerParams
-              );
-              renderStats.push(stats);
-            }
-          } finally {
-            renderPass.end();
-            if (submitEachRenderPass) {
-              this.device.submit();
-            }
-          }
-          clearColor = false;
-          clearDepth = false;
-          clearStencil = false;
-        }
-      }
-      return renderStats;
-    } finally {
-      if (!submitEachRenderPass) {
-        this.device.submit();
-      }
-    }
-  }
-  // When a viewport contains multiple subviewports (e.g. repeated web mercator map),
-  // this is only done once for the parent viewport
-  /* Resolve the parameters needed to draw each layer */
-  _getDrawLayerParams(viewport, {
-    layers,
-    pass,
-    isPicking = false,
-    layerFilter,
-    cullRect,
-    views,
-    effects,
-    canvasContext = this.device.canvasContext,
-    shaderModuleProps
-  }, evaluateShouldDrawOnly = false) {
-    var _a, _b;
-    const drawLayerParams = [];
-    const indexResolver = layerIndexResolver(this._lastRenderIndex + 1);
-    const drawContext = {
-      layer: layers[0],
-      viewport,
-      isPicking,
-      renderPass: pass,
-      cullRect
-    };
-    const layerFilterCache = {};
-    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
-      const layer = layers[layerIndex];
-      const shouldDrawLayer = this._shouldDrawLayer(
-        layer,
-        drawContext,
-        layerFilter,
-        layerFilterCache
-      );
-      const layerParam = { shouldDrawLayer };
-      if (shouldDrawLayer && !evaluateShouldDrawOnly) {
-        layerParam.shouldDrawLayer = true;
-        layerParam.layerRenderIndex = indexResolver(layer, shouldDrawLayer);
-        layerParam.shaderModuleProps = this._getShaderModuleProps(
-          layer,
-          effects,
-          pass,
-          canvasContext,
-          shaderModuleProps
-        );
-        const defaultParams = layer.context.device.type === "webgpu" ? WEBGPU_DEFAULT_DRAW_PARAMETERS : null;
-        layerParam.layerParameters = {
-          ...defaultParams,
-          ...(_a = layer.context.deck) == null ? void 0 : _a.props.parameters,
-          ...(_b = views == null ? void 0 : views[viewport.id]) == null ? void 0 : _b.props.parameters,
-          ...this.getLayerParameters(layer, layerIndex, viewport)
-        };
-      }
-      drawLayerParams[layerIndex] = layerParam;
-    }
-    return drawLayerParams;
-  }
-  // Draws a list of layers in one viewport
-  // TODO - when picking we could completely skip rendering viewports that dont
-  // intersect with the picking rect
-  /* eslint-disable max-depth, max-statements, complexity */
-  _drawLayersInViewport(renderPass, {
-    layers,
-    shaderModuleProps: globalModuleParameters,
-    pass,
-    target,
-    canvasContext,
-    viewport,
-    view,
-    isPicking
-  }, drawLayerParams) {
-    const glViewport = getGLViewport(this.device, {
-      canvasContext,
-      shaderModuleProps: globalModuleParameters,
-      target,
-      viewport
-    });
-    if (view) {
-      const { clear, clearColor, clearDepth, clearStencil } = view.props;
-      if (clear) {
-        let colorToUse = [0, 0, 0, 0];
-        let depthToUse = 1;
-        let stencilToUse = 0;
-        if (Array.isArray(clearColor) && !isPicking) {
-          colorToUse = [...clearColor.slice(0, 3), clearColor[3] || 255].map(
-            (c) => c / 255
-          );
-        } else if (clearColor === false) {
-          colorToUse = false;
-        }
-        if (clearDepth !== void 0) {
-          depthToUse = clearDepth;
-        }
-        if (clearStencil !== void 0) {
-          stencilToUse = clearStencil;
-        }
-        const clearRenderPass = this.device.beginRenderPass({
-          framebuffer: target,
-          parameters: {
-            viewport: glViewport,
-            scissorRect: glViewport
-          },
-          clearColor: colorToUse,
-          clearDepth: depthToUse,
-          clearStencil: stencilToUse
-        });
-        clearRenderPass.end();
-      }
-    }
-    const renderStatus = {
-      totalCount: layers.length,
-      visibleCount: 0,
-      compositeCount: 0,
-      pickableCount: 0
-    };
-    renderPass.setParameters({ viewport: glViewport });
-    for (let layerIndex = 0; layerIndex < layers.length; layerIndex++) {
-      const layer = layers[layerIndex];
-      const drawLayerParameters = drawLayerParams[layerIndex];
-      const { shouldDrawLayer } = drawLayerParameters;
-      if (shouldDrawLayer && layer.props.pickable) {
-        renderStatus.pickableCount++;
-      }
-      if (layer.isComposite) {
-        renderStatus.compositeCount++;
-      }
-      if (layer.isDrawable && drawLayerParameters.shouldDrawLayer) {
-        const { layerRenderIndex, shaderModuleProps, layerParameters } = drawLayerParameters;
-        renderStatus.visibleCount++;
-        this._lastRenderIndex = Math.max(this._lastRenderIndex, layerRenderIndex);
-        if (shaderModuleProps.project) {
-          shaderModuleProps.project.viewport = viewport;
-        }
-        layer.context.renderPass = renderPass;
-        try {
-          layer._drawLayer({
-            renderPass,
-            shaderModuleProps,
-            uniforms: { layerIndex: layerRenderIndex },
-            parameters: layerParameters
-          });
-        } catch (err) {
-          layer.raiseError(err, `drawing ${layer} to ${pass}`);
-        }
-      }
-    }
-    return renderStatus;
-  }
-  /* eslint-enable max-depth, max-statements */
-  /* Methods for subclass overrides */
-  shouldDrawLayer(layer) {
-    return true;
-  }
-  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
-    return null;
-  }
-  getLayerParameters(layer, layerIndex, viewport) {
-    return layer.props.parameters;
-  }
-  /* Private */
-  _shouldDrawLayer(layer, drawContext, layerFilter, layerFilterCache) {
-    const shouldDrawLayer = layer.props.visible && this.shouldDrawLayer(layer);
-    if (!shouldDrawLayer) {
-      return false;
-    }
-    drawContext.layer = layer;
-    let parent = layer.parent;
-    while (parent) {
-      if (!parent.props.visible || !parent.filterSubLayer(drawContext)) {
-        return false;
-      }
-      drawContext.layer = parent;
-      parent = parent.parent;
-    }
-    if (layerFilter) {
-      const rootLayerId = drawContext.layer.id;
-      if (!(rootLayerId in layerFilterCache)) {
-        layerFilterCache[rootLayerId] = layerFilter(drawContext);
-      }
-      if (!layerFilterCache[rootLayerId]) {
-        return false;
-      }
-    }
-    layer.activateViewport(drawContext.viewport);
-    return true;
-  }
-  _getShaderModuleProps(layer, effects, pass, canvasContext, overrides) {
-    var _a, _b;
-    const devicePixelRatio = canvasContext.cssToDeviceRatio();
-    const layerProps = ((_a = layer.internalState) == null ? void 0 : _a.propsInTransition) || layer.props;
-    const shaderModuleProps = {
-      layer: layerProps,
-      picking: {
-        isActive: false
-      },
-      project: {
-        viewport: layer.context.viewport,
-        devicePixelRatio,
-        modelMatrix: layerProps.modelMatrix,
-        coordinateSystem: layerProps.coordinateSystem,
-        coordinateOrigin: layerProps.coordinateOrigin,
-        autoWrapLongitude: layer.wrapLongitude
-      }
-    };
-    if (effects) {
-      for (const effect of effects) {
-        mergeModuleParameters(
-          shaderModuleProps,
-          (_b = effect.getShaderModuleProps) == null ? void 0 : _b.call(effect, layer, shaderModuleProps)
-        );
-      }
-    }
-    for (const module2 of layer.context.defaultShaderModules) {
-      if (!(module2.name in shaderModuleProps)) {
-        shaderModuleProps[module2.name] = {};
-      }
-    }
-    return mergeModuleParameters(
-      shaderModuleProps,
-      this.getShaderModuleProps(layer, effects, shaderModuleProps),
-      overrides
-    );
-  }
-};
-function layerIndexResolver(startIndex = 0, layerIndices = {}) {
-  const resolvers = {};
-  const resolveLayerIndex = (layer, isDrawn) => {
-    const indexOverride = layer.props._offset;
-    const layerId = layer.id;
-    const parentId = layer.parent && layer.parent.id;
-    let index;
-    if (parentId && !(parentId in layerIndices)) {
-      resolveLayerIndex(layer.parent, false);
-    }
-    if (parentId in resolvers) {
-      const resolver = resolvers[parentId] = resolvers[parentId] || layerIndexResolver(layerIndices[parentId], layerIndices);
-      index = resolver(layer, isDrawn);
-      resolvers[layerId] = resolver;
-    } else if (Number.isFinite(indexOverride)) {
-      index = indexOverride + (layerIndices[parentId] || 0);
-      resolvers[layerId] = null;
-    } else {
-      index = startIndex;
-    }
-    if (isDrawn && index >= startIndex) {
-      startIndex = index + 1;
-    }
-    layerIndices[layerId] = index;
-    return index;
-  };
-  return resolveLayerIndex;
-}
-function getGLViewport(device, {
-  canvasContext = device.canvasContext,
-  shaderModuleProps,
-  target,
-  viewport
-}) {
-  var _a;
-  const pixelRatio = ((_a = shaderModuleProps == null ? void 0 : shaderModuleProps.project) == null ? void 0 : _a.devicePixelRatio) ?? canvasContext.cssToDeviceRatio();
-  const [, drawingBufferHeight] = canvasContext.getDrawingBufferSize();
-  const height = target ? target.height : drawingBufferHeight;
-  const dimensions = viewport;
-  return [
-    dimensions.x * pixelRatio,
-    height - (dimensions.y + dimensions.height) * pixelRatio,
-    dimensions.width * pixelRatio,
-    dimensions.height * pixelRatio
-  ];
-}
-function mergeModuleParameters(target, ...sources) {
-  for (const source2 of sources) {
-    if (source2) {
-      for (const key in source2) {
-        if (target[key]) {
-          Object.assign(target[key], source2[key]);
-        } else {
-          target[key] = source2[key];
-        }
-      }
-    }
-  }
-  return target;
-}
-
-// ../core/src/utils/math-utils.ts
-var import_core2 = require("@math.gl/core");
-function createMat4() {
-  return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
-}
-function mod(value, divisor) {
-  const modulus = value % divisor;
-  return modulus < 0 ? divisor + modulus : modulus;
-}
-function getCameraPosition(viewMatrixInverse) {
-  return [viewMatrixInverse[12], viewMatrixInverse[13], viewMatrixInverse[14]];
-}
-function getFrustumPlanes(viewProjectionMatrix) {
-  return {
-    left: getFrustumPlane(
-      viewProjectionMatrix[3] + viewProjectionMatrix[0],
-      viewProjectionMatrix[7] + viewProjectionMatrix[4],
-      viewProjectionMatrix[11] + viewProjectionMatrix[8],
-      viewProjectionMatrix[15] + viewProjectionMatrix[12]
-    ),
-    right: getFrustumPlane(
-      viewProjectionMatrix[3] - viewProjectionMatrix[0],
-      viewProjectionMatrix[7] - viewProjectionMatrix[4],
-      viewProjectionMatrix[11] - viewProjectionMatrix[8],
-      viewProjectionMatrix[15] - viewProjectionMatrix[12]
-    ),
-    bottom: getFrustumPlane(
-      viewProjectionMatrix[3] + viewProjectionMatrix[1],
-      viewProjectionMatrix[7] + viewProjectionMatrix[5],
-      viewProjectionMatrix[11] + viewProjectionMatrix[9],
-      viewProjectionMatrix[15] + viewProjectionMatrix[13]
-    ),
-    top: getFrustumPlane(
-      viewProjectionMatrix[3] - viewProjectionMatrix[1],
-      viewProjectionMatrix[7] - viewProjectionMatrix[5],
-      viewProjectionMatrix[11] - viewProjectionMatrix[9],
-      viewProjectionMatrix[15] - viewProjectionMatrix[13]
-    ),
-    near: getFrustumPlane(
-      viewProjectionMatrix[3] + viewProjectionMatrix[2],
-      viewProjectionMatrix[7] + viewProjectionMatrix[6],
-      viewProjectionMatrix[11] + viewProjectionMatrix[10],
-      viewProjectionMatrix[15] + viewProjectionMatrix[14]
-    ),
-    far: getFrustumPlane(
-      viewProjectionMatrix[3] - viewProjectionMatrix[2],
-      viewProjectionMatrix[7] - viewProjectionMatrix[6],
-      viewProjectionMatrix[11] - viewProjectionMatrix[10],
-      viewProjectionMatrix[15] - viewProjectionMatrix[14]
-    )
-  };
-}
-var scratchVector = new import_core2.Vector3();
-function getFrustumPlane(a, b, c, d) {
-  scratchVector.set(a, b, c);
-  const L = scratchVector.len();
-  return { distance: d / L, normal: new import_core2.Vector3(-a / L, -b / L, -c / L) };
-}
-function fp64LowPart(x) {
-  return x - Math.fround(x);
-}
-
-// ../core/src/viewports/viewport.ts
-var import_core3 = require("@math.gl/core");
-var import_web_mercator = require("@math.gl/web-mercator");
-var DEGREES_TO_RADIANS = Math.PI / 180;
-var IDENTITY = createMat4();
-var ZERO_VECTOR2 = [0, 0, 0];
-var DEFAULT_DISTANCE_SCALES = {
-  unitsPerMeter: [1, 1, 1],
-  metersPerUnit: [1, 1, 1]
-};
-function createProjectionMatrix({
-  width,
-  height,
-  orthographic,
-  fovyRadians,
-  focalDistance,
-  padding,
-  near,
-  far
-}) {
-  const aspect = width / height;
-  const matrix = orthographic ? new import_core3.Matrix4().orthographic({ fovy: fovyRadians, aspect, focalDistance, near, far }) : new import_core3.Matrix4().perspective({ fovy: fovyRadians, aspect, near, far });
-  if (padding) {
-    const { left = 0, right = 0, top = 0, bottom = 0 } = padding;
-    const offsetX = (0, import_core3.clamp)((left + width - right) / 2, 0, width) - width / 2;
-    const offsetY = (0, import_core3.clamp)((top + height - bottom) / 2, 0, height) - height / 2;
-    matrix[8] -= offsetX * 2 / width;
-    matrix[9] += offsetY * 2 / height;
-  }
-  return matrix;
-}
-var _Viewport = class _Viewport {
-  // eslint-disable-next-line complexity
-  constructor(opts = {}) {
-    this._frustumPlanes = {};
-    this.id = opts.id || this.constructor.displayName || "viewport";
-    this.x = opts.x || 0;
-    this.y = opts.y || 0;
-    this.width = opts.width || 1;
-    this.height = opts.height || 1;
-    this.zoom = opts.zoom || 0;
-    this.padding = opts.padding;
-    this.distanceScales = opts.distanceScales || DEFAULT_DISTANCE_SCALES;
-    this.focalDistance = opts.focalDistance || 1;
-    this.position = opts.position || ZERO_VECTOR2;
-    this.modelMatrix = opts.modelMatrix || null;
-    const { longitude, latitude } = opts;
-    this.isGeospatial = Number.isFinite(latitude) && Number.isFinite(longitude);
-    this._initProps(opts);
-    this._initMatrices(opts);
-    this.equals = this.equals.bind(this);
-    this.project = this.project.bind(this);
-    this.unproject = this.unproject.bind(this);
-    this.projectPosition = this.projectPosition.bind(this);
-    this.unprojectPosition = this.unprojectPosition.bind(this);
-    this.projectFlat = this.projectFlat.bind(this);
-    this.unprojectFlat = this.unprojectFlat.bind(this);
-  }
-  get subViewports() {
-    return null;
-  }
-  get metersPerPixel() {
-    return this.distanceScales.metersPerUnit[2] / this.scale;
-  }
-  get projectionMode() {
-    if (this.isGeospatial) {
-      return this.zoom < 12 ? PROJECTION_MODE.WEB_MERCATOR : PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET;
-    }
-    return PROJECTION_MODE.IDENTITY;
-  }
-  // Two viewports are equal if their dimensions, common-space scale, and
-  // view and projection matrices are (approximately) equal.
-  equals(viewport) {
-    if (!(viewport instanceof _Viewport)) {
-      return false;
-    }
-    if (this === viewport) {
-      return true;
-    }
-    return viewport.width === this.width && viewport.height === this.height && viewport.scale === this.scale && viewport.projectionMode === this.projectionMode && viewport.resolution === this.resolution && (0, import_core3.equals)(viewport.distanceScales.unitsPerMeter, this.distanceScales.unitsPerMeter) && (0, import_core3.equals)(viewport.projectionMatrix, this.projectionMatrix) && (0, import_core3.equals)(viewport.viewMatrix, this.viewMatrix);
-  }
-  /**
-   * Projects xyz (possibly latitude and longitude) to pixel coordinates in window
-   * using viewport projection parameters
-   * - [longitude, latitude] to [x, y]
-   * - [longitude, latitude, Z] => [x, y, z]
-   * Note: By default, returns top-left coordinates for canvas/SVG type render
-   *
-   * @param {Array} lngLatZ - [lng, lat] or [lng, lat, Z]
-   * @param {Object} opts - options
-   * @param {Object} opts.topLeft=true - Whether projected coords are top left
-   * @return {Array} - [x, y] or [x, y, z] in top left coords
-   */
-  project(xyz, { topLeft = true } = {}) {
-    const worldPosition = this.projectPosition(xyz);
-    const coord = (0, import_web_mercator.worldToPixels)(worldPosition, this.pixelProjectionMatrix);
-    const [x, y] = coord;
-    const y2 = topLeft ? y : this.height - y;
-    return xyz.length === 2 ? [x, y2] : [x, y2, coord[2]];
-  }
-  /**
-   * Unproject pixel coordinates on screen onto world coordinates,
-   * (possibly [lon, lat]) on map.
-   * - [x, y] => [lng, lat]
-   * - [x, y, z] => [lng, lat, Z]
-   * @param {Array} xyz -
-   * @param {Object} opts - options
-   * @param {Object} opts.topLeft=true - Whether origin is top left
-   * @return {Array|null} - [lng, lat, Z] or [X, Y, Z]
-   */
-  unproject(xyz, { topLeft = true, targetZ } = {}) {
-    const [x, y, z] = xyz;
-    const y2 = topLeft ? y : this.height - y;
-    const targetZWorld = targetZ && targetZ * this.distanceScales.unitsPerMeter[2];
-    const coord = (0, import_web_mercator.pixelsToWorld)([x, y2, z], this.pixelUnprojectionMatrix, targetZWorld);
-    const [X, Y, Z] = this.unprojectPosition(coord);
-    if (Number.isFinite(z)) {
-      return [X, Y, Z];
-    }
-    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
-  }
-  // NON_LINEAR PROJECTION HOOKS
-  // Used for web meractor projection
-  projectPosition(xyz) {
-    const [X, Y] = this.projectFlat(xyz);
-    const Z = (xyz[2] || 0) * this.distanceScales.unitsPerMeter[2];
-    return [X, Y, Z];
-  }
-  unprojectPosition(xyz) {
-    const [X, Y] = this.unprojectFlat(xyz);
-    const Z = (xyz[2] || 0) * this.distanceScales.metersPerUnit[2];
-    return [X, Y, Z];
-  }
-  /**
-   * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.
-   * Performs the nonlinear part of the web mercator projection.
-   * Remaining projection is done with 4x4 matrices which also handles
-   * perspective.
-   * @param {Array} lngLat - [lng, lat] coordinates
-   *   Specifies a point on the sphere to project onto the map.
-   * @return {Array} [x,y] coordinates.
-   */
-  projectFlat(xyz) {
-    if (this.isGeospatial) {
-      const result = (0, import_web_mercator.lngLatToWorld)(xyz);
-      result[1] = (0, import_core3.clamp)(result[1], -318, 830);
-      return result;
-    }
-    return xyz;
-  }
-  /**
-   * Unproject world point [x,y] on map onto {lat, lon} on sphere
-   * @param {object|Vector} xy - object with {x,y} members
-   *  representing point on projected map plane
-   * @return {GeoCoordinates} - object with {lat,lon} of point on sphere.
-   *   Has toArray method if you need a GeoJSON Array.
-   *   Per cartographic tradition, lat and lon are specified as degrees.
-   */
-  unprojectFlat(xyz) {
-    if (this.isGeospatial) {
-      return (0, import_web_mercator.worldToLngLat)(xyz);
-    }
-    return xyz;
-  }
-  /**
-   * Get bounds of the current viewport
-   * @return {Array} - [minX, minY, maxX, maxY]
-   */
-  getBounds(options = {}) {
-    const unprojectOption = { targetZ: options.z || 0 };
-    const topLeft = this.unproject([0, 0], unprojectOption);
-    const topRight = this.unproject([this.width, 0], unprojectOption);
-    const bottomLeft = this.unproject([0, this.height], unprojectOption);
-    const bottomRight = this.unproject([this.width, this.height], unprojectOption);
-    return [
-      Math.min(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
-      Math.min(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1]),
-      Math.max(topLeft[0], topRight[0], bottomLeft[0], bottomRight[0]),
-      Math.max(topLeft[1], topRight[1], bottomLeft[1], bottomRight[1])
-    ];
-  }
-  getDistanceScales(coordinateOrigin) {
-    if (coordinateOrigin && this.isGeospatial) {
-      return (0, import_web_mercator.getDistanceScales)({
-        longitude: coordinateOrigin[0],
-        latitude: coordinateOrigin[1],
-        highPrecision: true
-      });
-    }
-    return this.distanceScales;
-  }
-  containsPixel({
-    x,
-    y,
-    width = 1,
-    height = 1
-  }) {
-    return x < this.x + this.width && this.x < x + width && y < this.y + this.height && this.y < y + height;
-  }
-  // Extract frustum planes in common space
-  getFrustumPlanes() {
-    if (this._frustumPlanes.near) {
-      return this._frustumPlanes;
-    }
-    Object.assign(this._frustumPlanes, getFrustumPlanes(this.viewProjectionMatrix));
-    return this._frustumPlanes;
-  }
-  // EXPERIMENTAL METHODS
-  /**
-   * Needed by panning and linear transition
-   * Pan the viewport to place a given world coordinate at screen point [x, y]
-   *
-   * @param {Array} coords - world coordinates
-   * @param {Array} pixel - [x,y] coordinates on screen
-   * @param {Array} startPixel - [x,y] screen position where pan started (optional, for delta-based panning)
-   * @return {Object} props of the new viewport
-   */
-  panByPosition(coords, pixel, startPixel) {
-    return null;
-  }
-  // INTERNAL METHODS
-  /* eslint-disable complexity, max-statements */
-  _initProps(opts) {
-    const longitude = opts.longitude;
-    const latitude = opts.latitude;
-    if (this.isGeospatial) {
-      if (!Number.isFinite(opts.zoom)) {
-        this.zoom = (0, import_web_mercator.getMeterZoom)({ latitude }) + Math.log2(this.focalDistance);
-      }
-      this.distanceScales = opts.distanceScales || (0, import_web_mercator.getDistanceScales)({ latitude, longitude });
-    }
-    const scale = Math.pow(2, this.zoom);
-    this.scale = scale;
-    const { position, modelMatrix } = opts;
-    let meterOffset = ZERO_VECTOR2;
-    if (position) {
-      meterOffset = modelMatrix ? new import_core3.Matrix4(modelMatrix).transformAsVector(position, []) : position;
-    }
-    if (this.isGeospatial) {
-      const center = this.projectPosition([longitude, latitude, 0]);
-      this.center = new import_core3.Vector3(meterOffset).scale(this.distanceScales.unitsPerMeter).add(center);
-    } else {
-      this.center = this.projectPosition(meterOffset);
-    }
-  }
-  /* eslint-enable complexity, max-statements */
-  _initMatrices(opts) {
-    const {
-      // View matrix
-      viewMatrix: viewMatrix2 = IDENTITY,
-      // Projection matrix
-      projectionMatrix = null,
-      // Projection matrix parameters, used if projectionMatrix not supplied
-      orthographic = false,
-      fovyRadians,
-      fovy = 75,
-      near = 0.1,
-      // Distance of near clipping plane
-      far = 1e3,
-      // Distance of far clipping plane
-      padding = null,
-      // Center offset in pixels
-      focalDistance = 1
-    } = opts;
-    this.viewMatrixUncentered = viewMatrix2;
-    this.viewMatrix = new import_core3.Matrix4().multiplyRight(viewMatrix2).translate(new import_core3.Vector3(this.center).negate());
-    this.projectionMatrix = projectionMatrix || createProjectionMatrix({
-      width: this.width,
-      height: this.height,
-      orthographic,
-      fovyRadians: fovyRadians || fovy * DEGREES_TO_RADIANS,
-      focalDistance,
-      padding,
-      near,
-      far
-    });
-    const vpm = createMat4();
-    import_core3.mat4.multiply(vpm, vpm, this.projectionMatrix);
-    import_core3.mat4.multiply(vpm, vpm, this.viewMatrix);
-    this.viewProjectionMatrix = vpm;
-    this.viewMatrixInverse = import_core3.mat4.invert([], this.viewMatrix) || this.viewMatrix;
-    this.cameraPosition = getCameraPosition(this.viewMatrixInverse);
-    const viewportMatrix = createMat4();
-    const pixelProjectionMatrix = createMat4();
-    import_core3.mat4.scale(viewportMatrix, viewportMatrix, [this.width / 2, -this.height / 2, 1]);
-    import_core3.mat4.translate(viewportMatrix, viewportMatrix, [1, -1, 0]);
-    import_core3.mat4.multiply(pixelProjectionMatrix, viewportMatrix, this.viewProjectionMatrix);
-    this.pixelProjectionMatrix = pixelProjectionMatrix;
-    this.pixelUnprojectionMatrix = import_core3.mat4.invert(createMat4(), this.pixelProjectionMatrix);
-    if (!this.pixelUnprojectionMatrix) {
-      log_default.warn("Pixel project matrix not invertible")();
-    }
-  }
-};
-_Viewport.displayName = "Viewport";
-var Viewport = _Viewport;
-
-// ../core/src/viewports/web-mercator-viewport.ts
-var import_web_mercator2 = require("@math.gl/web-mercator");
-var import_core4 = require("@math.gl/core");
-var _WebMercatorViewport = class _WebMercatorViewport extends Viewport {
-  /* eslint-disable complexity, max-statements */
-  constructor(opts = {}) {
-    const {
-      latitude = 0,
-      longitude = 0,
-      zoom = 0,
-      pitch = 0,
-      bearing = 0,
-      nearZMultiplier = 0.1,
-      farZMultiplier = 1.01,
-      nearZ,
-      farZ,
-      orthographic = false,
-      projectionMatrix,
-      repeat = false,
-      worldOffset = 0,
-      position,
-      padding,
-      // backward compatibility
-      // TODO: remove in v9
-      legacyMeterSizes = false
-    } = opts;
-    let { width, height, altitude = 1.5 } = opts;
-    const scale = Math.pow(2, zoom);
-    width = width || 1;
-    height = height || 1;
-    let fovy;
-    let projectionParameters = null;
-    if (projectionMatrix) {
-      altitude = projectionMatrix[5] / 2;
-      fovy = (0, import_web_mercator2.altitudeToFovy)(altitude);
-    } else {
-      if (opts.fovy) {
-        fovy = opts.fovy;
-        altitude = (0, import_web_mercator2.fovyToAltitude)(fovy);
-      } else {
-        fovy = (0, import_web_mercator2.altitudeToFovy)(altitude);
-      }
-      let offset;
-      if (padding) {
-        const { top = 0, bottom = 0 } = padding;
-        offset = [0, (0, import_core4.clamp)((top + height - bottom) / 2, 0, height) - height / 2];
-      }
-      projectionParameters = (0, import_web_mercator2.getProjectionParameters)({
-        width,
-        height,
-        scale,
-        center: position && [0, 0, position[2] * (0, import_web_mercator2.unitsPerMeter)(latitude)],
-        offset,
-        pitch,
-        fovy,
-        nearZMultiplier,
-        farZMultiplier
-      });
-      if (Number.isFinite(nearZ)) {
-        projectionParameters.near = nearZ;
-      }
-      if (Number.isFinite(farZ)) {
-        projectionParameters.far = farZ;
-      }
-    }
-    let viewMatrixUncentered = (0, import_web_mercator2.getViewMatrix)({
-      height,
-      pitch,
-      bearing,
-      scale,
-      altitude
-    });
-    if (worldOffset) {
-      const viewOffset = new import_core4.Matrix4().translate([512 * worldOffset, 0, 0]);
-      viewMatrixUncentered = viewOffset.multiplyLeft(viewMatrixUncentered);
-    }
-    super({
-      ...opts,
-      // x, y,
-      width,
-      height,
-      // view matrix
-      viewMatrix: viewMatrixUncentered,
-      longitude,
-      latitude,
-      zoom,
-      // projection matrix parameters
-      ...projectionParameters,
-      fovy,
-      focalDistance: altitude
-    });
-    this.latitude = latitude;
-    this.longitude = longitude;
-    this.zoom = zoom;
-    this.pitch = pitch;
-    this.bearing = bearing;
-    this.altitude = altitude;
-    this.fovy = fovy;
-    this.orthographic = orthographic;
-    this._subViewports = repeat ? [] : null;
-    this._pseudoMeters = legacyMeterSizes;
-    Object.freeze(this);
-  }
-  /* eslint-enable complexity, max-statements */
-  get subViewports() {
-    if (this._subViewports && !this._subViewports.length) {
-      const bounds = this.getBounds();
-      const minOffset = Math.floor((bounds[0] + 180) / 360);
-      const maxOffset = Math.ceil((bounds[2] - 180) / 360);
-      for (let x = minOffset; x <= maxOffset; x++) {
-        const offsetViewport = x ? new _WebMercatorViewport({
-          ...this,
-          worldOffset: x
-        }) : this;
-        this._subViewports.push(offsetViewport);
-      }
-    }
-    return this._subViewports;
-  }
-  /** Returns whether two Web Mercator viewports use the same projection settings. */
-  equals(viewport) {
-    return viewport instanceof _WebMercatorViewport && viewport._pseudoMeters === this._pseudoMeters && super.equals(viewport);
-  }
-  projectPosition(xyz) {
-    if (this._pseudoMeters) {
-      return super.projectPosition(xyz);
-    }
-    const [X, Y] = this.projectFlat(xyz);
-    const Z = (xyz[2] || 0) * (0, import_web_mercator2.unitsPerMeter)(xyz[1]);
-    return [X, Y, Z];
-  }
-  unprojectPosition(xyz) {
-    if (this._pseudoMeters) {
-      return super.unprojectPosition(xyz);
-    }
-    const [X, Y] = this.unprojectFlat(xyz);
-    const Z = (xyz[2] || 0) / (0, import_web_mercator2.unitsPerMeter)(Y);
-    return [X, Y, Z];
-  }
-  /**
-   * Add a meter delta to a base lnglat coordinate, returning a new lnglat array
-   *
-   * Note: Uses simple linear approximation around the viewport center
-   * Error increases with size of offset (roughly 1% per 100km)
-   *
-   * @param {[Number,Number]|[Number,Number,Number]) lngLatZ - base coordinate
-   * @param {[Number,Number]|[Number,Number,Number]) xyz - array of meter deltas
-   * @return {[Number,Number]|[Number,Number,Number]) array of [lng,lat,z] deltas
-   */
-  addMetersToLngLat(lngLatZ, xyz) {
-    return (0, import_web_mercator2.addMetersToLngLat)(lngLatZ, xyz);
-  }
-  panByPosition(coords, pixel, startPixel) {
-    const fromLocation = (0, import_web_mercator2.pixelsToWorld)(pixel, this.pixelUnprojectionMatrix);
-    const toLocation = this.projectFlat(coords);
-    const translate = import_core4.vec2.add([], toLocation, import_core4.vec2.negate([], fromLocation));
-    const newCenter = import_core4.vec2.add([], this.center, translate);
-    const [longitude, latitude] = this.unprojectFlat(newCenter);
-    return { longitude, latitude };
-  }
-  /**
-   * Returns a new longitude and latitude that keeps a 3D world coordinate at a given screen pixel
-   * This version handles the z-component (altitude) properly for cameras positioned above ground
-   */
-  panByPosition3D(coords, pixel) {
-    const targetZ = coords[2] || 0;
-    const deltaLngLat = import_core4.vec2.sub([], coords, this.unproject(pixel, { targetZ }));
-    return { longitude: this.longitude + deltaLngLat[0], latitude: this.latitude + deltaLngLat[1] };
-  }
-  getBounds(options = {}) {
-    const corners = (0, import_web_mercator2.getBounds)(this, options.z || 0);
-    return [
-      Math.min(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),
-      Math.min(corners[0][1], corners[1][1], corners[2][1], corners[3][1]),
-      Math.max(corners[0][0], corners[1][0], corners[2][0], corners[3][0]),
-      Math.max(corners[0][1], corners[1][1], corners[2][1], corners[3][1])
-    ];
-  }
-  /**
-   * Returns a new viewport that fit around the given rectangle.
-   * Only supports non-perspective mode.
-   */
-  fitBounds(bounds, options = {}) {
-    const { width, height } = this;
-    const { longitude, latitude, zoom } = (0, import_web_mercator2.fitBounds)({ width, height, bounds, ...options });
-    return new _WebMercatorViewport({ width, height, longitude, latitude, zoom });
-  }
-};
-_WebMercatorViewport.displayName = "WebMercatorViewport";
-var WebMercatorViewport = _WebMercatorViewport;
-
-// ../core/src/passes/pick-layers-pass.ts
-var PICKING_BLENDING = {
-  blendColorOperation: "add",
-  blendColorSrcFactor: "one",
-  blendColorDstFactor: "zero",
-  blendAlphaOperation: "add",
-  blendAlphaSrcFactor: "constant",
-  blendAlphaDstFactor: "zero"
-};
-var PickLayersPass = class extends LayersPass {
-  constructor() {
-    super(...arguments);
-    this._colorEncoderState = null;
-  }
-  render(props) {
-    if ("pickingFBO" in props) {
-      return this._drawPickingBuffer(props);
-    }
-    const stats = super._render(props);
-    return { decodePickingColor: null, stats };
-  }
-  // Private
-  // Draws list of layers and viewports into the picking buffer
-  // Note: does not sample the buffer, that has to be done by the caller
-  _drawPickingBuffer({
-    layers,
-    layerFilter,
-    views,
-    viewports,
-    onViewportActive,
-    pickingFBO,
-    deviceRect: { x, y, width, height },
-    cullRect,
-    effects,
-    pass = "picking",
-    pickZ,
-    canvasContext,
-    shaderModuleProps,
-    clearColor
-  }) {
-    this.pickZ = pickZ;
-    const colorEncoderState = this._resetColorEncoder(pickZ);
-    const scissorRect = [x, y, width, height];
-    const renderStatus = super._render({
-      target: pickingFBO,
-      layers,
-      layerFilter,
-      views,
-      viewports,
-      onViewportActive,
-      cullRect,
-      effects: effects == null ? void 0 : effects.filter((e) => e.useInPicking),
-      pass,
-      canvasContext,
-      isPicking: true,
-      shaderModuleProps,
-      clearColor: clearColor ?? [0, 0, 0, 0],
-      colorMask: 15,
-      scissorRect
-    });
-    this._colorEncoderState = null;
-    const decodePickingColor = colorEncoderState && decodeColor.bind(null, colorEncoderState);
-    return { decodePickingColor, stats: renderStatus };
-  }
-  shouldDrawLayer(layer) {
-    const { pickable, operation } = layer.props;
-    return pickable && operation.includes("draw") || operation.includes("terrain") || operation.includes("mask");
-  }
-  getShaderModuleProps(layer, effects, otherShaderModuleProps) {
-    var _a;
-    return {
-      picking: {
-        isActive: 1,
-        isAttribute: this.pickZ,
-        disabledPickingIndices: (_a = layer.internalState) == null ? void 0 : _a.disabledPickingIndices
-      },
-      lighting: { enabled: false }
-    };
-  }
-  getLayerParameters(layer, layerIndex, viewport) {
-    var _a;
-    const pickParameters = {
-      ...layer.props.parameters
-    };
-    const { pickable, operation } = layer.props;
-    if (!this._colorEncoderState) {
-      pickParameters.blend = false;
-    } else if (pickable && operation.includes("draw")) {
-      Object.assign(pickParameters, PICKING_BLENDING);
-      pickParameters.blend = true;
-      if (this.device.type === "webgpu") {
-        pickParameters.blendConstant = encodeColor(this._colorEncoderState, layer, viewport);
-      } else {
-        pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport);
-      }
-      if (operation.includes("terrain") && ((_a = layer.state) == null ? void 0 : _a._hasPickingCover)) {
-        pickParameters.blendAlphaSrcFactor = "one";
-      }
-    } else if (operation.includes("terrain")) {
-      pickParameters.blend = false;
-    }
-    return pickParameters;
-  }
-  _resetColorEncoder(pickZ) {
-    this._colorEncoderState = pickZ ? null : {
-      byLayer: /* @__PURE__ */ new Map(),
-      byAlpha: []
-    };
-    return this._colorEncoderState;
-  }
-};
-function encodeColor(encoded, layer, viewport) {
-  const { byLayer, byAlpha } = encoded;
-  let a;
-  let entry = byLayer.get(layer);
-  if (entry) {
-    entry.viewports.push(viewport);
-    a = entry.a;
-  } else {
-    a = byLayer.size + 1;
-    if (a <= 255) {
-      entry = { a, layer, viewports: [viewport] };
-      byLayer.set(layer, entry);
-      byAlpha[a] = entry;
-    } else {
-      log_default.warn("Too many pickable layers, only picking the first 255")();
-      a = 0;
-    }
-  }
-  return [0, 0, 0, a / 255];
-}
-function decodeColor(encoded, pickedColor) {
-  const entry = encoded.byAlpha[pickedColor[3]];
-  return entry && {
-    pickedLayer: entry.layer,
-    pickedViewports: entry.viewports,
-    pickedObjectIndex: entry.layer.decodePickingColor(pickedColor)
-  };
-}
-
-// ../core/src/utils/deep-equal.ts
-function deepEqual(a, b, depth) {
-  if (a === b) {
-    return true;
-  }
-  if (!depth || !a || !b) {
-    return false;
-  }
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b) || a.length !== b.length) {
-      return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-      if (!deepEqual(a[i], b[i], depth - 1)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (Array.isArray(b)) {
-    return false;
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    for (const key of aKeys) {
-      if (!b.hasOwnProperty(key)) {
-        return false;
-      }
-      if (!deepEqual(a[key], b[key], depth - 1)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-// ../core/src/utils/shader.ts
-function mergeShaders(target, source2) {
-  if (!source2) {
-    return target;
-  }
-  const result = { ...target, ...source2 };
-  if ("defines" in source2) {
-    result.defines = { ...target.defines, ...source2.defines };
-  }
-  if ("modules" in source2) {
-    result.modules = (target.modules || []).concat(source2.modules);
-    if (source2.modules.some((module2) => module2.name === "project64")) {
-      const index = result.modules.findIndex((module2) => module2.name === "project32");
-      if (index >= 0) {
-        result.modules.splice(index, 1);
-      }
-    }
-  }
-  if ("inject" in source2) {
-    if (!target.inject) {
-      result.inject = source2.inject;
-    } else {
-      const mergedInjection = { ...target.inject };
-      for (const key in source2.inject) {
-        mergedInjection[key] = (mergedInjection[key] || "") + source2.inject[key];
-      }
-      result.inject = mergedInjection;
-    }
-  }
-  return result;
-}
-
-// ../core/src/viewports/globe-viewport.ts
-var import_core5 = require("@math.gl/core");
-var import_web_mercator3 = require("@math.gl/web-mercator");
-var DEGREES_TO_RADIANS2 = Math.PI / 180;
-var RADIANS_TO_DEGREES = 180 / Math.PI;
-var NORTH_UP_BEARING_THRESHOLD = 1;
-var EARTH_RADIUS = 6370972;
-var GLOBE_RADIUS = 256;
-var GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO = 0.75;
-var GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO = 1.15;
-function isGlobeNorthUp(bearing) {
-  const normalizedBearing = mod(bearing + 180, 360) - 180;
-  return Math.abs(normalizedBearing) < NORTH_UP_BEARING_THRESHOLD;
-}
-function getDistanceScales2() {
-  const unitsPerMeter2 = GLOBE_RADIUS / EARTH_RADIUS;
-  const unitsPerDegree = Math.PI / 180 * GLOBE_RADIUS;
-  return {
-    unitsPerMeter: [unitsPerMeter2, unitsPerMeter2, unitsPerMeter2],
-    unitsPerMeter2: [0, 0, 0],
-    metersPerUnit: [1 / unitsPerMeter2, 1 / unitsPerMeter2, 1 / unitsPerMeter2],
-    unitsPerDegree: [unitsPerDegree, unitsPerDegree, unitsPerMeter2],
-    unitsPerDegree2: [0, 0, 0],
-    degreesPerUnit: [1 / unitsPerDegree, 1 / unitsPerDegree, 1 / unitsPerMeter2]
-  };
-}
-var GlobeViewport = class extends Viewport {
-  constructor(opts = {}) {
-    const {
-      longitude = 0,
-      bearing = 0,
-      pitch = 0,
-      zoom = 0,
-      // Matches Maplibre defaults
-      // https://github.com/maplibre/maplibre-gl-js/blob/f8ab4b48d59ab8fe7b068b102538793bbdd4c848/src/geo/projection/globe_transform.ts#L632-L633
-      nearZMultiplier = 0.5,
-      farZMultiplier = 1,
-      resolution = 10
-    } = opts;
-    let { latitude = 0, height, altitude = 1.5, fovy } = opts;
-    latitude = Math.max(Math.min(latitude, 90), -90);
-    height = height || 1;
-    if (fovy) {
-      altitude = (0, import_web_mercator3.fovyToAltitude)(fovy);
-    } else {
-      fovy = (0, import_web_mercator3.altitudeToFovy)(altitude);
-    }
-    const scaleLatitude = Math.max(Math.min(latitude, import_web_mercator3.MAX_LATITUDE), -import_web_mercator3.MAX_LATITUDE);
-    const scale = Math.pow(2, zoom - zoomAdjust(scaleLatitude));
-    const pitchRadians = pitch * DEGREES_TO_RADIANS2;
-    const nearZ = opts.nearZ ?? nearZMultiplier;
-    const farZ = opts.farZ ?? (altitude + GLOBE_RADIUS * 2 * scale / height / Math.max(Math.cos(pitchRadians), 0.1)) * farZMultiplier;
-    const viewMatrix2 = new import_core5.Matrix4().lookAt({ eye: [0, -altitude, 0], up: [0, 0, 1] }).rotateX(-pitchRadians).rotateY(-bearing * DEGREES_TO_RADIANS2).rotateX(latitude * DEGREES_TO_RADIANS2).rotateZ(-longitude * DEGREES_TO_RADIANS2).scale(scale / height);
-    super({
-      ...opts,
-      // x, y, width,
-      height,
-      // view matrix
-      viewMatrix: viewMatrix2,
-      longitude,
-      latitude,
-      zoom,
-      // projection matrix parameters
-      distanceScales: getDistanceScales2(),
-      fovy,
-      focalDistance: altitude,
-      near: nearZ,
-      far: farZ
-    });
-    this.scale = scale;
-    this.latitude = latitude;
-    this.longitude = longitude;
-    this.bearing = bearing;
-    this.pitch = pitch;
-    this.fovy = fovy;
-    this.resolution = resolution;
-  }
-  get projectionMode() {
-    return PROJECTION_MODE.GLOBE;
-  }
-  getDistanceScales() {
-    return this.distanceScales;
-  }
-  getBounds(options = {}) {
-    const unprojectOption = { targetZ: options.z || 0 };
-    const left = this.unproject([0, this.height / 2], unprojectOption);
-    const top = this.unproject([this.width / 2, 0], unprojectOption);
-    const right = this.unproject([this.width, this.height / 2], unprojectOption);
-    const bottom = this.unproject([this.width / 2, this.height], unprojectOption);
-    if (right[0] < this.longitude) right[0] += 360;
-    if (left[0] > this.longitude) left[0] -= 360;
-    return [
-      Math.min(left[0], right[0], top[0], bottom[0]),
-      Math.min(left[1], right[1], top[1], bottom[1]),
-      Math.max(left[0], right[0], top[0], bottom[0]),
-      Math.max(left[1], right[1], top[1], bottom[1])
-    ];
-  }
-  /**
-   * Builds the screen-pixel → globe-center ray and the intermediate ray/sphere
-   * math reused by `unproject` and anchored zoom. One function so the same
-   * pixelUnprojectionMatrix work isn't duplicated.
-   */
-  _getRayToGlobe(screenPosition, { topLeft = true, targetZ } = {}) {
-    const [screenX, screenY] = screenPosition;
-    const adjustedScreenY = topLeft ? screenY : this.height - screenY;
-    const { pixelUnprojectionMatrix } = this;
-    const rayStartPosition = transformVector(pixelUnprojectionMatrix, [
-      screenX,
-      adjustedScreenY,
-      -1,
-      1
-    ]);
-    const rayEndPosition = transformVector(pixelUnprojectionMatrix, [
-      screenX,
-      adjustedScreenY,
-      1,
-      1
-    ]);
-    const radius = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-    const rayLengthSquared = import_core5.vec3.sqrLen(import_core5.vec3.sub([], rayStartPosition, rayEndPosition));
-    const rayStartDistanceSquared = import_core5.vec3.sqrLen(rayStartPosition);
-    const rayEndDistanceSquared = import_core5.vec3.sqrLen(rayEndPosition);
-    const triangleAreaSquared = (4 * rayStartDistanceSquared * rayEndDistanceSquared - (rayLengthSquared - rayStartDistanceSquared - rayEndDistanceSquared) ** 2) / 16;
-    const distanceToCenterSquared = 4 * triangleAreaSquared / rayLengthSquared;
-    return {
-      rayStartPosition,
-      rayEndPosition,
-      radius,
-      rayLengthSquared,
-      rayStartDistanceSquared,
-      distanceToCenterSquared
-    };
-  }
-  _getRayDistanceToGlobeCenterRatio(screenPosition, options) {
-    const { distanceToCenterSquared, radius } = this._getRayToGlobe(screenPosition, options);
-    return Math.sqrt(Math.max(0, distanceToCenterSquared)) / radius;
-  }
-  /**
-   * Returns how strongly a screen position should anchor zoom on the visible globe.
-   * A value of `0` means that the controller should fall back to center zoom.
-   * @param screenPosition - Screen position to evaluate.
-   * @returns Anchor strength from `0` to `1`.
-   */
-  getZoomAnchorStrength(screenPosition) {
-    const distanceRatio = this._getRayDistanceToGlobeCenterRatio(screenPosition);
-    if (distanceRatio >= GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO) {
-      return 0;
-    }
-    const edgeProgress = Math.max(
-      0,
-      Math.min(
-        1,
-        (distanceRatio - GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO) / (GLOBE_ZOOM_ANCHOR_MAX_DISTANCE_RATIO - GLOBE_ZOOM_ANCHOR_DAMPING_START_RATIO)
-      )
-    );
-    const smoothProgress = edgeProgress * edgeProgress * (3 - 2 * edgeProgress);
-    return 1 - smoothProgress;
-  }
-  unproject(xyz, { topLeft = true, targetZ } = {}) {
-    const [x, y, z] = xyz;
-    const y2 = topLeft ? y : this.height - y;
-    const { pixelUnprojectionMatrix } = this;
-    let coord;
-    if (Number.isFinite(z)) {
-      coord = transformVector(pixelUnprojectionMatrix, [x, y2, z, 1]);
-    } else {
-      const {
-        rayStartPosition,
-        rayEndPosition,
-        radius,
-        rayLengthSquared,
-        rayStartDistanceSquared,
-        distanceToCenterSquared
-      } = this._getRayToGlobe(xyz, { topLeft, targetZ });
-      const rayStartToClosestApproach = Math.sqrt(
-        rayStartDistanceSquared - distanceToCenterSquared
-      );
-      const closestApproachToIntersection = Math.sqrt(
-        Math.max(0, radius * radius - distanceToCenterSquared)
-      );
-      const intersectionRatio = (rayStartToClosestApproach - closestApproachToIntersection) / Math.sqrt(rayLengthSquared);
-      coord = import_core5.vec3.lerp([], rayStartPosition, rayEndPosition, intersectionRatio);
-    }
-    const [X, Y, Z] = this.unprojectPosition(coord);
-    if (Number.isFinite(z)) {
-      return [X, Y, Z];
-    }
-    return Number.isFinite(targetZ) ? [X, Y, targetZ] : [X, Y];
-  }
-  projectPosition(xyz) {
-    const [lng, lat, Z = 0] = xyz;
-    const lambda = lng * DEGREES_TO_RADIANS2;
-    const phi = lat * DEGREES_TO_RADIANS2;
-    const cosPhi = Math.cos(phi);
-    const D = (Z / EARTH_RADIUS + 1) * GLOBE_RADIUS;
-    return [Math.sin(lambda) * cosPhi * D, -Math.cos(lambda) * cosPhi * D, Math.sin(phi) * D];
-  }
-  unprojectPosition(xyz) {
-    const [x, y, z] = xyz;
-    const D = import_core5.vec3.len(xyz);
-    const phi = Math.asin(z / D);
-    const lambda = Math.atan2(x, -y);
-    const lng = lambda * RADIANS_TO_DEGREES;
-    const lat = phi * RADIANS_TO_DEGREES;
-    const Z = (D / GLOBE_RADIUS - 1) * EARTH_RADIUS;
-    return [lng, lat, Z];
-  }
-  projectFlat(xyz) {
-    return xyz;
-  }
-  unprojectFlat(xyz) {
-    return xyz;
-  }
-  /**
-   * Pan the globe to place geographic coordinates at a screen pixel.
-   * When `dragStartPosition` is supplied, applies the delta-based movement used by globe dragging.
-   * @param coordinates - Geographic anchor, or the starting longitude, latitude and zoom.
-   * @param screenPosition - Current screen position.
-   * @param dragStartPosition - Screen position where a drag started.
-   * @returns Updated viewport options.
-   */
-  panByPosition(coordinates, screenPosition, dragStartPosition) {
-    if (!dragStartPosition) {
-      let anchorStrength = this.getZoomAnchorStrength(screenPosition);
-      if (anchorStrength === 0) {
-        return { longitude: this.longitude, latitude: this.latitude };
-      }
-      const currentCoordinates = this.unproject(screenPosition);
-      const longitudeDelta = mod(coordinates[0] - currentCoordinates[0] + 180, 360) - 180;
-      const latitudeDelta = coordinates[1] - currentCoordinates[1];
-      const crossesPole = Math.abs(currentCoordinates[1]) > import_web_mercator3.MAX_LATITUDE || Math.abs(longitudeDelta) > 90;
-      if (isGlobeNorthUp(this.bearing) && crossesPole) {
-        return { longitude: this.longitude, latitude: this.latitude };
-      }
-      if (isGlobeNorthUp(this.bearing) && latitudeDelta !== 0) {
-        const latitudeLimit = latitudeDelta > 0 ? import_web_mercator3.MAX_LATITUDE : -import_web_mercator3.MAX_LATITUDE;
-        const latitudeConstraintStrength = (latitudeLimit - this.latitude) / latitudeDelta;
-        anchorStrength = Math.min(anchorStrength, Math.max(0, latitudeConstraintStrength));
-      }
-      const longitude2 = this.longitude + longitudeDelta * anchorStrength;
-      const latitude2 = Math.max(Math.min(this.latitude + latitudeDelta * anchorStrength, 90), -90);
-      return { longitude: longitude2, latitude: latitude2 };
-    }
-    const [startLongitude, startLatitude, startZoom] = coordinates;
-    const scale = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
-    const rotationSpeed = 0.25 / scale;
-    const longitude = startLongitude + rotationSpeed * (dragStartPosition[0] - screenPosition[0]);
-    let latitude = startLatitude - rotationSpeed * (dragStartPosition[1] - screenPosition[1]);
-    latitude = Math.max(Math.min(latitude, 90), -90);
-    const nextViewState = { longitude, latitude, zoom: startZoom - zoomAdjust(startLatitude) };
-    nextViewState.zoom += zoomAdjust(nextViewState.latitude);
-    return nextViewState;
-  }
-};
-GlobeViewport.displayName = "GlobeViewport";
-function zoomAdjust(latitude, clampToPoles) {
-  if (clampToPoles) {
-    latitude = Math.max(Math.min(latitude, import_web_mercator3.MAX_LATITUDE), -import_web_mercator3.MAX_LATITUDE);
-  }
-  const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
-  return Math.log2(scaleAdjust);
-}
-function transformVector(matrix, vector) {
-  const result = import_core5.vec4.transformMat4([], vector, matrix);
-  import_core5.vec4.scale(result, result, 1 / result[3]);
-  return result;
-}
-
-// ../core/src/viewports/orthographic-viewport.ts
-var import_core6 = require("@math.gl/core");
-var import_web_mercator4 = require("@math.gl/web-mercator");
-var viewMatrix = new import_core6.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 = (0, import_core6.clamp)((l + width - r) / 2, 0, width) - width / 2;
-    const offsetY = (0, import_core6.clamp)((t + height - b) / 2, 0, height) - height / 2;
-    left -= offsetX;
-    right -= offsetX;
-    bottom += offsetY;
-    top += offsetY;
-  }
-  return new import_core6.Matrix4().ortho({
-    left,
-    right,
-    bottom,
-    top,
-    near,
-    far
-  });
-}
-var OrthographicViewport = class extends Viewport {
-  constructor(props) {
-    const {
-      width,
-      height,
-      near = 0.1,
-      far = 1e3,
-      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_ = Number.isFinite(props.zoom) ? props.zoom : Math.min(zoomX, zoomY);
-    const scale = Math.pow(2, zoom_);
-    let distanceScales;
-    if (zoomX !== zoom_ || zoomY !== zoom_) {
-      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: void 0,
-      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: unitsPerMeter2 } = this.distanceScales;
-    return [X * unitsPerMeter2[0], Y * unitsPerMeter2[1]];
-  }
-  unprojectFlat([x, y]) {
-    const { metersPerUnit } = this.distanceScales;
-    return [x * metersPerUnit[0], y * metersPerUnit[1]];
-  }
-  /* Needed by LinearInterpolator */
-  panByPosition(coords, pixel, startPixel) {
-    const fromLocation = (0, import_web_mercator4.pixelsToWorld)(pixel, this.pixelUnprojectionMatrix);
-    const toLocation = this.projectFlat(coords);
-    const translate = import_core6.vec2.add([], toLocation, import_core6.vec2.negate([], fromLocation));
-    const newCenter = import_core6.vec2.add([], this.center, translate);
-    return { target: this.unprojectFlat(newCenter) };
-  }
-};
-OrthographicViewport.displayName = "OrthographicViewport";
-
-// ../core/src/lib/layer-extension.ts
-var LayerExtension = class {
-  static get componentName() {
-    return Object.prototype.hasOwnProperty.call(this, "extensionName") ? this.extensionName : "";
-  }
-  constructor(opts) {
-    if (opts) {
-      this.opts = opts;
-    }
-  }
-  /** Returns true if two extensions are equivalent */
-  equals(extension) {
-    if (this === extension) {
-      return true;
-    }
-    return this.constructor === extension.constructor && deepEqual(this.opts, extension.opts, 1);
-  }
-  /** Only called if attached to a primitive layer */
-  getShaders(extension) {
-    return null;
-  }
-  /** Only called if attached to a CompositeLayer */
-  getSubLayerProps(extension) {
-    const { defaultProps: defaultProps9 } = extension.constructor;
-    const newProps = {
-      updateTriggers: {}
-    };
-    for (const key in defaultProps9) {
-      if (key in this.props) {
-        const propDef = defaultProps9[key];
-        const propValue = this.props[key];
-        newProps[key] = propValue;
-        if (propDef && propDef.type === "accessor") {
-          newProps.updateTriggers[key] = this.props.updateTriggers[key];
-          if (typeof propValue === "function") {
-            newProps[key] = this.getSubLayerAccessor(propValue);
-          }
-        }
-      }
-    }
-    return newProps;
-  }
-  /* eslint-disable @typescript-eslint/no-empty-function */
-  initializeState(context, extension) {
-  }
-  updateState(params, extension) {
-  }
-  onNeedsRedraw(extension) {
-  }
-  getNeedsPickingBuffer(extension) {
-    return false;
-  }
-  draw(params, extension) {
-  }
-  finalizeState(context, extension) {
-  }
-};
-LayerExtension.defaultProps = {};
-LayerExtension.extensionName = "LayerExtension";
+// dist/brushing/brushing-extension.js
+var import_core2 = require("@deck.gl/core");
 
 // dist/brushing/shader-module.js
+var import_core = require("@deck.gl/core");
 var uniformBlock = (
   /* glsl */
   `layout(std140) uniform brushingUniforms {
@@ -2704,7 +74,7 @@ var vertex = (
   }
 `
 );
-var vs2 = `
+var vs = `
 ${uniformBlock}
 ${vertex}
 `;
@@ -2714,7 +84,7 @@ var fragment = (
   in float brushing_isVisible;
 `
 );
-var fs2 = `
+var fs = `
 ${uniformBlock}
 ${fragment}
 `;
@@ -2757,9 +127,9 @@ var inject = {
 };
 var shader_module_default = {
   name: "brushing",
-  dependencies: [project_default],
-  vs: vs2,
-  fs: fs2,
+  dependencies: [import_core.project],
+  vs,
+  fs,
   inject,
   getUniforms: (opts) => {
     if (!opts || !("viewport" in opts)) {
@@ -2788,7 +158,7 @@ var defaultProps = {
   brushingEnabled: true,
   brushingRadius: 1e4
 };
-var BrushingExtension = class extends LayerExtension {
+var BrushingExtension = class extends import_core2.LayerExtension {
   getShaders() {
     return {
       modules: [shader_module_default]
@@ -2843,6 +213,9 @@ BrushingExtension.defaultProps = defaultProps;
 BrushingExtension.extensionName = "BrushingExtension";
 var brushing_extension_default = BrushingExtension;
 
+// dist/data-filter/data-filter-extension.js
+var import_core3 = require("@deck.gl/core");
+
 // dist/data-filter/shader-module.js
 var uniformBlock2 = (
   /* glsl */
@@ -3026,7 +399,7 @@ float dataFilter_reduceValue(vec4 value) {
 #endif
 `
 );
-var vs3 = `
+var vs2 = `
 ${uniformBlock2}
 ${vertex2}
 `;
@@ -3036,11 +409,11 @@ var fragment2 = (
 in float dataFilter_value;
 `
 );
-var fs3 = `
+var fs2 = `
 ${uniformBlock2}
 ${fragment2}
 `;
-function getUniforms2(opts) {
+function getUniforms(opts) {
   if (!opts || !("extensions" in opts)) {
     return {};
   }
@@ -3075,7 +448,7 @@ function getUniforms64(opts) {
   if (!opts || !("extensions" in opts)) {
     return {};
   }
-  const uniforms = getUniforms2(opts);
+  const uniforms = getUniforms(opts);
   const min64High = uniforms.min.map(Math.fround);
   uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);
   uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);
@@ -3153,16 +526,16 @@ function uniformTypesFromOptions(opts) {
 }
 var dataFilter = {
   name: "dataFilter",
-  vs: vs3,
-  fs: fs3,
+  vs: vs2,
+  fs: fs2,
   inject: inject2,
-  getUniforms: getUniforms2,
+  getUniforms,
   uniformTypesFromOptions
 };
 var dataFilter64 = {
   name: "dataFilter",
-  vs: vs3,
-  fs: fs3,
+  vs: vs2,
+  fs: fs2,
   inject: inject2,
   getUniforms: getUniforms64,
   uniformTypesFromOptions
@@ -3307,24 +680,24 @@ var DATA_TYPE_FROM_SIZE = {
   3: "vec3",
   4: "vec4"
 };
-var DataFilterExtension = class extends LayerExtension {
+var DataFilterExtension = class extends import_core3.LayerExtension {
   constructor(opts = {}) {
     super({ ...defaultOptions, ...opts });
   }
   getShaders(extension) {
     const { categorySize, filterSize, fp64: fp642 } = extension.opts;
-    const defines2 = {};
+    const defines = {};
     if (categorySize) {
-      defines2.DATACATEGORY_TYPE = CATEGORY_TYPE_FROM_SIZE[categorySize];
-      defines2.DATACATEGORY_CHANNELS = categorySize;
+      defines.DATACATEGORY_TYPE = CATEGORY_TYPE_FROM_SIZE[categorySize];
+      defines.DATACATEGORY_CHANNELS = categorySize;
     }
     if (filterSize) {
-      defines2.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
-      defines2.DATAFILTER_DOUBLE = Boolean(fp642);
+      defines.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
+      defines.DATAFILTER_DOUBLE = Boolean(fp642);
     }
     const module2 = fp642 ? dataFilter64 : dataFilter;
     module2.uniformTypes = module2.uniformTypesFromOptions(extension.opts);
-    return { modules: [module2], defines: defines2 };
+    return { modules: [module2], defines };
   }
   initializeState(context, extension) {
     const attributeManager = this.getAttributeManager();
@@ -3394,7 +767,7 @@ var DataFilterExtension = class extends LayerExtension {
       }
     }
     if (attributeManager == null ? void 0 : attributeManager.attributes.filterCategoryValues) {
-      const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() || !deepEqual(props.filterCategories, oldProps.filterCategories, 2);
+      const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() || !(0, import_core3._deepEqual)(props.filterCategories, oldProps.filterCategories, 2);
       if (categoryBitMaskNeedsUpdate) {
         this.setState({ categoryBitMask: null });
       }
@@ -3488,7 +861,7 @@ var DataFilterExtension = class extends LayerExtension {
           const channel = c * (maxCategories / 32) + Math.floor(key / 32);
           categoryBitMask[channel] += Math.pow(2, key % 32);
         } else {
-          log_default.warn(`Exceeded maximum number of categories (${maxCategories})`)();
+          import_core3.log.warn(`Exceeded maximum number of categories (${maxCategories})`)();
         }
       }
     }
@@ -3510,8 +883,12 @@ DataFilterExtension.defaultProps = defaultProps2;
 DataFilterExtension.extensionName = "DataFilterExtension";
 var data_filter_extension_default = DataFilterExtension;
 
+// dist/fp64/fp64-extension.js
+var import_core5 = require("@deck.gl/core");
+
 // dist/fp64/project64.js
-var import_shadertools3 = require("@luma.gl/shadertools");
+var import_shadertools = require("@luma.gl/shadertools");
+var import_core4 = require("@deck.gl/core");
 
 // dist/fp64/project64.glsl.js
 var project64_glsl_default = `const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
@@ -3590,12 +967,12 @@ position, position64xyLow, offset, commonPosition
 `;
 
 // dist/fp64/project64.js
-var { fp64ify, fp64ifyMatrix4 } = import_shadertools3.fp64;
+var { fp64ify, fp64ifyMatrix4 } = import_shadertools.fp64;
 var project64_default = {
   name: "project64",
-  dependencies: [project_default, import_shadertools3.fp64],
+  dependencies: [import_core4.project, import_shadertools.fp64],
   vs: project64_glsl_default,
-  getUniforms: getUniforms3,
+  getUniforms: getUniforms2,
   uniformTypes: {
     scale: "vec2<f32>",
     // Cannot pass as vec2[16], so instead split into 2 mat4x4
@@ -3603,8 +980,8 @@ var project64_default = {
     viewProjectionMatrix64Low: "mat4x4<f32>"
   }
 };
-var getMemoizedUniforms = memoize(calculateUniforms);
-function getUniforms3(opts) {
+var getMemoizedUniforms = (0, import_core4._memoize)(calculateUniforms);
+function getUniforms2(opts) {
   if (opts && "viewport" in opts) {
     const { viewProjectionMatrix, scale } = opts.viewport;
     return getMemoizedUniforms({ viewProjectionMatrix, scale });
@@ -3631,7 +1008,7 @@ function calculateUniforms({ viewProjectionMatrix, scale }) {
 }
 
 // dist/fp64/fp64-extension.js
-var Fp64Extension = class extends LayerExtension {
+var Fp64Extension = class extends import_core5.LayerExtension {
   getShaders() {
     const { coordinateSystem } = this.props;
     if (coordinateSystem !== "lnglat" && coordinateSystem !== "default") {
@@ -3650,7 +1027,8 @@ Fp64Extension.extensionName = "Fp64Extension";
 var fp64_extension_default = Fp64Extension;
 
 // dist/path-style/path-style-extension.js
-var import_core13 = require("@math.gl/core");
+var import_core6 = require("@deck.gl/core");
+var import_core7 = require("@math.gl/core");
 
 // dist/path-style/shaders.glsl.js
 var dashShaders = {
@@ -4060,14 +1438,14 @@ var DASH_UNITS = {
 };
 var PATH_STYLE_ATTRIBUTES = ["instanceDashArrays", "instanceDashOffsets", "instanceOffsets"];
 function dashMetricsProjectionPropsChanged({ props, oldProps }) {
-  return !deepEqual(props.modelMatrix, oldProps.modelMatrix, 2) || props.coordinateSystem !== oldProps.coordinateSystem || !deepEqual(props.coordinateOrigin, oldProps.coordinateOrigin, 1);
+  return !(0, import_core6._deepEqual)(props.modelMatrix, oldProps.modelMatrix, 2) || props.coordinateSystem !== oldProps.coordinateSystem || !(0, import_core6._deepEqual)(props.coordinateOrigin, oldProps.coordinateOrigin, 1);
 }
 function projectRenderedPathPosition(layer, position, projectUniforms) {
   const viewport = layer.context.viewport;
-  if (!(viewport instanceof WebMercatorViewport) || viewport.zoom < 12) {
+  if (!(viewport instanceof import_core6.WebMercatorViewport) || viewport.zoom < 12) {
     return layer.projectPosition(position, { autoOffset: false });
   }
-  const positionWorld = import_core13.vec4.transformMat4([], [position[0], position[1], position[2] || 0, 1], projectUniforms.modelMatrix);
+  const positionWorld = import_core7.vec4.transformMat4([], [position[0], position[1], position[2] || 0, 1], projectUniforms.modelMatrix);
   const coordinateSystem = layer.props.coordinateSystem === "default" ? "lnglat" : layer.props.coordinateSystem;
   if (coordinateSystem === "lnglat") {
     if (Math.abs(positionWorld[1] - projectUniforms.coordinateOrigin[1]) > 0.25) {
@@ -4082,15 +1460,15 @@ function projectRenderedPathPosition(layer, position, projectUniforms) {
         positionWorld[2] * projectUniforms.commonUnitsPerMeter[2]
       ];
     }
-    import_core13.vec3.sub(positionWorld, positionWorld, projectUniforms.coordinateOrigin);
+    import_core7.vec3.sub(positionWorld, positionWorld, projectUniforms.coordinateOrigin);
   } else if (coordinateSystem === "cartesian") {
-    import_core13.vec3.sub(positionWorld, positionWorld, projectUniforms.coordinateOrigin);
+    import_core7.vec3.sub(positionWorld, positionWorld, projectUniforms.coordinateOrigin);
   }
   const deltaLatitude = positionWorld[1];
-  const scale = import_core13.vec3.scaleAndAdd([], projectUniforms.commonUnitsPerWorldUnit, projectUniforms.commonUnitsPerWorldUnit2, deltaLatitude);
-  return import_core13.vec3.multiply([], positionWorld, scale);
+  const scale = import_core7.vec3.scaleAndAdd([], projectUniforms.commonUnitsPerWorldUnit, projectUniforms.commonUnitsPerWorldUnit2, deltaLatitude);
+  return import_core7.vec3.multiply([], positionWorld, scale);
 }
-var PathStyleExtension = class extends LayerExtension {
+var PathStyleExtension = class extends import_core6.LayerExtension {
   constructor({ dash = false, offset = false, dashMode, highPrecisionDash = false } = {}) {
     const resolvedDashMode = dashMode ?? (highPrecisionDash ? "path" : "segment");
     super({
@@ -4189,17 +1567,17 @@ var PathStyleExtension = class extends LayerExtension {
       return { modules: [pathStyle2] };
     }
     let result = {};
-    const defines2 = {};
+    const defines = {};
     if (extension.opts.dash) {
-      result = mergeShaders(result, dashShaders);
-      defines2.DASH_ENABLED = true;
+      result = (0, import_core6._mergeShaders)(result, dashShaders);
+      defines.DASH_ENABLED = true;
       if (extension.opts.dashMode === "path") {
-        defines2.HIGH_PRECISION_DASH = true;
+        defines.HIGH_PRECISION_DASH = true;
       }
     }
     if (extension.opts.offset) {
-      result = mergeShaders(result, offsetShaders);
-      defines2.PATH_STYLE_OFFSET = true;
+      result = (0, import_core6._mergeShaders)(result, offsetShaders);
+      defines.PATH_STYLE_OFFSET = true;
     }
     const { inject: inject6 } = result;
     const pathStyle = {
@@ -4215,7 +1593,7 @@ var PathStyleExtension = class extends LayerExtension {
     }
     return {
       modules: [pathStyle],
-      defines: defines2
+      defines
     };
   }
   initializeState(context, extension) {
@@ -4286,7 +1664,7 @@ var PathStyleExtension = class extends LayerExtension {
       binaryOffset = (binaryPath == null ? void 0 : binaryPath.offset) ? binaryPath.offset / bytesPerElement : 0;
     }
     const sourcePosition = new Array(3);
-    const projectUniforms = project_default.getUniforms({
+    const projectUniforms = import_core6.project.getUniforms({
       viewport: this.context.viewport,
       modelMatrix: this.props.modelMatrix,
       coordinateSystem: this.props.coordinateSystem,
@@ -4321,7 +1699,7 @@ var PathStyleExtension = class extends LayerExtension {
         output[outputIndex] = phase;
         const start = segmentIndex === previousSegment + 1 && previousEnd ? previousEnd : projectRenderedPathPosition(this, readPosition(segmentIndex), projectUniforms);
         const end = projectRenderedPathPosition(this, readPosition(segmentIndex + 1), projectUniforms);
-        phase += import_core13.vec3.dist(start, end);
+        phase += import_core7.vec3.dist(start, end);
         previousSegment = segmentIndex;
         previousEnd = end;
       }
@@ -4350,7 +1728,7 @@ var PathStyleExtension = class extends LayerExtension {
       p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
       p = this.projectPosition(p, { autoOffset: false });
       if (i > 0) {
-        result[i] = result[i - 1] + import_core13.vec3.dist(prevP, p);
+        result[i] = result[i - 1] + import_core7.vec3.dist(prevP, p);
       }
       prevP = p;
     }
@@ -4362,7 +1740,11 @@ PathStyleExtension.defaultProps = defaultProps3;
 PathStyleExtension.extensionName = "PathStyleExtension";
 var path_style_extension_default = PathStyleExtension;
 
+// dist/fill-style/fill-style-extension.js
+var import_core9 = require("@deck.gl/core");
+
 // dist/fill-style/shader-module.js
+var import_core8 = require("@deck.gl/core");
 var FILL_UV_SCALE = 512 / 4e7;
 function getPatternUnitScale(sizeUnits, viewport) {
   switch (sizeUnits) {
@@ -4407,7 +1789,7 @@ flat out vec4 fill_patternParams0;
 flat out vec4 fill_patternParams1;
 `
 );
-var vs4 = `
+var vs3 = `
 ${uniformBlock3}
 ${patternVs}
 `;
@@ -4550,7 +1932,7 @@ vec4 fill_blendOverBackground(vec4 pattern, vec4 background) {
 }
 `
 );
-var fs4 = `
+var fs3 = `
 ${uniformBlock3}
 ${patternFs}
 `;
@@ -4627,7 +2009,7 @@ function getPatternUniforms(opts) {
   }
   if ("project" in opts) {
     const { fillPatternMask = true, fillPatternEnabled = true, fillPatternSizeUnits = "meters", fillPatternCommonFrame = null, procedural = false } = opts;
-    const projectUniforms = project_default.getUniforms(opts.project);
+    const projectUniforms = import_core8.project.getUniforms(opts.project);
     const { commonOrigin: coordinateOriginCommon } = projectUniforms;
     const unitScale = getPatternUnitScale(fillPatternSizeUnits, opts.project.viewport);
     const origin = [coordinateOriginCommon[0], coordinateOriginCommon[1]];
@@ -4636,7 +2018,7 @@ function getPatternUniforms(opts) {
       origin[1] %= unitScale * fillPatternCommonFrame[1];
     }
     uniforms.uvCoordinateOrigin = origin;
-    uniforms.uvCoordinateOrigin64Low = [fp64LowPart(origin[0]), fp64LowPart(origin[1])];
+    uniforms.uvCoordinateOrigin64Low = [(0, import_core8.fp64LowPart)(origin[0]), (0, import_core8.fp64LowPart)(origin[1])];
     uniforms.patternUnitScale = unitScale;
     uniforms.patternMask = fillPatternMask;
     uniforms.patternEnabled = fillPatternEnabled;
@@ -4647,10 +2029,10 @@ function getPatternUniforms(opts) {
 }
 var patternShaders = {
   name: "fill",
-  vs: vs4,
-  fs: fs4,
+  vs: vs3,
+  fs: fs3,
   inject: inject3,
-  dependencies: [project_default],
+  dependencies: [import_core8.project],
   getUniforms: getPatternUniforms,
   uniformTypes: {
     patternTextureSize: "vec2<f32>",
@@ -4685,7 +2067,7 @@ var PROCEDURAL_PATTERN_OFFSETS = {
   elementCount: 6
 };
 var COMPONENTS_PER_PATTERN = PROCEDURAL_PATTERN_COMPONENTS_PER_TEXEL * PROCEDURAL_PATTERN_TEXELS_PER_PATTERN;
-var DEGREES_TO_RADIANS3 = Math.PI / 180;
+var DEGREES_TO_RADIANS = Math.PI / 180;
 var DEFAULT_SIZE = 1;
 var DEFAULT_GAP = 1;
 var DEFAULT_HATCH_ANGLE = 0;
@@ -4717,7 +2099,7 @@ function packProceduralPatterns(mapping) {
         data[offset + PROCEDURAL_PATTERN_OFFSETS.size] = strokeWidth;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap0] = gaps[0];
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap1] = gaps[1];
-        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angle * DEGREES_TO_RADIANS3;
+        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angle * DEGREES_TO_RADIANS;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.elementCount] = Array.isArray(gap) ? 2 : 1;
         break;
       }
@@ -4736,8 +2118,8 @@ function packProceduralPatterns(mapping) {
         data[offset + PROCEDURAL_PATTERN_OFFSETS.size] = strokeWidth;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap0] = gap;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap1] = gap;
-        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angles[0] * DEGREES_TO_RADIANS3;
-        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle1] = angles[1] * DEGREES_TO_RADIANS3;
+        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angles[0] * DEGREES_TO_RADIANS;
+        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle1] = angles[1] * DEGREES_TO_RADIANS;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.elementCount] = 2;
         break;
       }
@@ -4754,8 +2136,8 @@ function packProceduralPatterns(mapping) {
         data[offset + PROCEDURAL_PATTERN_OFFSETS.size] = radius;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap0] = gap;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.gap1] = gap;
-        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angle * DEGREES_TO_RADIANS3;
-        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle1] = skew * DEGREES_TO_RADIANS3;
+        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle0] = angle * DEGREES_TO_RADIANS;
+        data[offset + PROCEDURAL_PATTERN_OFFSETS.angle1] = skew * DEGREES_TO_RADIANS;
         data[offset + PROCEDURAL_PATTERN_OFFSETS.elementCount] = 2;
         break;
       }
@@ -4817,7 +2199,7 @@ var defaultProps4 = {
   getFillPatternOffset: { type: "accessor", value: [0, 0] },
   getFillPatternBackgroundColor: { type: "accessor", value: [0, 0, 0, 0] }
 };
-var FillStyleExtension = class extends LayerExtension {
+var FillStyleExtension = class extends import_core9.LayerExtension {
   constructor({ pattern = false, proceduralPattern = false } = {}) {
     super({ pattern: pattern || proceduralPattern, proceduralPattern });
   }
@@ -4961,6 +2343,7 @@ FillStyleExtension.extensionName = "FillStyleExtension";
 var fill_style_extension_default = FillStyleExtension;
 
 // dist/clip/clip-extension.js
+var import_core10 = require("@deck.gl/core");
 var defaultProps5 = {
   clipBounds: [0, 0, 1, 1],
   clipByInstance: void 0
@@ -5043,7 +2426,7 @@ in vec2 clip_commonPosition;
 `
   )
 };
-var ClipExtension = class extends LayerExtension {
+var ClipExtension = class extends import_core10.LayerExtension {
   getShaders() {
     let clipByInstance = "instancePositions" in this.getAttributeManager().attributes;
     if (this.props.clipByInstance !== void 0) {
@@ -5088,8 +2471,12 @@ ClipExtension.defaultProps = defaultProps5;
 ClipExtension.extensionName = "ClipExtension";
 var clip_extension_default = ClipExtension;
 
+// dist/collision-filter/collision-filter-extension.js
+var import_core15 = require("@deck.gl/core");
+
 // dist/collision-filter/shader-module.js
-var vs5 = (
+var import_core11 = require("@deck.gl/core");
+var vs4 = (
   /* glsl */
   `
 in float collisionPriorities;
@@ -5187,8 +2574,8 @@ var getCollisionUniforms = (opts) => {
 };
 var shader_module_default2 = {
   name: "collision",
-  dependencies: [project_default],
-  vs: vs5,
+  dependencies: [import_core11.project],
+  vs: vs4,
   inject: inject4,
   getUniforms: getCollisionUniforms,
   uniformTypes: {
@@ -5198,10 +2585,12 @@ var shader_module_default2 = {
 };
 
 // dist/collision-filter/collision-filter-effect.js
-var import_core19 = require("@math.gl/core");
+var import_core13 = require("@math.gl/core");
+var import_core14 = require("@deck.gl/core");
 
 // dist/collision-filter/collision-filter-pass.js
-var CollisionFilterPass = class extends LayersPass {
+var import_core12 = require("@deck.gl/core");
+var CollisionFilterPass = class extends import_core12._LayersPass {
   renderCollisionMap(target, options) {
     const padding = 1;
     const clearColor = [0, 0, 0, 0];
@@ -5292,8 +2681,8 @@ var CollisionFilterEffect = class {
     }
     const needsRender = viewportChanged || // If render info is new
     renderInfo === oldRenderInfo || // If sublayers have changed
-    !deepEqual(oldRenderInfo.layers, renderInfo.layers, 1) || // If a sublayer's bounds have been updated
-    renderInfo.layerBounds.some((b, i) => !(0, import_core19.equals)(b, oldRenderInfo.layerBounds[i])) || // If a sublayer's isLoaded state has been updated
+    !(0, import_core14._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || // If a sublayer's bounds have been updated
+    renderInfo.layerBounds.some((b, i) => !(0, import_core13.equals)(b, oldRenderInfo.layerBounds[i])) || // If a sublayer's isLoaded state has been updated
     renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || // Some prop is in transition
     renderInfo.layers.some((layer) => layer.props.transitions);
     this.channels[collisionGroup] = renderInfo;
@@ -5425,7 +2814,7 @@ var defaultProps6 = {
   collisionGroup: { type: "string", value: "default" },
   collisionTestProps: {}
 };
-var CollisionFilterExtension = class extends LayerExtension {
+var CollisionFilterExtension = class extends import_core15.LayerExtension {
   getShaders() {
     return { modules: [shader_module_default2] };
   }
@@ -5459,7 +2848,11 @@ CollisionFilterExtension.defaultProps = defaultProps6;
 CollisionFilterExtension.extensionName = "CollisionFilterExtension";
 var collision_filter_extension_default = CollisionFilterExtension;
 
+// dist/mask/mask-extension.js
+var import_core21 = require("@deck.gl/core");
+
 // dist/mask/shader-module.js
+var import_core16 = require("@deck.gl/core");
 var uniformBlock4 = (
   /* glsl */
   `layout(std140) uniform maskUniforms {
@@ -5479,7 +2872,7 @@ vec2 mask_getCoords(vec4 position) {
 }
 `
 );
-var vs6 = `
+var vs5 = `
 ${uniformBlock4}
 ${vertex3}
 `;
@@ -5512,7 +2905,7 @@ bool mask_isInBounds(vec2 texCoords) {
 }
 `
 );
-var fs5 = `
+var fs4 = `
 ${uniformBlock4}
 ${fragment3}
 `;
@@ -5566,9 +2959,9 @@ var getMaskUniforms = (opts) => {
 };
 var shader_module_default3 = {
   name: "mask",
-  dependencies: [project_default],
-  vs: vs6,
-  fs: fs5,
+  dependencies: [import_core16.project],
+  vs: vs5,
+  fs: fs4,
   inject: inject5,
   getUniforms: getMaskUniforms,
   uniformTypes: {
@@ -5581,9 +2974,11 @@ var shader_module_default3 = {
 };
 
 // dist/mask/mask-effect.js
-var import_core26 = require("@math.gl/core");
+var import_core19 = require("@deck.gl/core");
+var import_core20 = require("@math.gl/core");
 
 // dist/mask/mask-pass.js
+var import_core17 = require("@deck.gl/core");
 var MASK_BLENDING = {
   blendColorOperation: "subtract",
   blendColorSrcFactor: "zero",
@@ -5592,7 +2987,7 @@ var MASK_BLENDING = {
   blendAlphaSrcFactor: "zero",
   blendAlphaDstFactor: "one"
 };
-var MaskPass = class extends LayersPass {
+var MaskPass = class extends import_core17._LayersPass {
   constructor(device, props) {
     super(device, props);
     const { mapSize = 2048 } = props;
@@ -5637,7 +3032,8 @@ var MaskPass = class extends LayersPass {
 };
 
 // dist/utils/projection-utils.js
-var MERCATOR_REFERENCE_VIEWPORT = new WebMercatorViewport({
+var import_core18 = require("@deck.gl/core");
+var MERCATOR_REFERENCE_VIEWPORT = new import_core18.WebMercatorViewport({
   width: 1,
   height: 1,
   longitude: 0,
@@ -5699,7 +3095,7 @@ function makeViewport(opts) {
       zoom += Math.log2(r);
     }
   }
-  return isGeospatial ? new WebMercatorViewport({
+  return isGeospatial ? new import_core18.WebMercatorViewport({
     id: viewport.id,
     x: border,
     y: border,
@@ -5709,7 +3105,7 @@ function makeViewport(opts) {
     latitude: centerWorld[1],
     zoom,
     orthographic: true
-  }) : new OrthographicViewport({
+  }) : new import_core18.OrthographicViewport({
     id: viewport.id,
     x: border,
     y: border,
@@ -5802,7 +3198,7 @@ var MaskEffect = class {
     const viewport = viewports[0];
     const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
     if (viewport.resolution !== void 0) {
-      log_default.warn("MaskExtension is not supported in GlobeView")();
+      import_core19.log.warn("MaskExtension is not supported in GlobeView")();
       return { didRender };
     }
     for (const maskId in channelMap) {
@@ -5845,7 +3241,7 @@ var MaskEffect = class {
       this.lastViewport = viewport;
       const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
       channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
-      if (maskChanged || !(0, import_core26.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
+      if (maskChanged || !(0, import_core20.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
         const { maskPass, maskMap } = this;
         const maskViewport = layerBounds && makeViewport({
           bounds: channelInfo.bounds,
@@ -5896,7 +3292,7 @@ var MaskEffect = class {
       let channelInfo = channelMap[id];
       if (!channelInfo) {
         if (++channelCount > 4) {
-          log_default.warn("Too many mask layers. The max supported is 4")();
+          import_core19.log.warn("Too many mask layers. The max supported is 4")();
           continue;
         }
         channelInfo = {
@@ -5957,7 +3353,7 @@ var defaultProps7 = {
   maskByInstance: void 0,
   maskInverted: false
 };
-var MaskExtension = class extends LayerExtension {
+var MaskExtension = class extends import_core21.LayerExtension {
   initializeState() {
     var _a;
     (_a = this.context.deck) == null ? void 0 : _a._addDefaultEffect(new MaskEffect());
@@ -5985,8 +3381,8 @@ var MaskExtension = class extends LayerExtension {
       maskProps.enabled = true;
       maskProps.channel = index;
       maskProps.inverted = maskInverted;
-      if (fromCoordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
-        fromCoordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+      if (fromCoordinateSystem === import_core21.COORDINATE_SYSTEM.DEFAULT) {
+        fromCoordinateSystem = viewport.isGeospatial ? import_core21.COORDINATE_SYSTEM.LNGLAT : import_core21.COORDINATE_SYSTEM.CARTESIAN;
       }
       const opts = { modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem };
       const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
@@ -5994,7 +3390,7 @@ var MaskExtension = class extends LayerExtension {
       maskProps.bounds = [bl[0], bl[1], tr[0], tr[1]];
     } else {
       if (maskId) {
-        log_default.warn(`Could not find a mask layer with id: ${maskId}`)();
+        import_core21.log.warn(`Could not find a mask layer with id: ${maskId}`)();
       }
       maskProps.enabled = false;
     }
@@ -6005,7 +3401,14 @@ MaskExtension.defaultProps = defaultProps7;
 MaskExtension.extensionName = "MaskExtension";
 var mask_extension_default = MaskExtension;
 
+// dist/terrain/terrain-extension.js
+var import_core28 = require("@deck.gl/core");
+
+// dist/terrain/terrain-effect.js
+var import_core27 = require("@deck.gl/core");
+
 // dist/terrain/shader-module.js
+var import_core22 = require("@deck.gl/core");
 var TERRAIN_MODE = {
   NONE: 0,
   /** A terrain layer rendering encoded ground elevation into the height map */
@@ -6034,7 +3437,7 @@ uniform sampler2D terrain_map;
 );
 var terrainModule = {
   name: "terrain",
-  dependencies: [project_default],
+  dependencies: [import_core22.project],
   vs: `${uniformBlock5}
 out vec3 commonPos;
 // In globe mode, absolute Mercator position for terrain FBO UV lookups
@@ -6132,7 +3535,7 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
     }
     if ("terrainSkipRender" in opts || "drawToTerrainHeightMap" in opts) {
       const { drawToTerrainHeightMap, heightMap, heightMapBounds, dummyHeightMap, terrainCover, useTerrainHeightMap, terrainSkipRender } = opts;
-      const projectUniforms = project_default.getUniforms(opts.project);
+      const projectUniforms = import_core22.project.getUniforms(opts.project);
       const { commonOrigin } = projectUniforms;
       let mode = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       let sampler = dummyHeightMap;
@@ -6182,7 +3585,11 @@ if ((terrain.mode == TERRAIN_MODE_USE_COVER) || (terrain.mode == TERRAIN_MODE_US
   }
 };
 
+// dist/terrain/terrain-cover.js
+var import_core23 = require("@deck.gl/core");
+
 // dist/terrain/utils.js
+var import_constants = require("@luma.gl/webgl/constants");
 function createRenderTarget(device, opts) {
   return device.createFramebuffer({
     id: opts.id,
@@ -6296,7 +3703,7 @@ var TerrainCover = class {
     } else {
       const oldZoom = (_a = this.renderViewport) == null ? void 0 : _a.zoom;
       shouldRedraw = shouldRedraw || newZoom !== oldZoom;
-      const newBounds = viewport instanceof GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
+      const newBounds = viewport instanceof import_core23._GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
       const oldBounds = this.bounds;
       shouldRedraw = shouldRedraw || !oldBounds || newBounds.some((x, i) => x !== oldBounds[i]);
       this.bounds = newBounds;
@@ -6373,6 +3780,7 @@ function intersect(b1, b2) {
 }
 
 // dist/terrain/terrain-pass.js
+var import_core24 = require("@deck.gl/core");
 var TERRAIN_BLENDING = {
   blendColorOperation: "max",
   blendColorSrcFactor: "one",
@@ -6381,7 +3789,7 @@ var TERRAIN_BLENDING = {
   blendAlphaSrcFactor: "one",
   blendAlphaDstFactor: "one"
 };
-var TerrainPass = class extends LayersPass {
+var TerrainPass = class extends import_core24._LayersPass {
   getRenderableLayers(viewport, opts) {
     const { layers } = opts;
     const result = [];
@@ -6446,7 +3854,8 @@ var TerrainPass = class extends LayersPass {
 };
 
 // dist/terrain/terrain-picking-pass.js
-var TerrainPickingPass = class extends PickLayersPass {
+var import_core25 = require("@deck.gl/core");
+var TerrainPickingPass = class extends import_core25._PickLayersPass {
   constructor() {
     super(...arguments);
     this.drawParameters = {};
@@ -6517,6 +3926,7 @@ var TerrainPickingPass = class extends PickLayersPass {
 };
 
 // dist/terrain/height-map-builder.js
+var import_core26 = require("@deck.gl/core");
 var MAP_MAX_SIZE = 2048;
 var HeightMapBuilder = class {
   static isSupported(device) {
@@ -6563,7 +3973,7 @@ var HeightMapBuilder = class {
     if (!this.layersBoundsCommon) {
       this.renderViewport = null;
     } else if (layersChanged || viewportChanged) {
-      const bounds = viewport instanceof GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
+      const bounds = viewport instanceof import_core26._GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
       if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
         this.renderViewport = null;
         return false;
@@ -6621,7 +4031,7 @@ var TerrainEffect = class {
     if (HeightMapBuilder.isSupported(device)) {
       this.heightMap = new HeightMapBuilder(device);
     } else {
-      log_default.warn("Terrain offset mode is not supported by this browser")();
+      import_core27.log.warn("Terrain offset mode is not supported by this browser")();
     }
     deck._addDefaultShaderModule(terrainModule);
   }
@@ -6789,7 +4199,7 @@ var TerrainEffect = class {
 var defaultProps8 = {
   terrainDrawMode: void 0
 };
-var TerrainExtension = class extends LayerExtension {
+var TerrainExtension = class extends import_core28.LayerExtension {
   getShaders() {
     return {
       modules: [terrainModule]