leaflet-city-mapper 0.0.0-stage → 0.0.2

package/dist/utils/render.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/render.js"],
+  "sourcesContent": ["import { computeBounds } from \"./computeBounds.js\";\nimport { traverse } from \"./traverse.js\";\nimport { updateCamera } from \"./updateCamera.js\";\nimport { updateWorldMatrix } from \"./updateWorldMatrix.js\";\nimport { destroyTexture } from './destroyTexture.js';\nimport { drawGeometry } from './drawGeometry.js';\nimport { updatePointLights } from './updatePointLights.js';\nimport { renderSunlight } from './renderSunlight.js';\nimport { sortMeshes } from \"./sortMeshes.js\";\nimport { update } from \"./update.js\";\nimport { getRasterTileSize, pruneRasterTiles } from \"./rasterTiles.js\";\nimport { getElevation } from \"./getElevation.js\";\nimport { roofCoverage } from \"./roofCoverage.js\";\n\n/**\n * Rendering owner: CSS pixels -> scene metres -> perspective camera.\n * Lights and transparent sort centers are converted into the current camera space.\n * Without raster tiles, logical map projection supplies the same static alignment.\n */\n\nexport function render(backend) {\n  cancelAnimationFrame(backend._frame);\n  backend._frame = null;\n  if (backend._shared !== backend || !backend.renderer) return;\n  const map = backend._map;\n  const now = performance.now();\n  let appearing = false;\n  const size = map.getSize();\n  if (!size.x || !size.y) return;\n  if (map._animatingZoom) {\n    backend._zoomTransitions ||= new Map();\n    for (const animation of map.getContainer().getAnimations({ subtree: true })) {\n      if (!(animation instanceof CSSTransition) || animation.transitionProperty !== 'transform' ||\n        !animation.effect.target.classList.contains('leaflet-zoom-animated') ||\n        backend._zoomTransitions.has(animation)) {\n        continue;\n      }\n      const time = animation.currentTime || 0;\n      animation.pause();\n      backend._zoomTransitions.set(animation, { start: now, time });\n    }\n    // Freeze CSS between rendered frames: the compositor must not outrun the canvas.\n    for (const [animation, { start, time }] of backend._zoomTransitions) {\n      animation.currentTime = Math.min(animation.effect.getComputedTiming().endTime, time + now - start);\n    }\n    if (backend._zoomView) {\n      const view = backend._zoomView;\n      const proxy = [...backend._zoomTransitions.keys()].find(animation => animation.effect.target === map._proxy);\n      const progress = proxy?.effect.getComputedTiming().progress ?? Math.min(1, (now - view.start) / 250);\n      const targetScale = map.getZoomScale(view.targetZoom, view.zoom), scale = 1 + (targetScale - 1) * progress;\n      const from = map.project(view.from, view.zoom), to = map.project(view.to, view.zoom);\n      map._cameraView = { zoom: map.getScaleZoom(scale, view.zoom),\n        center: map.unproject(from.add(to.subtract(from).multiplyBy(targetScale * progress / scale)), view.zoom) };\n      map._updateCameraOverlays();\n    }\n  }\n  if (!backend._size || !backend._size.equals(size)) {\n    backend.renderer.width = size.x;\n    backend.renderer.height = size.y;\n    backend.renderer.canvas.width = Math.round(size.x * backend.renderer.dpr);\n    backend.renderer.canvas.height = Math.round(size.y * backend.renderer.dpr);\n    backend.renderer.canvas.style.width = `${size.x}px`;\n    backend.renderer.canvas.style.height = `${size.y}px`;\n    if (backend.renderer.depthTexture) destroyTexture(backend, backend.renderer.depthTexture);\n    backend.renderer.depthTexture = backend.renderer.device.createTexture({\n      size: [backend.renderer.canvas.width, backend.renderer.canvas.height],\n      format: 'depth24plus',\n      usage: GPUTextureUsage.RENDER_ATTACHMENT,\n    });\n    backend._size = size;\n  }\n\n  // Match the map's perspective, including the intermediate view of an animated zoom.\n  const zoom = map._cameraView?.zoom ?? map.getZoom(), center = map._cameraView?.center ?? map.getCenter();\n  const pixelsPerMeter = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));\n  const offset = map.project(center, zoom).subtract(map.project(backend._sceneOrigin, zoom));\n  const distance = size.y * 1.5 / pixelsPerMeter;\n  const target = [\n    offset.x / pixelsPerMeter,\n    (map._terrain3D ? getElevation(map._terrain3D, center): undefined) ?? 0,\n    offset.y / pixelsPerMeter\n  ];\n  const pitch = map.getPitch() * Math.PI / 180;\n  const bearing = map.getBearing() * Math.PI / 180;\n  const camera = backend.camera;\n  camera.fov = 2 * Math.atan(1 / 3) * 180 / Math.PI;\n  camera.aspect = size.x / size.y;\n  camera.near = Math.max(0.1, distance / 10000);\n  camera.far = Math.max(10000, distance * 10);\n  camera.position[0] = target[0] + Math.sin(bearing) * Math.sin(pitch) * distance;\n  camera.position[1] = target[1] + Math.cos(pitch) * distance;\n  camera.position[2] = target[2] + Math.cos(bearing) * Math.sin(pitch) * distance;\n  camera.up[0] = -Math.sin(bearing) * Math.cos(pitch);\n  camera.up[1] = Math.sin(pitch);\n  camera.up[2] = -Math.cos(bearing) * Math.cos(pitch);\n  camera.target[0] = target[0]; camera.target[1] = target[1]; camera.target[2] = target[2];\n  // Refresh the camera view, projection and combined projection-view matrices.\n  updateCamera(camera);\n  updateWorldMatrix(backend.scene);\n  for (const layer of backend._layers) layer._beforeRender?.();\n  const sunlight = map._sunlight;\n  const lightPoint = new DOMPoint(...(sunlight?.direction || [-300, 500, 300]), 0).matrixTransform(new DOMMatrix(camera.viewMatrix));\n  const lightLength = Math.hypot(lightPoint.x, lightPoint.y, lightPoint.z) || 1;\n  const light = [lightPoint.x / lightLength, lightPoint.y / lightLength, lightPoint.z / lightLength];\n  const skyPoint = new DOMPoint(0, 1, 0, 0).matrixTransform(new DOMMatrix(camera.viewMatrix));\n  const skyLength = Math.hypot(skyPoint.x, skyPoint.y, skyPoint.z) || 1;\n  const sky = [skyPoint.x / skyLength, skyPoint.y / skyLength, skyPoint.z / skyLength];\n  const projection = camera.projectionViewMatrix;\n  const frustum = [\n    [projection[3] + projection[0], projection[7] + projection[4], projection[11] + projection[8], projection[15] + projection[12]],\n    [projection[3] - projection[0], projection[7] - projection[4], projection[11] - projection[8], projection[15] - projection[12]],\n    [projection[3] + projection[1], projection[7] + projection[5], projection[11] + projection[9], projection[15] + projection[13]],\n    [projection[3] - projection[1], projection[7] - projection[5], projection[11] - projection[9], projection[15] - projection[13]],\n    [projection[2], projection[6], projection[10], projection[14]],\n    [projection[3] - projection[2], projection[7] - projection[6], projection[11] - projection[10], projection[15] - projection[14]],\n  ];\n  const frustumLengths = [\n    Math.hypot(frustum[0][0], frustum[0][1], frustum[0][2]),\n    Math.hypot(frustum[1][0], frustum[1][1], frustum[1][2]),\n    Math.hypot(frustum[2][0], frustum[2][1], frustum[2][2]),\n    Math.hypot(frustum[3][0], frustum[3][1], frustum[3][2]),\n    Math.hypot(frustum[4][0], frustum[4][1], frustum[4][2]),\n    Math.hypot(frustum[5][0], frustum[5][1], frustum[5][2]),\n  ];\n  updateWorldMatrix(backend.scene);\n  traverse(backend.scene, mesh => {\n    if (!mesh.visible) return true;\n    if (mesh.geometry) {\n      if (!mesh.geometry.bounds) computeBounds(mesh.geometry);\n      const bounds = mesh.geometry.bounds;\n      const world = mesh.worldMatrix;\n      const center = bounds.center;\n      const x = world[0] * center[0] + world[4] * center[1] + world[8] * center[2] + world[12];\n      const y = world[1] * center[0] + world[5] * center[1] + world[9] * center[2] + world[13];\n      const z = world[2] * center[0] + world[6] * center[1] + world[10] * center[2] + world[14];\n      const clipZ = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];\n      const clipW = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];\n      mesh._sortDepth = clipZ / clipW;\n      const radius = bounds.radius * Math.max(\n        Math.hypot(world[0], world[1], world[2]),\n        Math.hypot(world[4], world[5], world[6]),\n        Math.hypot(world[8], world[9], world[10])\n      );\n      mesh._visibleInFrame =\n        frustum[0][0] * x + frustum[0][1] * y + frustum[0][2] * z + frustum[0][3] >= -radius * frustumLengths[0] &&\n        frustum[1][0] * x + frustum[1][1] * y + frustum[1][2] * z + frustum[1][3] >= -radius * frustumLengths[1] &&\n        frustum[2][0] * x + frustum[2][1] * y + frustum[2][2] * z + frustum[2][3] >= -radius * frustumLengths[2] &&\n        frustum[3][0] * x + frustum[3][1] * y + frustum[3][2] * z + frustum[3][3] >= -radius * frustumLengths[3] &&\n        frustum[4][0] * x + frustum[4][1] * y + frustum[4][2] * z + frustum[4][3] >= -radius * frustumLengths[4] &&\n        frustum[5][0] * x + frustum[5][1] * y + frustum[5][2] * z + frustum[5][3] >= -radius * frustumLengths[5];\n      if (!mesh._visibleInFrame) return;\n    }\n  });\n  const renderer = backend.renderer;\n  let rasters = [];\n  if ([...backend._layers].some(layer => layer.options.roofTexture)) {\n    rasters = Object.values(map._layers).filter(layer => layer._type === 'pmtiles' && layer._rasterTiles && layer.options.opacity > 0);\n    const signature = rasters.map(layer =>\n      `${L.Util.stamp(layer)}:${layer._rasterVersion || 0}:${layer.options.opacity}:${layer.options.zIndex}`).join('|');\n    if (!backend._roofRaster || backend._roofRaster.signature !== signature &&\n      (!rasters.some(layer => layer._loadingTiles) || now - backend._roofRaster.updatedAt >= 50)) {\n      const tiles = rasters.flatMap(layer => [...layer._rasterTiles.values()]\n        .filter(tile => tile.done && !tile.request.signal.aborted && tile.image)\n        .map(tile => ({ tile, layer })));\n      const zoom = tiles.length ? Math.max(...tiles.map(({ tile }) => tile.coords.z)) : map.getZoom();\n      const bounds = new L.Bounds();\n      for (const { tile: { coords }, layer } of tiles) {\n        const size = getRasterTileSize().multiplyBy(map.getZoomScale(zoom, coords.z));\n        bounds.extend(new L.Point(coords.x, coords.y).scaleBy(size));\n        bounds.extend(new L.Point(coords.x + 1, coords.y + 1).scaleBy(size));\n      }\n      const min = bounds.min || map.project(backend._sceneOrigin, zoom);\n      const size = bounds.isValid() ? bounds.getSize() : new L.Point(1, 1);\n      // ponytail: cap at 4096 px; virtual textures if wide views need native detail.\n      const limit = 4096;\n      const scale = Math.min(1, limit / Math.max(size.x, size.y));\n      const width = Math.max(1, Math.ceil(size.x * scale));\n      const height = Math.max(1, Math.ceil(size.y * scale));\n      const origin = map.project(backend._sceneOrigin, zoom);\n      const pixels = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));\n      const matrix = new DOMMatrix();\n      matrix.m11 = pixels / size.x; matrix.m33 = pixels / size.y;\n      matrix.m41 = (origin.x - min.x) / size.x; matrix.m43 = (origin.y - min.y) / size.y;\n      const texture = backend._roofRaster?.texture;\n      if (texture && (texture.width !== width || texture.height !== height)) {\n        destroyTexture(backend, texture.texture);\n        texture.texture = renderer.device.createTexture({\n          size: [width, height],\n          format: 'rgba8unorm',\n          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n        });\n        texture.width = width;\n        texture.height = height;\n      }\n      backend._roofRaster = {\n        signature, updatedAt: now, matrix: Array.from(matrix.toFloat64Array()),\n        texture: texture || {\n          device: renderer.device,\n          texture: renderer.device.createTexture({\n            size: [width, height],\n            format: 'rgba8unorm',\n            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n          }),\n          sampler: renderer.device.createSampler({\n            addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',\n          }),\n          samplerOptions: { addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge' },\n          image: null, width, height,\n          format: 'rgba8unorm', srgb: false, flipY: false, uploaded: null,\n        },\n      };\n      // Compose the atlas on the GPU: re-uploading a large canvas stalls Firefox for hundreds of ms.\n      const device = renderer.device;\n      if (!renderer.roofBlit) {\n        const module = device.createShaderModule({\n          code: `\n          @group(0) @binding(0) var source: texture_2d<f32>;\n          @group(0) @binding(1) var sourceSampler: sampler;\n          @group(0) @binding(2) var<uniform> opacity: f32;\n          struct Varyings { @builtin(position) position: vec4f, @location(0) uv: vec2f };\n          @vertex fn vertexMain(@builtin(vertex_index) index: u32) -> Varyings {\n            let uv = vec2f(f32(index & 1u), f32(index >> 1u));\n            return Varyings(vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, 0.0, 1.0), uv);\n          }\n          @fragment fn fragmentMain(input: Varyings) -> @location(0) vec4f {\n            let color = textureSample(source, sourceSampler, input.uv);\n            return vec4f(color.rgb, color.a * opacity);\n          }\n        `\n        });\n        renderer.roofBlit = {\n          pipeline: device.createRenderPipeline({\n            layout: 'auto',\n            vertex: { module, entryPoint: 'vertexMain' },\n            fragment: {\n              module,\n              entryPoint: 'fragmentMain',\n              targets: [{\n                format: 'rgba8unorm',\n                blend: {\n                  color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },\n                  alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },\n                },\n              }],\n            },\n            primitive: { topology: 'triangle-strip' },\n          }),\n          sampler: device.createSampler({ magFilter: 'linear', minFilter: 'linear' }),\n        };\n      }\n      const opacities = new Float32Array(Math.max(1, tiles.length) * 64);\n      const opacityBuffer = device.createBuffer({\n        size: opacities.byteLength,\n        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,\n      });\n      const encoder = device.createCommandEncoder();\n      const atlasPass = encoder.beginRenderPass({\n        colorAttachments: [{\n          view: backend._roofRaster.texture.texture.createView(),\n          clearValue: { r: 0, g: 0, b: 0, a: 0 },\n          loadOp: 'clear',\n          storeOp: 'store',\n        }],\n      });\n      atlasPass.setPipeline(renderer.roofBlit.pipeline);\n      tiles.sort((a, b) => (a.layer.options.zIndex || 0) - (b.layer.options.zIndex || 0) ||\n        a.tile.coords.z - b.tile.coords.z);\n      for (const [i, { tile, layer }] of tiles.entries()) {\n        const { coords, image } = tile;\n        const source = tile.texture;\n        if (source.uploaded !== source.image) {\n          device.queue.copyExternalImageToTexture({ source: image }, { texture: source.texture },\n            [source.texture.width, source.texture.height]);\n          source.uploaded = source.image;\n        }\n        opacities[i * 64] = layer.options.opacity;\n        const tileSize = getRasterTileSize().multiplyBy(map.getZoomScale(zoom, coords.z));\n        const offset = new L.Point(coords.x, coords.y).scaleBy(tileSize).subtract(min);\n        const x = offset.x * width / size.x, y = offset.y * height / size.y;\n        atlasPass.setViewport(x, y, Math.min(tileSize.x * width / size.x, width - x),\n          Math.min(tileSize.y * height / size.y, height - y), 0, 1);\n        atlasPass.setBindGroup(0, device.createBindGroup({\n          layout: renderer.roofBlit.pipeline.getBindGroupLayout(0),\n          entries: [\n            { binding: 0, resource: source.texture.createView() },\n            { binding: 1, resource: renderer.roofBlit.sampler },\n            { binding: 2, resource: { buffer: opacityBuffer, offset: i * 256, size: 4 } },\n          ],\n        }));\n        atlasPass.draw(4);\n      }\n      atlasPass.end();\n      device.queue.writeBuffer(opacityBuffer, 0, opacities);\n      device.queue.submit([encoder.finish()]);\n      opacityBuffer.destroy();\n    }\n  } else if (backend._roofRaster) {\n    destroyTexture(backend, backend._roofRaster.texture.texture);\n    backend._roofRaster = null;\n  }\n  // Visible meshes: opaque first, transparent surfaces back-to-front.\n  const meshes = [];\n  traverse(backend.scene, mesh => {\n    if (!mesh.visible) return true;\n    if (!mesh.geometry || !mesh._visibleInFrame) return;\n    if (mesh.program.uniforms.roofTexture && !rasters.length) mesh._roofRevealed = true;\n    if (mesh.program.uniforms.roofTexture && !mesh._roofRevealed && rasters.length) {\n      if (mesh._roofCoverageSignature !== backend._roofRaster?.signature) {\n        mesh._roofCoverageSignature = backend._roofRaster?.signature;\n        mesh._roofCovered = roofCoverage(mesh, backend, rasters);\n      }\n      if (!mesh._roofCovered) { mesh._appearance = 0; return; }\n      mesh._roofRevealed = true;\n    }\n    if (mesh.fadeDuration) {\n      mesh.fadeStart ??= mesh.tile?.loadedAt ?? now;\n      const progress = Math.min(1, (now - mesh.fadeStart) / mesh.fadeDuration);\n      mesh._appearance = progress * progress * (3 - 2 * progress);\n      appearing ||= progress < 1;\n    }\n    meshes.push(mesh);\n  });\n  sortMeshes(meshes);\n  const encoder = renderer.device.createCommandEncoder();\n  // One uniform upload per frame: per-mesh writeBuffer calls dominate Firefox's GPU process.\n  // Slot 0 holds the camera; 256-byte mesh slots follow (double-sided meshes use two).\n  const shadowMeshes = [];\n  if (sunlight?.altitude >= 3) {\n    for (const layer of backend._layers) {\n      if (layer._type === 'terrain') continue;\n      traverse(layer.root, mesh => {\n        if (!mesh.visible) return true;\n        if (mesh.geometry && !mesh.tile && mesh._appearance !== 0 &&\n          !mesh.program.nightLight && mesh.program.depthTest !== false) shadowMeshes.push(mesh);\n      });\n    }\n  }\n  if (!renderer.uniformBuffer || renderer.uniformBuffer.size < (meshes.length * 2 + shadowMeshes.length + 1) * 256) {\n    if (renderer.uniformBuffer) destroyTexture(backend, renderer.uniformBuffer);\n    renderer.uniformBuffer = renderer.device.createBuffer({\n      size: Math.max(64, meshes.length * 4 + shadowMeshes.length * 2) * 256,\n      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,\n    });\n    renderer.uniformData = new Float32Array(renderer.uniformBuffer.size / 4);\n  }\n  const frameData = renderer.uniformData;\n  frameData.set(camera.viewMatrix, 0);\n  frameData.set(camera.projectionMatrix, 16);\n  frameData.set(backend._roofRaster?.matrix || [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], 32);\n  frameData.set(light, 48);\n  frameData[51] = sunlight && sunlight.altitude <= 0 ? 0 : 1;\n  frameData.set(sky, 52);\n  const night = sunlight ? Math.max(0, Math.min(1, (3 - sunlight.altitude) / 9)) : 0;\n  frameData[55] = night * night * (3 - 2 * night);\n  frameData.set(sunlight?.tint || [1, 1, 1], 56);\n  frameData[59] = 0;\n  if (night > 0) updatePointLights(backend);\n  renderer.uniformSlot = 1;\n  renderSunlight(backend, encoder, shadowMeshes, sunlight);\n  const pass = encoder.beginRenderPass({\n    colorAttachments: [{\n      view: renderer.context.getCurrentTexture().createView(),\n      clearValue: { r: 0, g: 0, b: 0, a: 0 },\n      loadOp: 'clear',\n      storeOp: 'store',\n    }],\n    depthStencilAttachment: {\n      view: renderer.depthTexture.createView(),\n      depthClearValue: 1,\n      depthLoadOp: 'clear',\n      depthStoreOp: 'store',\n    },\n  });\n  pass.setViewport(0, 0, renderer.canvas.width, renderer.canvas.height, 0, 1);\n  pass.setBindGroup(1, renderer.sunlight.bindGroup);\n  for (const mesh of meshes) {\n    const world = mesh.worldMatrix;\n    if (mesh.texture) {\n      mesh.program.uniforms.baseTexture.value = mesh.texture;\n      mesh.program.uniforms.opacity.value = mesh.opacity;\n    }\n    const uniforms = mesh.program.uniforms;\n    if (uniforms.roofTexture) uniforms.roofTexture.value = backend._roofRaster?.texture || renderer.roofFallbackTexture;\n    const determinant = world[0] * (world[5] * world[10] - world[6] * world[9]) -\n      world[4] * (world[1] * world[10] - world[2] * world[9]) +\n      world[8] * (world[1] * world[6] - world[2] * world[5]);\n    if (!Number.isFinite(determinant) || determinant === 0) {\n      throw new Error('Singular 3D transform');\n    }\n    const frontFace = determinant < 0 ? 'cw' : 'ccw';\n    const program = mesh.program;\n    if (program.transparent && program._layerMaterial.doubleSided && !mesh._nativeSource) {\n      drawGeometry(backend, mesh, pass, 'front', frontFace);\n      drawGeometry(backend, mesh, pass, 'back', frontFace);\n    } else {\n      drawGeometry(backend, mesh, pass, program.cullMode, frontFace);\n    }\n  }\n  pass.end();\n  renderer.device.queue.writeBuffer(renderer.uniformBuffer, 0, renderer.uniformData, 0, renderer.uniformSlot * 64);\n  renderer.device.queue.submit([encoder.finish()]);\n  for (const layer of backend._layers) {\n    if (layer._wantedRasterTiles) appearing = pruneRasterTiles(layer) || appearing;\n  }\n  if (map._animatingZoom || appearing) update(backend);\n}\n"],
+  "mappings": "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",
+  "names": ["computeBounds", "traverse", "updateCamera", "updateWorldMatrix", "destroyTexture", "drawGeometry", "updatePointLights", "renderSunlight", "sortMeshes", "update", "getRasterTileSize", "pruneRasterTiles", "getElevation", "roofCoverage", "render", "backend", "map", "now", "appearing", "size", "animation", "time", "start", "view", "progress", "targetScale", "scale", "from", "to", "zoom", "center", "pixelsPerMeter", "offset", "distance", "target", "pitch", "bearing", "camera", "layer", "sunlight", "lightPoint", "lightLength", "light", "skyPoint", "skyLength", "sky", "projection", "frustum", "frustumLengths", "mesh", "bounds", "world", "x", "y", "z", "clipZ", "clipW", "radius", "renderer", "rasters", "signature", "tiles", "tile", "coords", "min", "width", "height", "origin", "pixels", "matrix", "texture", "device", "module", "opacities", "opacityBuffer", "encoder", "atlasPass", "a", "b", "i", "image", "source", "tileSize", "meshes", "shadowMeshes", "frameData", "night", "pass", "uniforms", "determinant", "frontFace", "program"]
+}

