@deck.gl/extensions 9.4.0-alpha.1 → 9.4.0-beta.1

package/dist/index.cjs

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   BrushingExtension: () => brushing_extension_default,
   ClipExtension: () => clip_extension_default,
   CollisionFilterExtension: () => collision_filter_extension_default,
@@ -31,13 +31,2541 @@ __export(dist_exports, {
   _TerrainExtension: () => terrain_extension_default,
   project64: () => project64_default
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 
-// dist/brushing/brushing-extension.js
-var import_core2 = require("@deck.gl/core");
+// ../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(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 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 width and height are identical, and if
+  // their 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 && (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;
+  }
+  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/viewports/globe-viewport.ts
+var import_core5 = require("@math.gl/core");
+var import_web_mercator3 = require("@math.gl/web-mercator");
+var import_core6 = require("@math.gl/core");
+var import_web_mercator4 = require("@math.gl/web-mercator");
+var DEGREES_TO_RADIANS2 = Math.PI / 180;
+var RADIANS_TO_DEGREES = 180 / Math.PI;
+var EARTH_RADIUS = 6370972;
+var GLOBE_RADIUS = 256;
+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_mercator4.MAX_LATITUDE), -import_web_mercator4.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])
+    ];
+  }
+  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 coord0 = transformVector(pixelUnprojectionMatrix, [x, y2, -1, 1]);
+      const coord1 = transformVector(pixelUnprojectionMatrix, [x, y2, 1, 1]);
+      const lt = ((targetZ || 0) / EARTH_RADIUS + 1) * GLOBE_RADIUS;
+      const lSqr = import_core6.vec3.sqrLen(import_core6.vec3.sub([], coord0, coord1));
+      const l0Sqr = import_core6.vec3.sqrLen(coord0);
+      const l1Sqr = import_core6.vec3.sqrLen(coord1);
+      const sSqr = (4 * l0Sqr * l1Sqr - (lSqr - l0Sqr - l1Sqr) ** 2) / 16;
+      const dSqr = 4 * sSqr / lSqr;
+      const r0 = Math.sqrt(l0Sqr - dSqr);
+      const dr = Math.sqrt(Math.max(0, lt * lt - dSqr));
+      const t = (r0 - dr) / Math.sqrt(lSqr);
+      coord = import_core6.vec3.lerp([], coord0, coord1, t);
+    }
+    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_core6.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 using delta-based movement
+   * @param coords - the geographic coordinates where the pan started
+   * @param pixel - the current screen position
+   * @param startPixel - the screen position where the pan started
+   * @returns updated viewport options with new longitude/latitude
+   */
+  panByPosition([startLng, startLat, startZoom], pixel, startPixel) {
+    const scale = Math.pow(2, this.zoom - zoomAdjust(this.latitude));
+    const rotationSpeed = 0.25 / scale;
+    const longitude = startLng + rotationSpeed * (startPixel[0] - pixel[0]);
+    let latitude = startLat - rotationSpeed * (startPixel[1] - pixel[1]);
+    latitude = Math.max(Math.min(latitude, 90), -90);
+    const out = { longitude, latitude, zoom: startZoom - zoomAdjust(startLat) };
+    out.zoom += zoomAdjust(out.latitude);
+    return out;
+  }
+};
+GlobeViewport.displayName = "GlobeViewport";
+function zoomAdjust(latitude, clampToPoles) {
+  if (clampToPoles) {
+    latitude = Math.max(Math.min(latitude, import_web_mercator4.MAX_LATITUDE), -import_web_mercator4.MAX_LATITUDE);
+  }
+  const scaleAdjust = Math.PI * Math.cos(latitude * Math.PI / 180);
+  return Math.log2(scaleAdjust);
+}
+function transformVector(matrix, vector) {
+  const result = import_core6.vec4.transformMat4([], vector, matrix);
+  import_core6.vec4.scale(result, result, 1 / result[3]);
+  return result;
+}
+
+// ../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/orthographic-viewport.ts
+var import_core7 = require("@math.gl/core");
+var import_web_mercator5 = require("@math.gl/web-mercator");
+var viewMatrix = new import_core7.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_core7.clamp)((l + width - r) / 2, 0, width) - width / 2;
+    const offsetY = (0, import_core7.clamp)((t + height - b) / 2, 0, height) - height / 2;
+    left -= offsetX;
+    right -= offsetX;
+    bottom += offsetY;
+    top += offsetY;
+  }
+  return new import_core7.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_mercator5.pixelsToWorld)(pixel, this.pixelUnprojectionMatrix);
+    const toLocation = this.projectFlat(coords);
+    const translate = import_core7.vec2.add([], toLocation, import_core7.vec2.negate([], fromLocation));
+    const newCenter = import_core7.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/shader-module.js
-var import_core = require("@deck.gl/core");
 var uniformBlock = (
   /* glsl */
   `layout(std140) uniform brushingUniforms {
@@ -75,7 +2603,7 @@ var vertex = (
   }
 `
 );
