leaflet-city-mapper 0.0.5 → 0.0.6

package/dist/leaflet-city-mapper-src.js

@@ -214,6 +214,14 @@
     }
   });
 
+  // src/weakmaps/cameraHandlersByMap.js
+  var cameraHandlersByMap;
+  var init_cameraHandlersByMap = __esm({
+    "src/weakmaps/cameraHandlersByMap.js"() {
+      cameraHandlersByMap = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
   // src/weakmaps/rotateControlByMap.js
   var rotateControlByMap;
   var init_rotateControlByMap = __esm({
@@ -222,6 +230,22 @@
     }
   });
 
+  // src/weakmaps/touchPitchByMap.js
+  var touchPitchByMap;
+  var init_touchPitchByMap = __esm({
+    "src/weakmaps/touchPitchByMap.js"() {
+      touchPitchByMap = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
+  // src/weakmaps/touchRotateByMap.js
+  var touchRotateByMap;
+  var init_touchRotateByMap = __esm({
+    "src/weakmaps/touchRotateByMap.js"() {
+      touchRotateByMap = /* @__PURE__ */ new WeakMap();
+    }
+  });
+
   // src/globals/Compass.js
   var Compass;
   var init_Compass = __esm({
@@ -1032,22 +1056,6 @@
     }
   });
 
-  // src/weakmaps/touchPitchByMap.js
-  var touchPitchByMap;
-  var init_touchPitchByMap = __esm({
-    "src/weakmaps/touchPitchByMap.js"() {
-      touchPitchByMap = /* @__PURE__ */ new WeakMap();
-    }
-  });
-
-  // src/weakmaps/touchRotateByMap.js
-  var touchRotateByMap;
-  var init_touchRotateByMap = __esm({
-    "src/weakmaps/touchRotateByMap.js"() {
-      touchRotateByMap = /* @__PURE__ */ new WeakMap();
-    }
-  });
-
   // src/controls/startCameraTouch.js
   function startCameraTouch(event) {
     const state = touchByContainer.get(this), { map, container } = state;
@@ -1242,14 +1250,6 @@
     }
   });
 
-  // src/weakmaps/cameraHandlersByMap.js
-  var cameraHandlersByMap;
-  var init_cameraHandlersByMap = __esm({
-    "src/weakmaps/cameraHandlersByMap.js"() {
-      cameraHandlersByMap = /* @__PURE__ */ new WeakMap();
-    }
-  });
-
   // src/controls/addCameraHandler.js
   function addCameraHandler(map, name, Type) {
     let handlers = cameraHandlersByMap.get(map);
@@ -1282,6 +1282,8 @@
     addCameraHandler(map, "compassBearing", Compass.value);
     addCameraHandler(map, "touchRotate", TouchMode.value);
     addCameraHandler(map, "touchPitch", TouchMode.value);
+    touchRotateByMap.set(map, cameraHandlersByMap.get(map).get("touchRotate"));
+    touchPitchByMap.set(map, cameraHandlersByMap.get(map).get("touchPitch"));
     const container = map.getContainer();
     const state = (
       /* alloc */
@@ -1296,6 +1298,7 @@
     container.addEventListener("touchcancel", endCameraTouchEvent, true);
     window.addEventListener("blur", endAllCameraTouches);
     map.on("cameratouchchange", changeCameraTouch, map);
+    changeCameraTouch.call(map);
     if (map.options.rotateControl) {
       rotateControlByMap.set(
         map,
@@ -1309,7 +1312,10 @@
   var init_cameraControls = __esm({
     "src/controls/cameraControls.js"() {
       init_cameraTouchStateByMap();
+      init_cameraHandlersByMap();
       init_rotateControlByMap();
+      init_touchPitchByMap();
+      init_touchRotateByMap();
       init_L();
       init_Compass();
       init_ContainerResize();
@@ -1707,16 +1713,16 @@
   }
 
   // src/terrain/getElevation.js
-  function getElevation(layer, location) {
+  function getElevation(layer, location2) {
     if (!layer._map || !terrainReadyByLayer.get(layer)) return null;
-    const point = location instanceof L.Point ? location : layer._map.project(location, terrainZoomByLayer.get(layer));
+    const point = location2 instanceof L.Point ? location2 : layer._map.project(location2, terrainZoomByLayer.get(layer));
     return bridgeElevation(point, bridgesByLayer.get(layer)) ?? terrainElevation(point, terrainTilesByLayer.get(layer));
   }
 
   // src/terrain/mapElevationOf.js
-  function mapElevationOf(map, location) {
+  function mapElevationOf(map, location2) {
     const terrain = terrain3DByMap.get(map);
-    return terrain && getElevation(terrain, location);
+    return terrain && getElevation(terrain, location2);
   }
 
   // src/weakmaps/walkByMap.js
@@ -6154,18 +6160,24 @@
     return !(far < near);
   }
 
+  // src/collision/vertexCount.js
+  function vertexCount(position, index) {
+    return index?.count ?? index?.data.length ?? position.count ?? position.data.length / (position.size ?? 3);
+  }
+
   // src/collision/readTriangle.js
   function readTriangle(mesh, i, a, b, c) {
     const { position, index, instanceOffset } = mesh.geometry.attributes;
-    const vertices = index?.count || position.count;
+    const size = position.size ?? 3;
+    const vertices = vertexCount(position, index);
     const vertex = instanceOffset ? i % vertices : i;
     const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
     const x = instanceOffset?.data[offset] ?? 0;
     const y = instanceOffset?.data[offset + 1] ?? 0;
     const z = instanceOffset?.data[offset + 2] ?? 0;
-    const ai = (index ? index.data[vertex] : vertex) * position.size;
-    const bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
-    const ci = (index ? index.data[vertex + 2] : vertex + 2) * position.size;
+    const ai = (index ? index.data[vertex] : vertex) * size;
+    const bi = (index ? index.data[vertex + 1] : vertex + 1) * size;
+    const ci = (index ? index.data[vertex + 2] : vertex + 2) * size;
     a[0] = position.data[ai];
     a[1] = position.data[ai + 1];
     a[2] = position.data[ai + 2];
@@ -7621,1274 +7633,1325 @@
     layer.fire("progress", progress);
   }
 
-  // src/sources/buildAreaFeature.js
-  init_L();
-
-  // src/projections/projectTreePoint.js
-  init_L();
-  function projectedTree(context, lon, lat) {
-    const { backend: layer, crs, origin, metres, map } = context;
-    const location = (
+  // src/geometry/instanceAreaGeometry.js
+  function instanceAreaGeometry(context) {
+    const { positions, normals, colors, featureFaces } = context;
+    if (context.backend.options.nightLight || featureFaces.length < 2) return context;
+    const vertices = featureFaces[0].vertexEnd;
+    const length = vertices * 3;
+    if (!vertices || positions.length !== length * featureFaces.length) return context;
+    const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
+    const template = (
       /* alloc */
-      new L.LatLng(lat, lon)
+      new Float32Array(length)
+    );
+    let i, instance, face, start2;
+    for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
+    const offsets = (
+      /* alloc */
+      new Float32Array(featureFaces.length * 4)
     );
-    const point = crs.project(location);
-    const elevation = mapElevationOf(map, location), root = rootByLayer.get(layer);
+    for (instance = 0; instance < featureFaces.length; instance++) {
+      face = featureFaces[instance];
+      start2 = instance * length;
+      if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
+      offsets[instance * 4] = originX + positions[start2] - positions[0];
+      offsets[instance * 4 + 1] = originY + positions[start2 + 1] - positions[1];
+      offsets[instance * 4 + 2] = originZ + positions[start2 + 2] - positions[2];
+      offsets[instance * 4 + 3] = instance * vertices;
+      for (i = 0; i < length; i++) {
+        if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start2 + i]) || Math.fround(normals[i]) !== Math.fround(normals[start2 + i]) || Math.fround(colors[i]) !== Math.fround(colors[start2 + i])) return context;
+      }
+    }
     return (
       /* alloc */
       {
-        x: (point.x - origin.x) * metres,
-        y: (point.y - origin.y) * metres,
-        ground: Number.isFinite(elevation) && Number.isFinite(root.position[1]) ? elevation - root.position[1] : 0
+        positions: template,
+        normals: normals.slice(0, length),
+        colors: colors.slice(0, length),
+        instanceOffsets: offsets
       }
     );
   }
 
-  // src/globals/triangleContexts.js
-  var triangleContexts = [];
-
-  // src/sources/groundOffset.js
-  function groundOffset(point) {
-    return point.ground || 0;
-  }
-
-  // src/geometry/appendAreaTriangle.js
-  function addTriangle(context, a, ah, b, bh, c, ch, nx, ny, nz, color) {
-    const { backend: layer, positions, normals, colors, uvs } = context;
-    const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
-    const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
-    if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
-      const point = b, height = bh;
-      b = c;
-      bh = ch;
-      c = point;
-      ch = height;
-    }
-    positions.push(
-      a.x,
-      ah + groundOffset(a),
-      -a.y,
-      b.x,
-      bh + groundOffset(b),
-      -b.y,
-      c.x,
-      ch + groundOffset(c),
-      -c.y
-    );
-    normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
-    colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
-    if (layer.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
-  }
-
-  // src/geometry/addGeneratedTriangle.js
-  function addGeneratedTriangle(...args) {
-    addTriangle(triangleContexts[triangleContexts.length - 1], ...args);
-  }
-
-  // src/geometry/generateTreeGeometry.js
-  function generateTreeGeometry(context, generator, point, style) {
-    triangleContexts.push(context);
-    try {
-      generator(point, style, addGeneratedTriangle);
-    } finally {
-      triangleContexts.pop();
+  // src/sources/attachAreaMesh.js
+  function attachAreaMesh(context) {
+    const { backend: layer, area: area2 } = context;
+    if (!context.positions.length) {
+      area2.mesh = null, area2.buildings = 0, area2.skipped = context.skipped, area2.done = true;
+      return;
     }
-  }
-
-  // src/globals/lampDirections.js
-  var lampDirections = [
-    { x: Math.cos(0 * Math.PI / 3), y: Math.sin(0 * Math.PI / 3), nx: Math.cos(0.5 * Math.PI / 3), nz: -Math.sin(0.5 * Math.PI / 3) },
-    { x: Math.cos(1 * Math.PI / 3), y: Math.sin(1 * Math.PI / 3), nx: Math.cos(1.5 * Math.PI / 3), nz: -Math.sin(1.5 * Math.PI / 3) },
-    { x: Math.cos(2 * Math.PI / 3), y: Math.sin(2 * Math.PI / 3), nx: Math.cos(2.5 * Math.PI / 3), nz: -Math.sin(2.5 * Math.PI / 3) },
-    { x: Math.cos(3 * Math.PI / 3), y: Math.sin(3 * Math.PI / 3), nx: Math.cos(3.5 * Math.PI / 3), nz: -Math.sin(3.5 * Math.PI / 3) },
-    { x: Math.cos(4 * Math.PI / 3), y: Math.sin(4 * Math.PI / 3), nx: Math.cos(4.5 * Math.PI / 3), nz: -Math.sin(4.5 * Math.PI / 3) },
-    { x: Math.cos(5 * Math.PI / 3), y: Math.sin(5 * Math.PI / 3), nx: Math.cos(5.5 * Math.PI / 3), nz: -Math.sin(5.5 * Math.PI / 3) }
-  ];
-
-  // src/geometry/createLampRing.js
-  function ring(point, radius) {
-    const points = (
+    const device = rendererByLayer.get(layer).device;
+    const data = context.preparedGeometry || instanceAreaGeometry(context);
+    const attributes = (
       /* alloc */
-      new Array(lampDirections.length)
-    );
-    let i;
-    for (i = 0; i < points.length; i++) {
-      points[i] = /* alloc */
       {
-        x: point.x + lampDirections[i].x * radius,
-        y: point.y + lampDirections[i].y * radius,
-        ground: point.ground,
-        uv: (
+        position: (
           /* alloc */
-          [3, 3]
+          { size: 3, data: data.positions instanceof Float32Array ? data.positions : (
+            /* alloc */
+            new Float32Array(data.positions)
+          ) }
+        ),
+        normal: (
+          /* alloc */
+          { size: 3, data: data.normals instanceof Float32Array ? data.normals : (
+            /* alloc */
+            new Float32Array(data.normals)
+          ) }
+        ),
+        color: (
+          /* alloc */
+          { size: 3, data: data.colors instanceof Float32Array ? data.colors : (
+            /* alloc */
+            new Float32Array(data.colors)
+          ) }
         )
-      };
-    }
-    return points;
-  }
-
-  // src/geometry/lampPostGeometry.js
-  function lampPostGeometry(point, style, addTriangle2) {
-    const color = parseColor(5264986), radius = style.poleRadius;
-    if (!Number.isFinite(radius) || radius <= 0) {
-      throw (
+      }
+    );
+    if (data.instanceOffsets) attributes.instanceOffset = /* alloc */
+    { size: 4, data: data.instanceOffsets };
+    if (layer.options.nightLight) attributes.uv = /* alloc */
+    {
+      size: 2,
+      data: context.uvs instanceof Float32Array ? context.uvs : (
         /* alloc */
-        new Error("Invalid lamp pole radius")
+        new Float32Array(context.uvs)
+      )
+    };
+    let name, attribute;
+    for (name in attributes) {
+      attribute = attributes[name];
+      attribute.count = attribute.data.length / attribute.size;
+      attribute.buffer = device.createBuffer(
+        /* alloc */
+        {
+          size: Math.max(4, attribute.data.byteLength),
+          usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
+        }
       );
+      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
     }
-    const center = (
+    const meshGeometry = (
       /* alloc */
       {
-        ...point,
-        uv: (
+        device,
+        bounds: data.bounds,
+        attributes,
+        drawRange: (
           /* alloc */
-          [3, 3]
+          { start: 0, count: attributes.position.count }
         )
       }
     );
-    let r, low, high, points, i, a, b, nx, nz, section;
-    for (section = 0; section < 2; section++) {
-      r = section ? radius * 2.5 : radius;
-      low = section ? style.top - 0.25 : 0;
-      high = section ? style.top + 0.15 : style.top;
-      points = ring(point, r);
-      for (i = 0; i < 6; i++) {
-        a = points[i], b = points[(i + 1) % 6];
-        nx = lampDirections[i].nx, nz = lampDirections[i].nz;
-        addTriangle2(a, low, b, low, b, high, nx, 0, nz, color);
-        addTriangle2(a, low, b, high, a, high, nx, 0, nz, color);
-        addTriangle2(center, high, a, high, b, high, 0, 1, 0, color);
-        addTriangle2(center, low, b, low, a, low, 0, -1, 0, color);
-      }
-    }
-  }
-
-  // src/geometry/quad.js
-  function quad(addTriangle2, color, a, b, c, d, height, nx, ny, nz) {
-    if (typeof nx !== "number") {
-      addTriangle2(a, height, b, height, c, height, ...nx, color);
-      addTriangle2(a, height, c, height, d, height, ...nx, color);
-    } else {
-      addTriangle2(a, height, b, height, c, height, nx, ny, nz, color);
-      addTriangle2(a, height, c, height, d, height, nx, ny, nz, color);
-    }
-  }
-
-  // src/geometry/emitter.js
-  function emitter(point, u, v, axis) {
-    const r = 0.65;
-    return (
-      /* alloc */
-      {
-        x: point.x + (axis === 2 ? 0 : u * r),
-        y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),
-        ground: point.ground + (axis === 0 ? 0 : v * r),
-        uv: (
-          /* alloc */
-          [u, v]
-        )
-      }
-    );
-  }
-
-  // src/geometry/lightGeometry.js
-  function lightGeometry(point, style, addTriangle2) {
-    if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw (
-      /* alloc */
-      new Error("Invalid light radius")
-    );
-    const color = parseColor(style.color);
-    let axis;
-    for (axis = 0; axis < 3; axis++) {
-      quad(
-        addTriangle2,
-        color,
-        emitter(point, -1, -1, axis),
-        emitter(point, 1, -1, axis),
-        emitter(point, 1, 1, axis),
-        emitter(point, -1, 1, axis),
-        style.top,
-        axis === 2 ? 1 : 0,
-        axis === 0 ? 1 : 0,
-        axis === 1 ? 1 : 0
-      );
-    }
-  }
-
-  // src/globals/roundProfile.js
-  var roundProfile = [
-    [0, 0],
-    [0.35, 0.8],
-    [0.6, 1],
-    [0.85, 0.7],
-    [1, 0]
-  ];
-
-  // src/globals/ringDirections.js
-  var ringDirections = [
-    {
-      x: Math.cos(0 * Math.PI / 4),
-      y: Math.sin(0 * Math.PI / 4),
-      nx: Math.cos((0 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((0 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(1 * Math.PI / 4),
-      y: Math.sin(1 * Math.PI / 4),
-      nx: Math.cos((1 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((1 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(2 * Math.PI / 4),
-      y: Math.sin(2 * Math.PI / 4),
-      nx: Math.cos((2 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((2 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(3 * Math.PI / 4),
-      y: Math.sin(3 * Math.PI / 4),
-      nx: Math.cos((3 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((3 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(4 * Math.PI / 4),
-      y: Math.sin(4 * Math.PI / 4),
-      nx: Math.cos((4 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((4 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(5 * Math.PI / 4),
-      y: Math.sin(5 * Math.PI / 4),
-      nx: Math.cos((5 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((5 + 0.5) * Math.PI / 4)
-    },
-    {
-      x: Math.cos(6 * Math.PI / 4),
-      y: Math.sin(6 * Math.PI / 4),
-      nx: Math.cos((6 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((6 + 0.5) * Math.PI / 4)
-    },
+    area2.mesh = /* alloc */
     {
-      x: Math.cos(7 * Math.PI / 4),
-      y: Math.sin(7 * Math.PI / 4),
-      nx: Math.cos((7 + 0.5) * Math.PI / 4),
-      nz: -Math.sin((7 + 0.5) * Math.PI / 4)
-    }
-  ];
-
-  // src/geometry/createTreeRing.js
-  function ring2(point, radius) {
-    const result = (
-      /* alloc */
-      new Array(ringDirections.length)
-    );
-    let i;
-    for (i = 0; i < result.length; i++) {
-      result[i] = /* alloc */
-      {
-        x: point.x + ringDirections[i].x * radius,
-        y: point.y + ringDirections[i].y * radius,
-        ground: point.ground
-      };
-    }
-    return result;
+      ...emptyNode(),
+      device,
+      geometry: meshGeometry,
+      program: createProgram(
+        layer,
+        /* alloc */
+        {
+          instanced: Boolean(data.instanceOffsets),
+          vertexColors: true,
+          roofTexture: layer.options.roofTexture,
+          wallTexture: layer.options.wallTexture,
+          nightLight: Boolean(layer.options.nightLight),
+          alphaMode: layer.options.nightLight ? "BLEND" : void 0,
+          doubleSided: Boolean(layer.options.nightLight)
+        }
+      ),
+      id: nextId.value++,
+      renderOrder: 0,
+      fadeDuration: 250,
+      extras: (
+        /* alloc */
+        { featureFaces: context.featureFaces, lights: context.lights }
+      )
+    };
+    area2.buildings = context.featureFaces.length;
+    area2.skipped = context.skipped;
+    area2.done = true;
+    setParent(area2.mesh, rootByLayer.get(layer));
+    update(layer);
   }
 
-  // src/geometry/surface.js
-  function surface(point, addTriangle2, lowRadius, low, highRadius, high, color) {
-    const lower = ring2(point, lowRadius), upper = ring2(point, highRadius);
-    let i, next, slope, length, nx, nz, ny, normalX, normalZ;
-    for (i = 0; i < 8; i++) {
-      next = (i + 1) % 8;
-      slope = (lowRadius - highRadius) / (high - low);
-      length = Math.hypot(1, slope);
-      ({ nx, nz } = ringDirections[i]);
-      ny = slope / length;
-      normalX = nx / length, normalZ = nz / length;
-      if (lowRadius) addTriangle2(lower[i], low, lower[next], low, upper[next], high, normalX, ny, normalZ, color);
-      if (highRadius) addTriangle2(lower[i], low, upper[next], high, upper[i], high, normalX, ny, normalZ, color);
-    }
-  }
+  // src/globals/archiveDecoder.js
+  var archiveDecoder = new TextDecoder();
 
-  // src/geometry/validateTree.js
-  function validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape) {
-    if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) || trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top || crownShape !== "round" && crownShape !== "cone") {
+  // src/archives/tileId.js
+  function tileId(z, x, y) {
+    if (!Number.isInteger(z) || !Number.isInteger(x) || !Number.isInteger(y) || z < 0 || z > 26 || x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) {
       throw (
         /* alloc */
-        new Error("Invalid tree dimensions or crown shape")
+        new Error("Invalid PMTiles tile coordinates")
       );
     }
+    let id = (4 ** z - 1) / 3;
+    const n = 2 ** z;
+    let s, rx, ry, swap;
+    for (s = n / 2; s >= 1; s /= 2) {
+      rx = x & s ? 1 : 0, ry = y & s ? 1 : 0;
+      id += s * s * (3 * rx ^ ry);
+      if (!ry) {
+        if (rx) {
+          x = n - 1 - x;
+          y = n - 1 - y;
+        }
+        swap = x;
+        x = y;
+        y = swap;
+      }
+    }
+    return id;
   }
 
-  // src/geometry/treeGeometry.js
-  function treeGeometry(point, style, addTriangle2) {
-    const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = "round" } = style;
-    validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape);
-    const trunk = parseColor(style.trunkColor ?? 7491898);
-    const crown = parseColor(style.color ?? 5210683);
-    surface(point, addTriangle2, trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
-    let i, low, lr, high, hr;
-    if (crownShape === "cone") {
-      const base = ring2(point, crownRadius);
-      for (i = 0; i < 8; i++) addTriangle2(
-        point,
-        crownBottom,
-        base[i],
-        crownBottom,
-        base[(i + 1) % 8],
-        crownBottom,
-        0,
-        -1,
-        0,
-        crown
-      );
-      surface(point, addTriangle2, crownRadius, crownBottom, 0, top, crown);
-    } else {
-      for (i = 1; i < roundProfile.length; i++) {
-        [low, lr] = roundProfile[i - 1], [high, hr] = roundProfile[i];
-        surface(
-          point,
-          addTriangle2,
-          lr * crownRadius,
-          crownBottom + low * (top - crownBottom),
-          hr * crownRadius,
-          crownBottom + high * (top - crownBottom),
-          crown
+  // src/globals/directoryReader.js
+  var directoryReader = {
+    bytes: null,
+    cursor: 0
+  };
+
+  // src/archives/readVarint.js
+  function varint(reader) {
+    const { bytes } = reader;
+    let value = 0;
+    let factor, byte;
+    for (factor = 1; factor <= 2 ** 49; factor *= 128) {
+      if (reader.cursor >= bytes.length) {
+        throw (
+          /* alloc */
+          new Error("Truncated PMTiles directory")
+        );
+      }
+      byte = bytes[reader.cursor++];
+      value += (byte & 127) * factor;
+      if (!Number.isSafeInteger(value)) {
+        throw (
+          /* alloc */
+          new Error("Invalid PMTiles directory integer")
         );
       }
+      if (byte < 128) return value;
     }
+    throw (
+      /* alloc */
+      new Error("Invalid PMTiles directory integer")
+    );
   }
 
-  // src/geometry/buildProjectedPoint.js
-  function buildProjectedPoint(context, projected, style, baseColor, support) {
-    const { top } = style;
-    if (context.backend.options.nightLight) {
-      if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw (
-        /* alloc */
-        new Error("Invalid light flux")
-      );
-      if (style.poleRadius > 0 && !context.supports.has(support)) {
-        generateTreeGeometry(context, lampPostGeometry, projected, style);
-        context.supports.add(support);
+  // src/archives/decodeDirectory.js
+  function decodeDirectory(data) {
+    const reader = directoryReader;
+    const bytes = (
+      /* alloc */
+      new Uint8Array(data)
+    );
+    reader.bytes = bytes;
+    reader.cursor = 0;
+    try {
+      const count = varint(reader);
+      if (count > (bytes.length - reader.cursor) / 4) {
+        throw (
+          /* alloc */
+          new Error("Invalid PMTiles directory count")
+        );
       }
-      generateTreeGeometry(context, lightGeometry, projected, style);
-      context.lights.push(
+      const entries = (
         /* alloc */
-        {
-          position: (
+        new Array(count)
+      );
+      let tileId2 = 0;
+      let i, entry, value;
+      for (i = 0; i < count; i++) {
+        tileId2 += varint(reader);
+        if (!Number.isSafeInteger(tileId2) || i && tileId2 <= entries[i - 1].tileId) {
+          throw (
             /* alloc */
-            [projected.x, projected.ground + top, -projected.y]
-          ),
-          radius: Math.hypot(top, style.lightRadius),
-          color: (
+            new Error("Invalid PMTiles directory tile IDs")
+          );
+        }
+        entries[i] = /* alloc */
+        { tileId: tileId2, runLength: 0, length: 0, offset: 0 };
+      }
+      for (entry of entries) entry.runLength = varint(reader);
+      for (entry of entries) {
+        entry.length = varint(reader);
+        if (!entry.length) {
+          throw (
             /* alloc */
-            [baseColor.r, baseColor.g, baseColor.b]
-          ),
-          flux: style.lightFlux
+            new Error("Invalid PMTiles directory length")
+          );
         }
-      );
-    } else generateTreeGeometry(context, treeGeometry, projected, style);
-  }
-
-  // src/sources/buildAreaPoint.js
-  function buildAreaPoint(context, feature, lon, lat, style, baseColor) {
-    const projected = projectedTree(context, lon, lat);
-    buildProjectedPoint(context, projected, style, baseColor, feature.properties?.cod_ouvrag || `${lon},${lat}`);
-  }
-
-  // src/projections/projectRing.js
-  init_L();
-  function projectRing(context, ring3) {
-    const { backend: layer, crs, origin, metres, map } = context;
-    if (ring3.length < 4) throw (
-      /* alloc */
-      new Error("Invalid GeoJSON polygon ring")
-    );
-    const path = (
-      /* alloc */
-      []
-    );
-    const root = rootByLayer.get(layer);
-    let i, lng, lat, location, point, elevation;
-    for (i = 0; i < ring3.length - 1; i++) {
-      lng = ring3[i][0], lat = ring3[i][1];
-      if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw (
-        /* alloc */
-        new Error("Invalid GeoJSON coordinates")
-      );
-      location = /* alloc */
-      new L.LatLng(lat, lng);
-      point = crs.project(location);
-      elevation = mapElevationOf(map, location);
-      path.push(
-        /* alloc */
-        {
-          x: (point.x - origin.x) * metres,
-          y: (point.y - origin.y) * metres,
-          ground: Number.isFinite(elevation) && Number.isFinite(root.position[1]) ? elevation - root.position[1] : 0
+      }
+      for (i = 0; i < entries.length; i++) {
+        entry = entries[i];
+        value = varint(reader);
+        if (!value && !i) {
+          throw (
+            /* alloc */
+            new Error("Invalid PMTiles directory offset")
+          );
         }
-      );
+        entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
+      }
+      if (reader.cursor !== bytes.length) {
+        throw (
+          /* alloc */
+          new Error("Trailing PMTiles directory data")
+        );
+      }
+      return entries;
+    } finally {
+      reader.bytes = null;
+      reader.cursor = 0;
     }
-    return path;
   }
 
-  // src/geometry/buildProjectedPolygon.js
-  function buildProjectedPolygon(context, paths, top, bottom, baseColor) {
-    const points = (
+  // src/archives/decompress.js
+  async function decompress(data, compression) {
+    if (compression === 1) return data;
+    if (compression !== 2) {
+      throw (
+        /* alloc */
+        new Error(`Unsupported PMTiles compression: ${compression}`)
+      );
+    }
+    const blob = (
       /* alloc */
-      []
+      new Blob(
+        /* alloc */
+        [data]
+      )
     );
-    let path, point, a, b, c, index, sign, i, length, nx, nz;
-    for (path of paths) for (point of path) points.push(point);
-    for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
-      addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
-      if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
-    }
-    for (index = 0; index < paths.length; index++) {
-      path = paths[index];
-      sign = isClockWise(path) === (index === 0) ? -1 : 1;
-      for (i = 0; i < path.length; i++) {
-        a = path[i], b = path[(i + 1) % path.length];
-        length = Math.hypot(b.x - a.x, b.y - a.y);
-        if (!length) continue;
-        nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
-        addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
-        addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
-      }
-    }
-  }
-
-  // src/geometry/buildExtrudedPolygon.js
-  function buildAreaPolygon(context, rings, top, bottom, baseColor) {
-    if (!rings.length) throw (
+    const stream = (
       /* alloc */
-      new Error("Empty GeoJSON polygon")
+      new DecompressionStream("gzip")
     );
-    const paths = (
+    return (
       /* alloc */
-      []
+      new Response(blob.stream().pipeThrough(stream)).arrayBuffer()
     );
-    let ring3;
-    for (ring3 of rings) paths.push(projectRing(context, ring3));
-    buildProjectedPolygon(context, paths, top, bottom, baseColor);
   }
 
-  // src/sources/featureAnchor.js
-  function featureAnchor(feature, nightLight) {
-    const geometry = feature?.geometry, point = geometry?.type === "Point";
-    if (nightLight && !point) throw (
-      /* alloc */
-      new Error("Night lights require Point geometry")
-    );
-    if (geometry?.type !== "Polygon" && geometry?.type !== "MultiPolygon" && !point) throw (
-      /* alloc */
-      new Error("Unsupported GeoJSON geometry")
-    );
-    const coordinates = point ? geometry.coordinates : geometry.type === "Polygon" ? geometry.coordinates[0]?.[0] : geometry.coordinates[0]?.[0]?.[0];
-    if (!Number.isFinite(coordinates?.[0]) || !Number.isFinite(coordinates?.[1])) throw (
-      /* alloc */
-      new Error("Invalid GeoJSON coordinates")
-    );
-    return coordinates;
+  // src/archives/loadDirectory.js
+  async function loadDirectory(layer, offset, length, compression) {
+    return decodeDirectory(await decompress(await read(layer, offset, length), compression));
   }
 
-  // src/sources/extrusionStyle.js
-  function extrusionStyle(layer, feature) {
-    const style = layer.options.style(feature);
-    if (style === null) return null;
-    if (!style || typeof style !== "object") throw (
-      /* alloc */
-      new Error("style must return an extrusion style or null")
-    );
-    const { top, bottom = 0 } = style;
-    if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
-      throw (
-        /* alloc */
-        new Error("Invalid extrusion heights: expected top > bottom >= 0")
-      );
+  // src/archives/getDirectoryEntries.js
+  async function getDirectoryEntries(layer, offset, length, compression) {
+    const directories = directoriesByLayer.get(layer);
+    const key = `${offset}:${length}`;
+    if (!directories.has(key)) {
+      if (directories.size >= 32) directories.delete(directories.keys().next().value);
+      directories.set(key, loadDirectory(layer, offset, length, compression));
+    }
+    const pending = directories.get(key);
+    try {
+      return await pending;
+    } catch (error) {
+      if (directories.get(key) === pending) directories.delete(key);
+      throw error;
     }
-    return style;
   }
 
-  // src/sources/prepareAreaGeometryJob.js
-  function prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor) {
-    const geometry = feature.geometry;
-    const polygons = (
-      /* alloc */
-      []
-    );
-    const rings = geometry.type === "Polygon" ? (
-      /* alloc */
-      [geometry.coordinates]
-    ) : geometry.type === "MultiPolygon" ? geometry.coordinates : (
-      /* alloc */
-      []
-    );
-    let polygon2, ring3, paths;
-    for (polygon2 of rings) {
-      if (!polygon2.length) throw (
-        /* alloc */
-        new Error("Empty GeoJSON polygon")
-      );
-      paths = /* alloc */
-      [];
-      for (ring3 of polygon2) paths.push(projectRing(context, ring3));
-      polygons.push(paths);
+  // src/archives/findDirectoryEntry.js
+  function findDirectoryEntry(entries, id) {
+    let low = 0, high = entries.length - 1, mid;
+    while (low <= high) {
+      mid = low + high >> 1;
+      if (entries[mid].tileId <= id) low = mid + 1;
+      else high = mid - 1;
     }
-    const point = geometry.type === "Point" ? projectedTree(context, lon, lat) : null;
-    const nightLight = context.backend.options.nightLight;
-    const crownColor = point ? parseColor(style.color ?? (nightLight ? void 0 : 5210683)) : baseColor;
-    const trunkColor = point && !nightLight ? parseColor(style.trunkColor ?? 7491898) : null;
-    context.jobs.push(
-      /* alloc */
-      {
-        point,
-        polygons,
-        baseColor: (
-          /* alloc */
-          { r: baseColor.r, g: baseColor.g, b: baseColor.b }
-        ),
-        support: feature.properties?.cod_ouvrag || `${lon},${lat}`,
-        style: (
-          /* alloc */
-          {
-            top: style.top,
-            bottom: style.bottom ?? 0,
-            color: (
-              /* alloc */
-              { r: crownColor.r, g: crownColor.g, b: crownColor.b }
-            ),
-            trunkColor: trunkColor ? (
-              /* alloc */
-              { r: trunkColor.r, g: trunkColor.g, b: trunkColor.b }
-            ) : void 0,
-            trunkRadius: style.trunkRadius,
-            crownRadius: style.crownRadius,
-            crownBottom: style.crownBottom,
-            crownShape: style.crownShape,
-            poleRadius: style.poleRadius,
-            lightRadius: style.lightRadius,
-            lightFlux: style.lightFlux
-          }
-        )
-      }
-    );
+    return entries[high];
   }
 
-  // src/sources/buildAreaFeature.js
-  function buildAreaFeature(context, feature) {
-    const { backend: layer, area: area2, map } = context;
-    const coords = area2.coords;
-    const coordinates = featureAnchor(feature, layer.options.nightLight);
-    const geometry = feature.geometry, isTree = geometry.type === "Point";
-    const lon = coordinates[0], lat = coordinates[1];
-    if (coords) {
-      const anchor = map.project(
-        /* alloc */
-        new L.LatLng(lat, lon),
-        coords.z
-      );
-      if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) return;
-    }
-    const style = extrusionStyle(layer, feature);
-    if (style === null) {
-      context.skipped++;
-      return;
-    }
-    const { top, bottom = 0, color = 14267276 } = style;
-    const baseColor = parseColor(color);
-    if (context.jobs) {
-      prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
-      context.featureFaces.push(
+  // src/archives/getTileData.js
+  async function getTileData(layer, header, entry, id, signal) {
+    if (id - entry.tileId >= entry.runLength) return;
+    if (entry.offset + entry.length > header.tileDataLength) {
+      throw (
         /* alloc */
-        {
-          id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-          properties: feature.properties,
-          baseColor
-        }
+        new Error("PMTiles tile outside data section")
       );
-      return;
     }
-    const vertexStart = context.positions.length / 3;
-    if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
-    let polygon2;
-    if (geometry.type === "Polygon") buildAreaPolygon(context, geometry.coordinates, top, bottom, baseColor);
-    else if (geometry.type === "MultiPolygon") for (polygon2 of geometry.coordinates) buildAreaPolygon(context, polygon2, top, bottom, baseColor);
-    const vertexEnd = context.positions.length / 3;
-    context.featureFaces.push(
+    const data = await decompress(
+      await read(layer, header.tileDataOffset + entry.offset, entry.length, signal),
+      header.tileCompression
+    );
+    signal?.throwIfAborted();
+    return (
       /* alloc */
-      {
-        id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
-        properties: feature.properties,
-        baseColor,
-        faceStart: vertexStart / 3,
-        faceEnd: vertexEnd / 3,
-        vertexStart,
-        vertexEnd
+      { data }
+    );
+  }
+
+  // src/archives/findTile.js
+  async function findTile(layer, header, id, signal) {
+    let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
+    let firstOffset = -1, secondOffset = -1, thirdOffset = -1;
+    let depth, entries, entry, tile;
+    for (depth = 0; depth < 4; depth++) {
+      if (offset === firstOffset || offset === secondOffset || offset === thirdOffset) {
+        throw (
+          /* alloc */
+          new Error("Cyclic PMTiles directory")
+        );
+      }
+      if (depth === 0) firstOffset = offset;
+      else if (depth === 1) secondOffset = offset;
+      else if (depth === 2) thirdOffset = offset;
+      entries = await getDirectoryEntries(layer, offset, length, header.internalCompression);
+      signal?.throwIfAborted();
+      entry = findDirectoryEntry(entries, id);
+      if (!entry) return;
+      if (entry.runLength) {
+        tile = await getTileData(layer, header, entry, id, signal);
+        return tile;
+      }
+      if (entry.offset + entry.length > header.leafDirectoryLength) {
+        throw (
+          /* alloc */
+          new Error("PMTiles directory outside leaf section")
+        );
       }
+      offset = header.leafDirectoryOffset + entry.offset;
+      length = entry.length;
+    }
+    throw (
+      /* alloc */
+      new Error("PMTiles directory depth exceeds four levels")
     );
   }
 
-  // src/geometry/instanceAreaGeometry.js
-  function instanceAreaGeometry(context) {
-    const { positions, normals, colors, featureFaces } = context;
-    if (context.backend.options.nightLight || featureFaces.length < 2) return context;
-    const vertices = featureFaces[0].vertexEnd;
-    const length = vertices * 3;
-    if (!vertices || positions.length !== length * featureFaces.length) return context;
-    const originX = Math.trunc(positions[0]), originY = Math.trunc(positions[1]), originZ = Math.trunc(positions[2]);
-    const template = (
-      /* alloc */
-      new Float32Array(length)
-    );
-    let i, instance, face, start2;
-    for (i = 0; i < length; i++) template[i] = positions[i] - (i % 3 === 0 ? originX : i % 3 === 1 ? originY : originZ);
-    const offsets = (
-      /* alloc */
-      new Float32Array(featureFaces.length * 4)
-    );
-    for (instance = 0; instance < featureFaces.length; instance++) {
-      face = featureFaces[instance];
-      start2 = instance * length;
-      if (face.vertexStart !== instance * vertices || face.vertexEnd !== (instance + 1) * vertices) return context;
-      offsets[instance * 4] = originX + positions[start2] - positions[0];
-      offsets[instance * 4 + 1] = originY + positions[start2 + 1] - positions[1];
-      offsets[instance * 4 + 2] = originZ + positions[start2 + 2] - positions[2];
-      offsets[instance * 4 + 3] = instance * vertices;
-      for (i = 0; i < length; i++) {
-        if (Math.fround(template[i] + offsets[instance * 4 + i % 3]) !== Math.fround(positions[start2 + i]) || Math.fround(normals[i]) !== Math.fround(normals[start2 + i]) || Math.fround(colors[i]) !== Math.fround(colors[start2 + i])) return context;
+  // src/archives/getZxy.js
+  async function getZxy(layer, z, x, y, signal) {
+    if (!sceneLayers.has(layer)) return layer.getZxy(z, x, y, signal);
+    if (layer.options.archive && layer.options.archive !== layer) {
+      return getZxy(layer.options.archive, z, x, y, signal);
+    }
+    const id = tileId(z, x, y);
+    signal?.throwIfAborted();
+    const header = await getHeader(layer);
+    signal?.throwIfAborted();
+    if (z < header.minZoom || z > header.maxZoom) return;
+    return findTile(layer, header, id, signal);
+  }
+
+  // src/archives/loadSource.js
+  async function loadSource(layer, area2) {
+    if (geojsonByLayer.get(layer)) {
+      const { data, url } = layer.options;
+      if (data !== void 0 && url) {
+        throw (
+          /* alloc */
+          new Error("GeoJSON source requires either data or url")
+        );
+      }
+      if (data !== void 0) return data;
+      if (!url) {
+        throw (
+          /* alloc */
+          new Error("GeoJSON source requires either data or url")
+        );
+      }
+      const sourceUrl = (
+        /* alloc */
+        new URL(url, document.baseURI)
+      );
+      const response = await fetch(
+        sourceUrl,
+        /* alloc */
+        { signal: area2.request.signal }
+      );
+      if (!response.ok) {
+        throw (
+          /* alloc */
+          new Error(`Unable to load GeoJSON: HTTP ${response.status}`)
+        );
       }
+      return response.json();
     }
-    return (
+    const result = await getZxy(layer, area2.coords.z, area2.coords.x, area2.coords.y, area2.request.signal);
+    return result ? JSON.parse(archiveDecoder.decode(result.data)) : (
       /* alloc */
       {
-        positions: template,
-        normals: normals.slice(0, length),
-        colors: colors.slice(0, length),
-        instanceOffsets: offsets
+        type: "FeatureCollection",
+        features: (
+          /* alloc */
+          []
+        )
       }
     );
   }
 
-  // src/sources/attachAreaMesh.js
-  function attachAreaMesh(context) {
-    const { backend: layer, area: area2 } = context;
-    if (!context.positions.length) {
-      area2.mesh = null, area2.buildings = 0, area2.skipped = context.skipped, area2.done = true;
-      return;
-    }
-    const device = rendererByLayer.get(layer).device;
-    const data = context.preparedGeometry || instanceAreaGeometry(context);
-    const attributes = (
+  // src/sources/sourceAreaContext.js
+  init_radians();
+  function sourceAreaContext(layer, area2, map) {
+    const crs = map.options.crs, origin = crs.project(locationByLayer.get(layer));
+    return (
       /* alloc */
       {
-        position: (
+        backend: layer,
+        area: area2,
+        map,
+        crs,
+        origin,
+        metres: Math.cos(locationByLayer.get(layer).lat * radians),
+        positions: (
           /* alloc */
-          { size: 3, data: data.positions instanceof Float32Array ? data.positions : (
-            /* alloc */
-            new Float32Array(data.positions)
-          ) }
+          []
         ),
-        normal: (
+        normals: (
           /* alloc */
-          { size: 3, data: data.normals instanceof Float32Array ? data.normals : (
-            /* alloc */
-            new Float32Array(data.normals)
-          ) }
+          []
         ),
-        color: (
+        colors: (
           /* alloc */
-          { size: 3, data: data.colors instanceof Float32Array ? data.colors : (
-            /* alloc */
-            new Float32Array(data.colors)
-          ) }
-        )
+          []
+        ),
+        uvs: (
+          /* alloc */
+          []
+        ),
+        featureFaces: (
+          /* alloc */
+          []
+        ),
+        lights: (
+          /* alloc */
+          []
+        ),
+        supports: (
+          /* alloc */
+          /* @__PURE__ */ new Set()
+        ),
+        skipped: 0
       }
     );
-    if (data.instanceOffsets) attributes.instanceOffset = /* alloc */
-    { size: 4, data: data.instanceOffsets };
-    if (layer.options.nightLight) attributes.uv = /* alloc */
-    {
-      size: 2,
-      data: context.uvs instanceof Float32Array ? context.uvs : (
-        /* alloc */
-        new Float32Array(context.uvs)
-      )
-    };
-    let name, attribute;
-    for (name in attributes) {
-      attribute = attributes[name];
-      attribute.count = attribute.data.length / attribute.size;
-      attribute.buffer = device.createBuffer(
+  }
+
+  // src/globals/geometryWorkerUrl.js
+  var geometryWorkerUrl = void 0 ? new URL("../workers/geometryWorker.js", null.url).href : new URL("leaflet-city-mapper-worker.js", document.currentScript?.src || document.baseURI).href;
+
+  // src/workers/settleGeometryWorker.js
+  function settleGeometryWorker(task, event) {
+    if (event.type === "abort") task.reject(task.signal.reason);
+    else if (event.type === "error") task.reject(
+      /* alloc */
+      new Error(`Geometry worker failed: ${event.message}`)
+    );
+    else if (event.type === "messageerror") task.reject(
+      /* alloc */
+      new Error("Unable to receive geometry worker buffers")
+    );
+    else if (event.data.error) {
+      const error = (
         /* alloc */
-        {
-          size: Math.max(4, attribute.data.byteLength),
-          usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST
-        }
+        new Error(event.data.error.message)
       );
-      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    }
-    const meshGeometry = (
+      error.name = event.data.error.name;
+      task.reject(error);
+    } else task.resolve(event.data);
+  }
+
+  // src/workers/startGeometryWorker.js
+  function startGeometryWorker(task, resolve, reject) {
+    task.resolve = resolve;
+    task.reject = reject;
+    task.onEvent = settleGeometryWorker.bind(null, task);
+    task.worker.addEventListener("message", task.onEvent);
+    task.worker.addEventListener("error", task.onEvent);
+    task.worker.addEventListener("messageerror", task.onEvent);
+    task.signal.addEventListener(
+      "abort",
+      task.onEvent,
       /* alloc */
-      {
-        device,
-        bounds: data.bounds,
-        attributes,
-        drawRange: (
-          /* alloc */
-          { start: 0, count: attributes.position.count }
-        )
-      }
+      { once: true }
     );
-    area2.mesh = /* alloc */
-    {
-      ...emptyNode(),
-      device,
-      geometry: meshGeometry,
-      program: createProgram(
-        layer,
-        /* alloc */
-        {
-          instanced: Boolean(data.instanceOffsets),
-          vertexColors: true,
-          roofTexture: layer.options.roofTexture,
-          wallTexture: layer.options.wallTexture,
-          nightLight: Boolean(layer.options.nightLight),
-          alphaMode: layer.options.nightLight ? "BLEND" : void 0,
-          doubleSided: Boolean(layer.options.nightLight)
-        }
-      ),
-      id: nextId.value++,
-      renderOrder: 0,
-      fadeDuration: 250,
-      extras: (
-        /* alloc */
-        { featureFaces: context.featureFaces, lights: context.lights }
-      )
-    };
-    area2.buildings = context.featureFaces.length;
-    area2.skipped = context.skipped;
-    area2.done = true;
-    setParent(area2.mesh, rootByLayer.get(layer));
-    update(layer);
+    if (task.signal.aborted) {
+      reject(task.signal.reason);
+      return;
+    }
+    task.worker.postMessage(task.input);
   }
 
-  // src/globals/archiveDecoder.js
-  var archiveDecoder = new TextDecoder();
+  // src/weakmaps/geometryWorkersByMap.js
+  var geometryWorkersByMap = /* @__PURE__ */ new WeakMap();
 
-  // src/archives/tileId.js
-  function tileId(z, x, y) {
-    if (!Number.isInteger(z) || !Number.isInteger(x) || !Number.isInteger(y) || z < 0 || z > 26 || x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) {
-      throw (
+  // src/workers/closeGeometryWorkers.js
+  function closeGeometryWorkers(pool) {
+    pool.closed = true;
+    let entry;
+    for (entry of pool.entries) {
+      entry.closed = true;
+      entry.worker.terminate();
+      if (entry.task) entry.task.reject(
         /* alloc */
-        new Error("Invalid PMTiles tile coordinates")
+        new DOMException("Map removed", "AbortError")
       );
     }
-    let id = (4 ** z - 1) / 3;
-    const n = 2 ** z;
-    let s, rx, ry, swap;
-    for (s = n / 2; s >= 1; s /= 2) {
-      rx = x & s ? 1 : 0, ry = y & s ? 1 : 0;
-      id += s * s * (3 * rx ^ ry);
-      if (!ry) {
-        if (rx) {
-          x = n - 1 - x;
-          y = n - 1 - y;
-        }
-        swap = x;
-        x = y;
-        y = swap;
-      }
-    }
-    return id;
+    pool.entries.clear();
+    pool.idle.length = 0;
   }
 
-  // src/globals/directoryReader.js
-  var directoryReader = {
-    bytes: null,
-    cursor: 0
-  };
-
-  // src/archives/readVarint.js
-  function varint(reader) {
-    const { bytes } = reader;
-    let value = 0;
-    let factor, byte;
-    for (factor = 1; factor <= 2 ** 49; factor *= 128) {
-      if (reader.cursor >= bytes.length) {
-        throw (
-          /* alloc */
-          new Error("Truncated PMTiles directory")
-        );
-      }
-      byte = bytes[reader.cursor++];
-      value += (byte & 127) * factor;
-      if (!Number.isSafeInteger(value)) {
-        throw (
+  // src/workers/createGeometryWorker.js
+  function createGeometryWorker(url, pool) {
+    let workerUrl = url, blobUrl, worker;
+    if (globalThis.location) {
+      const resolved = (
+        /* alloc */
+        new URL(url, location.href)
+      );
+      if ((resolved.protocol === "https:" || resolved.protocol === "http:") && resolved.origin !== location.origin) {
+        blobUrl = URL.createObjectURL(
           /* alloc */
-          new Error("Invalid PMTiles directory integer")
+          new Blob(
+            /* alloc */
+            [`import ${JSON.stringify(resolved.href)};`],
+            /* alloc */
+            { type: "text/javascript" }
+          )
         );
+        workerUrl = blobUrl;
       }
-      if (byte < 128) return value;
     }
-    throw (
+    try {
+      worker = /* alloc */
+      new Worker(
+        workerUrl,
+        /* alloc */
+        { type: "module" }
+      );
+    } finally {
+      if (!worker && blobUrl) URL.revokeObjectURL(blobUrl);
+    }
+    const entry = (
       /* alloc */
-      new Error("Invalid PMTiles directory integer")
+      { url, pool, worker, blobUrl }
     );
+    if (pool) pool.entries.add(entry);
+    return entry;
   }
 
-  // src/archives/decodeDirectory.js
-  function decodeDirectory(data) {
-    const reader = directoryReader;
-    const bytes = (
-      /* alloc */
-      new Uint8Array(data)
-    );
-    reader.bytes = bytes;
-    reader.cursor = 0;
-    try {
-      const count = varint(reader);
-      if (count > (bytes.length - reader.cursor) / 4) {
-        throw (
-          /* alloc */
-          new Error("Invalid PMTiles directory count")
-        );
-      }
-      const entries = (
+  // src/workers/acquireGeometryWorker.js
+  function acquireGeometryWorker(map, url) {
+    let pool = map && geometryWorkersByMap.get(map);
+    if (map && !pool) {
+      pool = /* alloc */
+      { entries: (
         /* alloc */
-        new Array(count)
+        /* @__PURE__ */ new Set()
+      ), idle: (
+        /* alloc */
+        []
+      ), closed: false };
+      geometryWorkersByMap.set(map, pool);
+      map.once("unload", closeGeometryWorkers.bind(null, pool));
+    }
+    let entry, i;
+    if (pool) {
+      if (pool.closed) throw (
+        /* alloc */
+        new DOMException("Map removed", "AbortError")
       );
-      let tileId2 = 0;
-      let i, entry, value;
-      for (i = 0; i < count; i++) {
-        tileId2 += varint(reader);
-        if (!Number.isSafeInteger(tileId2) || i && tileId2 <= entries[i - 1].tileId) {
-          throw (
-            /* alloc */
-            new Error("Invalid PMTiles directory tile IDs")
-          );
-        }
-        entries[i] = /* alloc */
-        { tileId: tileId2, runLength: 0, length: 0, offset: 0 };
-      }
-      for (entry of entries) entry.runLength = varint(reader);
-      for (entry of entries) {
-        entry.length = varint(reader);
-        if (!entry.length) {
-          throw (
-            /* alloc */
-            new Error("Invalid PMTiles directory length")
-          );
-        }
+      for (i = 0; i < pool.idle.length; i++) {
+        if (pool.idle[i].url !== url) continue;
+        entry = pool.idle[i];
+        pool.idle.splice(i, 1);
+        return entry;
       }
-      for (i = 0; i < entries.length; i++) {
-        entry = entries[i];
-        value = varint(reader);
-        if (!value && !i) {
-          throw (
-            /* alloc */
-            new Error("Invalid PMTiles directory offset")
-          );
-        }
-        entry.offset = value ? value - 1 : entries[i - 1].offset + entries[i - 1].length;
+      entry = pool.idle.pop();
+      if (entry) {
+        entry.closed = true;
+        entry.worker.terminate();
+        pool.entries.delete(entry);
       }
-      if (reader.cursor !== bytes.length) {
-        throw (
+    }
+    return createGeometryWorker(url, pool);
+  }
+
+  // src/workers/buildAreaInWorker.js
+  async function buildAreaInWorker(context, signal) {
+    const entry = acquireGeometryWorker(context.map || context.backend._map, context.backend.options.workerUrl || geometryWorkerUrl);
+    const { worker, pool } = entry;
+    const task = (
+      /* alloc */
+      {
+        worker,
+        signal,
+        input: (
           /* alloc */
-          new Error("Trailing PMTiles directory data")
-        );
+          { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) }
+        )
       }
-      return entries;
+    );
+    entry.task = task;
+    let completed = false;
+    try {
+      const data = await /* alloc */
+      new Promise(startGeometryWorker.bind(null, task));
+      let i;
+      for (i = 0; i < data.ranges.length; i++) Object.assign(context.featureFaces[i], data.ranges[i]);
+      context.positions = data.positions;
+      context.uvs = data.uvs;
+      context.lights = data.lights;
+      context.preparedGeometry = data;
+      completed = true;
+    } finally {
+      worker.removeEventListener("message", task.onEvent);
+      worker.removeEventListener("error", task.onEvent);
+      worker.removeEventListener("messageerror", task.onEvent);
+      signal.removeEventListener("abort", task.onEvent);
+      entry.task = null;
+      if (completed && pool && !pool.closed && !signal.aborted) pool.idle.push(entry);
+      else {
+        if (!entry.closed) worker.terminate();
+        if (pool) pool.entries.delete(entry);
+      }
+      if (entry.blobUrl) {
+        URL.revokeObjectURL(entry.blobUrl);
+        entry.blobUrl = null;
+      }
+      context.jobs = null;
+    }
+  }
+
+  // src/projections/projectTreePoint.js
+  init_L();
+  function projectedTree(context, lon, lat) {
+    const { backend: layer, crs, origin, metres, map } = context;
+    const location2 = (
+      /* alloc */
+      new L.LatLng(lat, lon)
+    );
+    const point = crs.project(location2);
+    const elevation = mapElevationOf(map, location2), root = rootByLayer.get(layer);
+    return (
+      /* alloc */
+      {
+        x: (point.x - origin.x) * metres,
+        y: (point.y - origin.y) * metres,
+        ground: Number.isFinite(elevation) && Number.isFinite(root.position[1]) ? elevation - root.position[1] : 0
+      }
+    );
+  }
+
+  // src/globals/triangleContexts.js
+  var triangleContexts = [];
+
+  // src/sources/groundOffset.js
+  function groundOffset(point) {
+    return point.ground || 0;
+  }
+
+  // src/geometry/appendAreaTriangle.js
+  function addTriangle(context, a, ah, b, bh, c, ch, nx, ny, nz, color) {
+    const { backend: layer, positions, normals, colors, uvs } = context;
+    const ux = b.x - a.x, uy = bh - ah, uz = a.y - b.y;
+    const vx = c.x - a.x, vy = ch - ah, vz = a.y - c.y;
+    if ((uy * vz - uz * vy) * nx + (uz * vx - ux * vz) * ny + (ux * vy - uy * vx) * nz < 0) {
+      const point = b, height = bh;
+      b = c;
+      bh = ch;
+      c = point;
+      ch = height;
+    }
+    positions.push(
+      a.x,
+      ah + groundOffset(a),
+      -a.y,
+      b.x,
+      bh + groundOffset(b),
+      -b.y,
+      c.x,
+      ch + groundOffset(c),
+      -c.y
+    );
+    normals.push(nx, ny, nz, nx, ny, nz, nx, ny, nz);
+    colors.push(color.r, color.g, color.b, color.r, color.g, color.b, color.r, color.g, color.b);
+    if (layer.options.nightLight) uvs.push(...a.uv, ...b.uv, ...c.uv);
+  }
+
+  // src/geometry/addGeneratedTriangle.js
+  function addGeneratedTriangle(...args) {
+    addTriangle(triangleContexts[triangleContexts.length - 1], ...args);
+  }
+
+  // src/geometry/generateTreeGeometry.js
+  function generateTreeGeometry(context, generator, point, style) {
+    triangleContexts.push(context);
+    try {
+      generator(point, style, addGeneratedTriangle);
     } finally {
-      reader.bytes = null;
-      reader.cursor = 0;
+      triangleContexts.pop();
     }
   }
 
-  // src/archives/decompress.js
-  async function decompress(data, compression) {
-    if (compression === 1) return data;
-    if (compression !== 2) {
+  // src/globals/lampDirections.js
+  var lampDirections = [
+    { x: Math.cos(0 * Math.PI / 3), y: Math.sin(0 * Math.PI / 3), nx: Math.cos(0.5 * Math.PI / 3), nz: -Math.sin(0.5 * Math.PI / 3) },
+    { x: Math.cos(1 * Math.PI / 3), y: Math.sin(1 * Math.PI / 3), nx: Math.cos(1.5 * Math.PI / 3), nz: -Math.sin(1.5 * Math.PI / 3) },
+    { x: Math.cos(2 * Math.PI / 3), y: Math.sin(2 * Math.PI / 3), nx: Math.cos(2.5 * Math.PI / 3), nz: -Math.sin(2.5 * Math.PI / 3) },
+    { x: Math.cos(3 * Math.PI / 3), y: Math.sin(3 * Math.PI / 3), nx: Math.cos(3.5 * Math.PI / 3), nz: -Math.sin(3.5 * Math.PI / 3) },
+    { x: Math.cos(4 * Math.PI / 3), y: Math.sin(4 * Math.PI / 3), nx: Math.cos(4.5 * Math.PI / 3), nz: -Math.sin(4.5 * Math.PI / 3) },
+    { x: Math.cos(5 * Math.PI / 3), y: Math.sin(5 * Math.PI / 3), nx: Math.cos(5.5 * Math.PI / 3), nz: -Math.sin(5.5 * Math.PI / 3) }
+  ];
+
+  // src/geometry/createLampRing.js
+  function ring(point, radius) {
+    const points = (
+      /* alloc */
+      new Array(lampDirections.length)
+    );
+    let i;
+    for (i = 0; i < points.length; i++) {
+      points[i] = /* alloc */
+      {
+        x: point.x + lampDirections[i].x * radius,
+        y: point.y + lampDirections[i].y * radius,
+        ground: point.ground,
+        uv: (
+          /* alloc */
+          [3, 3]
+        )
+      };
+    }
+    return points;
+  }
+
+  // src/geometry/lampPostGeometry.js
+  function lampPostGeometry(point, style, addTriangle2) {
+    const color = parseColor(5264986), radius = style.poleRadius;
+    if (!Number.isFinite(radius) || radius <= 0) {
       throw (
         /* alloc */
-        new Error(`Unsupported PMTiles compression: ${compression}`)
+        new Error("Invalid lamp pole radius")
       );
     }
-    const blob = (
-      /* alloc */
-      new Blob(
-        /* alloc */
-        [data]
-      )
-    );
-    const stream = (
+    const center = (
       /* alloc */
-      new DecompressionStream("gzip")
+      {
+        ...point,
+        uv: (
+          /* alloc */
+          [3, 3]
+        )
+      }
     );
+    let r, low, high, points, i, a, b, nx, nz, section;
+    for (section = 0; section < 2; section++) {
+      r = section ? radius * 2.5 : radius;
+      low = section ? style.top - 0.25 : 0;
+      high = section ? style.top + 0.15 : style.top;
+      points = ring(point, r);
+      for (i = 0; i < 6; i++) {
+        a = points[i], b = points[(i + 1) % 6];
+        nx = lampDirections[i].nx, nz = lampDirections[i].nz;
+        addTriangle2(a, low, b, low, b, high, nx, 0, nz, color);
+        addTriangle2(a, low, b, high, a, high, nx, 0, nz, color);
+        addTriangle2(center, high, a, high, b, high, 0, 1, 0, color);
+        addTriangle2(center, low, b, low, a, low, 0, -1, 0, color);
+      }
+    }
+  }
+
+  // src/geometry/quad.js
+  function quad(addTriangle2, color, a, b, c, d, height, nx, ny, nz) {
+    if (typeof nx !== "number") {
+      addTriangle2(a, height, b, height, c, height, ...nx, color);
+      addTriangle2(a, height, c, height, d, height, ...nx, color);
+    } else {
+      addTriangle2(a, height, b, height, c, height, nx, ny, nz, color);
+      addTriangle2(a, height, c, height, d, height, nx, ny, nz, color);
+    }
+  }
+
+  // src/geometry/emitter.js
+  function emitter(point, u, v, axis) {
+    const r = 0.65;
     return (
       /* alloc */
-      new Response(blob.stream().pipeThrough(stream)).arrayBuffer()
+      {
+        x: point.x + (axis === 2 ? 0 : u * r),
+        y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),
+        ground: point.ground + (axis === 0 ? 0 : v * r),
+        uv: (
+          /* alloc */
+          [u, v]
+        )
+      }
     );
   }
 
-  // src/archives/loadDirectory.js
-  async function loadDirectory(layer, offset, length, compression) {
-    return decodeDirectory(await decompress(await read(layer, offset, length), compression));
+  // src/geometry/lightGeometry.js
+  function lightGeometry(point, style, addTriangle2) {
+    if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw (
+      /* alloc */
+      new Error("Invalid light radius")
+    );
+    const color = parseColor(style.color);
+    let axis;
+    for (axis = 0; axis < 3; axis++) {
+      quad(
+        addTriangle2,
+        color,
+        emitter(point, -1, -1, axis),
+        emitter(point, 1, -1, axis),
+        emitter(point, 1, 1, axis),
+        emitter(point, -1, 1, axis),
+        style.top,
+        axis === 2 ? 1 : 0,
+        axis === 0 ? 1 : 0,
+        axis === 1 ? 1 : 0
+      );
+    }
   }
 
-  // src/archives/getDirectoryEntries.js
-  async function getDirectoryEntries(layer, offset, length, compression) {
-    const directories = directoriesByLayer.get(layer);
-    const key = `${offset}:${length}`;
-    if (!directories.has(key)) {
-      if (directories.size >= 32) directories.delete(directories.keys().next().value);
-      directories.set(key, loadDirectory(layer, offset, length, compression));
-    }
-    const pending = directories.get(key);
-    try {
-      return await pending;
-    } catch (error) {
-      if (directories.get(key) === pending) directories.delete(key);
-      throw error;
+  // src/globals/roundProfile.js
+  var roundProfile = [
+    [0, 0],
+    [0.35, 0.8],
+    [0.6, 1],
+    [0.85, 0.7],
+    [1, 0]
+  ];
+
+  // src/globals/ringDirections.js
+  var ringDirections = [
+    {
+      x: Math.cos(0 * Math.PI / 4),
+      y: Math.sin(0 * Math.PI / 4),
+      nx: Math.cos((0 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((0 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(1 * Math.PI / 4),
+      y: Math.sin(1 * Math.PI / 4),
+      nx: Math.cos((1 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((1 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(2 * Math.PI / 4),
+      y: Math.sin(2 * Math.PI / 4),
+      nx: Math.cos((2 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((2 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(3 * Math.PI / 4),
+      y: Math.sin(3 * Math.PI / 4),
+      nx: Math.cos((3 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((3 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(4 * Math.PI / 4),
+      y: Math.sin(4 * Math.PI / 4),
+      nx: Math.cos((4 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((4 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(5 * Math.PI / 4),
+      y: Math.sin(5 * Math.PI / 4),
+      nx: Math.cos((5 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((5 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(6 * Math.PI / 4),
+      y: Math.sin(6 * Math.PI / 4),
+      nx: Math.cos((6 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((6 + 0.5) * Math.PI / 4)
+    },
+    {
+      x: Math.cos(7 * Math.PI / 4),
+      y: Math.sin(7 * Math.PI / 4),
+      nx: Math.cos((7 + 0.5) * Math.PI / 4),
+      nz: -Math.sin((7 + 0.5) * Math.PI / 4)
     }
-  }
+  ];
 
-  // src/archives/findDirectoryEntry.js
-  function findDirectoryEntry(entries, id) {
-    let low = 0, high = entries.length - 1, mid;
-    while (low <= high) {
-      mid = low + high >> 1;
-      if (entries[mid].tileId <= id) low = mid + 1;
-      else high = mid - 1;
+  // src/geometry/createTreeRing.js
+  function ring2(point, radius) {
+    const result = (
+      /* alloc */
+      new Array(ringDirections.length)
+    );
+    let i;
+    for (i = 0; i < result.length; i++) {
+      result[i] = /* alloc */
+      {
+        x: point.x + ringDirections[i].x * radius,
+        y: point.y + ringDirections[i].y * radius,
+        ground: point.ground
+      };
     }
-    return entries[high];
+    return result;
   }
 
-  // src/archives/getTileData.js
-  async function getTileData(layer, header, entry, id, signal) {
-    if (id - entry.tileId >= entry.runLength) return;
-    if (entry.offset + entry.length > header.tileDataLength) {
+  // src/geometry/surface.js
+  function surface(point, addTriangle2, lowRadius, low, highRadius, high, color) {
+    const lower = ring2(point, lowRadius), upper = ring2(point, highRadius);
+    let i, next, slope, length, nx, nz, ny, normalX, normalZ;
+    for (i = 0; i < 8; i++) {
+      next = (i + 1) % 8;
+      slope = (lowRadius - highRadius) / (high - low);
+      length = Math.hypot(1, slope);
+      ({ nx, nz } = ringDirections[i]);
+      ny = slope / length;
+      normalX = nx / length, normalZ = nz / length;
+      if (lowRadius) addTriangle2(lower[i], low, lower[next], low, upper[next], high, normalX, ny, normalZ, color);
+      if (highRadius) addTriangle2(lower[i], low, upper[next], high, upper[i], high, normalX, ny, normalZ, color);
+    }
+  }
+
+  // src/geometry/validateTree.js
+  function validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape) {
+    if (!Number.isFinite(trunkRadius) || !Number.isFinite(crownRadius) || !Number.isFinite(crownBottom) || trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top || crownShape !== "round" && crownShape !== "cone") {
       throw (
         /* alloc */
-        new Error("PMTiles tile outside data section")
+        new Error("Invalid tree dimensions or crown shape")
       );
     }
-    const data = await decompress(
-      await read(layer, header.tileDataOffset + entry.offset, entry.length, signal),
-      header.tileCompression
-    );
-    signal?.throwIfAborted();
-    return (
-      /* alloc */
-      { data }
-    );
   }
 
-  // src/archives/findTile.js
-  async function findTile(layer, header, id, signal) {
-    let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;
-    let firstOffset = -1, secondOffset = -1, thirdOffset = -1;
-    let depth, entries, entry, tile;
-    for (depth = 0; depth < 4; depth++) {
-      if (offset === firstOffset || offset === secondOffset || offset === thirdOffset) {
-        throw (
-          /* alloc */
-          new Error("Cyclic PMTiles directory")
-        );
-      }
-      if (depth === 0) firstOffset = offset;
-      else if (depth === 1) secondOffset = offset;
-      else if (depth === 2) thirdOffset = offset;
-      entries = await getDirectoryEntries(layer, offset, length, header.internalCompression);
-      signal?.throwIfAborted();
-      entry = findDirectoryEntry(entries, id);
-      if (!entry) return;
-      if (entry.runLength) {
-        tile = await getTileData(layer, header, entry, id, signal);
-        return tile;
-      }
-      if (entry.offset + entry.length > header.leafDirectoryLength) {
-        throw (
-          /* alloc */
-          new Error("PMTiles directory outside leaf section")
+  // src/geometry/treeGeometry.js
+  function treeGeometry(point, style, addTriangle2) {
+    const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = "round" } = style;
+    validateTree(trunkRadius, crownRadius, crownBottom, bottom, top, crownShape);
+    const trunk = parseColor(style.trunkColor ?? 7491898);
+    const crown = parseColor(style.color ?? 5210683);
+    surface(point, addTriangle2, trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);
+    let i, low, lr, high, hr;
+    if (crownShape === "cone") {
+      const base = ring2(point, crownRadius);
+      for (i = 0; i < 8; i++) addTriangle2(
+        point,
+        crownBottom,
+        base[i],
+        crownBottom,
+        base[(i + 1) % 8],
+        crownBottom,
+        0,
+        -1,
+        0,
+        crown
+      );
+      surface(point, addTriangle2, crownRadius, crownBottom, 0, top, crown);
+    } else {
+      for (i = 1; i < roundProfile.length; i++) {
+        [low, lr] = roundProfile[i - 1], [high, hr] = roundProfile[i];
+        surface(
+          point,
+          addTriangle2,
+          lr * crownRadius,
+          crownBottom + low * (top - crownBottom),
+          hr * crownRadius,
+          crownBottom + high * (top - crownBottom),
+          crown
         );
       }
-      offset = header.leafDirectoryOffset + entry.offset;
-      length = entry.length;
     }
-    throw (
-      /* alloc */
-      new Error("PMTiles directory depth exceeds four levels")
-    );
   }
 
-  // src/archives/getZxy.js
-  async function getZxy(layer, z, x, y, signal) {
-    if (!sceneLayers.has(layer)) return layer.getZxy(z, x, y, signal);
-    if (layer.options.archive && layer.options.archive !== layer) {
-      return getZxy(layer.options.archive, z, x, y, signal);
-    }
-    const id = tileId(z, x, y);
-    signal?.throwIfAborted();
-    const header = await getHeader(layer);
-    signal?.throwIfAborted();
-    if (z < header.minZoom || z > header.maxZoom) return;
-    return findTile(layer, header, id, signal);
+  // src/geometry/buildProjectedPoint.js
+  function buildProjectedPoint(context, projected, style, baseColor, support) {
+    const { top } = style;
+    if (context.backend.options.nightLight) {
+      if (!Number.isFinite(style.lightFlux) || style.lightFlux <= 0) throw (
+        /* alloc */
+        new Error("Invalid light flux")
+      );
+      if (style.poleRadius > 0 && !context.supports.has(support)) {
+        generateTreeGeometry(context, lampPostGeometry, projected, style);
+        context.supports.add(support);
+      }
+      generateTreeGeometry(context, lightGeometry, projected, style);
+      context.lights.push(
+        /* alloc */
+        {
+          position: (
+            /* alloc */
+            [projected.x, projected.ground + top, -projected.y]
+          ),
+          radius: Math.hypot(top, style.lightRadius),
+          color: (
+            /* alloc */
+            [baseColor.r, baseColor.g, baseColor.b]
+          ),
+          flux: style.lightFlux
+        }
+      );
+    } else generateTreeGeometry(context, treeGeometry, projected, style);
   }
 
-  // src/archives/loadSource.js
-  async function loadSource(layer, area2) {
-    if (geojsonByLayer.get(layer)) {
-      const { data, url } = layer.options;
-      if (data !== void 0 && url) {
-        throw (
-          /* alloc */
-          new Error("GeoJSON source requires either data or url")
-        );
-      }
-      if (data !== void 0) return data;
-      if (!url) {
-        throw (
-          /* alloc */
-          new Error("GeoJSON source requires either data or url")
-        );
-      }
-      const sourceUrl = (
+  // src/sources/buildAreaPoint.js
+  function buildAreaPoint(context, feature, lon, lat, style, baseColor) {
+    const projected = projectedTree(context, lon, lat);
+    buildProjectedPoint(context, projected, style, baseColor, feature.properties?.cod_ouvrag || `${lon},${lat}`);
+  }
+
+  // src/projections/projectRing.js
+  init_L();
+  function projectRing(context, ring3) {
+    const { backend: layer, crs, origin, metres, map } = context;
+    if (ring3.length < 4) throw (
+      /* alloc */
+      new Error("Invalid GeoJSON polygon ring")
+    );
+    const path = (
+      /* alloc */
+      []
+    );
+    const root = rootByLayer.get(layer);
+    let i, lng, lat, location2, point, elevation;
+    for (i = 0; i < ring3.length - 1; i++) {
+      lng = ring3[i][0], lat = ring3[i][1];
+      if (!Number.isFinite(lng) || !Number.isFinite(lat)) throw (
         /* alloc */
-        new URL(url, document.baseURI)
+        new Error("Invalid GeoJSON coordinates")
       );
-      const response = await fetch(
-        sourceUrl,
+      location2 = /* alloc */
+      new L.LatLng(lat, lng);
+      point = crs.project(location2);
+      elevation = mapElevationOf(map, location2);
+      path.push(
         /* alloc */
-        { signal: area2.request.signal }
+        {
+          x: (point.x - origin.x) * metres,
+          y: (point.y - origin.y) * metres,
+          ground: Number.isFinite(elevation) && Number.isFinite(root.position[1]) ? elevation - root.position[1] : 0
+        }
       );
-      if (!response.ok) {
-        throw (
-          /* alloc */
-          new Error(`Unable to load GeoJSON: HTTP ${response.status}`)
-        );
-      }
-      return response.json();
     }
-    const result = await getZxy(layer, area2.coords.z, area2.coords.x, area2.coords.y, area2.request.signal);
-    return result ? JSON.parse(archiveDecoder.decode(result.data)) : (
-      /* alloc */
-      {
-        type: "FeatureCollection",
-        features: (
-          /* alloc */
-          []
-        )
-      }
-    );
+    return path;
   }
 
-  // src/sources/sourceAreaContext.js
-  init_radians();
-  function sourceAreaContext(layer, area2, map) {
-    const crs = map.options.crs, origin = crs.project(locationByLayer.get(layer));
-    return (
+  // src/geometry/buildProjectedPolygon.js
+  function buildProjectedPolygon(context, paths, top, bottom, baseColor) {
+    const points = (
       /* alloc */
-      {
-        backend: layer,
-        area: area2,
-        map,
-        crs,
-        origin,
-        metres: Math.cos(locationByLayer.get(layer).lat * radians),
-        positions: (
-          /* alloc */
-          []
-        ),
-        normals: (
-          /* alloc */
-          []
-        ),
-        colors: (
-          /* alloc */
-          []
-        ),
-        uvs: (
-          /* alloc */
-          []
-        ),
-        featureFaces: (
-          /* alloc */
-          []
-        ),
-        lights: (
-          /* alloc */
-          []
-        ),
-        supports: (
-          /* alloc */
-          /* @__PURE__ */ new Set()
-        ),
-        skipped: 0
+      []
+    );
+    let path, point, a, b, c, index, sign, i, length, nx, nz;
+    for (path of paths) for (point of path) points.push(point);
+    for ([a, b, c] of triangulate(paths[0], paths.slice(1))) {
+      addTriangle(context, points[a], top, points[b], top, points[c], top, 0, 1, 0, baseColor);
+      if (bottom > 0) addTriangle(context, points[a], bottom, points[b], bottom, points[c], bottom, 0, -1, 0, baseColor);
+    }
+    for (index = 0; index < paths.length; index++) {
+      path = paths[index];
+      sign = isClockWise(path) === (index === 0) ? -1 : 1;
+      for (i = 0; i < path.length; i++) {
+        a = path[i], b = path[(i + 1) % path.length];
+        length = Math.hypot(b.x - a.x, b.y - a.y);
+        if (!length) continue;
+        nx = sign * (b.y - a.y) / length, nz = sign * (b.x - a.x) / length;
+        addTriangle(context, a, bottom, b, bottom, b, top, nx, 0, nz, baseColor);
+        addTriangle(context, a, bottom, b, top, a, top, nx, 0, nz, baseColor);
       }
-    );
+    }
   }
 
-  // src/globals/geometryWorkerUrl.js
-  var geometryWorkerUrl = void 0 ? new URL("../workers/geometryWorker.js", null.url).href : new URL("leaflet-city-mapper-worker.js", document.currentScript?.src || document.baseURI).href;
-
-  // src/workers/settleGeometryWorker.js
-  function settleGeometryWorker(task, event) {
-    if (event.type === "abort") task.reject(task.signal.reason);
-    else if (event.type === "error") task.reject(
+  // src/geometry/buildExtrudedPolygon.js
+  function buildAreaPolygon(context, rings, top, bottom, baseColor) {
+    if (!rings.length) throw (
       /* alloc */
-      new Error(`Geometry worker failed: ${event.message}`)
+      new Error("Empty GeoJSON polygon")
     );
-    else if (event.type === "messageerror") task.reject(
+    const paths = (
       /* alloc */
-      new Error("Unable to receive geometry worker buffers")
+      []
     );
-    else if (event.data.error) {
-      const error = (
-        /* alloc */
-        new Error(event.data.error.message)
-      );
-      error.name = event.data.error.name;
-      task.reject(error);
-    } else task.resolve(event.data);
+    let ring3;
+    for (ring3 of rings) paths.push(projectRing(context, ring3));
+    buildProjectedPolygon(context, paths, top, bottom, baseColor);
   }
 
-  // src/workers/startGeometryWorker.js
-  function startGeometryWorker(task, resolve, reject) {
-    task.resolve = resolve;
-    task.reject = reject;
-    task.onEvent = settleGeometryWorker.bind(null, task);
-    task.worker.addEventListener("message", task.onEvent);
-    task.worker.addEventListener("error", task.onEvent);
-    task.worker.addEventListener("messageerror", task.onEvent);
-    task.signal.addEventListener(
-      "abort",
-      task.onEvent,
+  // src/sources/featureAnchor.js
+  function featureAnchor(feature, nightLight) {
+    const geometry = feature?.geometry, point = geometry?.type === "Point";
+    if (nightLight && !point) throw (
       /* alloc */
-      { once: true }
+      new Error("Night lights require Point geometry")
     );
-    if (task.signal.aborted) {
-      reject(task.signal.reason);
-      return;
-    }
-    task.worker.postMessage(task.input);
+    if (geometry?.type !== "Polygon" && geometry?.type !== "MultiPolygon" && !point) throw (
+      /* alloc */
+      new Error("Unsupported GeoJSON geometry")
+    );
+    const coordinates = point ? geometry.coordinates : geometry.type === "Polygon" ? geometry.coordinates[0]?.[0] : geometry.coordinates[0]?.[0]?.[0];
+    if (!Number.isFinite(coordinates?.[0]) || !Number.isFinite(coordinates?.[1])) throw (
+      /* alloc */
+      new Error("Invalid GeoJSON coordinates")
+    );
+    return coordinates;
   }
 
-  // src/weakmaps/geometryWorkersByMap.js
-  var geometryWorkersByMap = /* @__PURE__ */ new WeakMap();
-
-  // src/workers/closeGeometryWorkers.js
-  function closeGeometryWorkers(pool) {
-    pool.closed = true;
-    let entry;
-    for (entry of pool.entries) {
-      entry.closed = true;
-      entry.worker.terminate();
-      if (entry.task) entry.task.reject(
+  // src/sources/extrusionStyle.js
+  function extrusionStyle(layer, feature) {
+    const style = layer.options.style(feature);
+    if (style === null) return null;
+    if (!style || typeof style !== "object") throw (
+      /* alloc */
+      new Error("style must return an extrusion style or null")
+    );
+    const { top, bottom = 0 } = style;
+    if (!Number.isFinite(top) || !Number.isFinite(bottom) || bottom < 0 || top <= bottom) {
+      throw (
         /* alloc */
-        new DOMException("Map removed", "AbortError")
+        new Error("Invalid extrusion heights: expected top > bottom >= 0")
       );
     }
-    pool.entries.clear();
-    pool.idle.length = 0;
+    return style;
   }
 
-  // src/workers/acquireGeometryWorker.js
-  function acquireGeometryWorker(map, url) {
-    let pool = map && geometryWorkersByMap.get(map);
-    if (map && !pool) {
-      pool = /* alloc */
-      { entries: (
-        /* alloc */
-        /* @__PURE__ */ new Set()
-      ), idle: (
-        /* alloc */
-        []
-      ), closed: false };
-      geometryWorkersByMap.set(map, pool);
-      map.once("unload", closeGeometryWorkers.bind(null, pool));
-    }
-    let entry, i;
-    if (pool) {
-      if (pool.closed) throw (
+  // src/sources/projectAreaPolygons.js
+  function projectAreaPolygons(context, geometry) {
+    const rings = geometry.type === "Polygon" ? (
+      /* alloc */
+      [geometry.coordinates]
+    ) : geometry.type === "MultiPolygon" ? geometry.coordinates : (
+      /* alloc */
+      []
+    );
+    const polygons = (
+      /* alloc */
+      []
+    );
+    let polygon2, ring3, paths;
+    for (polygon2 of rings) {
+      if (!polygon2.length) throw (
         /* alloc */
-        new DOMException("Map removed", "AbortError")
+        new Error("Empty GeoJSON polygon")
       );
-      for (i = 0; i < pool.idle.length; i++) {
-        if (pool.idle[i].url !== url) continue;
-        entry = pool.idle[i];
-        pool.idle.splice(i, 1);
-        return entry;
-      }
-      entry = pool.idle.pop();
-      if (entry) {
-        entry.closed = true;
-        entry.worker.terminate();
-        pool.entries.delete(entry);
-      }
+      paths = /* alloc */
+      [];
+      for (ring3 of polygon2) paths.push(projectRing(context, ring3));
+      polygons.push(paths);
     }
-    entry = /* alloc */
-    {
-      url,
-      pool,
-      worker: (
-        /* alloc */
-        new Worker(
-          url,
-          /* alloc */
-          { type: "module" }
-        )
-      )
-    };
-    if (pool) pool.entries.add(entry);
-    return entry;
+    return polygons;
   }
 
-  // src/workers/buildAreaInWorker.js
-  async function buildAreaInWorker(context, signal) {
-    const entry = acquireGeometryWorker(context.map || context.backend._map, context.backend.options.workerUrl || geometryWorkerUrl);
-    const { worker, pool } = entry;
-    const task = (
+  // src/sources/prepareAreaGeometryJob.js
+  function prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor) {
+    const geometry = feature.geometry;
+    const polygons = projectAreaPolygons(context, geometry);
+    const point = geometry.type === "Point" ? projectedTree(context, lon, lat) : null;
+    const nightLight = context.backend.options.nightLight;
+    const crownColor = point ? parseColor(style.color ?? (nightLight ? void 0 : 5210683)) : baseColor;
+    const trunkColor = point && !nightLight ? parseColor(style.trunkColor ?? 7491898) : null;
+    context.jobs.push(
       /* alloc */
       {
-        worker,
-        signal,
-        input: (
+        point,
+        polygons,
+        baseColor: (
           /* alloc */
-          { jobs: context.jobs, nightLight: Boolean(context.backend.options.nightLight) }
+          { r: baseColor.r, g: baseColor.g, b: baseColor.b }
+        ),
+        support: feature.properties?.cod_ouvrag || `${lon},${lat}`,
+        style: (
+          /* alloc */
+          {
+            top: style.top,
+            bottom: style.bottom ?? 0,
+            color: (
+              /* alloc */
+              { r: crownColor.r, g: crownColor.g, b: crownColor.b }
+            ),
+            trunkColor: trunkColor ? (
+              /* alloc */
+              { r: trunkColor.r, g: trunkColor.g, b: trunkColor.b }
+            ) : void 0,
+            trunkRadius: style.trunkRadius,
+            crownRadius: style.crownRadius,
+            crownBottom: style.crownBottom,
+            crownShape: style.crownShape,
+            poleRadius: style.poleRadius,
+            lightRadius: style.lightRadius,
+            lightFlux: style.lightFlux
+          }
         )
       }
     );
-    entry.task = task;
-    let completed = false;
-    try {
-      const data = await /* alloc */
-      new Promise(startGeometryWorker.bind(null, task));
-      let i;
-      for (i = 0; i < data.ranges.length; i++) Object.assign(context.featureFaces[i], data.ranges[i]);
-      context.positions = data.positions;
-      context.uvs = data.uvs;
-      context.lights = data.lights;
-      context.preparedGeometry = data;
-      completed = true;
-    } finally {
-      worker.removeEventListener("message", task.onEvent);
-      worker.removeEventListener("error", task.onEvent);
-      worker.removeEventListener("messageerror", task.onEvent);
-      signal.removeEventListener("abort", task.onEvent);
-      entry.task = null;
-      if (completed && pool && !pool.closed && !signal.aborted) pool.idle.push(entry);
-      else {
-        if (!entry.closed) worker.terminate();
-        if (pool) pool.entries.delete(entry);
+  }
+
+  // src/sources/matchesAreaTile.js
+  init_L();
+  function matchesAreaTile(map, coords, lon, lat) {
+    if (!coords) return true;
+    const anchor = map.project(
+      /* alloc */
+      new L.LatLng(lat, lon),
+      coords.z
+    );
+    return Math.floor(anchor.x / 256) === coords.x && Math.floor(anchor.y / 256) === coords.y;
+  }
+
+  // src/sources/buildAreaFeature.js
+  function buildAreaFeature(context, feature) {
+    const { backend: layer, area: area2, map } = context;
+    const coords = area2.coords;
+    const coordinates = featureAnchor(feature, layer.options.nightLight);
+    const geometry = feature.geometry, isTree = geometry.type === "Point";
+    const lon = coordinates[0], lat = coordinates[1];
+    if (!matchesAreaTile(map, coords, lon, lat)) return;
+    const style = extrusionStyle(layer, feature);
+    if (style === null) {
+      context.skipped++;
+      return;
+    }
+    const { top, bottom = 0, color = 14267276 } = style;
+    const baseColor = parseColor(color);
+    if (context.jobs) {
+      prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor);
+      context.featureFaces.push(
+        /* alloc */
+        {
+          id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
+          properties: feature.properties,
+          baseColor
+        }
+      );
+      return;
+    }
+    const vertexStart = context.positions.length / 3;
+    if (isTree) buildAreaPoint(context, feature, lon, lat, style, baseColor);
+    let polygon2;
+    if (geometry.type === "Polygon") buildAreaPolygon(context, geometry.coordinates, top, bottom, baseColor);
+    else if (geometry.type === "MultiPolygon") for (polygon2 of geometry.coordinates) buildAreaPolygon(context, polygon2, top, bottom, baseColor);
+    const vertexEnd = context.positions.length / 3;
+    context.featureFaces.push(
+      /* alloc */
+      {
+        id: feature.id ?? feature.properties?.objectid ?? JSON.stringify(geometry),
+        properties: feature.properties,
+        baseColor,
+        faceStart: vertexStart / 3,
+        faceEnd: vertexEnd / 3,
+        vertexStart,
+        vertexEnd
       }
-      context.jobs = null;
+    );
+  }
+
+  // src/sources/buildAreaFeatures.js
+  async function buildAreaFeatures(context, area2, features) {
+    let deadline = performance.now() + 4, feature;
+    for (feature of features) {
+      if (area2.request.signal.aborted) return;
+      if (performance.now() >= deadline) {
+        await /* alloc */
+        new Promise(requestAnimationFrame);
+        if (area2.request.signal.aborted) return;
+        deadline = performance.now() + 4;
+      }
+      buildAreaFeature(context, feature);
     }
   }
 
   // src/sources/buildArea.js
   async function buildArea(layer, area2, map) {
-    let feature;
     try {
       await /* alloc */
       new Promise(requestAnimationFrame);
@@ -8913,17 +8976,8 @@
         context.jobs = /* alloc */
         [];
       }
-      let deadline = performance.now() + 4;
-      for (feature of data.features) {
-        if (area2.request.signal.aborted) return;
-        if (performance.now() >= deadline) {
-          await /* alloc */
-          new Promise(requestAnimationFrame);
-          if (area2.request.signal.aborted) return;
-          deadline = performance.now() + 4;
-        }
-        buildAreaFeature(context, feature);
-      }
+      await buildAreaFeatures(context, area2, data.features);
+      if (area2.request.signal.aborted) return;
       if (context.jobs) await buildAreaInWorker(context, area2.request.signal);
       if (area2.request.signal.aborted) return;
       attachAreaMesh(context);
@@ -10261,26 +10315,26 @@
       /* alloc */
       new Error("glTF mesh has no positions")
     );
-    const vertexCount = attributes.position.data.length / 3;
-    if (attributes.position.size !== 3 || vertexCount < 3) throw (
+    const vertexCount2 = attributes.position.data.length / 3;
+    if (attributes.position.size !== 3 || vertexCount2 < 3) throw (
       /* alloc */
       new Error("Invalid glTF vertex attributes")
     );
     let attribute;
     for (attribute of Object.values(attributes)) {
-      if (attribute.data.length / attribute.size !== vertexCount) throw (
+      if (attribute.data.length / attribute.size !== vertexCount2) throw (
         /* alloc */
         new Error("Invalid glTF vertex attributes")
       );
     }
     return (
       /* alloc */
-      { attributes, vertexCount }
+      { attributes, vertexCount: vertexCount2 }
     );
   }
 
   // src/models/readModelIndices.js
-  function readModelIndices(description, primitive, attributes, vertexCount) {
+  function readModelIndices(description, primitive, attributes, vertexCount2) {
     if (primitive.indices !== void 0) {
       const index = readAccessor(description, primitive.indices);
       attributes.index = /* alloc */
@@ -10292,11 +10346,11 @@
         );
       }
       let value;
-      for (value of index.indices) if (value >= vertexCount) throw (
+      for (value of index.indices) if (value >= vertexCount2) throw (
         /* alloc */
         new Error("Invalid glTF triangle indices")
       );
-    } else if (vertexCount % 3) {
+    } else if (vertexCount2 % 3) {
       throw (
         /* alloc */
         new Error("Incomplete glTF triangle")
@@ -10383,13 +10437,13 @@
       }
     );
     group.matrix = nodeMatrix(spec);
-    let primitive, attributeData, attributes, vertexCount, built, mesh, child;
+    let primitive, attributeData, attributes, vertexCount2, built, mesh, child;
     if (spec.mesh !== void 0) {
       for (primitive of description.meshes[spec.mesh].primitives) {
         attributeData = readModelAttributes(description, primitive);
         attributes = attributeData.attributes;
-        vertexCount = attributeData.vertexCount;
-        readModelIndices(description, primitive, attributes, vertexCount);
+        vertexCount2 = attributeData.vertexCount;
+        readModelIndices(description, primitive, attributes, vertexCount2);
         built = createModelGeometry(context, primitive, attributes);
         mesh = /* alloc */
         {
@@ -14446,8 +14500,8 @@
   function local2(output) {
     const { layer, state } = this;
     const map = layer._map, crs = map.options.crs;
-    const location = locationByLayer.get(layer), root = rootByLayer.get(layer);
-    const origin = crs.project(location), metres = Math.cos(location.lat * radians);
+    const location2 = locationByLayer.get(layer), root = rootByLayer.get(layer);
+    const origin = crs.project(location2), metres = Math.cos(location2.lat * radians);
     const p = crs.project(state.latlng);
     const ground = mapElevationOf(map, state.latlng) || 0;
     output[0] = (p.x - origin.x) * metres;
@@ -14534,49 +14588,21 @@
   init_mapGetBearing();
   init_mapSetPitch();
 
-  // src/utils/wrap.js
-  function wrap(angle) {
-    return Math.atan2(Math.sin(angle), Math.cos(angle));
-  }
-
-  // src/picking/shouldSkipOther.js
-  function shouldSkipOther(other, layer) {
-    return other === layer || typeByLayer.get(other) === "terrain" || typeByLayer.get(other) === "traffic";
-  }
-
-  // src/walk/landWalker.js
-  function land(previousY) {
-    const ray = raycasterByLayer.get(this.layer);
-    const feet = local2.call(this, this.local), root = rootByLayer.get(this.layer);
-    const x = root.position[0] + feet[0] * root.scale[0];
-    const y = root.position[1] + feet[1] * root.scale[1];
-    const z = root.position[2] + feet[2] * root.scale[2];
-    if (y > previousY || this.verticalSpeed > 0) return;
-    updateWorldMatrix(sceneByLayer.get(this.layer));
-    ray.origin[0] = x;
-    ray.origin[1] = previousY + 0.01;
-    ray.origin[2] = z;
-    ray.direction[0] = 0;
-    ray.direction[1] = -1;
-    ray.direction[2] = 0;
-    ray.meshes.length = 0;
-    let layer, hit2;
-    for (layer of layersByLayer.get(sharedByLayer.get(this.layer))) {
-      if (shouldSkipOther(layer, this.layer) || kindByLayer.get(layer) === "raster" || layer.options.nightLight) continue;
-      traverse(rootByLayer.get(layer), collectVisibleMesh2, ray.meshes);
-    }
-    for (hit2 of intersectMeshes(ray, ray.meshes)) {
-      if (hit2.point[1] < y - 1e-3) break;
-      this.state.height += (hit2.point[1] - y) / root.scale[1];
-      this.verticalSpeed = 0;
-      break;
+  // src/walk/stepWalkerHeight.js
+  function stepWalkerHeight(dt) {
+    if (this.keys.has("Space")) {
+      this.verticalSpeed = 6;
+      this.state.height += this.verticalSpeed * dt;
+      return true;
     }
-    ray.meshes.length = 0;
+    if (!this.verticalSpeed && !this.state.height) return false;
+    this.state.height = Math.max(0, this.state.height + this.verticalSpeed * dt - 9.81 * dt * dt / 2);
+    this.verticalSpeed = this.state.height > 0 ? this.verticalSpeed - 9.81 * dt : 0;
+    return true;
   }
 
-  // src/walk/moveWalker.js
+  // src/walk/resolveWalkerPosition.js
   init_L();
-  init_radians();
 
   // src/globals/CELL.js
   var CELL = 8;
@@ -14603,8 +14629,8 @@
   function collider(mesh) {
     let c = colliders.get(mesh.geometry);
     if (c) return c;
-    const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
-    const vertices = index ? index.count : p.length / 3;
+    const m = mesh.worldMatrix, { position, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
+    const vertices = vertexCount(position, index);
     const count = vertices * (instanceOffset?.count ?? 1);
     const tri = (
       /* alloc */
@@ -14667,34 +14693,269 @@
       nrm.push(nx / h, nz / h);
       indexTriangle(cells, v, t);
     }
-    c = /* alloc */
-    {
-      tri: Float32Array.from(tri),
-      nrm: Float32Array.from(nrm),
-      cells,
-      maxX,
-      origin: (
-        /* alloc */
-        [m[12], m[13], m[14]]
-      )
-    };
-    colliders.set(mesh.geometry, c);
-    return c;
+    c = /* alloc */
+    {
+      tri: Float32Array.from(tri),
+      nrm: Float32Array.from(nrm),
+      cells,
+      maxX,
+      origin: (
+        /* alloc */
+        [m[12], m[13], m[14]]
+      )
+    };
+    colliders.set(mesh.geometry, c);
+    return c;
+  }
+
+  // src/collision/horizontalRay.js
+  function horizontalRay(v, t, ox, oy, oz, dx, dz) {
+    const i = t * 9, ex = v[i + 3] - v[i], ey = v[i + 4] - v[i + 1], ez = v[i + 5] - v[i + 2];
+    const fx = v[i + 6] - v[i], fy = v[i + 7] - v[i + 1], fz = v[i + 8] - v[i + 2];
+    const px = -dz * fy, py = dz * fx - dx * fz, pz = dx * fy, det = ex * px + ey * py + ez * pz;
+    if (Math.abs(det) < 1e-9) return -1;
+    const tx = ox - v[i], ty = oy - v[i + 1], tz = oz - v[i + 2], u = (tx * px + ty * py + tz * pz) / det;
+    if (u < 0 || u > 1) return -1;
+    const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex, w = (dx * qx + dz * qz) / det;
+    if (w < 0 || u + w > 1) return -1;
+    return (fx * qx + fy * qy + fz * qz) / det;
+  }
+
+  // src/collision/collectIntersections.js
+  function collectIntersections(shape, x, y, z, seen, hits, end, iz) {
+    let ix, cell, triangle3, distance;
+    for (ix = Math.floor(x / CELL); ix <= end; ix++) {
+      cell = shape.cells.get(`${ix},${iz}`);
+      if (!cell) continue;
+      for (triangle3 of cell) {
+        if (seen.has(triangle3)) continue;
+        seen.add(triangle3);
+        distance = horizontalRay(shape.tri, triangle3, x, y, z, 1, 0);
+        if (distance > 1e-4) hits.push(distance);
+      }
+    }
+  }
+
+  // src/collision/countCrossings.js
+  function countCrossings(hits) {
+    let ix, j, distance;
+    for (ix = 1; ix < hits.length; ix++) {
+      distance = hits[ix];
+      j = ix - 1;
+      while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
+      hits[j + 1] = distance;
+    }
+    let crossings = 0, previous = -Infinity;
+    for (distance of hits) {
+      if (distance - previous > 1e-4) crossings++;
+      previous = distance;
+    }
+    return crossings;
+  }
+
+  // src/collision/insideMesh.js
+  function insideMesh(mesh, x, y, z, seen, intersections) {
+    const geometry = mesh.geometry;
+    if (!mesh.visible || !geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return false;
+    if (!geometry.bounds) computeBounds(geometry);
+    const bounds = geometry.bounds;
+    const world = mesh.worldMatrix;
+    const center = bounds.center;
+    const cx = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
+    const cy = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
+    const cz = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
+    const radius = bounds.radius * Math.max(
+      Math.hypot(world[0], world[1], world[2]),
+      Math.hypot(world[4], world[5], world[6]),
+      Math.hypot(world[8], world[9], world[10])
+    );
+    if (Math.hypot(cx - x, cy - y, cz - z) > radius) return false;
+    const shape = collider(mesh);
+    const end = Math.floor(shape.maxX / CELL);
+    if (x >= shape.maxX) return false;
+    const iz = Math.floor(z / CELL);
+    const hits = intersections;
+    hits.length = 0;
+    seen.clear();
+    collectIntersections(shape, x, y, z, seen, hits, end, iz);
+    return countCrossings(hits) % 2 === 1;
+  }
+
+  // src/collision/setTrafficNormal.js
+  function setTrafficNormal(data, x, z, distance, dx, dz) {
+    if (distance < 1e-6) {
+      data.normal[0] = -dx;
+      data.normal[1] = -dz;
+    } else {
+      data.normal[0] = x / distance;
+      data.normal[1] = z / distance;
+    }
+  }
+
+  // src/collision/trafficCollision.js
+  function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
+    const state = trafficByLayer.get(layer);
+    if (!state?.mesh || !state.trips.length) return false;
+    let bounds = state.collisionBounds;
+    if (!bounds) {
+      bounds = state.collisionBounds = /* alloc */
+      { radius: 0, minY: Infinity, maxY: -Infinity };
+      let i, px2, py, pz2;
+      for (i = 0; i < state.template.position.length; i += 3) {
+        px2 = state.template.position[i];
+        py = state.template.position[i + 1];
+        pz2 = state.template.position[i + 2];
+        bounds.radius = Math.max(bounds.radius, Math.hypot(px2, pz2));
+        bounds.minY = Math.min(bounds.minY, py);
+        bounds.maxY = Math.max(bounds.maxY, py);
+      }
+    }
+    const root = rootByLayer.get(layer), position = state.position ||= /* alloc */
+    {};
+    const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
+    const radius = bounds.radius * scale + 0.35;
+    let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
+    for (trip of state.trips) {
+      ({ x: px, y: bottom, z: pz } = locateTraffic(state, trip, position));
+      bottom = root.position[1] + (bottom + bounds.minY) * root.scale[1];
+      top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
+      if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) continue;
+      px = root.position[0] + px * root.scale[0];
+      pz = root.position[2] + pz * root.scale[2];
+      projection = (px - x) * dx + (pz - z) * dz;
+      closest = Math.max(0, Math.min(reach, projection));
+      rx = x + closest * dx - px;
+      rz = z + closest * dz - pz;
+      perpendicular = rx * rx + rz * rz;
+      if (perpendicular >= radius * radius) continue;
+      if (reach === 0) {
+        data.found = true;
+        distance = Math.hypot(x - px, z - pz);
+        data.normal[0] = distance ? (x - px) / distance : 0;
+        data.normal[1] = distance ? (z - pz) / distance : 0;
+        continue;
+      }
+      entry = Math.max(0, projection - Math.sqrt(radius * radius - perpendicular));
+      if (entry > reach || entry >= data.best) continue;
+      data.best = entry;
+      data.found = true;
+      distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
+      setTrafficNormal(data, x + entry * dx - px, z + entry * dz - pz, distance, dx, dz);
+    }
+    return data.found;
+  }
+
+  // src/collision/insideWalker.js
+  function insideWalker(context) {
+    const { layer, local: localBuffer, hitData } = context;
+    const shared = sharedByLayer.get(layer);
+    if (!shared || !layersByLayer.get(shared)) return false;
+    updateWorldMatrix(sceneByLayer.get(layer));
+    const root = rootByLayer.get(layer);
+    const feet = local2.call(context, localBuffer);
+    const x = root.position[0] + feet[0] * root.scale[0];
+    const y = root.position[1] + feet[1] * root.scale[1];
+    const z = root.position[2] + feet[2] * root.scale[2];
+    const layers = layersByLayer.get(shared);
+    let other, node, child, nodes;
+    for (other of layers) {
+      if (other === layer || kindByLayer.get(other) === "terrain") continue;
+      if (kindByLayer.get(other) === "traffic") {
+        hitData.best = 0;
+        hitData.found = false;
+        if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
+        continue;
+      }
+      nodes = hitData.nodes;
+      nodes.length = 0;
+      if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
+      while (nodes.length) {
+        node = nodes.pop();
+        if (!node.visible) continue;
+        if (node.geometry && (insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) || insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections))) return true;
+        for (child of node.children) nodes.push(child);
+      }
+    }
+    return false;
+  }
+
+  // src/walk/resolveWalkerPosition.js
+  function resolveWalkerPosition() {
+    if (!this.saved || !insideWalker(this)) return false;
+    const map = this.layer._map;
+    const origin = this.state.latlng;
+    const height = this.state.height;
+    let distance, angle, candidate;
+    for (distance = 0.5; distance <= 20; distance += 0.5) {
+      for (angle = 0; angle < Math.PI * 2; angle += Math.PI / 4) {
+        candidate = /* alloc */
+        new L.LatLng(
+          origin.lat + Math.cos(angle) * distance / 111320,
+          origin.lng + Math.sin(angle) * distance / (111320 * Math.cos(origin.lat * Math.PI / 180))
+        );
+        this.state.latlng = candidate;
+        this.state.height = 0;
+        if (!insideWalker(this)) {
+          this.verticalSpeed = 0;
+          map.setView(
+            candidate,
+            map.getZoom(),
+            /* alloc */
+            { animate: false }
+          );
+          return true;
+        }
+      }
+    }
+    this.state.latlng = origin;
+    this.state.height = height;
+    return false;
   }
 
-  // src/collision/horizontalRay.js
-  function horizontalRay(v, t, ox, oy, oz, dx, dz) {
-    const i = t * 9, ex = v[i + 3] - v[i], ey = v[i + 4] - v[i + 1], ez = v[i + 5] - v[i + 2];
-    const fx = v[i + 6] - v[i], fy = v[i + 7] - v[i + 1], fz = v[i + 8] - v[i + 2];
-    const px = -dz * fy, py = dz * fx - dx * fz, pz = dx * fy, det = ex * px + ey * py + ez * pz;
-    if (Math.abs(det) < 1e-9) return -1;
-    const tx = ox - v[i], ty = oy - v[i + 1], tz = oz - v[i + 2], u = (tx * px + ty * py + tz * pz) / det;
-    if (u < 0 || u > 1) return -1;
-    const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex, w = (dx * qx + dz * qz) / det;
-    if (w < 0 || u + w > 1) return -1;
-    return (fx * qx + fy * qy + fz * qz) / det;
+  // src/utils/wrap.js
+  function wrap(angle) {
+    return Math.atan2(Math.sin(angle), Math.cos(angle));
+  }
+
+  // src/picking/shouldSkipOther.js
+  function shouldSkipOther(other, layer) {
+    return other === layer || typeByLayer.get(other) === "terrain" || typeByLayer.get(other) === "traffic";
+  }
+
+  // src/walk/landWalker.js
+  function land(previousY) {
+    const ray = raycasterByLayer.get(this.layer);
+    const feet = local2.call(this, this.local), root = rootByLayer.get(this.layer);
+    const x = root.position[0] + feet[0] * root.scale[0];
+    const y = root.position[1] + feet[1] * root.scale[1];
+    const z = root.position[2] + feet[2] * root.scale[2];
+    if (y > previousY || this.verticalSpeed > 0) return;
+    updateWorldMatrix(sceneByLayer.get(this.layer));
+    ray.origin[0] = x;
+    ray.origin[1] = previousY + 0.01;
+    ray.origin[2] = z;
+    ray.direction[0] = 0;
+    ray.direction[1] = -1;
+    ray.direction[2] = 0;
+    ray.meshes.length = 0;
+    let layer, hit2;
+    for (layer of layersByLayer.get(sharedByLayer.get(this.layer))) {
+      if (shouldSkipOther(layer, this.layer) || kindByLayer.get(layer) === "raster" || layer.options.nightLight) continue;
+      traverse(rootByLayer.get(layer), collectVisibleMesh2, ray.meshes);
+    }
+    for (hit2 of intersectMeshes(ray, ray.meshes)) {
+      if (hit2.point[1] < y - 1e-3) break;
+      this.state.height += (hit2.point[1] - y) / root.scale[1];
+      this.verticalSpeed = 0;
+      break;
+    }
+    ray.meshes.length = 0;
   }
 
+  // src/walk/moveWalker.js
+  init_L();
+  init_radians();
+
   // src/picking/hitColliderCell.js
   function hitColliderCell(cell, c, data, ox, oy, oz) {
     const { dx, dz, seen } = data;
@@ -14734,63 +14995,6 @@
       }
   }
 
-  // src/collision/trafficCollision.js
-  function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
-    const state = trafficByLayer.get(layer);
-    if (!state?.mesh || !state.trips.length) return false;
-    let bounds = state.collisionBounds;
-    if (!bounds) {
-      bounds = state.collisionBounds = { radius: 0, minY: Infinity, maxY: -Infinity };
-      let i, px2, py, pz2;
-      for (i = 0; i < state.template.position.length; i += 3) {
-        px2 = state.template.position[i];
-        py = state.template.position[i + 1];
-        pz2 = state.template.position[i + 2];
-        bounds.radius = Math.max(bounds.radius, Math.hypot(px2, pz2));
-        bounds.minY = Math.min(bounds.minY, py);
-        bounds.maxY = Math.max(bounds.maxY, py);
-      }
-    }
-    const root = rootByLayer.get(layer), position = state.position ||= {};
-    const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
-    const radius = bounds.radius * scale + 0.35;
-    let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
-    for (trip of state.trips) {
-      ({ x: px, y: bottom, z: pz } = locateTraffic(state, trip, position));
-      bottom = root.position[1] + (bottom + bounds.minY) * root.scale[1];
-      top = root.position[1] + (position.y + bounds.maxY) * root.scale[1];
-      if (bottom > y + 1.7 * scale || top < y + 0.2 * scale) continue;
-      px = root.position[0] + px * root.scale[0];
-      pz = root.position[2] + pz * root.scale[2];
-      projection = (px - x) * dx + (pz - z) * dz;
-      closest = Math.max(0, Math.min(reach, projection));
-      rx = x + closest * dx - px;
-      rz = z + closest * dz - pz;
-      perpendicular = rx * rx + rz * rz;
-      if (perpendicular >= radius * radius) continue;
-      if (reach === 0) {
-        data.found = true;
-        distance = Math.hypot(x - px, z - pz);
-        data.normal[0] = distance ? (x - px) / distance : 0;
-        data.normal[1] = distance ? (z - pz) / distance : 0;
-        continue;
-      }
-      entry = Math.max(0, projection - Math.sqrt(radius * radius - perpendicular));
-      if (entry > reach || entry >= data.best) continue;
-      data.best = entry;
-      data.found = true;
-      distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
-      if (distance < 1e-6) {
-        data.normal[0] = -dx;
-        data.normal[1] = -dz;
-      } else {
-        data.normal[0] = (x + entry * dx - px) / distance;
-        data.normal[1] = (z + entry * dz - pz) / distance;
-      }
-    }
-    return data.found;
-  }
-
   // src/picking/hit.js
   function hit(layer, x, y, z, dx, dz, reach, data) {
     updateWorldMatrix(sceneByLayer.get(layer));
@@ -14834,19 +15038,6 @@
     this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;
   }
 
-  // src/walk/stepWalkerHeight.js
-  function stepWalkerHeight(dt) {
-    if (this.keys.has("Space")) {
-      this.verticalSpeed = 6;
-      this.state.height += this.verticalSpeed * dt;
-      return true;
-    }
-    if (!this.verticalSpeed && !this.state.height) return false;
-    this.state.height = Math.max(0, this.state.height + this.verticalSpeed * dt - 9.81 * dt * dt / 2);
-    this.verticalSpeed = this.state.height > 0 ? this.verticalSpeed - 9.81 * dt : 0;
-    return true;
-  }
-
   // src/walk/updateWalkerView.js
   init_degrees();
   init_radians();
@@ -14873,123 +15064,19 @@
     return false;
   }
 
-  // src/walk/resolveWalkerPosition.js
-  init_L();
-
-  // src/collision/insideMesh.js
-  function insideMesh(mesh, x, y, z, seen, intersections) {
-    const geometry = mesh.geometry;
-    if (!mesh.visible || !geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return false;
-    if (!geometry.bounds) computeBounds(geometry);
-    const bounds = geometry.bounds;
-    const world = mesh.worldMatrix;
-    const center = bounds.center;
-    const cx = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];
-    const cy = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];
-    const cz = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];
-    const radius = bounds.radius * Math.max(
-      Math.hypot(world[0], world[1], world[2]),
-      Math.hypot(world[4], world[5], world[6]),
-      Math.hypot(world[8], world[9], world[10])
-    );
-    if (Math.hypot(cx - x, cy - y, cz - z) > radius) return false;
-    const shape = collider(mesh);
-    const end = Math.floor(shape.maxX / CELL);
-    if (x >= shape.maxX) return false;
-    const iz = Math.floor(z / CELL);
-    const hits = intersections;
-    hits.length = 0;
-    seen.clear();
-    let ix, cell, triangle3, distance;
-    for (ix = Math.floor(x / CELL); ix <= end; ix++) {
-      cell = shape.cells.get(`${ix},${iz}`);
-      if (!cell) continue;
-      for (triangle3 of cell) {
-        if (seen.has(triangle3)) continue;
-        seen.add(triangle3);
-        distance = horizontalRay(shape.tri, triangle3, x, y, z, 1, 0);
-        if (distance > 1e-4) hits.push(distance);
-      }
-    }
-    for (ix = 1; ix < hits.length; ix++) {
-      distance = hits[ix];
-      let j = ix - 1;
-      while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
-      hits[j + 1] = distance;
-    }
-    let crossings = 0, previous = -Infinity;
-    for (distance of hits) {
-      if (distance - previous > 1e-4) crossings++;
-      previous = distance;
-    }
-    return crossings % 2 === 1;
-  }
-
-  // src/collision/insideWalker.js
-  function insideWalker(context) {
-    const { layer, local: localBuffer, hitData } = context;
-    const shared = sharedByLayer.get(layer);
-    if (!shared || !layersByLayer.get(shared)) return false;
-    updateWorldMatrix(sceneByLayer.get(layer));
-    const root = rootByLayer.get(layer);
-    const feet = local2.call(context, localBuffer);
-    const x = root.position[0] + feet[0] * root.scale[0];
-    const y = root.position[1] + feet[1] * root.scale[1];
-    const z = root.position[2] + feet[2] * root.scale[2];
-    const layers = layersByLayer.get(shared);
-    let other, node, child;
-    for (other of layers) {
-      if (other === layer || kindByLayer.get(other) === "terrain") continue;
-      if (kindByLayer.get(other) === "traffic") {
-        hitData.best = 0;
-        hitData.found = false;
-        if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
-        continue;
-      }
-      const nodes = hitData.nodes;
-      nodes.length = 0;
-      if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
-      while (nodes.length) {
-        node = nodes.pop();
-        if (!node.visible) continue;
-        if (node.geometry && (insideMesh(node, x, y + 0.45 * root.scale[1], z, hitData.seen, hitData.intersections) || insideMesh(node, x, y + 1.35 * root.scale[1], z, hitData.seen, hitData.intersections))) return true;
-        for (child of node.children) nodes.push(child);
-      }
+  // src/walk/updateWalkerFrame.js
+  function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
+    if (turn) {
+      walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
+      changed = true;
     }
-    return false;
-  }
-
-  // src/walk/resolveWalkerPosition.js
-  function resolveWalkerPosition() {
-    if (!this.saved || !insideWalker(this)) return false;
-    const map = this.layer._map;
-    const origin = this.state.latlng;
-    const height = this.state.height;
-    let distance, angle, candidate;
-    for (distance = 0.5; distance <= 20; distance += 0.5) {
-      for (angle = 0; angle < Math.PI * 2; angle += Math.PI / 4) {
-        candidate = /* alloc */
-        new L.LatLng(
-          origin.lat + Math.cos(angle) * distance / 111320,
-          origin.lng + Math.sin(angle) * distance / (111320 * Math.cos(origin.lat * Math.PI / 180))
-        );
-        this.state.latlng = candidate;
-        this.state.height = 0;
-        if (!insideWalker(this)) {
-          this.verticalSpeed = 0;
-          map.setView(
-            candidate,
-            map.getZoom(),
-            /* alloc */
-            { animate: false }
-          );
-          return true;
-        }
-      }
+    if (forward) {
+      moveWalker.call(walker, forward, dt);
+      changed = true;
     }
-    this.state.latlng = origin;
-    this.state.height = height;
-    return false;
+    if (changed) land.call(walker, previousY);
+    if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
+    if (changed) place.call(walker);
   }
 
   // src/walk/animateWalker.js
@@ -15020,17 +15107,7 @@
     }
     forward = Math.sign(forward);
     turn = Math.sign(turn);
-    if (turn) {
-      this.state.heading = wrap(this.state.heading + turn * 2.5 * dt);
-      changed = true;
-    }
-    if (forward) {
-      moveWalker.call(this, forward, dt);
-      changed = true;
-    }
-    if (changed) land.call(this, previousY);
-    if (updateWalkerView.call(this, forward, turn, dt)) changed = true;
-    if (changed) place.call(this);
+    updateWalkerFrame(this, previousY, forward, turn, dt, changed);
   }
 
   // src/walk/startWalking.js