package/dist/utils/renderSunlight.js

@@ -0,0 +1,13 @@
+import{computeBounds as R}from"./computeBounds.js";import{updateCamera as D}from"./updateCamera.js";import{resizeSunlight as O}from"./resizeSunlight.js";function z(w,L,c,l){const s=w.renderer,a=s.device,i=s.sunlight;if(!c.length||!l||l.altitude<3){if(!i.enabled)return;const e=new Float32Array(20);e.set([1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]),a.queue.writeBuffer(i.buffer,0,e),i.enabled=!1,i.cache=null;return}const g=i.cache;if(i.enabled&&g?.meshes.size===c.length&&l.direction.every((e,t)=>e===g.direction[t])&&c.every(e=>{const t=g.meshes.get(e),n=e.geometry.drawRange;return t&&t.world===e._worldMatrixVersion&&t.geometry===e.geometry&&t.start===n.start&&t.count===n.count&&t.appearance===(e._appearance??1)&&Object.values(e.geometry.attributes).every(r=>!r.needsUpdate)}))return;const x=new Float32Array(20);i.enabled=!0,O(w,Math.min(2048,a.limits.maxTextureDimension2D));const d=[1/0,1/0,1/0],y=[-1/0,-1/0,-1/0];for(const e of c){(!e.geometry.bounds||e.geometry.attributes.position.needsUpdate)&&R(e.geometry);const t=e.geometry.bounds,n=e.worldMatrix;let r=e._shadowBounds;if(!r||r.version!==e._worldMatrixVersion||r.bounds!==t){r=e._shadowBounds={version:e._worldMatrixVersion,bounds:t,min:[1/0,1/0,1/0],max:[-1/0,-1/0,-1/0]};for(let o=0;o<8;o++){const I=o&1?t.max[0]:t.min[0],S=o&2?t.max[1]:t.min[1],G=o&4?t.max[2]:t.min[2],V=n[3]*I+n[7]*S+n[11]*G+n[15];for(let f=0;f<3;f++){const _=(n[f]*I+n[f+4]*S+n[f+8]*G+n[f+12])/V;r.min[f]=Math.min(r.min[f],_),r.max[f]=Math.max(r.max[f],_)}}}for(let o=0;o<3;o++)d[o]=Math.min(d[o],r.min[o]),y[o]=Math.max(y[o],r.max[o])}d[1]=Math.min(0,d[1]);const b=Math.max(100,Math.hypot(...d.map((e,t)=>y[t]-e))),M=d.map((e,t)=>(e+y[t])/2),v={position:M.map((e,t)=>e+l.direction[t]*b*2),target:M,up:[0,0,-1],fov:45,aspect:1,near:1,far:b*5,viewMatrix:[],projectionMatrix:[],projectionViewMatrix:[]};D(v);const B=new DOMMatrix(v.viewMatrix),h=[1/0,1/0,1/0],p=[-1/0,-1/0,-1/0];for(let e=0;e<8;e++){const t=new DOMPoint(...d.map((n,r)=>e&1<<r?y[r]:n),1).matrixTransform(B);[t.x,t.y,t.z].forEach((n,r)=>{h[r]=Math.min(h[r],n-20),p[r]=Math.max(p[r],n+20)})}const m=h.map((e,t)=>p[t]-e),P=new DOMMatrix([2/m[0],0,0,0,0,2/m[1],0,0,0,0,-1/m[2],0,-(p[0]+h[0])/m[0],-(p[1]+h[1])/m[1],p[2]/m[2],1]);if(x.set(P.multiply(B).toFloat32Array()),x[16]=1,a.queue.writeBuffer(i.buffer,0,x),!i.pipeline){i.meshLayout=a.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform",hasDynamicOffset:!0}}]}),i.depthLayout=a.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}}]}),i.depthBindGroup=a.createBindGroup({layout:i.depthLayout,entries:[{binding:0,resource:{buffer:i.buffer}}]});const e=a.createShaderModule({code:`
+      struct Mesh { world: mat4x4<f32>, padding: array<vec4<f32>, 4>, highlight: vec4<f32> };
+      @group(0) @binding(0) var<uniform> mesh: Mesh;
+      @group(1) @binding(0) var<uniform> matrix: mat4x4<f32>;
+      @vertex fn main(@location(0) position: vec3<f32>) -> @builtin(position) vec4<f32> {
+        return matrix * mesh.world * vec4<f32>(position, 1.0);
+      }
+      @fragment fn fragmentMain(@builtin(position) position: vec4<f32>) {
+        let noise = fract(52.9829189 * fract(dot(floor(position.xy), vec2<f32>(0.06711056, 0.00583715))));
+        if (mesh.highlight.w < 1.0 && noise >= mesh.highlight.w) { discard; }
+      }
+    `});i.pipeline=a.createRenderPipeline({layout:a.createPipelineLayout({bindGroupLayouts:[i.meshLayout,i.depthLayout]}),vertex:{module:e,entryPoint:"main",buffers:[{arrayStride:12,attributes:[{shaderLocation:0,offset:0,format:"float32x3"}]}]},fragment:{module:e,entryPoint:"fragmentMain",targets:[]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"depth32float",depthWriteEnabled:!0,depthCompare:"less",depthBias:2,depthBiasSlopeScale:2}})}const u=L.beginRenderPass({colorAttachments:[],depthStencilAttachment:{view:i.texture.createView(),depthClearValue:1,depthLoadOp:"clear",depthStoreOp:"store"}});u.setPipeline(i.pipeline),u.setBindGroup(1,i.depthBindGroup);for(const e of c){const t=s.uniformSlot++*256;s.uniformData.set(e.worldMatrix,t/4),s.uniformData[t/4+35]=e._appearance??1,e._shadowBuffer!==s.uniformBuffer&&(e._shadowBuffer=s.uniformBuffer,e._shadowBindGroup=a.createBindGroup({layout:i.meshLayout,entries:[{binding:0,resource:{buffer:s.uniformBuffer,size:144}}]}));for(const o of Object.values(e.geometry.attributes))o.needsUpdate&&(a.queue.writeBuffer(o.buffer,0,o.data),o.needsUpdate=!1);u.setBindGroup(0,e._shadowBindGroup,[t]),u.setVertexBuffer(0,e.geometry.attributes.position.buffer);const n=e.geometry.attributes.index,r=e.geometry.drawRange;n?(u.setIndexBuffer(n.buffer,n.indexFormat),u.drawIndexed(r.count,1,r.start,0,0)):u.draw(r.count,1,r.start,0)}u.end(),i.cache={direction:[...l.direction],meshes:new Map(c.map(e=>[e,{world:e._worldMatrixVersion,geometry:e.geometry,start:e.geometry.drawRange.start,count:e.geometry.drawRange.count,appearance:e._appearance??1}]))}}export{z as renderSunlight};
+//# sourceMappingURL=renderSunlight.js.map

package/dist/utils/renderSunlight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/renderSunlight.js"],
+  "sourcesContent": ["import { computeBounds } from './computeBounds.js';\nimport { updateCamera } from './updateCamera.js';\nimport { resizeSunlight } from './resizeSunlight.js';\n\n/** One shared directional depth map. Off-screen but loaded geometry can cast shadows. */\n\nexport function renderSunlight(backend, encoder, meshes, sunlight) {\n  const renderer = backend.renderer, device = renderer.device, sun = renderer.sunlight;\n  if (!meshes.length || !sunlight || sunlight.altitude < 3) {\n    if (!sun.enabled) return;\n    const values = new Float32Array(20);\n    values.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);\n    device.queue.writeBuffer(sun.buffer, 0, values);\n    sun.enabled = false;\n    sun.cache = null;\n    return;\n  }\n  const cache = sun.cache;\n  const unchanged = sun.enabled && cache?.meshes.size === meshes.length &&\n    sunlight.direction.every((value, i) => value === cache.direction[i]) &&\n    meshes.every(mesh => {\n      const previous = cache.meshes.get(mesh), range = mesh.geometry.drawRange;\n      return previous && previous.world === mesh._worldMatrixVersion && previous.geometry === mesh.geometry &&\n        previous.start === range.start && previous.count === range.count &&\n        previous.appearance === (mesh._appearance ?? 1) &&\n        Object.values(mesh.geometry.attributes).every(attribute => !attribute.needsUpdate);\n    });\n  if (unchanged) return;\n  const values = new Float32Array(20);\n  sun.enabled = true;\n  resizeSunlight(backend, Math.min(2048, device.limits.maxTextureDimension2D));\n  const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];\n  for (const mesh of meshes) {\n    if (!mesh.geometry.bounds || mesh.geometry.attributes.position.needsUpdate) computeBounds(mesh.geometry);\n    const bounds = mesh.geometry.bounds, matrix = mesh.worldMatrix;\n    let cached = mesh._shadowBounds;\n    if (!cached || cached.version !== mesh._worldMatrixVersion || cached.bounds !== bounds) {\n      cached = mesh._shadowBounds = { version: mesh._worldMatrixVersion, bounds,\n        min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] };\n      for (let i = 0; i < 8; i++) {\n        const x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];\n        const z = i & 4 ? bounds.max[2] : bounds.min[2];\n        const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];\n        for (let axis = 0; axis < 3; axis++) {\n          const value = (matrix[axis] * x + matrix[axis + 4] * y + matrix[axis + 8] * z + matrix[axis + 12]) / w;\n          cached.min[axis] = Math.min(cached.min[axis], value);\n          cached.max[axis] = Math.max(cached.max[axis], value);\n        }\n      }\n    }\n    for (let axis = 0; axis < 3; axis++) {\n      min[axis] = Math.min(min[axis], cached.min[axis]);\n      max[axis] = Math.max(max[axis], cached.max[axis]);\n    }\n  }\n  // Include ground receivers below/around the loaded buildings and trees.\n  min[1] = Math.min(0, min[1]);\n  const radius = Math.max(100, Math.hypot(...min.map((v, i) => max[i] - v)));\n  const center = min.map((v, i) => (v + max[i]) / 2);\n  const lightCamera = {\n    position: center.map((v, i) => v + sunlight.direction[i] * radius * 2),\n    target: center, up: [0, 0, -1], fov: 45, aspect: 1, near: 1, far: radius * 5,\n    viewMatrix: [], projectionMatrix: [], projectionViewMatrix: [],\n  };\n  updateCamera(lightCamera);\n  const view = new DOMMatrix(lightCamera.viewMatrix);\n  const low = [Infinity, Infinity, Infinity], high = [-Infinity, -Infinity, -Infinity];\n  for (let i = 0; i < 8; i++) {\n    const point = new DOMPoint(...min.map((v, axis) => (i & (1 << axis)) ? max[axis] : v), 1).matrixTransform(view);\n    [point.x, point.y, point.z].forEach((value, axis) => {\n      low[axis] = Math.min(low[axis], value - 20);\n      high[axis] = Math.max(high[axis], value + 20);\n    });\n  }\n  const span = low.map((v, i) => high[i] - v);\n  const projection = new DOMMatrix([\n    2 / span[0], 0, 0, 0, 0, 2 / span[1], 0, 0, 0, 0, -1 / span[2], 0,\n    -(high[0] + low[0]) / span[0], -(high[1] + low[1]) / span[1], high[2] / span[2], 1,\n  ]);\n  values.set(projection.multiply(view).toFloat32Array());\n  values[16] = 1;\n  device.queue.writeBuffer(sun.buffer, 0, values);\n  if (!sun.pipeline) {\n    sun.meshLayout = device.createBindGroupLayout({\n      entries: [\n        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true } },\n      ]\n    });\n    // Do not bind the sampled depth texture while it is a render attachment.\n    sun.depthLayout = device.createBindGroupLayout({\n      entries: [\n        { binding: 0, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform' } },\n      ]\n    });\n    sun.depthBindGroup = device.createBindGroup({\n      layout: sun.depthLayout, entries: [{ binding: 0, resource: { buffer: sun.buffer } }],\n    });\n    const shader = device.createShaderModule({\n      code: `\n      struct Mesh { world: mat4x4<f32>, padding: array<vec4<f32>, 4>, highlight: vec4<f32> };\n      @group(0) @binding(0) var<uniform> mesh: Mesh;\n      @group(1) @binding(0) var<uniform> matrix: mat4x4<f32>;\n      @vertex fn main(@location(0) position: vec3<f32>) -> @builtin(position) vec4<f32> {\n        return matrix * mesh.world * vec4<f32>(position, 1.0);\n      }\n      @fragment fn fragmentMain(@builtin(position) position: vec4<f32>) {\n        let noise = fract(52.9829189 * fract(dot(floor(position.xy), vec2<f32>(0.06711056, 0.00583715))));\n        if (mesh.highlight.w < 1.0 && noise >= mesh.highlight.w) { discard; }\n      }\n    ` });\n    sun.pipeline = device.createRenderPipeline({\n      layout: device.createPipelineLayout({ bindGroupLayouts: [sun.meshLayout, sun.depthLayout] }),\n      vertex: {\n        module: shader, entryPoint: 'main', buffers: [\n          { arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: 'float32x3' }] },\n        ]\n      },\n      fragment: { module: shader, entryPoint: 'fragmentMain', targets: [] },\n      primitive: { topology: 'triangle-list', cullMode: 'none' },\n      depthStencil: {\n        format: 'depth32float', depthWriteEnabled: true, depthCompare: 'less',\n        depthBias: 2, depthBiasSlopeScale: 2\n      },\n    });\n  }\n  const pass = encoder.beginRenderPass({\n    colorAttachments: [],\n    depthStencilAttachment: {\n      view: sun.texture.createView(), depthClearValue: 1,\n      depthLoadOp: 'clear', depthStoreOp: 'store'\n    },\n  });\n  pass.setPipeline(sun.pipeline);\n  pass.setBindGroup(1, sun.depthBindGroup);\n  for (const mesh of meshes) {\n    const offset = renderer.uniformSlot++ * 256;\n    renderer.uniformData.set(mesh.worldMatrix, offset / 4);\n    renderer.uniformData[offset / 4 + 35] = mesh._appearance ?? 1;\n    if (mesh._shadowBuffer !== renderer.uniformBuffer) {\n      mesh._shadowBuffer = renderer.uniformBuffer;\n      mesh._shadowBindGroup = device.createBindGroup({\n        layout: sun.meshLayout, entries: [\n          { binding: 0, resource: { buffer: renderer.uniformBuffer, size: 144 } },\n        ]\n      });\n    }\n    for (const attribute of Object.values(mesh.geometry.attributes)) {\n      if (attribute.needsUpdate) {\n        device.queue.writeBuffer(attribute.buffer, 0, attribute.data);\n        attribute.needsUpdate = false;\n      }\n    }\n    pass.setBindGroup(0, mesh._shadowBindGroup, [offset]);\n    pass.setVertexBuffer(0, mesh.geometry.attributes.position.buffer);\n    const index = mesh.geometry.attributes.index, range = mesh.geometry.drawRange;\n    if (index) {\n      pass.setIndexBuffer(index.buffer, index.indexFormat);\n      pass.drawIndexed(range.count, 1, range.start, 0, 0);\n    } else pass.draw(range.count, 1, range.start, 0);\n  }\n  pass.end();\n  sun.cache = {\n    direction: [...sunlight.direction],\n    meshes: new Map(meshes.map(mesh => [mesh, {\n      world: mesh._worldMatrixVersion, geometry: mesh.geometry,\n      start: mesh.geometry.drawRange.start, count: mesh.geometry.drawRange.count,\n      appearance: mesh._appearance ?? 1,\n    }])),\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["computeBounds", "updateCamera", "resizeSunlight", "renderSunlight", "backend", "encoder", "meshes", "sunlight", "renderer", "device", "sun", "values", "cache", "value", "i", "mesh", "previous", "range", "attribute", "min", "max", "bounds", "matrix", "cached", "x", "y", "z", "w", "axis", "radius", "v", "center", "lightCamera", "view", "low", "high", "point", "span", "projection", "shader", "pass", "offset", "index"]
+}

package/dist/utils/renderers.js

@@ -0,0 +1,2 @@
+const e=new WeakMap;export{e as renderers};
+//# sourceMappingURL=renderers.js.map

package/dist/utils/renderers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/renderers.js"],
+  "sourcesContent": ["/** Rendering owner per map; entries are removed on the last layer removal. */\nexport const renderers = new WeakMap();\n"],
+  "mappings": "AACO,MAAMA,EAAY,IAAI",
+  "names": ["renderers"]
+}

package/dist/utils/resizeSunlight.js

@@ -0,0 +1,2 @@
+import{bindSunlight as i}from"./bindSunlight.js";import{destroyTexture as o}from"./destroyTexture.js";function x(r,t){const u=r.renderer.device,e=r.renderer.sunlight;e.size!==t&&(e.texture&&o(r,e.texture),e.size=t,e.texture=u.createTexture({size:[t,t],format:"depth32float",usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC}),i(r))}export{x as resizeSunlight};
+//# sourceMappingURL=resizeSunlight.js.map

package/dist/utils/resizeSunlight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/resizeSunlight.js"],
+  "sourcesContent": ["import { bindSunlight } from './bindSunlight.js';\nimport { destroyTexture } from './destroyTexture.js';\n\n\nexport function resizeSunlight(backend, size) {\n  const device = backend.renderer.device, sun = backend.renderer.sunlight;\n  if (sun.size === size) return;\n  if (sun.texture) destroyTexture(backend, sun.texture);\n  sun.size = size;\n  sun.texture = device.createTexture({\n    size: [size, size], format: 'depth32float',\n    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,\n  });\n  bindSunlight(backend);\n}\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB,oBAC7B,OAAS,kBAAAC,MAAsB,sBAGxB,SAASC,EAAeC,EAASC,EAAM,CAC5C,MAAMC,EAASF,EAAQ,SAAS,OAAQG,EAAMH,EAAQ,SAAS,SAC3DG,EAAI,OAASF,IACbE,EAAI,SAASL,EAAeE,EAASG,EAAI,OAAO,EACpDA,EAAI,KAAOF,EACXE,EAAI,QAAUD,EAAO,cAAc,CACjC,KAAM,CAACD,EAAMA,CAAI,EAAG,OAAQ,eAC5B,MAAO,gBAAgB,kBAAoB,gBAAgB,gBAAkB,gBAAgB,QAC/F,CAAC,EACDJ,EAAaG,CAAO,EACtB",
+  "names": ["bindSunlight", "destroyTexture", "resizeSunlight", "backend", "size", "device", "sun"]
+}

package/dist/utils/roofCoverage.js

@@ -0,0 +1,2 @@
+function O(_,L,w){const M=L._map,c=_.geometry.bounds,r=_.worldMatrix;let z=!1;for(const o of w){const f=o._tileZoom,j=M.project(L._sceneOrigin,f),v=M.options.crs.scale(f)/(4007501668557849e-8*Math.cos(L._sceneOrigin.lat*Math.PI/180)),t=[1/0,1/0],e=[-1/0,-1/0];for(let n=0;n<8;n++){const i=n&1?c.max[0]:c.min[0],h=n&2?c.max[1]:c.min[1],d=n&4?c.max[2]:c.min[2],a=j.x+(r[0]*i+r[4]*h+r[8]*d+r[12])*v,s=j.y+(r[2]*i+r[6]*h+r[10]*d+r[14])*v;t[0]=Math.min(t[0],a),t[1]=Math.min(t[1],s),e[0]=Math.max(e[0],a),e[1]=Math.max(e[1],s)}if(o.header.maxLat!==void 0&&o.header.minLon!==void 0&&o.header.minLat!==void 0&&o.header.maxLon!==void 0){const n=M.project([o.header.maxLat,o.header.minLon],f),i=M.project([o.header.minLat,o.header.maxLon],f);if(t[0]=Math.max(t[0],n.x),t[1]=Math.max(t[1],n.y),e[0]=Math.min(e[0],i.x),e[1]=Math.min(e[1],i.y),t[0]>=e[0]||t[1]>=e[1])continue}z=!0;let g=[[t[0],t[1],e[0],e[1]]];for(const n of o._rasterTiles.values()){if(!n.done&&!n.error)continue;const i=256*2**(f-n.coords.z),h=n.coords.x*i,d=n.coords.y*i;if(g=g.flatMap(([a,s,m,x])=>{const y=Math.max(a,h),u=Math.max(s,d),I=Math.min(m,h+i),l=Math.min(x,d+i);if(y>=I||u>=l)return[[a,s,m,x]];const p=[];return s<u&&p.push([a,s,m,u]),l<x&&p.push([a,l,m,x]),a<y&&p.push([a,u,y,l]),I<m&&p.push([I,u,m,l]),p}),!g.length)return!0}}return!z}export{O as roofCoverage};
+//# sourceMappingURL=roofCoverage.js.map

package/dist/utils/roofCoverage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/roofCoverage.js"],
+  "sourcesContent": ["/** Test the mesh's ground footprint against loaded imagery, including coarse parent tiles. */\r\nexport function roofCoverage(mesh, backend, rasters) {\r\n  const map = backend._map, bounds = mesh.geometry.bounds, world = mesh.worldMatrix;\r\n  let intersectsArchive = false;\r\n  for (const layer of rasters) {\r\n    const zoom = layer._tileZoom, origin = map.project(backend._sceneOrigin, zoom);\r\n    const scale = map.options.crs.scale(zoom) / (40075016.68557849 * Math.cos(backend._sceneOrigin.lat * Math.PI / 180));\r\n    const min = [Infinity, Infinity], max = [-Infinity, -Infinity];\r\n    for (let i = 0; i < 8; i++) {\r\n      const x = i & 1 ? bounds.max[0] : bounds.min[0], y = i & 2 ? bounds.max[1] : bounds.min[1];\r\n      const z = i & 4 ? bounds.max[2] : bounds.min[2];\r\n      const px = origin.x + (world[0] * x + world[4] * y + world[8] * z + world[12]) * scale;\r\n      const py = origin.y + (world[2] * x + world[6] * y + world[10] * z + world[14]) * scale;\r\n      min[0] = Math.min(min[0], px); min[1] = Math.min(min[1], py);\r\n      max[0] = Math.max(max[0], px); max[1] = Math.max(max[1], py);\r\n    }\r\n    if (layer.header.maxLat !== undefined && layer.header.minLon !== undefined &&\r\n      layer.header.minLat !== undefined && layer.header.maxLon !== undefined) {\r\n      const nw = map.project([layer.header.maxLat, layer.header.minLon], zoom);\r\n      const se = map.project([layer.header.minLat, layer.header.maxLon], zoom);\r\n      min[0] = Math.max(min[0], nw.x); min[1] = Math.max(min[1], nw.y);\r\n      max[0] = Math.min(max[0], se.x); max[1] = Math.min(max[1], se.y);\r\n      if (min[0] >= max[0] || min[1] >= max[1]) continue;\r\n    }\r\n    intersectsArchive = true;\r\n    let remaining = [[min[0], min[1], max[0], max[1]]];\r\n    for (const tile of layer._rasterTiles.values()) {\r\n      // Failed imagery already reports an error; do not hide the building indefinitely.\r\n      if (!tile.done && !tile.error) continue;\r\n      const size = 256 * 2 ** (zoom - tile.coords.z);\r\n      const left = tile.coords.x * size, top = tile.coords.y * size;\r\n      remaining = remaining.flatMap(([x0, y0, x1, y1]) => {\r\n        const l = Math.max(x0, left), t = Math.max(y0, top);\r\n        const r = Math.min(x1, left + size), b = Math.min(y1, top + size);\r\n        if (l >= r || t >= b) return [[x0, y0, x1, y1]];\r\n        const pieces = [];\r\n        if (y0 < t) pieces.push([x0, y0, x1, t]);\r\n        if (b < y1) pieces.push([x0, b, x1, y1]);\r\n        if (x0 < l) pieces.push([x0, t, l, b]);\r\n        if (r < x1) pieces.push([r, t, x1, b]);\r\n        return pieces;\r\n      });\r\n      if (!remaining.length) return true;\r\n    }\r\n  }\r\n  return !intersectsArchive;\r\n}\r\n"],
+  "mappings": "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",
+  "names": ["roofCoverage", "mesh", "backend", "rasters", "map", "bounds", "world", "intersectsArchive", "layer", "zoom", "origin", "scale", "min", "max", "i", "x", "y", "z", "px", "py", "nw", "se", "remaining", "tile", "size", "left", "top", "x0", "y0", "x1", "y1", "l", "t", "r", "b", "pieces"]
+}

package/dist/utils/routeGeometry.js

@@ -0,0 +1,2 @@
+function b(y){const d=[],m=[],x=[];for(const{points:h,lengths:n}of y)for(let o=1;o<h.length;o++){const t=h[o-1],g=h[o],a=g[0]-t[0],l=g[1]-t[1],i=n[o]-n[o-1];if(!i)continue;const s=-l/i*2.5,c=a/i*2.5;for(let f=Math.floor(n[o-1]/30)*30;f<n[o];f+=30){const p=Math.max(0,(f-n[o-1])/i),u=Math.min(1,(f+18-n[o-1])/i);if(u<=p)continue;const e=[t[0]+a*p,t[1]+l*p],r=[t[0]+a*u,t[1]+l*u],z=t[2]+.4;for(const M of[[e[0]-s,e[1]-c],[e[0]+s,e[1]+c],[r[0]+s,r[1]+c],[e[0]-s,e[1]-c],[r[0]+s,r[1]+c],[r[0]-s,r[1]-c]])d.push(M[0],z,M[1]),m.push(0,1,0),x.push(.08,.7,.85)}}return{position:d,normal:m,color:x}}export{b as routeGeometry};
+//# sourceMappingURL=routeGeometry.js.map

package/dist/utils/routeGeometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/routeGeometry.js"],
+  "sourcesContent": ["/** Dashed lane outline, in layer-local metres. */\n\nexport function routeGeometry(lanes) {\n  const position = [], normal = [], color = [];\n  for (const { points, lengths } of lanes) for (let i = 1; i < points.length; i++) {\n    const a = points[i - 1], b = points[i];\n    const dx = b[0] - a[0], dz = b[1] - a[1], length = lengths[i] - lengths[i - 1];\n    if (!length) continue;\n    const x = -dz / length * 2.5, z = dx / length * 2.5;\n    for (let distance = Math.floor(lengths[i - 1] / 30) * 30; distance < lengths[i]; distance += 30) {\n      const start = Math.max(0, (distance - lengths[i - 1]) / length);\n      const end = Math.min(1, (distance + 18 - lengths[i - 1]) / length);\n      if (end <= start) continue;\n      const p = [a[0] + dx * start, a[1] + dz * start], q = [a[0] + dx * end, a[1] + dz * end], y = a[2] + 0.4;\n      for (const point of [[p[0] - x, p[1] - z], [p[0] + x, p[1] + z], [q[0] + x, q[1] + z],\n      [p[0] - x, p[1] - z], [q[0] + x, q[1] + z], [q[0] - x, q[1] - z]]) {\n        position.push(point[0], y, point[1]); normal.push(0, 1, 0); color.push(0.08, 0.7, 0.85);\n      }\n    }\n  }\n  return { position, normal, color };\n}\n"],
+  "mappings": "AAEO,SAASA,EAAcC,EAAO,CACnC,MAAMC,EAAW,CAAC,EAAGC,EAAS,CAAC,EAAGC,EAAQ,CAAC,EAC3C,SAAW,CAAE,OAAAC,EAAQ,QAAAC,CAAQ,IAAKL,EAAO,QAASM,EAAI,EAAGA,EAAIF,EAAO,OAAQE,IAAK,CAC/E,MAAMC,EAAIH,EAAOE,EAAI,CAAC,EAAGE,EAAIJ,EAAOE,CAAC,EAC/BG,EAAKD,EAAE,CAAC,EAAID,EAAE,CAAC,EAAGG,EAAKF,EAAE,CAAC,EAAID,EAAE,CAAC,EAAGI,EAASN,EAAQC,CAAC,EAAID,EAAQC,EAAI,CAAC,EAC7E,GAAI,CAACK,EAAQ,SACb,MAAMC,EAAI,CAACF,EAAKC,EAAS,IAAKE,EAAIJ,EAAKE,EAAS,IAChD,QAASG,EAAW,KAAK,MAAMT,EAAQC,EAAI,CAAC,EAAI,EAAE,EAAI,GAAIQ,EAAWT,EAAQC,CAAC,EAAGQ,GAAY,GAAI,CAC/F,MAAMC,EAAQ,KAAK,IAAI,GAAID,EAAWT,EAAQC,EAAI,CAAC,GAAKK,CAAM,EACxDK,EAAM,KAAK,IAAI,GAAIF,EAAW,GAAKT,EAAQC,EAAI,CAAC,GAAKK,CAAM,EACjE,GAAIK,GAAOD,EAAO,SAClB,MAAME,EAAI,CAACV,EAAE,CAAC,EAAIE,EAAKM,EAAOR,EAAE,CAAC,EAAIG,EAAKK,CAAK,EAAGG,EAAI,CAACX,EAAE,CAAC,EAAIE,EAAKO,EAAKT,EAAE,CAAC,EAAIG,EAAKM,CAAG,EAAGG,EAAIZ,EAAE,CAAC,EAAI,GACrG,UAAWa,IAAS,CAAC,CAACH,EAAE,CAAC,EAAIL,EAAGK,EAAE,CAAC,EAAIJ,CAAC,EAAG,CAACI,EAAE,CAAC,EAAIL,EAAGK,EAAE,CAAC,EAAIJ,CAAC,EAAG,CAACK,EAAE,CAAC,EAAIN,EAAGM,EAAE,CAAC,EAAIL,CAAC,EACpF,CAACI,EAAE,CAAC,EAAIL,EAAGK,EAAE,CAAC,EAAIJ,CAAC,EAAG,CAACK,EAAE,CAAC,EAAIN,EAAGM,EAAE,CAAC,EAAIL,CAAC,EAAG,CAACK,EAAE,CAAC,EAAIN,EAAGM,EAAE,CAAC,EAAIL,CAAC,CAAC,EAC9DZ,EAAS,KAAKmB,EAAM,CAAC,EAAGD,EAAGC,EAAM,CAAC,CAAC,EAAGlB,EAAO,KAAK,EAAG,EAAG,CAAC,EAAGC,EAAM,KAAK,IAAM,GAAK,GAAI,CAE1F,CACF,CACA,MAAO,CAAE,SAAAF,EAAU,OAAAC,EAAQ,MAAAC,CAAM,CACnC",
+  "names": ["routeGeometry", "lanes", "position", "normal", "color", "points", "lengths", "i", "a", "b", "dx", "dz", "length", "x", "z", "distance", "start", "end", "p", "q", "y", "point"]
+}

package/dist/utils/scheduledTrips.js

@@ -0,0 +1,2 @@
+function p(d,{timeZone:l,duration:a,services:u}){const n=new Date(d);if(!Number.isFinite(n.getTime()))throw new Error("Invalid date");const f=new Intl.DateTimeFormat("en-GB",{timeZone:l,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",hourCycle:"h23"}),e=Object.fromEntries(f.formatToParts(n).filter(t=>t.type!=="literal").map(t=>[t.type,Number(t.value)])),o=e.hour*60+e.minute+(e.second+n.getUTCMilliseconds()/1e3)/60,y=new Date(Date.UTC(e.year,e.month-1,e.day)).getUTCDay(),c=t=>t.split(":").reduce((i,r)=>i*60+Number(r)),m=[];for(const{from:t,to:i,every:r=1/0,months:h,weekdays:g}of u)if(!(h?.includes(e.month)===!1||g?.includes(y)===!1))for(let s=c(t);s<=c(i);s+=r)m.push(s);return m.sort((t,i)=>t-i).filter(t=>o>=t&&o<t+a).map(t=>({id:`${e.year}-${e.month}-${e.day}-${t}`,departure:`${String(Math.floor(t/60)).padStart(2,"0")}:${String(t%60).padStart(2,"0")}`,progress:(o-t)/a}))}export{p as scheduledTrips};
+//# sourceMappingURL=scheduledTrips.js.map

package/dist/utils/scheduledTrips.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/scheduledTrips.js"],
+  "sourcesContent": ["/**\n * Trips of a frequency-based timetable (like GTFS frequencies.txt) underway at `date`, in the timetable's local time.\n * @param {{timeZone: string, duration: number, services: Array<{from: string, to: string, every?: number, months?: number[], weekdays?: number[]}>}} timetable\n * `duration` and `every` are minutes; `from`/`to` are 'HH:MM' first/last departures; months are 1-12, weekdays 0 (Sunday)-6.\n * @returns {Array<{id: string, departure: string, progress: number}>} `progress` is 0-1 along the lane.\n */\n\nexport function scheduledTrips(date, { timeZone, duration, services }) {\n  const time = new Date(date);\n  if (!Number.isFinite(time.getTime())) throw new Error('Invalid date');\n  const clock = new Intl.DateTimeFormat('en-GB', {\n    timeZone, year: 'numeric', month: '2-digit', day: '2-digit',\n    hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23',\n  });\n  const parts = Object.fromEntries(clock.formatToParts(time).filter(p => p.type !== 'literal').map(p => [p.type, Number(p.value)]));\n  const minute = parts.hour * 60 + parts.minute + (parts.second + time.getUTCMilliseconds() / 1000) / 60;\n  const weekday = new Date(Date.UTC(parts.year, parts.month - 1, parts.day)).getUTCDay();\n  const minutes = clockTime => clockTime.split(':').reduce((hours, value) => hours * 60 + Number(value));\n  const departures = [];\n  for (const { from, to, every = Infinity, months, weekdays } of services) {\n    if (months?.includes(parts.month) === false || weekdays?.includes(weekday) === false) continue;\n    for (let departure = minutes(from); departure <= minutes(to); departure += every) departures.push(departure);\n  }\n  return departures.sort((a, b) => a - b).filter(departure => minute >= departure && minute < departure + duration).map(departure => ({\n    id: `${parts.year}-${parts.month}-${parts.day}-${departure}`,\n    departure: `${String(Math.floor(departure / 60)).padStart(2, '0')}:${String(departure % 60).padStart(2, '0')}`,\n    progress: (minute - departure) / duration,\n  }));\n}\n"],
+  "mappings": "AAOO,SAASA,EAAeC,EAAM,CAAE,SAAAC,EAAU,SAAAC,EAAU,SAAAC,CAAS,EAAG,CACrE,MAAMC,EAAO,IAAI,KAAKJ,CAAI,EAC1B,GAAI,CAAC,OAAO,SAASI,EAAK,QAAQ,CAAC,EAAG,MAAM,IAAI,MAAM,cAAc,EACpE,MAAMC,EAAQ,IAAI,KAAK,eAAe,QAAS,CAC7C,SAAAJ,EAAU,KAAM,UAAW,MAAO,UAAW,IAAK,UAClD,KAAM,UAAW,OAAQ,UAAW,OAAQ,UAAW,UAAW,KACpE,CAAC,EACKK,EAAQ,OAAO,YAAYD,EAAM,cAAcD,CAAI,EAAE,OAAOG,GAAKA,EAAE,OAAS,SAAS,EAAE,IAAIA,GAAK,CAACA,EAAE,KAAM,OAAOA,EAAE,KAAK,CAAC,CAAC,CAAC,EAC1HC,EAASF,EAAM,KAAO,GAAKA,EAAM,QAAUA,EAAM,OAASF,EAAK,mBAAmB,EAAI,KAAQ,GAC9FK,EAAU,IAAI,KAAK,KAAK,IAAIH,EAAM,KAAMA,EAAM,MAAQ,EAAGA,EAAM,GAAG,CAAC,EAAE,UAAU,EAC/EI,EAAUC,GAAaA,EAAU,MAAM,GAAG,EAAE,OAAO,CAACC,EAAOC,IAAUD,EAAQ,GAAK,OAAOC,CAAK,CAAC,EAC/FC,EAAa,CAAC,EACpB,SAAW,CAAE,KAAAC,EAAM,GAAAC,EAAI,MAAAC,EAAQ,IAAU,OAAAC,EAAQ,SAAAC,CAAS,IAAKhB,EAC7D,GAAI,EAAAe,GAAQ,SAASZ,EAAM,KAAK,IAAM,IAASa,GAAU,SAASV,CAAO,IAAM,IAC/E,QAASW,EAAYV,EAAQK,CAAI,EAAGK,GAAaV,EAAQM,CAAE,EAAGI,GAAaH,EAAOH,EAAW,KAAKM,CAAS,EAE7G,OAAON,EAAW,KAAK,CAACO,EAAGC,IAAMD,EAAIC,CAAC,EAAE,OAAOF,GAAaZ,GAAUY,GAAaZ,EAASY,EAAYlB,CAAQ,EAAE,IAAIkB,IAAc,CAClI,GAAI,GAAGd,EAAM,IAAI,IAAIA,EAAM,KAAK,IAAIA,EAAM,GAAG,IAAIc,CAAS,GAC1D,UAAW,GAAG,OAAO,KAAK,MAAMA,EAAY,EAAE,CAAC,EAAE,SAAS,EAAG,GAAG,CAAC,IAAI,OAAOA,EAAY,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,GAC5G,UAAWZ,EAASY,GAAalB,CACnC,EAAE,CACJ",
+  "names": ["scheduledTrips", "date", "timeZone", "duration", "services", "time", "clock", "parts", "p", "minute", "weekday", "minutes", "clockTime", "hours", "value", "departures", "from", "to", "every", "months", "weekdays", "departure", "a", "b"]
+}

package/dist/utils/setGeoJSONData.js

@@ -0,0 +1,2 @@
+import{releaseArea as a}from"./releaseArea.js";import{updateArea as r}from"./updateArea.js";function p(o,t){o.options.data=t,delete o.options.url;for(const e of o._areas.values())a(o,e);return o._areas.clear(),r(o),o}export{p as setGeoJSONData};
+//# sourceMappingURL=setGeoJSONData.js.map

package/dist/utils/setGeoJSONData.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setGeoJSONData.js"],
+  "sourcesContent": ["import { releaseArea } from './releaseArea.js';\nimport { updateArea } from './updateArea.js';\n\nexport function setGeoJSONData(layer, data) {\n  layer.options.data = data;\n  delete layer.options.url;\n  for (const area of layer._areas.values()) releaseArea(layer, area);\n  layer._areas.clear();\n  updateArea(layer);\n  return layer;\n}\n"],
+  "mappings": "AAAA,OAAS,eAAAA,MAAmB,mBAC5B,OAAS,cAAAC,MAAkB,kBAEpB,SAASC,EAAeC,EAAOC,EAAM,CAC1CD,EAAM,QAAQ,KAAOC,EACrB,OAAOD,EAAM,QAAQ,IACrB,UAAWE,KAAQF,EAAM,OAAO,OAAO,EAAGH,EAAYG,EAAOE,CAAI,EACjE,OAAAF,EAAM,OAAO,MAAM,EACnBF,EAAWE,CAAK,EACTA,CACT",
+  "names": ["releaseArea", "updateArea", "setGeoJSONData", "layer", "data", "area"]
+}

package/dist/utils/setHighlight.js

@@ -0,0 +1,2 @@
+import{update as t}from"./update.js";function l(i,h){h?.model&&(h=null),!(i.highlightedFeature?.mesh===h?.mesh&&i.highlightedFeature?.vertexStart===h?.vertexStart)&&(i.highlightedFeature&&(i.highlightedFeature.mesh.highlight=null),i.highlightedFeature=h,h&&(h.mesh.highlight=[h.vertexStart,h.vertexEnd]),t(i))}export{l as setHighlight};
+//# sourceMappingURL=setHighlight.js.map

package/dist/utils/setHighlight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setHighlight.js"],
+  "sourcesContent": ["import { update } from './update.js';\n\n/** Highlight a source vertex range in the shader; vertex colors stay untouched. */\n\nexport function setHighlight(backend, feature) {\n  if (feature?.model) feature = null;\n  if (backend.highlightedFeature?.mesh === feature?.mesh &&\n    backend.highlightedFeature?.vertexStart === feature?.vertexStart) return;\n  if (backend.highlightedFeature) backend.highlightedFeature.mesh.highlight = null;\n  backend.highlightedFeature = feature;\n  if (feature) feature.mesh.highlight = [feature.vertexStart, feature.vertexEnd];\n  update(backend);\n}\n"],
+  "mappings": "AAAA,OAAS,UAAAA,MAAc,cAIhB,SAASC,EAAaC,EAASC,EAAS,CACzCA,GAAS,QAAOA,EAAU,MAC1B,EAAAD,EAAQ,oBAAoB,OAASC,GAAS,MAChDD,EAAQ,oBAAoB,cAAgBC,GAAS,eACnDD,EAAQ,qBAAoBA,EAAQ,mBAAmB,KAAK,UAAY,MAC5EA,EAAQ,mBAAqBC,EACzBA,IAASA,EAAQ,KAAK,UAAY,CAACA,EAAQ,YAAaA,EAAQ,SAAS,GAC7EH,EAAOE,CAAO,EAChB",
+  "names": ["update", "setHighlight", "backend", "feature"]
+}

package/dist/utils/setPMTileOpacity.js

@@ -0,0 +1,2 @@
+import{setRasterOpacity as o}from"./rasterTiles.js";function p(t,i){return t.options.opacity=i,o(t,i),t}export{p as setPMTileOpacity};
+//# sourceMappingURL=setPMTileOpacity.js.map

package/dist/utils/setPMTileOpacity.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setPMTileOpacity.js"],
+  "sourcesContent": ["import { setRasterOpacity } from './rasterTiles.js';\n\nexport function setPMTileOpacity(backend, opacity) {\n  backend.options.opacity = opacity;\n  setRasterOpacity(backend, opacity);\n  return backend;\n}\n"],
+  "mappings": "AAAA,OAAS,oBAAAA,MAAwB,mBAE1B,SAASC,EAAiBC,EAASC,EAAS,CACjD,OAAAD,EAAQ,QAAQ,QAAUC,EAC1BH,EAAiBE,EAASC,CAAO,EAC1BD,CACT",
+  "names": ["setRasterOpacity", "setPMTileOpacity", "backend", "opacity"]
+}

package/dist/utils/setPMTileZIndex.js

@@ -0,0 +1,2 @@
+import{setRasterZIndex as o}from"./rasterTiles.js";function i(t,e){return t.options.zIndex=e,o(t,e),t}export{i as setPMTileZIndex};
+//# sourceMappingURL=setPMTileZIndex.js.map

package/dist/utils/setPMTileZIndex.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setPMTileZIndex.js"],
+  "sourcesContent": ["import { setRasterZIndex } from './rasterTiles.js';\n\nexport function setPMTileZIndex(backend, zIndex) {\n  backend.options.zIndex = zIndex;\n  setRasterZIndex(backend, zIndex);\n  return backend;\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,mBAEzB,SAASC,EAAgBC,EAASC,EAAQ,CAC/C,OAAAD,EAAQ,QAAQ,OAASC,EACzBH,EAAgBE,EAASC,CAAM,EACxBD,CACT",
+  "names": ["setRasterZIndex", "setPMTileZIndex", "backend", "zIndex"]
+}

package/dist/utils/setParent.js

@@ -0,0 +1,2 @@
+function t(i,r){i.parent&&i.parent.children.splice(i.parent.children.indexOf(i),1),i.parent=r,r&&r.children.push(i)}export{t as setParent};
+//# sourceMappingURL=setParent.js.map

package/dist/utils/setParent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setParent.js"],
+  "sourcesContent": ["/** Reparent/detach scene data without drawing or disposing GPU resources. */\n\nexport function setParent(node, parent) {\n  if (node.parent) node.parent.children.splice(node.parent.children.indexOf(node), 1);\n  node.parent = parent;\n  if (parent) parent.children.push(node);\n}\n"],
+  "mappings": "AAEO,SAASA,EAAUC,EAAMC,EAAQ,CAClCD,EAAK,QAAQA,EAAK,OAAO,SAAS,OAAOA,EAAK,OAAO,SAAS,QAAQA,CAAI,EAAG,CAAC,EAClFA,EAAK,OAASC,EACVA,GAAQA,EAAO,SAAS,KAAKD,CAAI,CACvC",
+  "names": ["setParent", "node", "parent"]
+}

package/dist/utils/setTerrainHeight.js

@@ -0,0 +1,2 @@
+import{getElevation as r}from"./getElevation.js";function s(t){if(!t.root||!t.location)return;t._terrainBaseY??=t.root.position[1];const o=t._map?._terrain3D,i=o&&r(o,t.location),n=Number.isFinite(i)?t.options.terrainOffset??0:0;t.root.position[1]=t._terrainBaseY+(i??0)+n}export{s as setTerrainHeight};
+//# sourceMappingURL=setTerrainHeight.js.map

package/dist/utils/setTerrainHeight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setTerrainHeight.js"],
+  "sourcesContent": ["import { getElevation } from './getElevation.js';\r\n\r\nexport function setTerrainHeight(layer) {\r\n  if (!layer.root || !layer.location) return;\r\n  layer._terrainBaseY ??= layer.root.position[1];\r\n  const terrain = layer._map?._terrain3D;\r\n  const elevation = terrain && getElevation(terrain, layer.location);\r\n  const offset = Number.isFinite(elevation) ? layer.options.terrainOffset ?? 0 : 0;\r\n  layer.root.position[1] = layer._terrainBaseY + (elevation ?? 0) + offset;\r\n}\r\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB,oBAEtB,SAASC,EAAiBC,EAAO,CACtC,GAAI,CAACA,EAAM,MAAQ,CAACA,EAAM,SAAU,OACpCA,EAAM,gBAAkBA,EAAM,KAAK,SAAS,CAAC,EAC7C,MAAMC,EAAUD,EAAM,MAAM,WACtBE,EAAYD,GAAWH,EAAaG,EAASD,EAAM,QAAQ,EAC3DG,EAAS,OAAO,SAASD,CAAS,EAAIF,EAAM,QAAQ,eAAiB,EAAI,EAC/EA,EAAM,KAAK,SAAS,CAAC,EAAIA,EAAM,eAAiBE,GAAa,GAAKC,CACpE",
+  "names": ["getElevation", "setTerrainHeight", "layer", "terrain", "elevation", "offset"]
+}

package/dist/utils/setVertexColor.js

@@ -0,0 +1,2 @@
+function i(r,o,a,t){for(let e=o;e<a;e++)r.geometry.attributes.color.data.set([t.r,t.g,t.b],e*3);r.geometry.attributes.color.needsUpdate=!0}export{i as setVertexColor};
+//# sourceMappingURL=setVertexColor.js.map

package/dist/utils/setVertexColor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/setVertexColor.js"],
+  "sourcesContent": ["/**\n * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.\n * @param {Object} mesh Layer-created mesh with a color attribute.\n * @param {number} start Inclusive vertex index, not an offset into the RGB array.\n * @param {number} end Exclusive vertex index.\n * @param {Object} color sRGB {r,g,b}, typically from parseColor().\n */\n\nexport function setVertexColor(mesh, start, end, color) {\n  for (let i = start; i < end; i++) {\n    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);\n  }\n  mesh.geometry.attributes.color.needsUpdate = true;\n}\n"],
+  "mappings": "AAQO,SAASA,EAAeC,EAAMC,EAAOC,EAAKC,EAAO,CACtD,QAASC,EAAIH,EAAOG,EAAIF,EAAKE,IAC3BJ,EAAK,SAAS,WAAW,MAAM,KAAK,IAAI,CAACG,EAAM,EAAGA,EAAM,EAAGA,EAAM,CAAC,EAAGC,EAAI,CAAC,EAE5EJ,EAAK,SAAS,WAAW,MAAM,YAAc,EAC/C",
+  "names": ["setVertexColor", "mesh", "start", "end", "color", "i"]
+}

package/dist/utils/showFeature.js

@@ -0,0 +1,2 @@
+function f(e,n,l){const t=e._tooltip;if(!t)return;if(n){t.replaceChildren(e.options.tooltip(n)),t.hidden=!1;const s=e.container.getBoundingClientRect(),i=l.clientX-s.left,r=l.clientY-s.top;t.style.left=`${i+t.offsetWidth+16>s.width?i-t.offsetWidth-12:i+12}px`,t.style.top=`${r+t.offsetHeight+16>s.height?r-t.offsetHeight-12:r+12}px`}else t.hidden=!0;const o=e._shared;o&&([...o._layers].some(i=>i._tooltip&&!i._tooltip.hidden)?(o._cursor===void 0&&(o._cursor=e.container.style.cursor),e.container.style.cursor="pointer"):o._cursor!==void 0&&(e.container.style.cursor=o._cursor,delete o._cursor))}export{f as showFeature};
+//# sourceMappingURL=showFeature.js.map

package/dist/utils/showFeature.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/showFeature.js"],
+  "sourcesContent": ["/** Update tooltip content/position and arbitrate cursor ownership across shared layers. */\n\nexport function showFeature(backend, feature, event) {\n  const tooltip = backend._tooltip;\n  if (!tooltip) return;\n  if (feature) {\n    tooltip.replaceChildren(backend.options.tooltip(feature));\n    tooltip.hidden = false;\n    const rect = backend.container.getBoundingClientRect();\n    const x = event.clientX - rect.left, y = event.clientY - rect.top;\n    tooltip.style.left = `${x + tooltip.offsetWidth + 16 > rect.width ? x - tooltip.offsetWidth - 12 : x + 12}px`;\n    tooltip.style.top = `${y + tooltip.offsetHeight + 16 > rect.height ? y - tooltip.offsetHeight - 12 : y + 12}px`;\n  } else {\n    tooltip.hidden = true;\n  }\n  const shared = backend._shared;\n  if (shared) {\n    const visible = [...shared._layers].some(layer => layer._tooltip && !layer._tooltip.hidden);\n    if (visible) {\n      if (shared._cursor === undefined) shared._cursor = backend.container.style.cursor;\n      backend.container.style.cursor = 'pointer';\n    } else if (shared._cursor !== undefined) {\n      backend.container.style.cursor = shared._cursor;\n      delete shared._cursor;\n    }\n  }\n}\n"],
+  "mappings": "AAEO,SAASA,EAAYC,EAASC,EAASC,EAAO,CACnD,MAAMC,EAAUH,EAAQ,SACxB,GAAI,CAACG,EAAS,OACd,GAAIF,EAAS,CACXE,EAAQ,gBAAgBH,EAAQ,QAAQ,QAAQC,CAAO,CAAC,EACxDE,EAAQ,OAAS,GACjB,MAAMC,EAAOJ,EAAQ,UAAU,sBAAsB,EAC/CK,EAAIH,EAAM,QAAUE,EAAK,KAAME,EAAIJ,EAAM,QAAUE,EAAK,IAC9DD,EAAQ,MAAM,KAAO,GAAGE,EAAIF,EAAQ,YAAc,GAAKC,EAAK,MAAQC,EAAIF,EAAQ,YAAc,GAAKE,EAAI,EAAE,KACzGF,EAAQ,MAAM,IAAM,GAAGG,EAAIH,EAAQ,aAAe,GAAKC,EAAK,OAASE,EAAIH,EAAQ,aAAe,GAAKG,EAAI,EAAE,IAC7G,MACEH,EAAQ,OAAS,GAEnB,MAAMI,EAASP,EAAQ,QACnBO,IACc,CAAC,GAAGA,EAAO,OAAO,EAAE,KAAKC,GAASA,EAAM,UAAY,CAACA,EAAM,SAAS,MAAM,GAEpFD,EAAO,UAAY,SAAWA,EAAO,QAAUP,EAAQ,UAAU,MAAM,QAC3EA,EAAQ,UAAU,MAAM,OAAS,WACxBO,EAAO,UAAY,SAC5BP,EAAQ,UAAU,MAAM,OAASO,EAAO,QACxC,OAAOA,EAAO,SAGpB",
+  "names": ["showFeature", "backend", "feature", "event", "tooltip", "rect", "x", "y", "shared", "layer"]
+}

package/dist/utils/sizes.js

@@ -0,0 +1,2 @@
+const C={SCALAR:1,VEC2:2,VEC3:3,VEC4:4};export{C as sizes};
+//# sourceMappingURL=sizes.js.map

package/dist/utils/sizes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/sizes.js"],
+  "sourcesContent": ["export const sizes = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 };\n"],
+  "mappings": "AAAO,MAAMA,EAAQ,CAAE,OAAQ,EAAG,KAAM,EAAG,KAAM,EAAG,KAAM,CAAE",
+  "names": ["sizes"]
+}

package/dist/utils/skin.js

@@ -0,0 +1,2 @@
+const r=[.85,.64,.5],s=[.75,.2,.15],t=[.16,.2,.32],o=[.08,.07,.06];export{o as dark,s as shirt,r as skin,t as trousers};
+//# sourceMappingURL=skin.js.map

package/dist/utils/skin.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/skin.js"],
+  "sourcesContent": ["// Pedestrian, about 1.77 m tall, prisms as in utils/vehicles.js (forward -z). Limbs hang from their pivot at y = 0.\nexport const skin = [0.85, 0.64, 0.5], shirt = [0.75, 0.2, 0.15], trousers = [0.16, 0.2, 0.32], dark = [0.08, 0.07, 0.06];\n"],
+  "mappings": "AACO,MAAMA,EAAO,CAAC,IAAM,IAAM,EAAG,EAAGC,EAAQ,CAAC,IAAM,GAAK,GAAI,EAAGC,EAAW,CAAC,IAAM,GAAK,GAAI,EAAGC,EAAO,CAAC,IAAM,IAAM,GAAI",
+  "names": ["skin", "shirt", "trousers", "dark"]
+}

package/dist/utils/solarPosition.js

@@ -0,0 +1,2 @@
+import{horizontalPosition as m}from"./horizontalPosition.js";function b(h,i,n){const s=new Date(h).getTime();if(!Number.isFinite(s)||!Number.isFinite(i)||Math.abs(i)>90||!Number.isFinite(n)||Math.abs(n)>180)throw new Error("Invalid solar date or location");const o=Math.PI/180,e=s/864e5-10957.5,t=(357.5291+.98560028*e)*o,a=t+(1.9148*Math.sin(t)+.02*Math.sin(2*t)+3e-4*Math.sin(3*t)+102.9372+180)*o,r=23.4397*o,c=Math.asin(Math.sin(a)*Math.sin(r)),M=Math.atan2(Math.sin(a)*Math.cos(r),Math.cos(a));return m(e,i,n,M,c)}export{b as solarPosition};
+//# sourceMappingURL=solarPosition.js.map

package/dist/utils/solarPosition.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/solarPosition.js"],
+  "sourcesContent": ["import { horizontalPosition } from \"./horizontalPosition.js\";\n\n// Solar centre, without atmospheric refraction.\n\nexport function solarPosition(date, lat, lng) {\n  const time = new Date(date).getTime();\n  if (!Number.isFinite(time) || !Number.isFinite(lat) || Math.abs(lat) > 90 ||\n    !Number.isFinite(lng) || Math.abs(lng) > 180) throw new Error('Invalid solar date or location');\n  const rad = Math.PI / 180, d = time / 86400000 - 10957.5;\n  const mean = (357.5291 + 0.98560028 * d) * rad;\n  const longitude = mean + (1.9148 * Math.sin(mean) + 0.02 * Math.sin(2 * mean) +\n    0.0003 * Math.sin(3 * mean) + 102.9372 + 180) * rad;\n  const obliquity = 23.4397 * rad;\n  const declination = Math.asin(Math.sin(longitude) * Math.sin(obliquity));\n  const ascension = Math.atan2(Math.sin(longitude) * Math.cos(obliquity), Math.cos(longitude));\n  return horizontalPosition(d, lat, lng, ascension, declination);\n}\n"],
+  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,0BAI5B,SAASC,EAAcC,EAAMC,EAAKC,EAAK,CAC5C,MAAMC,EAAO,IAAI,KAAKH,CAAI,EAAE,QAAQ,EACpC,GAAI,CAAC,OAAO,SAASG,CAAI,GAAK,CAAC,OAAO,SAASF,CAAG,GAAK,KAAK,IAAIA,CAAG,EAAI,IACrE,CAAC,OAAO,SAASC,CAAG,GAAK,KAAK,IAAIA,CAAG,EAAI,IAAK,MAAM,IAAI,MAAM,gCAAgC,EAChG,MAAME,EAAM,KAAK,GAAK,IAAKC,EAAIF,EAAO,MAAW,QAC3CG,GAAQ,SAAW,UAAaD,GAAKD,EACrCG,EAAYD,GAAQ,OAAS,KAAK,IAAIA,CAAI,EAAI,IAAO,KAAK,IAAI,EAAIA,CAAI,EAC1E,KAAS,KAAK,IAAI,EAAIA,CAAI,EAAI,SAAW,KAAOF,EAC5CI,EAAY,QAAUJ,EACtBK,EAAc,KAAK,KAAK,KAAK,IAAIF,CAAS,EAAI,KAAK,IAAIC,CAAS,CAAC,EACjEE,EAAY,KAAK,MAAM,KAAK,IAAIH,CAAS,EAAI,KAAK,IAAIC,CAAS,EAAG,KAAK,IAAID,CAAS,CAAC,EAC3F,OAAOT,EAAmBO,EAAGJ,EAAKC,EAAKQ,EAAWD,CAAW,CAC/D",
+  "names": ["horizontalPosition", "solarPosition", "date", "lat", "lng", "time", "rad", "d", "mean", "longitude", "obliquity", "declination", "ascension"]
+}

package/dist/utils/sortMeshes.js

@@ -0,0 +1,2 @@
+function t(o){return o.sort((r,e)=>+!!e.ground-+!!r.ground||(r.ground&&e.ground?(r.renderOrder||0)-(e.renderOrder||0)||r.tile.coords.z-e.tile.coords.z:0)||Number(r.program.transparent)-Number(e.program.transparent)||(r.program.transparent?(r.renderOrder||0)-(e.renderOrder||0)||e._sortDepth-r._sortDepth||r.id-e.id:(r._sortDepth??0)-(e._sortDepth??0)||r.id-e.id))}export{t as sortMeshes};
+//# sourceMappingURL=sortMeshes.js.map

package/dist/utils/sortMeshes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/sortMeshes.js"],
+  "sourcesContent": ["\nexport function sortMeshes(meshes) {\n  return meshes.sort((a, b) => Number(Boolean(b.ground)) - Number(Boolean(a.ground)) ||\n    (a.ground && b.ground ? (a.renderOrder || 0) - (b.renderOrder || 0) ||\n      a.tile.coords.z - b.tile.coords.z : 0) ||\n    Number(a.program.transparent) - Number(b.program.transparent) ||\n    (a.program.transparent\n      ? (a.renderOrder || 0) - (b.renderOrder || 0) ||\n      b._sortDepth - a._sortDepth || a.id - b.id\n      : (a._sortDepth ?? 0) - (b._sortDepth ?? 0) || a.id - b.id)\n  );\n}\n"],
+  "mappings": "AACO,SAASA,EAAWC,EAAQ,CACjC,OAAOA,EAAO,KAAK,CAACC,EAAGC,IAAM,CAAO,EAAQA,EAAE,OAAW,CAAO,EAAQD,EAAE,SACvEA,EAAE,QAAUC,EAAE,QAAUD,EAAE,aAAe,IAAMC,EAAE,aAAe,IAC/DD,EAAE,KAAK,OAAO,EAAIC,EAAE,KAAK,OAAO,EAAI,IACtC,OAAOD,EAAE,QAAQ,WAAW,EAAI,OAAOC,EAAE,QAAQ,WAAW,IAC3DD,EAAE,QAAQ,aACNA,EAAE,aAAe,IAAMC,EAAE,aAAe,IAC3CA,EAAE,WAAaD,EAAE,YAAcA,EAAE,GAAKC,EAAE,IACrCD,EAAE,YAAc,IAAMC,EAAE,YAAc,IAAMD,EAAE,GAAKC,EAAE,GAC5D,CACF",
+  "names": ["sortMeshes", "meshes", "a", "b"]
+}

package/dist/utils/speed.js

@@ -0,0 +1,2 @@
+const e=8;export{e as speed};
+//# sourceMappingURL=speed.js.map

package/dist/utils/speed.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/speed.js"],
+  "sourcesContent": ["// Pure helpers of the 'traffic' type: lane interpolation and vehicle scheduling.\n/** Default urban speed (m/s) used to turn a lane's hourly `flow` into vehicles on the road. */\nexport const speed = 8;\n"],
+  "mappings": "AAEO,MAAMA,EAAQ",
+  "names": ["speed"]
+}

package/dist/utils/startZoom.js

@@ -0,0 +1,2 @@
+function o(){this._zoomLevel=null}export{o as startZoom};
+//# sourceMappingURL=startZoom.js.map

package/dist/utils/startZoom.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/startZoom.js"],
+  "sourcesContent": ["/** Preserve the outgoing tile level before Leaflet changes its logical zoom. */\n\nexport function startZoom() {\n  this._zoomLevel = null;\n}\n"],
+  "mappings": "AAEO,SAASA,GAAY,CAC1B,KAAK,WAAa,IACpB",
+  "names": ["startZoom"]
+}

package/dist/utils/taillight.js

@@ -0,0 +1,2 @@
+const t=[1.7,.06,.05];export{t as taillight};
+//# sourceMappingURL=taillight.js.map

package/dist/utils/taillight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/taillight.js"],
+  "sourcesContent": ["export const taillight = [1.7, 0.06, 0.05];\n"],
+  "mappings": "AAAO,MAAMA,EAAY,CAAC,IAAK,IAAM,GAAI",
+  "names": ["taillight"]
+}

package/dist/utils/terrainAtlas.js

@@ -0,0 +1,2 @@
+function u(m,t){const o=t.max.x-t.min.x+1,c=t.max.y-t.min.y+1,l=new Float32Array(o*c*65536).fill(-1e9);let r=1/0,a=-1/0;for(const[f,s]of m){const[x,y]=f.split("/").map(Number),h=(y-t.min.y)*256*o*256+(x-t.min.x)*256;for(let i=0;i<256;i++)for(let e=0;e<256;e++){const n=s[i*256+e];!Number.isFinite(n)||n<=-1e3||(l[h+i*o*256+e]=n,r=Math.min(r,n),a=Math.max(a,n))}}return{elevations:l,low:r,high:a}}export{u as terrainAtlas};
+//# sourceMappingURL=terrainAtlas.js.map

package/dist/utils/terrainAtlas.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/terrainAtlas.js"],
+  "sourcesContent": ["/** Float32 DEM atlas; missing samples retain the shader no-data sentinel. */\n\nexport function terrainAtlas(tiles, bounds) {\n  const columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;\n  const elevations = new Float32Array(columns * rows * 65536).fill(-1e9);\n  let low = Infinity, high = -Infinity;\n  for (const [key, values] of tiles) {\n    const [x, y] = key.split('/').map(Number);\n    const start = (y - bounds.min.y) * 256 * columns * 256 + (x - bounds.min.x) * 256;\n    for (let row = 0; row < 256; row++) {\n      for (let column = 0; column < 256; column++) {\n        const value = values[row * 256 + column];\n        if (!Number.isFinite(value) || value <= -1000) continue;\n        elevations[start + row * columns * 256 + column] = value;\n        low = Math.min(low, value);\n        high = Math.max(high, value);\n      }\n    }\n  }\n  return { elevations, low, high };\n}\n"],
+  "mappings": "AAEO,SAASA,EAAaC,EAAOC,EAAQ,CAC1C,MAAMC,EAAUD,EAAO,IAAI,EAAIA,EAAO,IAAI,EAAI,EAAGE,EAAOF,EAAO,IAAI,EAAIA,EAAO,IAAI,EAAI,EAChFG,EAAa,IAAI,aAAaF,EAAUC,EAAO,KAAK,EAAE,KAAK,IAAI,EACrE,IAAIE,EAAM,IAAUC,EAAO,KAC3B,SAAW,CAACC,EAAKC,CAAM,IAAKR,EAAO,CACjC,KAAM,CAAC,EAAG,CAAC,EAAIO,EAAI,MAAM,GAAG,EAAE,IAAI,MAAM,EAClCE,GAAS,EAAIR,EAAO,IAAI,GAAK,IAAMC,EAAU,KAAO,EAAID,EAAO,IAAI,GAAK,IAC9E,QAASS,EAAM,EAAGA,EAAM,IAAKA,IAC3B,QAASC,EAAS,EAAGA,EAAS,IAAKA,IAAU,CAC3C,MAAMC,EAAQJ,EAAOE,EAAM,IAAMC,CAAM,EACnC,CAAC,OAAO,SAASC,CAAK,GAAKA,GAAS,OACxCR,EAAWK,EAAQC,EAAMR,EAAU,IAAMS,CAAM,EAAIC,EACnDP,EAAM,KAAK,IAAIA,EAAKO,CAAK,EACzBN,EAAO,KAAK,IAAIA,EAAMM,CAAK,EAC7B,CAEJ,CACA,MAAO,CAAE,WAAAR,EAAY,IAAAC,EAAK,KAAAC,CAAK,CACjC",
+  "names": ["terrainAtlas", "tiles", "bounds", "columns", "rows", "elevations", "low", "high", "key", "values", "start", "row", "column", "value"]
+}

package/dist/utils/terrainElevation.js

@@ -0,0 +1,2 @@
+function g(a,M){const f=a.x-.5,c=a.y-.5,e=Math.floor(f),l=Math.floor(c),o=f-e,h=c-l,r=(n,i)=>{const m=Math.floor(n/256),v=Math.floor(i/256),x=M.get(`${m}/${v}`);if(!x)return null;const u=x[(i-v*256)*256+n-m*256];return Number.isFinite(u)&&u>-1e3?u:null},t=[r(e,l),r(e+1,l),r(e,l+1),r(e+1,l+1)],s=t.map((n,i)=>Number.isFinite(n)?i:-1).filter(n=>n>=0);return s.length?s.length<4?t[s[0]]:(t[0]*(1-o)+t[1]*o)*(1-h)+(t[2]*(1-o)+t[3]*o)*h:null}export{g as terrainElevation};
+//# sourceMappingURL=terrainElevation.js.map

package/dist/utils/terrainElevation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/terrainElevation.js"],
+  "sourcesContent": ["/** Bilinear DEM sampling, with the original first-valid-neighbour no-data rule. */\n\nexport function terrainElevation(point, tiles) {\n  const x = point.x - 0.5, y = point.y - 0.5;\n  const x0 = Math.floor(x), y0 = Math.floor(y);\n  const fx = x - x0, fy = y - y0;\n  const sample = (px, py) => {\n    const tileX = Math.floor(px / 256), tileY = Math.floor(py / 256);\n    const tile = tiles.get(`${tileX}/${tileY}`);\n    if (!tile) return null;\n    const elevation = tile[(py - tileY * 256) * 256 + px - tileX * 256];\n    return Number.isFinite(elevation) && elevation > -1000 ? elevation : null;\n  };\n  const values = [sample(x0, y0), sample(x0 + 1, y0), sample(x0, y0 + 1), sample(x0 + 1, y0 + 1)];\n  const valid = values.map((value, i) => Number.isFinite(value) ? i : -1).filter(i => i >= 0);\n  if (!valid.length) return null;\n  if (valid.length < 4) return values[valid[0]];\n  return (values[0] * (1 - fx) + values[1] * fx) * (1 - fy) +\n    (values[2] * (1 - fx) + values[3] * fx) * fy;\n}\n"],
+  "mappings": "AAEO,SAASA,EAAiBC,EAAOC,EAAO,CAC7C,MAAMC,EAAIF,EAAM,EAAI,GAAKG,EAAIH,EAAM,EAAI,GACjCI,EAAK,KAAK,MAAMF,CAAC,EAAGG,EAAK,KAAK,MAAMF,CAAC,EACrCG,EAAKJ,EAAIE,EAAIG,EAAKJ,EAAIE,EACtBG,EAAS,CAACC,EAAIC,IAAO,CACzB,MAAMC,EAAQ,KAAK,MAAMF,EAAK,GAAG,EAAGG,EAAQ,KAAK,MAAMF,EAAK,GAAG,EACzDG,EAAOZ,EAAM,IAAI,GAAGU,CAAK,IAAIC,CAAK,EAAE,EAC1C,GAAI,CAACC,EAAM,OAAO,KAClB,MAAMC,EAAYD,GAAMH,EAAKE,EAAQ,KAAO,IAAMH,EAAKE,EAAQ,GAAG,EAClE,OAAO,OAAO,SAASG,CAAS,GAAKA,EAAY,KAAQA,EAAY,IACvE,EACMC,EAAS,CAACP,EAAOJ,EAAIC,CAAE,EAAGG,EAAOJ,EAAK,EAAGC,CAAE,EAAGG,EAAOJ,EAAIC,EAAK,CAAC,EAAGG,EAAOJ,EAAK,EAAGC,EAAK,CAAC,CAAC,EACxFW,EAAQD,EAAO,IAAI,CAACE,EAAO,IAAM,OAAO,SAASA,CAAK,EAAI,EAAI,EAAE,EAAE,OAAOC,GAAKA,GAAK,CAAC,EAC1F,OAAKF,EAAM,OACPA,EAAM,OAAS,EAAUD,EAAOC,EAAM,CAAC,CAAC,GACpCD,EAAO,CAAC,GAAK,EAAIT,GAAMS,EAAO,CAAC,EAAIT,IAAO,EAAIC,IACnDQ,EAAO,CAAC,GAAK,EAAIT,GAAMS,EAAO,CAAC,EAAIT,GAAMC,EAHlB,IAI5B",
+  "names": ["terrainElevation", "point", "tiles", "x", "y", "x0", "y0", "fx", "fy", "sample", "px", "py", "tileX", "tileY", "tile", "elevation", "values", "valid", "value", "i"]
+}

package/dist/utils/terrainGrid.js

@@ -0,0 +1,2 @@
+function f(a){const o=[],u=[],l=[],c=[];for(let r=0;r<=a;r++)for(let t=0;t<=a;t++)if(o.push(t/a,0,r/a),u.push(0,1,0),l.push(t/a,r/a),r<a&&t<a){const e=r*(a+1)+t,p=e+1,n=e+a+1,w=n+1;c.push(e,n,p,p,n,w)}return{position:{size:3,data:new Float32Array(o)},normal:{size:3,data:new Float32Array(u)},uv:{size:2,data:new Float32Array(l)},index:{data:new Uint16Array(c)}}}export{f as terrainGrid};
+//# sourceMappingURL=terrainGrid.js.map

package/dist/utils/terrainGrid.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/terrainGrid.js"],
+  "sourcesContent": ["/** Unit tile grid; the vertex shader supplies the elevation. */\n\nexport function terrainGrid(divisions) {\n  const positions = [], normals = [], uvs = [], indices = [];\n  for (let row = 0; row <= divisions; row++) {\n    for (let column = 0; column <= divisions; column++) {\n      positions.push(column / divisions, 0, row / divisions);\n      normals.push(0, 1, 0);\n      uvs.push(column / divisions, row / divisions);\n      if (row < divisions && column < divisions) {\n        const a = row * (divisions + 1) + column;\n        const b = a + 1, c = a + divisions + 1, d = c + 1;\n        indices.push(a, c, b, b, c, d);\n      }\n    }\n  }\n  return {\n    position: { size: 3, data: new Float32Array(positions) },\n    normal: { size: 3, data: new Float32Array(normals) },\n    uv: { size: 2, data: new Float32Array(uvs) },\n    index: { data: new Uint16Array(indices) },\n  };\n}\n"],
+  "mappings": "AAEO,SAASA,EAAYC,EAAW,CACrC,MAAMC,EAAY,CAAC,EAAGC,EAAU,CAAC,EAAGC,EAAM,CAAC,EAAGC,EAAU,CAAC,EACzD,QAASC,EAAM,EAAGA,GAAOL,EAAWK,IAClC,QAASC,EAAS,EAAGA,GAAUN,EAAWM,IAIxC,GAHAL,EAAU,KAAKK,EAASN,EAAW,EAAGK,EAAML,CAAS,EACrDE,EAAQ,KAAK,EAAG,EAAG,CAAC,EACpBC,EAAI,KAAKG,EAASN,EAAWK,EAAML,CAAS,EACxCK,EAAML,GAAaM,EAASN,EAAW,CACzC,MAAMO,EAAIF,GAAOL,EAAY,GAAKM,EAC5BE,EAAID,EAAI,EAAGE,EAAIF,EAAIP,EAAY,EAAGU,EAAID,EAAI,EAChDL,EAAQ,KAAKG,EAAGE,EAAGD,EAAGA,EAAGC,EAAGC,CAAC,CAC/B,CAGJ,MAAO,CACL,SAAU,CAAE,KAAM,EAAG,KAAM,IAAI,aAAaT,CAAS,CAAE,EACvD,OAAQ,CAAE,KAAM,EAAG,KAAM,IAAI,aAAaC,CAAO,CAAE,EACnD,GAAI,CAAE,KAAM,EAAG,KAAM,IAAI,aAAaC,CAAG,CAAE,EAC3C,MAAO,CAAE,KAAM,IAAI,YAAYC,CAAO,CAAE,CAC1C,CACF",
+  "names": ["terrainGrid", "divisions", "positions", "normals", "uvs", "indices", "row", "column", "a", "b", "c", "d"]
+}

package/dist/utils/textureSampler.js

@@ -0,0 +1,2 @@
+function r(e){return{addressModeU:e.wrapS===33071?"clamp-to-edge":e.wrapS===33648?"mirror-repeat":"repeat",addressModeV:e.wrapT===33071?"clamp-to-edge":e.wrapT===33648?"mirror-repeat":"repeat",magFilter:e.magFilter===9728?"nearest":"linear",minFilter:e.minFilter===9728||e.minFilter===9984||e.minFilter===9986?"nearest":"linear"}}export{r as textureSampler};
+//# sourceMappingURL=textureSampler.js.map

package/dist/utils/textureSampler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/textureSampler.js"],
+  "sourcesContent": ["/** Translate glTF sampler constants into WebGPU sampler options. */\n\nexport function textureSampler(sampler) {\n  return {\n    addressModeU: sampler.wrapS === 33071 ? 'clamp-to-edge' : sampler.wrapS === 33648 ? 'mirror-repeat' : 'repeat',\n    addressModeV: sampler.wrapT === 33071 ? 'clamp-to-edge' : sampler.wrapT === 33648 ? 'mirror-repeat' : 'repeat',\n    magFilter: sampler.magFilter === 9728 ? 'nearest' : 'linear',\n    minFilter: sampler.minFilter === 9728 || sampler.minFilter === 9984 || sampler.minFilter === 9986 ? 'nearest' : 'linear',\n  };\n}\n"],
+  "mappings": "AAEO,SAASA,EAAeC,EAAS,CACtC,MAAO,CACL,aAAcA,EAAQ,QAAU,MAAQ,gBAAkBA,EAAQ,QAAU,MAAQ,gBAAkB,SACtG,aAAcA,EAAQ,QAAU,MAAQ,gBAAkBA,EAAQ,QAAU,MAAQ,gBAAkB,SACtG,UAAWA,EAAQ,YAAc,KAAO,UAAY,SACpD,UAAWA,EAAQ,YAAc,MAAQA,EAAQ,YAAc,MAAQA,EAAQ,YAAc,KAAO,UAAY,QAClH,CACF",
+  "names": ["textureSampler", "sampler"]
+}

package/dist/utils/tileId.js

@@ -0,0 +1,2 @@
+function f(t,e,r){if(![t,e,r].every(Number.isInteger)||t<0||t>26||e<0||r<0||e>=2**t||r>=2**t)throw new Error("Invalid PMTiles tile coordinates");let o=(4**t-1)/3;const n=2**t;for(let i=n/2;i>=1;i/=2){const l=e&i?1:0,s=r&i?1:0;o+=i*i*(3*l^s),s||(l&&(e=n-1-e,r=n-1-r),[e,r]=[r,e])}return o}export{f as tileId};
+//# sourceMappingURL=tileId.js.map

package/dist/utils/tileId.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/tileId.js"],
+  "sourcesContent": ["/** Cumulative Hilbert ID for an archive tile. */\n\nexport function tileId(z, x, y) {\n  if (![z, x, y].every(Number.isInteger) || z < 0 || z > 26 ||\n    x < 0 || y < 0 || x >= 2 ** z || y >= 2 ** z) throw new Error('Invalid PMTiles tile coordinates');\n  let id = (4 ** z - 1) / 3;\n  const n = 2 ** z;\n  // Same cumulative Hilbert ordering used by build/pmtiles.js.\n  for (let s = n / 2; s >= 1; s /= 2) {\n    const rx = (x & s) ? 1 : 0, ry = (y & s) ? 1 : 0;\n    id += s * s * ((3 * rx) ^ ry);\n    if (!ry) {\n      if (rx) { x = n - 1 - x; y = n - 1 - y; }\n      [x, y] = [y, x];\n    }\n  }\n  return id;\n}\n"],
+  "mappings": "AAEO,SAASA,EAAOC,EAAGC,EAAGC,EAAG,CAC9B,GAAI,CAAC,CAACF,EAAGC,EAAGC,CAAC,EAAE,MAAM,OAAO,SAAS,GAAKF,EAAI,GAAKA,EAAI,IACrDC,EAAI,GAAKC,EAAI,GAAKD,GAAK,GAAKD,GAAKE,GAAK,GAAKF,EAAG,MAAM,IAAI,MAAM,kCAAkC,EAClG,IAAIG,GAAM,GAAKH,EAAI,GAAK,EACxB,MAAM,EAAI,GAAKA,EAEf,QAASI,EAAI,EAAI,EAAGA,GAAK,EAAGA,GAAK,EAAG,CAClC,MAAMC,EAAMJ,EAAIG,EAAK,EAAI,EAAGE,EAAMJ,EAAIE,EAAK,EAAI,EAC/CD,GAAMC,EAAIA,GAAM,EAAIC,EAAMC,GACrBA,IACCD,IAAMJ,EAAI,EAAI,EAAIA,EAAGC,EAAI,EAAI,EAAIA,GACrC,CAACD,EAAGC,CAAC,EAAI,CAACA,EAAGD,CAAC,EAElB,CACA,OAAOE,CACT",
+  "names": ["tileId", "z", "x", "y", "id", "s", "rx", "ry"]
+}

package/dist/utils/toLanes.js

@@ -0,0 +1,2 @@
+const o=({features:i=[]})=>i.flatMap(({geometry:n,properties:t})=>(n?.type==="LineString"?[n.coordinates]:n?.type==="MultiLineString"?n.coordinates:[]).map(a=>({latlngs:a.map(([e,l])=>[l,e]),properties:t??{},elevation:t?.elevation})));export{o as toLanes};
+//# sourceMappingURL=toLanes.js.map

package/dist/utils/toLanes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/toLanes.js"],
+  "sourcesContent": ["// GeoJSON (Multi)LineStrings become lanes ({latlngs, properties, elevation?}); prepare() adds `points` ([x, z, ground]),\n// `lengths` and `length` in layer-local metres.\n\nexport const toLanes = ({ features = [] }) => features.flatMap(({ geometry, properties }) => {\n  const lines = geometry?.type === 'LineString' ? [geometry.coordinates] : geometry?.type === 'MultiLineString' ? geometry.coordinates : [];\n  return lines.map(line => ({ latlngs: line.map(([lng, lat]) => [lat, lng]), properties: properties ?? {}, elevation: properties?.elevation }));\n});\n"],
+  "mappings": "AAGO,MAAMA,EAAU,CAAC,CAAE,SAAAC,EAAW,CAAC,CAAE,IAAMA,EAAS,QAAQ,CAAC,CAAE,SAAAC,EAAU,WAAAC,CAAW,KACvED,GAAU,OAAS,aAAe,CAACA,EAAS,WAAW,EAAIA,GAAU,OAAS,kBAAoBA,EAAS,YAAc,CAAC,GAC3H,IAAIE,IAAS,CAAE,QAASA,EAAK,IAAI,CAAC,CAACC,EAAKC,CAAG,IAAM,CAACA,EAAKD,CAAG,CAAC,EAAG,WAAYF,GAAc,CAAC,EAAG,UAAWA,GAAY,SAAU,EAAE,CAC7I",
+  "names": ["toLanes", "features", "geometry", "properties", "line", "lng", "lat"]
+}