-var vs = `
+var vs2 = `
 ${uniformBlock}
 ${vertex}
 `;
@@ -85,7 +2613,7 @@ var fragment = (
   in float brushing_isVisible;
 `
 );
-var fs = `
+var fs2 = `
 ${uniformBlock}
 ${fragment}
 `;
@@ -128,9 +2656,9 @@ var inject = {
 };
 var shader_module_default = {
   name: "brushing",
-  dependencies: [import_core.project],
-  vs,
-  fs,
+  dependencies: [project_default],
+  vs: vs2,
+  fs: fs2,
   inject,
   getUniforms: (opts) => {
     if (!opts || !("viewport" in opts)) {
@@ -159,7 +2687,7 @@ var defaultProps = {
   brushingEnabled: true,
   brushingRadius: 1e4
 };
-var BrushingExtension = class extends import_core2.LayerExtension {
+var BrushingExtension = class extends LayerExtension {
   getShaders() {
     return {
       modules: [shader_module_default]
@@ -214,9 +2742,6 @@ 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 */
@@ -400,7 +2925,7 @@ float dataFilter_reduceValue(vec4 value) {
 #endif
 `
 );
-var vs2 = `
+var vs3 = `
 ${uniformBlock2}
 ${vertex2}
 `;
@@ -410,11 +2935,11 @@ var fragment2 = (
 in float dataFilter_value;
 `
 );
-var fs2 = `
+var fs3 = `
 ${uniformBlock2}
 ${fragment2}
 `;
-function getUniforms(opts) {
+function getUniforms2(opts) {
   if (!opts || !("extensions" in opts)) {
     return {};
   }
@@ -449,7 +2974,7 @@ function getUniforms64(opts) {
   if (!opts || !("extensions" in opts)) {
     return {};
   }
-  const uniforms = getUniforms(opts);
+  const uniforms = getUniforms2(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]);
@@ -527,16 +3052,16 @@ function uniformTypesFromOptions(opts) {
 }
 var dataFilter = {
   name: "dataFilter",
-  vs: vs2,
-  fs: fs2,
+  vs: vs3,
+  fs: fs3,
   inject: inject2,
-  getUniforms,
+  getUniforms: getUniforms2,
   uniformTypesFromOptions
 };
 var dataFilter64 = {
   name: "dataFilter",
-  vs: vs2,
-  fs: fs2,
+  vs: vs3,
+  fs: fs3,
   inject: inject2,
   getUniforms: getUniforms64,
   uniformTypesFromOptions
@@ -681,24 +3206,24 @@ var DATA_TYPE_FROM_SIZE = {
   3: "vec3",
   4: "vec4"
 };
-var DataFilterExtension = class extends import_core3.LayerExtension {
+var DataFilterExtension = class extends LayerExtension {
   constructor(opts = {}) {
     super({ ...defaultOptions, ...opts });
   }
   getShaders(extension) {
     const { categorySize, filterSize, fp64: fp642 } = extension.opts;
-    const defines = {};
+    const defines2 = {};
     if (categorySize) {
-      defines.DATACATEGORY_TYPE = CATEGORY_TYPE_FROM_SIZE[categorySize];
-      defines.DATACATEGORY_CHANNELS = categorySize;
+      defines2.DATACATEGORY_TYPE = CATEGORY_TYPE_FROM_SIZE[categorySize];
+      defines2.DATACATEGORY_CHANNELS = categorySize;
     }
     if (filterSize) {
-      defines.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
-      defines.DATAFILTER_DOUBLE = Boolean(fp642);
+      defines2.DATAFILTER_TYPE = DATA_TYPE_FROM_SIZE[filterSize];
+      defines2.DATAFILTER_DOUBLE = Boolean(fp642);
     }
     const module2 = fp642 ? dataFilter64 : dataFilter;
     module2.uniformTypes = module2.uniformTypesFromOptions(extension.opts);
-    return { modules: [module2], defines };
+    return { modules: [module2], defines: defines2 };
   }
   initializeState(context, extension) {
     const attributeManager = this.getAttributeManager();
@@ -768,7 +3293,7 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
       }
     }
     if (attributeManager == null ? void 0 : attributeManager.attributes.filterCategoryValues) {
-      const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() || !(0, import_core3._deepEqual)(props.filterCategories, oldProps.filterCategories, 2);
+      const categoryBitMaskNeedsUpdate = attributeManager.attributes.filterCategoryValues.needsUpdate() || !deepEqual(props.filterCategories, oldProps.filterCategories, 2);
       if (categoryBitMaskNeedsUpdate) {
         this.setState({ categoryBitMask: null });
       }
@@ -862,7 +3387,7 @@ var DataFilterExtension = class extends import_core3.LayerExtension {
           const channel = c * (maxCategories / 32) + Math.floor(key / 32);
           categoryBitMask[channel] += Math.pow(2, key % 32);
         } else {
-          import_core3.log.warn(`Exceeded maximum number of categories (${maxCategories})`)();
+          log_default.warn(`Exceeded maximum number of categories (${maxCategories})`)();
         }
       }
     }
@@ -884,12 +3409,8 @@ 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_shadertools = require("@luma.gl/shadertools");
-var import_core4 = require("@deck.gl/core");
+var import_shadertools3 = require("@luma.gl/shadertools");
 
 // dist/fp64/project64.glsl.js
 var project64_glsl_default = `const vec2 WORLD_SCALE_FP64 = vec2(81.4873275756836, 0.0000032873668232014097);
@@ -968,12 +3489,12 @@ position, position64xyLow, offset, commonPosition
 `;
 
 // dist/fp64/project64.js
-var { fp64ify, fp64ifyMatrix4 } = import_shadertools.fp64;
+var { fp64ify, fp64ifyMatrix4 } = import_shadertools3.fp64;
 var project64_default = {
   name: "project64",
-  dependencies: [import_core4.project, import_shadertools.fp64],
+  dependencies: [project_default, import_shadertools3.fp64],
   vs: project64_glsl_default,
-  getUniforms: getUniforms2,
+  getUniforms: getUniforms3,
   uniformTypes: {
     scale: "vec2<f32>",
     // Cannot pass as vec2[16], so instead split into 2 mat4x4
@@ -981,8 +3502,8 @@ var project64_default = {
     viewProjectionMatrix64Low: "mat4x4<f32>"
   }
 };
-var getMemoizedUniforms = (0, import_core4._memoize)(calculateUniforms);
-function getUniforms2(opts) {
+var getMemoizedUniforms = memoize(calculateUniforms);
+function getUniforms3(opts) {
   if (opts && "viewport" in opts) {
     const { viewProjectionMatrix, scale } = opts.viewport;
     return getMemoizedUniforms({ viewProjectionMatrix, scale });
@@ -1009,7 +3530,7 @@ function calculateUniforms({ viewProjectionMatrix, scale }) {
 }
 
 // dist/fp64/fp64-extension.js
-var Fp64Extension = class extends import_core5.LayerExtension {
+var Fp64Extension = class extends LayerExtension {
   getShaders() {
     const { coordinateSystem } = this.props;
     if (coordinateSystem !== "lnglat" && coordinateSystem !== "default") {
@@ -1028,8 +3549,7 @@ Fp64Extension.extensionName = "Fp64Extension";
 var fp64_extension_default = Fp64Extension;
 
 // dist/path-style/path-style-extension.js
-var import_core6 = require("@deck.gl/core");
-var import_core7 = require("@math.gl/core");
+var import_core14 = require("@math.gl/core");
 
 // dist/path-style/shaders.glsl.js
 var dashShaders = {
@@ -1315,7 +3835,7 @@ var defaultProps3 = {
   dashJustified: false,
   dashGapPickable: false
 };
-var PathStyleExtension = class extends import_core6.LayerExtension {
+var PathStyleExtension = class extends LayerExtension {
   constructor({ dash = false, offset = false, highPrecisionDash = false } = {}) {
     super({ dash: dash || highPrecisionDash, offset, highPrecisionDash });
   }
@@ -1355,15 +3875,15 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
       return { modules: [pathStyle2] };
     }
     let result = {};
-    const defines = {};
+    const defines2 = {};
     if (extension.opts.dash) {
-      result = (0, import_core6._mergeShaders)(result, dashShaders);
+      result = mergeShaders(result, dashShaders);
       if (extension.opts.highPrecisionDash) {
-        defines.HIGH_PRECISION_DASH = true;
+        defines2.HIGH_PRECISION_DASH = true;
       }
     }
     if (extension.opts.offset) {
-      result = (0, import_core6._mergeShaders)(result, offsetShaders);
+      result = mergeShaders(result, offsetShaders);
     }
     const { inject: inject6 } = result;
     const pathStyle = {
@@ -1376,7 +3896,7 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
     };
     return {
       modules: [pathStyle],
-      defines
+      defines: defines2
     };
   }
   initializeState(context, extension) {
@@ -1434,7 +3954,7 @@ var PathStyleExtension = class extends import_core6.LayerExtension {
       p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
       p = this.projectPosition(p);
       if (i > 0) {
-        result[i] = result[i - 1] + import_core7.vec3.dist(prevP, p);
+        result[i] = result[i - 1] + import_core14.vec3.dist(prevP, p);
       }
       prevP = p;
     }
@@ -1446,11 +3966,7 @@ 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 uniformBlock3 = (
   /* glsl */
   `layout(std140) uniform fillUniforms {
@@ -1474,7 +3990,7 @@ out vec4 fill_patternBounds;
 out vec4 fill_patternPlacement;
 `
 );
-var vs3 = `
+var vs4 = `
 ${uniformBlock3}
 ${patternVs}
 `;
@@ -1490,7 +4006,7 @@ in vec2 fill_uv;
 const float FILL_UV_SCALE = 512.0 / 40000000.0;
 `
 );
-var fs3 = `
+var fs4 = `
 ${uniformBlock3}
 ${patternFs}
 `;
@@ -1542,11 +4058,11 @@ function getPatternUniforms(opts) {
   }
   if ("project" in opts) {
     const { fillPatternMask = true, fillPatternEnabled = true } = opts;
-    const projectUniforms = import_core8.project.getUniforms(opts.project);
+    const projectUniforms = project_default.getUniforms(opts.project);
     const { commonOrigin: coordinateOriginCommon } = projectUniforms;
     const coordinateOriginCommon64Low = [
-      (0, import_core8.fp64LowPart)(coordinateOriginCommon[0]),
-      (0, import_core8.fp64LowPart)(coordinateOriginCommon[1])
+      fp64LowPart(coordinateOriginCommon[0]),
+      fp64LowPart(coordinateOriginCommon[1])
     ];
     uniforms.uvCoordinateOrigin = coordinateOriginCommon.slice(0, 2);
     uniforms.uvCoordinateOrigin64Low = coordinateOriginCommon64Low;
@@ -1557,10 +4073,10 @@ function getPatternUniforms(opts) {
 }
 var patternShaders = {
   name: "fill",
-  vs: vs3,
-  fs: fs3,
+  vs: vs4,
+  fs: fs4,
   inject: inject3,
-  dependencies: [import_core8.project],
+  dependencies: [project_default],
   getUniforms: getPatternUniforms,
   uniformTypes: {
     patternTextureSize: "vec2<f32>",
@@ -1586,7 +4102,7 @@ var defaultProps4 = {
   getFillPatternScale: { type: "accessor", value: 1 },
   getFillPatternOffset: { type: "accessor", value: [0, 0] }
 };
-var FillStyleExtension = class extends import_core9.LayerExtension {
+var FillStyleExtension = class extends LayerExtension {
   constructor({ pattern = false } = {}) {
     super({ pattern });
   }
@@ -1671,7 +4187,6 @@ 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
@@ -1754,13 +4269,16 @@ in vec2 clip_commonPosition;
 `
   )
 };
-var ClipExtension = class extends import_core10.LayerExtension {
+var ClipExtension = class extends LayerExtension {
   getShaders() {
     let clipByInstance = "instancePositions" in this.getAttributeManager().attributes;
     if (this.props.clipByInstance !== void 0) {
       clipByInstance = Boolean(this.props.clipByInstance);
     }
     this.state.clipByInstance = clipByInstance;
+    if (this.context.device.type === "webgpu") {
+      return {};
+    }
     return clipByInstance ? {
       modules: [shaderModuleVs],
       inject: injectionVs
@@ -1785,6 +4303,10 @@ var ClipExtension = class extends import_core10.LayerExtension {
         Math.max(corner0[1], corner1[1])
       ];
     }
+    if (this.context.device.type === "webgpu") {
+      clipProps.enabled = true;
+      clipProps.mode = this.state.clipByInstance ? "instance" : "geometry";
+    }
     this.setShaderModuleProps({ clip: clipProps });
   }
 };
@@ -1792,12 +4314,8 @@ 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 import_core11 = require("@deck.gl/core");
-var vs4 = (
+var vs5 = (
   /* glsl */
   `
 in float collisionPriorities;
@@ -1895,8 +4413,8 @@ var getCollisionUniforms = (opts) => {
 };
 var shader_module_default2 = {
   name: "collision",
-  dependencies: [import_core11.project],
-  vs: vs4,
+  dependencies: [project_default],
+  vs: vs5,
   inject: inject4,
   getUniforms: getCollisionUniforms,
   uniformTypes: {
@@ -1906,12 +4424,10 @@ var shader_module_default2 = {
 };
 
 // dist/collision-filter/collision-filter-effect.js
-var import_core13 = require("@math.gl/core");
-var import_core14 = require("@deck.gl/core");
+var import_core20 = require("@math.gl/core");
 
 // dist/collision-filter/collision-filter-pass.js
-var import_core12 = require("@deck.gl/core");
-var CollisionFilterPass = class extends import_core12._LayersPass {
+var CollisionFilterPass = class extends LayersPass {
   renderCollisionMap(target, options) {
     const padding = 1;
     const clearColor = [0, 0, 0, 0];
@@ -2002,8 +4518,8 @@ var CollisionFilterEffect = class {
     }
     const needsRender = viewportChanged || // If render info is new
     renderInfo === oldRenderInfo || // If sublayers have changed
-    !(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
+    !deepEqual(oldRenderInfo.layers, renderInfo.layers, 1) || // If a sublayer's bounds have been updated
+    renderInfo.layerBounds.some((b, i) => !(0, import_core20.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;
@@ -2135,7 +4651,7 @@ var defaultProps6 = {
   collisionGroup: { type: "string", value: "default" },
   collisionTestProps: {}
 };
-var CollisionFilterExtension = class extends import_core15.LayerExtension {
+var CollisionFilterExtension = class extends LayerExtension {
   getShaders() {
     return { modules: [shader_module_default2] };
   }
@@ -2169,11 +4685,7 @@ 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 {
@@ -2193,7 +4705,7 @@ vec2 mask_getCoords(vec4 position) {
 }
 `
 );
-var vs5 = `
+var vs6 = `
 ${uniformBlock4}
 ${vertex3}
 `;
@@ -2226,7 +4738,7 @@ bool mask_isInBounds(vec2 texCoords) {
 }
 `
 );
-var fs4 = `
+var fs5 = `
 ${uniformBlock4}
 ${fragment3}
 `;
@@ -2280,9 +4792,9 @@ var getMaskUniforms = (opts) => {
 };
 var shader_module_default3 = {
   name: "mask",
-  dependencies: [import_core16.project],
-  vs: vs5,
-  fs: fs4,
+  dependencies: [project_default],
+  vs: vs6,
+  fs: fs5,
   inject: inject5,
   getUniforms: getMaskUniforms,
   uniformTypes: {
@@ -2295,11 +4807,9 @@ var shader_module_default3 = {
 };
 
 // dist/mask/mask-effect.js
-var import_core19 = require("@deck.gl/core");
-var import_core20 = require("@math.gl/core");
+var import_core27 = require("@math.gl/core");
 
 // dist/mask/mask-pass.js
-var import_core17 = require("@deck.gl/core");
 var MASK_BLENDING = {
   blendColorOperation: "subtract",
   blendColorSrcFactor: "zero",
@@ -2308,7 +4818,7 @@ var MASK_BLENDING = {
   blendAlphaSrcFactor: "zero",
   blendAlphaDstFactor: "one"
 };
-var MaskPass = class extends import_core17._LayersPass {
+var MaskPass = class extends LayersPass {
   constructor(device, props) {
     super(device, props);
     const { mapSize = 2048 } = props;
@@ -2353,8 +4863,7 @@ var MaskPass = class extends import_core17._LayersPass {
 };
 
 // dist/utils/projection-utils.js
-var import_core18 = require("@deck.gl/core");
-var MERCATOR_REFERENCE_VIEWPORT = new import_core18.WebMercatorViewport({
+var MERCATOR_REFERENCE_VIEWPORT = new WebMercatorViewport({
   width: 1,
   height: 1,
   longitude: 0,
@@ -2416,7 +4925,7 @@ function makeViewport(opts) {
       zoom += Math.log2(r);
     }
   }
-  return isGeospatial ? new import_core18.WebMercatorViewport({
+  return isGeospatial ? new WebMercatorViewport({
     id: viewport.id,
     x: border,
     y: border,
@@ -2426,7 +4935,7 @@ function makeViewport(opts) {
     latitude: centerWorld[1],
     zoom,
     orthographic: true
-  }) : new import_core18.OrthographicViewport({
+  }) : new OrthographicViewport({
     id: viewport.id,
     x: border,
     y: border,
@@ -2519,7 +5028,7 @@ var MaskEffect = class {
     const viewport = viewports[0];
     const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
     if (viewport.resolution !== void 0) {
-      import_core19.log.warn("MaskExtension is not supported in GlobeView")();
+      log_default.warn("MaskExtension is not supported in GlobeView")();
       return { didRender };
     }
     for (const maskId in channelMap) {
@@ -2562,7 +5071,7 @@ var MaskEffect = class {
       this.lastViewport = viewport;
       const layerBounds = joinLayerBounds(channelInfo.layers, viewport);
       channelInfo.bounds = layerBounds && getRenderBounds(layerBounds, viewport);
-      if (maskChanged || !(0, import_core20.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
+      if (maskChanged || !(0, import_core27.equals)(channelInfo.bounds, oldChannelInfo.bounds)) {
         const { maskPass, maskMap } = this;
         const maskViewport = layerBounds && makeViewport({
           bounds: channelInfo.bounds,
@@ -2613,7 +5122,7 @@ var MaskEffect = class {
       let channelInfo = channelMap[id];
       if (!channelInfo) {
         if (++channelCount > 4) {
-          import_core19.log.warn("Too many mask layers. The max supported is 4")();
+          log_default.warn("Too many mask layers. The max supported is 4")();
           continue;
         }
         channelInfo = {
@@ -2674,7 +5183,7 @@ var defaultProps7 = {
   maskByInstance: void 0,
   maskInverted: false
 };
-var MaskExtension = class extends import_core21.LayerExtension {
+var MaskExtension = class extends LayerExtension {
   initializeState() {
     var _a;
     (_a = this.context.deck) == null ? void 0 : _a._addDefaultEffect(new MaskEffect());
@@ -2702,8 +5211,8 @@ var MaskExtension = class extends import_core21.LayerExtension {
       maskProps.enabled = true;
       maskProps.channel = index;
       maskProps.inverted = maskInverted;
-      if (fromCoordinateSystem === import_core21.COORDINATE_SYSTEM.DEFAULT) {
-        fromCoordinateSystem = viewport.isGeospatial ? import_core21.COORDINATE_SYSTEM.LNGLAT : import_core21.COORDINATE_SYSTEM.CARTESIAN;
+      if (fromCoordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
+        fromCoordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
       }
       const opts = { modelMatrix: null, fromCoordinateOrigin, fromCoordinateSystem };
       const bl = this.projectPosition([bounds[0], bounds[1], 0], opts);
@@ -2711,7 +5220,7 @@ var MaskExtension = class extends import_core21.LayerExtension {
       maskProps.bounds = [bl[0], bl[1], tr[0], tr[1]];
     } else {
       if (maskId) {
-        import_core21.log.warn(`Could not find a mask layer with id: ${maskId}`)();
+        log_default.warn(`Could not find a mask layer with id: ${maskId}`)();
       }
       maskProps.enabled = false;
     }
@@ -2722,14 +5231,7 @@ 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 */
@@ -2758,7 +5260,7 @@ uniform sampler2D terrain_map;
 );
 var terrainModule = {
   name: "terrain",
-  dependencies: [import_core22.project],
+  dependencies: [project_default],
   vs: `${uniformBlock5}
 out vec3 commonPos;
 // In globe mode, absolute Mercator position for terrain FBO UV lookups
@@ -2856,7 +5358,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 = import_core22.project.getUniforms(opts.project);
+      const projectUniforms = project_default.getUniforms(opts.project);
       const { commonOrigin } = projectUniforms;
       let mode = terrainSkipRender ? TERRAIN_MODE.SKIP : TERRAIN_MODE.NONE;
       let sampler = dummyHeightMap;
@@ -2906,11 +5408,7 @@ 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,
@@ -3024,7 +5522,7 @@ var TerrainCover = class {
     } else {
       const oldZoom = (_a = this.renderViewport) == null ? void 0 : _a.zoom;
       shouldRedraw = shouldRedraw || newZoom !== oldZoom;
-      const newBounds = viewport instanceof import_core23._GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
+      const newBounds = viewport instanceof GlobeViewport ? this.targetBoundsCommon : getRenderBounds(this.targetBoundsCommon, viewport);
       const oldBounds = this.bounds;
       shouldRedraw = shouldRedraw || !oldBounds || newBounds.some((x, i) => x !== oldBounds[i]);
       this.bounds = newBounds;
@@ -3101,7 +5599,6 @@ function intersect(b1, b2) {
 }
 
 // dist/terrain/terrain-pass.js
-var import_core24 = require("@deck.gl/core");
 var TERRAIN_BLENDING = {
   blendColorOperation: "max",
   blendColorSrcFactor: "one",
@@ -3110,7 +5607,7 @@ var TERRAIN_BLENDING = {
   blendAlphaSrcFactor: "one",
   blendAlphaDstFactor: "one"
 };
-var TerrainPass = class extends import_core24._LayersPass {
+var TerrainPass = class extends LayersPass {
   getRenderableLayers(viewport, opts) {
     const { layers } = opts;
     const result = [];
@@ -3175,8 +5672,7 @@ var TerrainPass = class extends import_core24._LayersPass {
 };
 
 // dist/terrain/terrain-picking-pass.js
-var import_core25 = require("@deck.gl/core");
-var TerrainPickingPass = class extends import_core25._PickLayersPass {
+var TerrainPickingPass = class extends PickLayersPass {
   constructor() {
     super(...arguments);
     this.drawParameters = {};
@@ -3247,7 +5743,6 @@ var TerrainPickingPass = class extends import_core25._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) {
@@ -3294,7 +5789,7 @@ var HeightMapBuilder = class {
     if (!this.layersBoundsCommon) {
       this.renderViewport = null;
     } else if (layersChanged || viewportChanged) {
-      const bounds = viewport instanceof import_core26._GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
+      const bounds = viewport instanceof GlobeViewport ? this.layersBoundsCommon : getRenderBounds(this.layersBoundsCommon, viewport);
       if (bounds[2] <= bounds[0] || bounds[3] <= bounds[1]) {
         this.renderViewport = null;
         return false;
@@ -3352,7 +5847,7 @@ var TerrainEffect = class {
     if (HeightMapBuilder.isSupported(device)) {
       this.heightMap = new HeightMapBuilder(device);
     } else {
-      import_core27.log.warn("Terrain offset mode is not supported by this browser")();
+      log_default.warn("Terrain offset mode is not supported by this browser")();
     }
     deck._addDefaultShaderModule(terrainModule);
   }
@@ -3520,7 +6015,7 @@ var TerrainEffect = class {
 var defaultProps8 = {
   terrainDrawMode: void 0
 };
-var TerrainExtension = class extends import_core28.LayerExtension {
+var TerrainExtension = class extends LayerExtension {
   getShaders() {
     return {
       modules: [terrainModule]