leaflet-city-mapper 0.0.2 → 0.0.4

package/dist/utils/vehicleOffsets.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/vehicleOffsets.js"],
-  "sourcesContent": ["import { speed } from \"./speed.js\";\n\n/** Evenly spaced starting offsets (metres) for `flow` vehicles/h moving at `velocity` m/s on a `length` metres lane. */\n\nexport function vehicleOffsets(length, flow, velocity = speed) {\n  const count = Math.round(length * flow / 3600 / velocity);\n  return Array.from({ length: count }, (_, i) => (i + 0.5) * length / count);\n}\n"],
-  "mappings": "AAAA,OAAS,SAAAA,MAAa,aAIf,SAASC,EAAeC,EAAQC,EAAMC,EAAWJ,EAAO,CAC7D,MAAMK,EAAQ,KAAK,MAAMH,EAASC,EAAO,KAAOC,CAAQ,EACxD,OAAO,MAAM,KAAK,CAAE,OAAQC,CAAM,EAAG,CAACC,EAAGC,KAAOA,EAAI,IAAOL,EAASG,CAAK,CAC3E",
-  "names": ["speed", "vehicleOffsets", "length", "flow", "velocity", "count", "_", "i"]
-}

package/dist/utils/vehicles.js

@@ -1,2 +0,0 @@
-import{hull as s}from"./hull.js";import{box as o}from"./box.js";import{glass as m,tyre as e}from"./glass.js";import{mirror as t}from"./mirror.js";import{white as r}from"./white.js";import{paints as p}from"./paints.js";import{headlight as f}from"./headlight.js";import{taillight as a}from"./taillight.js";const y={car:{side:1.8,model:l=>{const i=p[l%p.length];return[...t(.7,.92,-1.68,-1.02,0,.64,e),...t(.7,.92,1.02,1.68,0,.64,e),[[[-.9,-1.95],[-.72,-2.25],[.72,-2.25],[.9,-1.95],[.9,2.05],[.76,2.25],[-.76,2.25],[-.9,2.05]],.28,.82,i],[o(-.84,.84,-.75,1.6),.82,1.38,m,o(-.7,.7,-.05,1.3)],[o(-.71,.71,-.06,1.31),1.38,1.46,i],...t(.38,.8,-2.3,-2.16,.56,.76,f),[o(-.78,.78,2.16,2.3),.6,.76,a]]},lights:[{position:[0,1.2,-6],radius:10,color:[1,.94,.82],flux:800}]},boat:{side:0,model:()=>[[s,0,.8,[.1,.16,.26]],[s,.8,1.4,r],[o(-5,5,-18,26),1.4,3.7,m,o(-4.6,4.6,-17.4,25.6)],...t(4.64,4.74,-17,25,3.25,3.45,[1.6,1.25,.8]),[o(-4.8,4.8,-17.8,25.8),3.7,3.9,r],...Array.from({length:12},(l,i)=>t(.5,3.8,-12+i*3,-11.3+i*3,3.9,4.4,[.62,.1,.1])).flat(),...t(4.65,4.8,-13.6,25.8,3.9,4.8,r),[o(-4.8,4.8,25.65,25.8),3.9,4.8,r],[o(-2.2,2.2,-17.6,-14),3.9,4.7,r],[o(-2.2,2.2,-17.6,-14),4.7,5.5,m],[o(-2.5,2.5,-18,-13.6),5.5,5.7,r],[o(-2.45,-2.2,-16.2,-15.8),5,5.3,[2,.15,.1]],[o(2.2,2.45,-16.2,-15.8),5,5.3,[.1,2,.4]],[o(-.1,.1,-15.9,-15.7),5.7,6.6,r],[o(-.15,.15,-15.95,-15.65),6.6,6.8,[2,2,1.9]]],lights:[{position:[0,8,4],radius:30,color:[1,.8,.55],flux:2e4}]}};export{y as vehicles};
-//# sourceMappingURL=vehicles.js.map

package/dist/utils/vehicles.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/vehicles.js"],
-  "sourcesContent": ["import { hull } from \"./hull.js\";\nimport { box } from './box.js';\nimport { glass, tyre } from './glass.js';\nimport { mirror } from './mirror.js';\nimport { white } from \"./white.js\";\nimport { paints } from './paints.js';\nimport { headlight } from './headlight.js';\nimport { taillight } from './taillight.js';\n\n/**\n * `side`: default offset (metres) to the right of the lane centreline. `model(i)` gives the prisms of the i-th vehicle.\n * `lights`: night point lights in model space (see the night lighting grid), e.g. the pool cast by the headlights.\n */\nexport const vehicles = {\n  car: {\n    side: 1.8,\n    model: i => {\n      const paint = paints[i % paints.length];\n      return [\n        ...mirror(0.7, 0.92, -1.68, -1.02, 0, 0.64, tyre),\n        ...mirror(0.7, 0.92, 1.02, 1.68, 0, 0.64, tyre),\n        [[[-0.9, -1.95], [-0.72, -2.25], [0.72, -2.25], [0.9, -1.95], [0.9, 2.05], [0.76, 2.25], [-0.76, 2.25], [-0.9, 2.05]],\n          0.28, 0.82, paint],\n        // Greenhouse: the windscreen leans back, the rear window less.\n        [box(-0.84, 0.84, -0.75, 1.6), 0.82, 1.38, glass, box(-0.7, 0.7, -0.05, 1.3)],\n        [box(-0.71, 0.71, -0.06, 1.31), 1.38, 1.46, paint],\n        ...mirror(0.38, 0.8, -2.3, -2.16, 0.56, 0.76, headlight),\n        [box(-0.78, 0.78, 2.16, 2.3), 0.6, 0.76, taillight],\n      ];\n    },\n    lights: [{\n      position: [0, 1.2, -6],\n      radius: 10,\n      color: [1, 0.94, 0.82],\n      flux: 800\n    }]\n  },\n  // Panoramic river cruiser, about 60 \u00D7 11 m: glass saloon, open upper deck with benches, wheelhouse forward.\n  boat: {\n    side: 0,\n    model: () => [\n      [hull, 0, 0.8, [0.1, 0.16, 0.26]],\n      [hull, 0.8, 1.4, white],\n      [box(-5, 5, -18, 26), 1.4, 3.7, glass, box(-4.6, 4.6, -17.4, 25.6)],\n      ...mirror(4.64, 4.74, -17, 25, 3.25, 3.45, [1.6, 1.25, 0.8]),\n      [box(-4.8, 4.8, -17.8, 25.8), 3.7, 3.9, white],\n      ...Array.from({ length: 12 }, (_, i) => mirror(0.5, 3.8, -12 + i * 3, -11.3 + i * 3, 3.9, 4.4, [0.62, 0.1, 0.1])).flat(),\n      ...mirror(4.65, 4.8, -13.6, 25.8, 3.9, 4.8, white),\n      [box(-4.8, 4.8, 25.65, 25.8), 3.9, 4.8, white],\n      [box(-2.2, 2.2, -17.6, -14), 3.9, 4.7, white],\n      [box(-2.2, 2.2, -17.6, -14), 4.7, 5.5, glass],\n      [box(-2.5, 2.5, -18, -13.6), 5.5, 5.7, white],\n      [box(-2.45, -2.2, -16.2, -15.8), 5, 5.3, [2, 0.15, 0.1]],\n      [box(2.2, 2.45, -16.2, -15.8), 5, 5.3, [0.1, 2, 0.4]],\n      [box(-0.1, 0.1, -15.9, -15.7), 5.7, 6.6, white],\n      [box(-0.15, 0.15, -15.95, -15.65), 6.6, 6.8, [2, 2, 1.9]],\n    ],\n    lights: [{\n      position: [0, 8, 4],\n      radius: 30,\n      color: [1, 0.8, 0.55],\n      flux: 20000\n    }]\n  },\n};\n"],
-  "mappings": "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",
-  "names": ["hull", "box", "glass", "tyre", "mirror", "white", "paints", "headlight", "taillight", "vehicles", "i", "paint", "_"]
-}

package/dist/utils/vertexNormals.js

@@ -1,2 +0,0 @@
-function s(l,o){const f=new Float32Array(l.length);for(let t=0;t<(o?.length||l.length/3);t+=3){const h=o?o[t]:t,n=o?o[t+1]:t+1,m=o?o[t+2]:t+2,a=[0,1,2].map(r=>l[n*3+r]-l[h*3+r]),e=[0,1,2].map(r=>l[m*3+r]-l[h*3+r]),u=[a[1]*e[2]-a[2]*e[1],a[2]*e[0]-a[0]*e[2],a[0]*e[1]-a[1]*e[0]];for(const r of[h,n,m])for(let g=0;g<3;g++)f[r*3+g]+=u[g]}for(let t=0;t<f.length;t+=3){const h=Math.hypot(...f.subarray(t,t+3))||1;for(let n=0;n<3;n++)f[t+n]/=h}return f}export{s as vertexNormals};
-//# sourceMappingURL=vertexNormals.js.map

package/dist/utils/vertexNormals.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/vertexNormals.js"],
-  "sourcesContent": ["/** Area-weighted vertex normals, for indexed or non-indexed triangles. */\n\nexport function vertexNormals(p, indices) {\n  // Accumulate area-weighted face normals for shared vertices, then normalize.\n  const normals = new Float32Array(p.length);\n  for (let i = 0; i < (indices?.length || p.length / 3); i += 3) {\n    const a = indices ? indices[i] : i,\n          b = indices ? indices[i + 1] : i + 1,\n          c = indices ? indices[i + 2] : i + 2;\n    const u = [0, 1, 2].map(j => p[b * 3 + j] - p[a * 3 + j]),\n          v = [0, 1, 2].map(j => p[c * 3 + j] - p[a * 3 + j]);\n    const n = [\n      u[1] * v[2] - u[2] * v[1],\n      u[2] * v[0] - u[0] * v[2],\n      u[0] * v[1] - u[1] * v[0]\n    ];\n    for (const index of [a, b, c]) {\n      for (let j = 0; j < 3; j++) {\n        normals[index * 3 + j] += n[j];\n      }\n    }\n  }\n  for (let i = 0; i < normals.length; i += 3) {\n    const length = Math.hypot(...normals.subarray(i, i + 3)) || 1;\n    for (let j = 0; j < 3; j++) {\n      normals[i + j] /= length;\n    }\n  }\n  return normals;\n}\n"],
-  "mappings": "AAEO,SAASA,EAAcC,EAAGC,EAAS,CAExC,MAAMC,EAAU,IAAI,aAAaF,EAAE,MAAM,EACzC,QAASG,EAAI,EAAGA,GAAKF,GAAS,QAAUD,EAAE,OAAS,GAAIG,GAAK,EAAG,CAC7D,MAAMC,EAAIH,EAAUA,EAAQE,CAAC,EAAIA,EAC3BE,EAAIJ,EAAUA,EAAQE,EAAI,CAAC,EAAIA,EAAI,EACnCG,EAAIL,EAAUA,EAAQE,EAAI,CAAC,EAAIA,EAAI,EACnCI,EAAI,CAAC,EAAG,EAAG,CAAC,EAAE,IAAIC,GAAKR,EAAEK,EAAI,EAAIG,CAAC,EAAIR,EAAEI,EAAI,EAAII,CAAC,CAAC,EAClDC,EAAI,CAAC,EAAG,EAAG,CAAC,EAAE,IAAID,GAAKR,EAAEM,EAAI,EAAIE,CAAC,EAAIR,EAAEI,EAAI,EAAII,CAAC,CAAC,EAClDE,EAAI,CACRH,EAAE,CAAC,EAAIE,EAAE,CAAC,EAAIF,EAAE,CAAC,EAAIE,EAAE,CAAC,EACxBF,EAAE,CAAC,EAAIE,EAAE,CAAC,EAAIF,EAAE,CAAC,EAAIE,EAAE,CAAC,EACxBF,EAAE,CAAC,EAAIE,EAAE,CAAC,EAAIF,EAAE,CAAC,EAAIE,EAAE,CAAC,CAC1B,EACA,UAAWE,IAAS,CAACP,EAAGC,EAAGC,CAAC,EAC1B,QAASE,EAAI,EAAGA,EAAI,EAAGA,IACrBN,EAAQS,EAAQ,EAAIH,CAAC,GAAKE,EAAEF,CAAC,CAGnC,CACA,QAASL,EAAI,EAAGA,EAAID,EAAQ,OAAQC,GAAK,EAAG,CAC1C,MAAMS,EAAS,KAAK,MAAM,GAAGV,EAAQ,SAASC,EAAGA,EAAI,CAAC,CAAC,GAAK,EAC5D,QAASK,EAAI,EAAGA,EAAI,EAAGA,IACrBN,EAAQC,EAAIK,CAAC,GAAKI,CAEtB,CACA,OAAOV,CACT",
-  "names": ["vertexNormals", "p", "indices", "normals", "i", "a", "b", "c", "u", "j", "v", "n", "index", "length"]
-}

package/dist/utils/walk.js

@@ -1,2 +0,0 @@
-import*as Z from"./createMesh.js";import*as A from"./disposeMesh.js";import*as D from"./update.js";import{build as B}from"./build.js";import{getElevation as E}from"./getElevation.js";import{hit as I}from"./hit.js";import{limbs as u}from"./limbs.js";import{moves as y}from"./moves.js";import{parts as C}from"./parts.js";import{wrap as M}from"./wrap.js";function x(){const{layer:t,state:e}=this,i=t._map,s=i.options.crs,o=s.project(t.location),r=Math.cos(t.location.lat*Math.PI/180),n=s.project(e.latlng),l=i._terrain3D?._terrainReady&&i._terrain3D,a=l&&E(l,e.latlng)||0;return[(n.x-o.x)*r,a-t.root.position[1],-(n.y-o.y)*r]}function b(){const[t,e,i]=x.call(this),s=-this.state.heading,o=Math.cos(s),r=Math.sin(s);for(let n=0;n<u.length;n++){const[,l,a,c]=u[n],p=this.meshes[n];p.position[0]=t+l*o,p.position[1]=e+a,p.position[2]=i-l*r,p.rotation[0]=c*this.swing*Math.sin(this.state.phase),p.rotation[1]=s}D.update(this.layer)}function w(t,e,i){const s=Math.hypot(t,e);return s>1e-6&&I(this.layer,i[0],i[1],i[2],t/s,-e/s,s+.3)}function X(t){const e=this.layer,i=e._map;this.frame=requestAnimationFrame(this.step);const s=Math.min(.1,(t-(this.last??t))/1e3);if(this.last=t,!e.renderer)return;let o=!1;if(!this.meshes){this.meshes=[];for(const[a]of u)this.meshes.push(Z.createMesh(e,B(C[a])));o=!0}let r=0,n=0;for(const a of this.keys)r+=y[a]?.[0]||0,n+=y[a]?.[1]||0;if(r=Math.sign(r),n=Math.sign(n),n&&(this.state.heading=M(this.state.heading+n*2.5*s),o=!0),r){const a=r*this.speed*s,{lat:c,lng:p}=this.state.latlng,{position:k,scale:_}=e.root;let m=Math.sin(this.state.heading)*a,d=Math.cos(this.state.heading)*a;const f=x.call(this);for(let h=0;h<f.length;h++)f[h]=k[h]+_[h]*f[h];const g=w.call(this,m,d,f);if(g){const h=m*g[0]-d*g[1];m-=h*g[0],d+=h*g[1],w.call(this,m,d,f)&&(m=d=0)}this.state.latlng=new L.LatLng(c+d/111320,p+m/(111320*Math.cos(c*Math.PI/180))),this.state.phase+=Math.hypot(m,d)/1.6*Math.PI,o=!0}if(r||n){const a=i.getBearing()*Math.PI/180,c=M(-this.state.heading-a);Math.abs(c)>.001&&i._setPitchAndBearing(i.getPitch(),(a+c*Math.min(1,s*4))*180/Math.PI),i.setView(this.state.latlng,i.getZoom(),{animate:!1})}const l=r?.9:0;Math.abs(this.swing-l)>.001&&(this.swing+=(l-this.swing)*Math.min(1,s*10),o=!0),o&&b.call(this)}function Y(t){if(!(t.target.closest?.("input:not([type=checkbox], [type=radio]), select, textarea, [contenteditable]")||t.ctrlKey||t.altKey||t.metaKey)){if(t.type==="keydown"&&t.code==="Escape"){this.stop();return}y[t.code]&&(t.preventDefault(),t.type==="keydown"?this.keys.add(t.code):this.keys.delete(t.code))}}function j(){this.keys.clear()}function q(t){const e=this.layer._map;if(t.type==="pointerdown"){if(t.button!==0||t.target.closest(".leaflet-control"))return;this.drag={x:t.clientX,y:t.clientY},e.getContainer().setPointerCapture(t.pointerId)}else this.drag&&t.type==="pointermove"?(e._setPitchAndBearing(Math.max(20,Math.min(85,e.getPitch()-(t.clientY-this.drag.y)*.2)),e.getBearing()-(t.clientX-this.drag.x)*.25),this.drag={x:t.clientX,y:t.clientY}):this.drag=null}function O(){this.meshes&&b.call(this)}function K(){const t=this.layer._map;if(this.saved||!t)return;this.state.latlng=t.getCenter();const e=t.getSize().y*1.5/this.distance,i=Math.min(t.getMaxZoom(),Math.log2(e*4007501668557849e-8*Math.cos(this.state.latlng.lat*Math.PI/180)/256)),s=[];for(const o of["dragging","keyboard","doubleClickZoom","boxZoom"])t[o]?.enabled()&&s.push(o);this.saved={zoom:t.getZoom(),pitch:t.getPitch(),scrollWheelZoom:t.options.scrollWheelZoom,handlers:s};for(const o of this.saved.handlers)t[o].disable();t.options.scrollWheelZoom=this.saved.scrollWheelZoom&&"center",this.state.heading=-t.getBearing()*Math.PI/180,t.setView(this.state.latlng,i,{animate:!1}),t.setPitch(75),L.DomEvent.on(document,"keydown keyup",this.onKey),L.DomEvent.on(window,"blur",this.onBlur),L.DomEvent.on(t.getContainer(),"pointerdown pointermove pointerup pointercancel",this.onPointer),t.on("terrainchange",this.onTerrain),this.button.setAttribute("aria-pressed","true"),this.button.style.background="#e4e4e4",this.hint.style.display="",this.last=void 0,this.frame=requestAnimationFrame(this.step)}function P(){const t=this.layer._map;cancelAnimationFrame(this.frame),this.keys.clear(),this.drag=null,L.DomEvent.off(document,"keydown keyup",this.onKey),L.DomEvent.off(window,"blur",this.onBlur);for(const e of this.meshes||[])A.disposeMesh(this.layer,e);if(this.meshes=null,this.button.setAttribute("aria-pressed","false"),this.button.style.background="#fff",this.hint.style.display="none",!(!t||!this.saved)){L.DomEvent.off(t.getContainer(),"pointerdown pointermove pointerup pointercancel",this.onPointer),t.off("terrainchange",this.onTerrain),t.options.scrollWheelZoom=this.saved.scrollWheelZoom;for(const e of this.saved.handlers)t[e].enable();t.setView(this.state.latlng,this.saved.zoom,{animate:!1}),t.setPitch(this.saved.pitch),this.saved=null}}function S(){this.saved?P.call(this):K.call(this)}function G(){return this.container}function H(){this.ready=!0,this.layer._map&&this.control.addTo(this.layer._map)}function J(){this.ready&&this.control.addTo(this.layer._map)}function N(){P.call(this),this.control.remove()}export{w as blocked,G as controlOnAdd,x as local,j as onBlur,Y as onKey,J as onLayerAdd,N as onLayerRemove,q as onPointer,H as onReady,O as onTerrain,b as place,K as start,X as step,P as stop,S as toggle};
-//# sourceMappingURL=walk.js.map

package/dist/utils/walk.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/walk.js"],
-  "sourcesContent": ["import * as createMesh from './createMesh.js';\r\nimport * as disposeMesh from './disposeMesh.js';\r\nimport * as update from './update.js';\r\nimport { build } from './build.js';\r\nimport { getElevation } from './getElevation.js';\r\nimport { hit } from './hit.js';\r\nimport { limbs } from './limbs.js';\r\nimport { moves } from './moves.js';\r\nimport { parts } from './parts.js';\r\nimport { wrap } from './wrap.js';\r\n\r\nexport function local() {\r\n  const { layer, state } = this;\r\n  const map = layer._map, crs = map.options.crs, origin = crs.project(layer.location);\r\n  const metres = Math.cos(layer.location.lat * Math.PI / 180);\r\n  const p = crs.project(state.latlng), terrain = map._terrain3D?._terrainReady && map._terrain3D;\r\n  const ground = (terrain && getElevation(terrain, state.latlng)) || 0;\r\n  return [(p.x - origin.x) * metres, ground - layer.root.position[1], -(p.y - origin.y) * metres];\r\n}\r\n\r\nexport function place() {\r\n  const [x, y, z] = local.call(this);\r\n  // Model forward is -z; a yaw of -heading turns it to the compass heading (x east, -z north).\r\n  const yaw = -this.state.heading, cos = Math.cos(yaw), sin = Math.sin(yaw);\r\n  for (let i = 0; i < limbs.length; i++) {\r\n    const [, px, py, sign] = limbs[i];\r\n    const mesh = this.meshes[i];\r\n    mesh.position[0] = x + px * cos; mesh.position[1] = y + py; mesh.position[2] = z - px * sin;\r\n    mesh.rotation[0] = sign * this.swing * Math.sin(this.state.phase);\r\n    mesh.rotation[1] = yaw;\r\n  }\r\n  update.update(this.layer);\r\n}\r\n\r\nexport function blocked(east, north, feet) {\r\n  const length = Math.hypot(east, north);\r\n  return length > 1e-6 && hit(this.layer, feet[0], feet[1], feet[2], east / length, -north / length, length + 0.3);\r\n}\r\n\r\nexport function step(now) {\r\n  const layer = this.layer, map = layer._map;\r\n  this.frame = requestAnimationFrame(this.step);\r\n  const dt = Math.min(0.1, (now - (this.last ?? now)) / 1000);\r\n  this.last = now;\r\n  if (!layer.renderer) return;\r\n  let changed = false;\r\n  if (!this.meshes) {\r\n    this.meshes = [];\r\n    for (const [part] of limbs) this.meshes.push(createMesh.createMesh(layer, build(parts[part])));\r\n    changed = true;\r\n  }\r\n  let forward = 0, turn = 0;\r\n  for (const key of this.keys) { forward += moves[key]?.[0] || 0; turn += moves[key]?.[1] || 0; }\r\n  forward = Math.sign(forward); turn = Math.sign(turn);\r\n  if (turn) { this.state.heading = wrap(this.state.heading + turn * 2.5 * dt); changed = true; }\r\n  if (forward) {\r\n    const metres = forward * this.speed * dt, { lat, lng } = this.state.latlng, { position, scale } = layer.root;\r\n    let east = Math.sin(this.state.heading) * metres, north = Math.cos(this.state.heading) * metres;\r\n    const feet = local.call(this);\r\n    for (let i = 0; i < feet.length; i++) feet[i] = position[i] + scale[i] * feet[i];\r\n    // World x is east, z south; keep 0.3 m from walls and slide along the one in the way.\r\n    const wall = blocked.call(this, east, north, feet);\r\n    if (wall) {\r\n      const into = east * wall[0] - north * wall[1];\r\n      east -= into * wall[0]; north += into * wall[1];\r\n      if (blocked.call(this, east, north, feet)) east = north = 0;\r\n    }\r\n    this.state.latlng = new L.LatLng(lat + north / 111320, lng + east / (111320 * Math.cos(lat * Math.PI / 180)));\r\n    this.state.phase += Math.hypot(east, north) / 1.6 * Math.PI;\r\n    changed = true;\r\n  }\r\n  if (forward || turn) {\r\n    // The camera (looking along -bearing) swings back behind the walker.\r\n    const bearing = map.getBearing() * Math.PI / 180, behind = wrap(-this.state.heading - bearing);\r\n    if (Math.abs(behind) > 1e-3) map._setPitchAndBearing(map.getPitch(), (bearing + behind * Math.min(1, dt * 4)) * 180 / Math.PI);\r\n    map.setView(this.state.latlng, map.getZoom(), { animate: false });\r\n  }\r\n  const target = forward ? 0.9 : 0;\r\n  if (Math.abs(this.swing - target) > 1e-3) { this.swing += (target - this.swing) * Math.min(1, dt * 10); changed = true; }\r\n  if (changed) place.call(this);\r\n}\r\n\r\nexport function onKey(event) {\r\n  // Text fields and sliders keep their keys; buttons and checkboxes don't.\r\n  if (event.target.closest?.('input:not([type=checkbox], [type=radio]), select, textarea, [contenteditable]') ||\r\n    event.ctrlKey || event.altKey || event.metaKey) return;\r\n  if (event.type === 'keydown' && event.code === 'Escape') { this.stop(); return; }\r\n  if (!moves[event.code]) return;\r\n  event.preventDefault();\r\n  if (event.type === 'keydown') this.keys.add(event.code); else this.keys.delete(event.code);\r\n}\r\n\r\nexport function onBlur() {\r\n  this.keys.clear();\r\n}\r\n\r\nexport function onPointer(event) {\r\n  // Dragging only turns the camera around the walker: horizontal = bearing, vertical = pitch.\r\n  const map = this.layer._map;\r\n  if (event.type === 'pointerdown') {\r\n    if (event.button !== 0 || event.target.closest('.leaflet-control')) return;\r\n    this.drag = { x: event.clientX, y: event.clientY };\r\n    map.getContainer().setPointerCapture(event.pointerId);\r\n  } else if (this.drag && event.type === 'pointermove') {\r\n    map._setPitchAndBearing(Math.max(20, Math.min(85, map.getPitch() - (event.clientY - this.drag.y) * 0.2)),\r\n      map.getBearing() - (event.clientX - this.drag.x) * 0.25);\r\n    this.drag = { x: event.clientX, y: event.clientY };\r\n  } else this.drag = null;\r\n}\r\n\r\nexport function onTerrain() {\r\n  if (this.meshes) place.call(this);\r\n}\r\n\r\nexport function start() {\r\n  const map = this.layer._map;\r\n  if (this.saved || !map) return;\r\n  this.state.latlng = map.getCenter();\r\n  // Zoom whose camera distance (1.5 viewport heights, as in scene/render.js) is about `distance` metres behind the walker.\r\n  const pixelsPerMetre = map.getSize().y * 1.5 / this.distance;\r\n  const zoom = Math.min(map.getMaxZoom(), Math.log2(pixelsPerMetre * 40075016.68557849 * Math.cos(this.state.latlng.lat * Math.PI / 180) / 256));\r\n  const handlers = [];\r\n  for (const name of ['dragging', 'keyboard', 'doubleClickZoom', 'boxZoom']) {\r\n    if (map[name]?.enabled()) handlers.push(name);\r\n  }\r\n  this.saved = {\r\n    zoom: map.getZoom(), pitch: map.getPitch(), scrollWheelZoom: map.options.scrollWheelZoom, handlers\r\n  };\r\n  for (const name of this.saved.handlers) map[name].disable();\r\n  // Wheel zoom moves the camera closer or farther, keeping the walker centred.\r\n  map.options.scrollWheelZoom = this.saved.scrollWheelZoom && 'center';\r\n  this.state.heading = -map.getBearing() * Math.PI / 180;\r\n  map.setView(this.state.latlng, zoom, { animate: false });\r\n  map.setPitch(75);\r\n  L.DomEvent.on(document, 'keydown keyup', this.onKey);\r\n  L.DomEvent.on(window, 'blur', this.onBlur);\r\n  L.DomEvent.on(map.getContainer(), 'pointerdown pointermove pointerup pointercancel', this.onPointer);\r\n  map.on('terrainchange', this.onTerrain);\r\n  this.button.setAttribute('aria-pressed', 'true');\r\n  this.button.style.background = '#e4e4e4';\r\n  this.hint.style.display = '';\r\n  this.last = undefined;\r\n  this.frame = requestAnimationFrame(this.step);\r\n}\r\n\r\nexport function stop() {\r\n  const map = this.layer._map;\r\n  cancelAnimationFrame(this.frame);\r\n  this.keys.clear(); this.drag = null;\r\n  L.DomEvent.off(document, 'keydown keyup', this.onKey);\r\n  L.DomEvent.off(window, 'blur', this.onBlur);\r\n  for (const mesh of this.meshes || []) disposeMesh.disposeMesh(this.layer, mesh);\r\n  this.meshes = null;\r\n  this.button.setAttribute('aria-pressed', 'false');\r\n  this.button.style.background = '#fff';\r\n  this.hint.style.display = 'none';\r\n  if (!map || !this.saved) return;\r\n  L.DomEvent.off(map.getContainer(), 'pointerdown pointermove pointerup pointercancel', this.onPointer);\r\n  map.off('terrainchange', this.onTerrain);\r\n  map.options.scrollWheelZoom = this.saved.scrollWheelZoom;\r\n  for (const name of this.saved.handlers) map[name].enable();\r\n  map.setView(this.state.latlng, this.saved.zoom, { animate: false });\r\n  map.setPitch(this.saved.pitch);\r\n  this.saved = null;\r\n}\r\n\r\nexport function toggle() {\r\n  if (this.saved) stop.call(this); else start.call(this);\r\n}\r\n\r\nexport function controlOnAdd() {\r\n  return this.container;\r\n}\r\n\r\nexport function onReady() {\r\n  this.ready = true;\r\n  if (this.layer._map) this.control.addTo(this.layer._map);\r\n}\r\n\r\nexport function onLayerAdd() {\r\n  if (this.ready) this.control.addTo(this.layer._map);\r\n}\r\n\r\nexport function onLayerRemove() {\r\n  stop.call(this);\r\n  this.control.remove();\r\n}\r\n"],
-  "mappings": "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",
-  "names": ["createMesh", "disposeMesh", "update", "build", "getElevation", "hit", "limbs", "moves", "parts", "wrap", "local", "layer", "state", "map", "crs", "origin", "metres", "p", "terrain", "ground", "place", "x", "y", "z", "yaw", "cos", "sin", "i", "px", "py", "sign", "mesh", "blocked", "east", "north", "feet", "length", "step", "now", "dt", "changed", "part", "forward", "turn", "key", "lat", "lng", "position", "scale", "wall", "into", "bearing", "behind", "target", "onKey", "event", "onBlur", "onPointer", "onTerrain", "start", "pixelsPerMetre", "zoom", "handlers", "name", "stop", "toggle", "controlOnAdd", "onReady", "onLayerAdd", "onLayerRemove"]
-}

package/dist/utils/white.js

@@ -1,2 +0,0 @@
-const t=[.92,.93,.92];export{t as white};
-//# sourceMappingURL=white.js.map

package/dist/utils/white.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/white.js"],
-  "sourcesContent": ["export const white = [0.92, 0.93, 0.92];\n"],
-  "mappings": "AAAO,MAAMA,EAAQ,CAAC,IAAM,IAAM,GAAI",
-  "names": ["white"]
-}

package/dist/utils/worldLights.js

@@ -1,2 +0,0 @@
-function u(a,t){const s=new Float32Array(a.length*8);return a.forEach(({position:[o,n,r],radius:c,color:h,flux:i},l)=>{const e=t[3]*o+t[7]*n+t[11]*r+t[15];s.set([(t[0]*o+t[4]*n+t[8]*r+t[12])/e,(t[1]*o+t[5]*n+t[9]*r+t[13])/e,(t[2]*o+t[6]*n+t[10]*r+t[14])/e,c,...h,i/(4*Math.PI)*.03],l*8)}),s}export{u as worldLights};
-//# sourceMappingURL=worldLights.js.map

package/dist/utils/worldLights.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/worldLights.js"],
-  "sourcesContent": ["\n/** World-space [x, y, z, radius, r, g, b, intensity] for one mesh's point lights. */\nexport function worldLights(lights, m) {\n  const values = new Float32Array(lights.length * 8);\n  lights.forEach(({\n    position: [x, y, z],\n    radius,\n    color,\n    flux\n  }, i) => {\n    const w = m[3] * x + m[7] * y + m[11] * z + m[15];\n    values.set(\n      [\n        (m[0] * x + m[4] * y + m[8] * z + m[12]) / w,\n        (m[1] * x + m[5] * y + m[9] * z + m[13]) / w,\n       (m[2] * x + m[6] * y + m[10] * z + m[14]) / w,\n       radius,\n       ...color,\n       flux / (4 * Math.PI) * 0.03\n      ],\n       i * 8\n    );\n  });\n  return values;\n}"],
-  "mappings": "AAEO,SAASA,EAAYC,EAAQC,EAAG,CACrC,MAAMC,EAAS,IAAI,aAAaF,EAAO,OAAS,CAAC,EACjD,OAAAA,EAAO,QAAQ,CAAC,CACd,SAAU,CAACG,EAAGC,EAAGC,CAAC,EAClB,OAAAC,EACA,MAAAC,EACA,KAAAC,CACF,EAAGC,IAAM,CACP,MAAMC,EAAIT,EAAE,CAAC,EAAIE,EAAIF,EAAE,CAAC,EAAIG,EAAIH,EAAE,EAAE,EAAII,EAAIJ,EAAE,EAAE,EAChDC,EAAO,IACL,EACGD,EAAE,CAAC,EAAIE,EAAIF,EAAE,CAAC,EAAIG,EAAIH,EAAE,CAAC,EAAII,EAAIJ,EAAE,EAAE,GAAKS,GAC1CT,EAAE,CAAC,EAAIE,EAAIF,EAAE,CAAC,EAAIG,EAAIH,EAAE,CAAC,EAAII,EAAIJ,EAAE,EAAE,GAAKS,GAC3CT,EAAE,CAAC,EAAIE,EAAIF,EAAE,CAAC,EAAIG,EAAIH,EAAE,EAAE,EAAII,EAAIJ,EAAE,EAAE,GAAKS,EAC5CJ,EACA,GAAGC,EACHC,GAAQ,EAAI,KAAK,IAAM,GACxB,EACCC,EAAI,CACP,CACF,CAAC,EACMP,CACT",
-  "names": ["worldLights", "lights", "m", "values", "x", "y", "z", "radius", "color", "flux", "i", "w"]
-}

package/dist/utils/wrap.js

@@ -1,2 +0,0 @@
-const a=t=>Math.atan2(Math.sin(t),Math.cos(t));export{a as wrap};
-//# sourceMappingURL=wrap.js.map

package/dist/utils/wrap.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/utils/wrap.js"],
-  "sourcesContent": ["export const wrap = angle => Math.atan2(Math.sin(angle), Math.cos(angle));\n"],
-  "mappings": "AAAO,MAAMA,EAAOC,GAAS,KAAK,MAAM,KAAK,IAAIA,CAAK,EAAG,KAAK,IAAIA,CAAK,CAAC",
-  "names": ["wrap", "angle"]
-}

package/src/utils/CELL.js

@@ -1,4 +0,0 @@
-// Walls (non-horizontal triangles) of a mesh in world space, bucketed by 8 m cells; `origin` is the world translation
-// at build time, since layer roots only move vertically with the terrain afterwards.
-
-export const CELL = 8;

package/src/utils/addBridges.js

@@ -1,66 +0,0 @@
-import { createMesh } from './createMesh.js';
-import { triangulate } from './triangulate.js';
-
-/**
- * Bare-earth DEMs drop bridges: `getElevation` returns the deck height inside these polygons (GeoJSON
- * Polygon/MultiPolygon with Z, e.g. IGN BD TOPO), and one mesh draws the 1.2 m thick decks.
- * ponytail: anything under a deck (quays, boats asking `getElevation`) also gets the deck height.
- */
-
-export function addBridges(backend, geojson) {
-  const map = backend._map, crs = map.options.crs, zoom = backend._terrainZoom;
-  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);
-  const base = backend.root.position[1], position = [], normal = [], color = [];
-  const local = ([lng, lat, z]) => {
-    const p = crs.project(new L.LatLng(lat, lng));
-    return [(p.x - origin.x) * metres, z - base, -(p.y - origin.y) * metres];
-  };
-  const push = (p, n) => { position.push(...p); normal.push(...n); color.push(0.6, 0.58, 0.54); };
-  backend._bridges = new Map();
-  for (const { geometry } of geojson.features) {
-    const polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.type === 'MultiPolygon' ? geometry.coordinates : [];
-    for (const polygon of polygons) {
-      const rings = polygon.map(ring => ring.slice(0, -1)).filter(ring => ring.length >= 3);
-      if (!rings.length) continue;
-      const pixels = rings.flat().map(([lng, lat, z]) => { const p = map.project([lat, lng], zoom); return [p.x, p.y, z]; });
-      const points = rings.flat().map(local);
-      let triangles;
-      try {
-        const starts = rings.map((ring, r) => rings.slice(0, r).reduce((sum, previous) => sum + previous.length, 0));
-        const [contour, ...holes] = rings.map((ring, r) => ring.map((c, i) => ({ x: pixels[starts[r] + i][0], y: pixels[starts[r] + i][1] })));
-        triangles = triangulate(contour, holes);
-      } catch { continue; }
-      const bridge = {
-        triangles: triangles.map(t => t.map(i => pixels[i])),
-        min: [Math.min(...pixels.map(p => p[0])), Math.min(...pixels.map(p => p[1]))],
-        max: [Math.max(...pixels.map(p => p[0])), Math.max(...pixels.map(p => p[1]))],
-      };
-      for (let x = Math.floor(bridge.min[0] / 64); x <= Math.floor(bridge.max[0] / 64); x++) {
-        for (let y = Math.floor(bridge.min[1] / 64); y <= Math.floor(bridge.max[1] / 64); y++) {
-          const key = `${x}/${y}`;
-          backend._bridges.set(key, [...backend._bridges.get(key) || [], bridge]);
-        }
-      }
-      const below = p => [p[0], p[1] - 1.2, p[2]];
-      for (let [a, b, c] of triangles) {
-        // Counter-clockwise seen from above, so double-sided shading keeps the top lit.
-        const [pa, pb, pc] = [points[a], points[b], points[c]];
-        if ((pb[2] - pa[2]) * (pc[0] - pa[0]) - (pb[0] - pa[0]) * (pc[2] - pa[2]) < 0) [b, c] = [c, b];
-        for (const i of [a, b, c]) push(points[i], [0, 1, 0]);
-        for (const i of [a, c, b]) push(below(points[i]), [0, -1, 0]);
-      }
-      let start = 0;
-      for (const ring of rings) {
-        for (let i = 0; i < ring.length; i++) {
-          const p = points[start + i], q = points[start + (i + 1) % ring.length];
-          const length = Math.hypot(q[0] - p[0], q[2] - p[2]) || 1, n = [(q[2] - p[2]) / length, 0, -(q[0] - p[0]) / length];
-          for (const corner of [p, q, below(q), p, below(q), below(p)]) push(corner, n);
-        }
-        start += ring.length;
-      }
-    }
-  }
-  if (position.length) {
-    backend._bridgeMesh = createMesh(backend, { position, normal, color });
-  }
-}

package/src/utils/addRasterTile.js

@@ -1,112 +0,0 @@
-import { createProgram } from './createProgram.js';
-import { destroyTexture } from './destroyTexture.js';
-import { terrainAtlas } from './terrainAtlas.js';
-import { terrainGrid } from './terrainGrid.js';
-import { setParent } from './setParent.js';
-import { update } from './update.js';
-
-export async function addRasterTile(backend, layer, coords, tile) {
-  const ready = await backend._terrainPromise;
-  if (!ready || !backend._map || backend._map._terrain3D !== backend || layer._terrain3D !== backend ||
-    tile.request.signal.aborted || !layer._rasterTiles.has(`${coords.z}/${coords.x}/${coords.y}`) ||
-    backend._rasterTiles.has(tile)) {
-    return;
-  }
-  // Match DEM pixel spacing, capped at 64 subdivisions per tile.
-  const divisions = Math.max(1, Math.min(64, 256 / 2 ** (coords.z - backend._terrainZoom)));
-  const map = backend._map, crs = map.options.crs;
-  const origin = crs.project(backend.location), metres = Math.cos(backend.location.lat * Math.PI / 180);
-  // Tile pixels map linearly to projected metres: one scaled unit grid per tile, elevation in the vertex shader.
-  const scale = crs.scale(coords.z), terrainScale = 2 ** (backend._terrainZoom - coords.z);
-  const corner = crs.transformation.untransform(new L.Point(coords.x * 256, coords.y * 256), scale);
-  const opposite = crs.transformation.untransform(new L.Point((coords.x + 1) * 256, (coords.y + 1) * 256), scale);
-  const device = backend.renderer.device;
-  const texture = tile.texture;
-  if (!backend._rasterProgram || backend._rasterProgram.device !== device) {
-    // DEM atlas over the archive's tile grid; invalid or missing samples become -1e9 (the shader's no-data).
-    // ponytail: one texture, capped by maxTextureDimension2D (32×32 DEM tiles at 8192 px); split it for larger archives.
-    const bounds = backend._terrainBounds, columns = bounds.max.x - bounds.min.x + 1, rows = bounds.max.y - bounds.min.y + 1;
-    const { elevations, low, high } = terrainAtlas(backend._terrainTiles, bounds);
-    if (backend._dem) destroyTexture(backend, backend._dem.texture);
-    backend._dem = {
-      texture: device.createTexture({
-        size: [columns * 256, rows * 256],
-        format: 'r32float',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
-      }),
-      low: Number.isFinite(low) ? low : backend._terrainOriginElevation,
-      high: Number.isFinite(high) ? high : backend._terrainOriginElevation,
-    };
-    device.queue.writeTexture({ texture: backend._dem.texture }, elevations,
-      { bytesPerRow: columns * 1024 }, [columns * 256, rows * 256]);
-    backend._terrainGrids = new Map();
-    backend._rasterProgram = createProgram(backend, {
-      baseTexture: texture,
-      unlit: true,
-      terrain: backend._dem,
-      alphaMode: 'BLEND',
-      depthWrite: true,
-    });
-  }
-  let attributes = backend._terrainGrids.get(divisions);
-  if (!attributes) {
-    attributes = terrainGrid(divisions);
-    for (const [name, attribute] of Object.entries(attributes)) {
-      attribute.size ||= 1;
-      attribute.count = attribute.data.length / attribute.size;
-      attribute.indexFormat = 'uint16';
-      attribute.buffer = device.createBuffer({
-        size: Math.max(4, attribute.data.byteLength),
-        usage: name === 'index'
-          ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-          : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-      });
-      device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-    }
-    backend._terrainGrids.set(divisions, attributes);
-  }
-  const base = backend._terrainOriginElevation;
-  const bottom = Math.min(backend._dem.low, base) - base, top = Math.max(backend._dem.high, base) - base;
-  const sizeX = (opposite.x - corner.x) * metres, sizeZ = -(opposite.y - corner.y) * metres;
-  // ponytail: ray picking sees the flat unit grid; read the DEM back if terrain must be pickable.
-  const geometry = {
-    device,
-    attributes,
-    drawRange: { start: 0, count: attributes.index.count },
-    // Local bounds whose radius, scaled by the largest axis, still covers the displaced tile.
-    bounds: {
-      min: [0, bottom, 0], max: [1, top, 1], center: [0.5, (bottom + top) / 2, 0.5],
-      radius: Math.hypot(sizeX, top - bottom, sizeZ) / 2 / Math.max(sizeX, 1, sizeZ),
-    },
-  };
-  const mesh = {
-    position: [(corner.x - origin.x) * metres, 0, -(corner.y - origin.y) * metres],
-    rotation: [0, 0, 0],
-    scale: [sizeX, 1, sizeZ],
-    worldMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-    children: [],
-    visible: true,
-    device,
-    geometry,
-    program: backend._rasterProgram,
-    texture,
-    // DEM pixel of the tile's corner, DEM pixels per tile, and the elevation at the layer origin.
-    terrain: [
-      coords.x * 256 * terrainScale - backend._terrainBounds.min.x * 256,
-      coords.y * 256 * terrainScale - backend._terrainBounds.min.y * 256,
-      256 * terrainScale,
-      base,
-    ],
-    tile,
-    opacity: layer.options.opacity ?? 1,
-    id: L.Layer._nextId++,
-    renderOrder: layer.options.zIndex || 0,
-    fadeDuration: 250,
-    fadeStart: tile.loadedAt,
-    ground: true,
-  };
-  tile.mesh.visible = false;
-  setParent(mesh, backend.root);
-  update(backend);
-  backend._rasterTiles.set(tile, mesh);
-}

package/src/utils/along.js

@@ -1,9 +0,0 @@
-/** Point and unit direction at distance `s` along `points` ([x, z, y?]) with cumulative `lengths`. */
-
-export function along(points, lengths, s) {
-  let i = 1;
-  while (i < lengths.length - 1 && lengths[i] < s) i++;
-  const a = points[i - 1], b = points[i], d = lengths[i] - lengths[i - 1] || 1;
-  const t = (s - lengths[i - 1]) / d;
-  return { x: a[0] + (b[0] - a[0]) * t, y: (a[2] ?? 0) + ((b[2] ?? 0) - (a[2] ?? 0)) * t, z: a[1] + (b[1] - a[1]) * t, dx: (b[0] - a[0]) / d, dz: (b[1] - a[1]) / d };
-}

package/src/utils/atmosphere.js

@@ -1,20 +0,0 @@
-
-export function atmosphere(altitude) {
-  if (!Number.isFinite(altitude)) {
-    throw new Error('Invalid solar altitude');
-  }
-  const stops = [
-    [-18, [3, 7, 20], [17, 28, 54], [0.025, 0.04, 0.09]],
-    [-6, [37, 53, 84], [182, 106, 86], [0.12, 0.10, 0.14]],
-    [0, [101, 131, 171], [246, 170, 115], [0.38, 0.24, 0.18]],
-    [10, [74, 147, 208], [197, 221, 237], [0.80, 0.75, 0.68]],
-    [25, [53, 144, 213], [223, 238, 250], [1, 1, 1]],
-  ];
-  const upper = stops.findIndex(stop => stop[0] >= altitude);
-  const b = stops[upper < 0 ? stops.length - 1 : upper],
-        a = stops[Math.max(0, upper - 1)];
-  const t = a === b || upper < 0 ? 1 : (altitude - a[0]) / (b[0] - a[0]);
-  const mix = index => a[index].map((value, i) => value + (b[index][i] - value) * t);
-  const rgb = values => `rgb(${values.map(Math.round).join(', ')})`;
-  return { background: `linear-gradient(${rgb(mix(1))}, ${rgb(mix(2))})`, tint: mix(3) };
-}

package/src/utils/attach.js

@@ -1,255 +0,0 @@
-import { emptyNode } from './emptyNode.js';
-import { setParent } from './setParent.js';
-import { traverse } from './traverse.js';
-import { createProgram } from './createProgram.js';
-import { endZoom } from './endZoom.js';
-import { onMapChange } from './onMapChange.js';
-import { onZoomAnim } from './onZoomAnim.js';
-import { render } from './render.js';
-import { startZoom } from './startZoom.js';
-import { update } from './update.js';
-import { updateArea } from './updateArea.js';
-import { setTerrainHeight } from './setTerrainHeight.js';
-import { resizeSunlight } from './resizeSunlight.js';
-
-function showWebGPUWarning(map) {
-  const container = map.getContainer();
-  if (container.querySelector('.leaflet-webgpu-warning')) return;
-  const warning = document.createElement('div');
-  warning.className = 'leaflet-webgpu-warning';
-  warning.setAttribute('role', 'alert');
-  warning.style.cssText = 'position:absolute;z-index:1000;top:50%;left:50%;transform:translate(-50%,-50%);max-width:calc(100% - 32px);box-sizing:border-box;padding:12px 16px;border:1px solid #c98b24;border-radius:6px;background:#fff8e6;box-shadow:0 3px 12px #0005;color:#30251d;font:14px/1.5 sans-serif;text-align:center;pointer-events:auto';
-  warning.append('WebGPU is not available in this browser or device. ');
-  const link = document.createElement('a');
-  link.href = 'https://developer.mozilla.org/en-US/docs/Web/API/WebGPU_API#browser_compatibility';
-  link.target = '_blank';
-  link.rel = 'noopener noreferrer';
-  link.textContent = 'Learn more';
-  warning.append(link);
-  container.append(warning);
-}
-
-/** WebGPU device attachment, materials/pipelines and draw calls. */
-/**
- * Join/create this map's shared scene and rebuild GPU objects if its context changed.
- * Buffer/program handles belong to one context; typed arrays and decoded images do not.
- * @private
- */
-
-export async function attach(backend, map) {
-  let shared = L.Layer._renderers.get(map);
-  if (shared?._rendererReady) {
-    await shared._rendererReady.promise;
-  }
-  if (!shared) {
-    shared = backend;
-    backend._rendererReady = Promise.withResolvers();
-    backend._rendererReady.promise.catch(() => { });
-    L.Layer._renderers.set(map, shared);
-    const fail = error => {
-      showWebGPUWarning(map);
-      backend._rendererReady.reject(error);
-      L.Layer._renderers.delete(map);
-      throw error;
-    };
-    const canvas = document.createElement('canvas');
-    if (!navigator.gpu) {
-      fail(new Error('Layer3D requires WebGPU'));
-    }
-    const adapter = await navigator.gpu.requestAdapter().catch(fail);
-    if (!adapter) {
-      fail(new Error('Unable to acquire a WebGPU adapter'));
-    }
-    const device = await adapter.requestDevice().catch(fail);
-    device.addEventListener('uncapturederror', event => {
-      const owner = L.Layer._renderers.get(map);
-      if (owner?.renderer?.device !== device) {
-        return;
-      }
-      for (const layer of owner?._layers || []) {
-        layer.fire('error', { error: event.error });
-      }
-    });
-    device.lost.then(info => {
-      const owner = L.Layer._renderers.get(map);
-      if (!owner || owner.renderer?.device !== device) {
-        return;
-      }
-      const error = new Error(`WebGPU device lost: ${info.message || info.reason}`);
-      for (const layer of owner._layers) {
-        layer.fire('error', { error });
-      }
-    });
-    const context = canvas.getContext('webgpu');
-    if (!context) {
-      device.destroy();
-      fail(new Error('Unable to create a WebGPU canvas context'));
-    }
-    const format = navigator.gpu.getPreferredCanvasFormat();
-    context.configure({ device, format, alphaMode: 'premultiplied' });
-    map.getContainer().querySelector('.leaflet-webgpu-warning')?.remove();
-    backend._shared = backend;
-    backend._layers = new Set();
-    backend._sceneOrigin = backend.location;
-    backend.scene = emptyNode();
-    // Perspective camera state: fov in degrees, near/far in scene metres.
-    backend.camera = {
-      position: [0, 0, 0],
-      up: [0, 1, 0],
-      target: [0, 0, 0],
-      viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      projectionViewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-      fov: 45,
-      aspect: 1,
-      near: 0.1,
-      far: 10000,
-    };
-    backend.renderer = {
-      device,
-      context,
-      format,
-      canvas,
-      dpr: Math.min(window.devicePixelRatio, 2)
-    };
-    const layout = device.createBindGroupLayout({
-      entries: [
-        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: 'uniform' } },
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: 'depth' } },
-        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' } },
-        { binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'read-only-storage' } },
-      ]
-    });
-    const buffer = backend.renderer.device.createBuffer({ size: 80, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
-    const sampler = backend.renderer.device.createSampler({ compare: 'less-equal', minFilter: 'linear', magFilter: 'linear' });
-    const lights = backend.renderer.device.createBuffer({ size: 32, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
-    backend.renderer.sunlight = { layout, buffer, sampler, lights, size: 0 };
-    const values = new Float32Array(20);
-    values.set([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    backend.renderer.device.queue.writeBuffer(buffer, 0, values);
-    resizeSunlight(backend, 1);
-    const emptyImage = document.createElement('canvas');
-    emptyImage.width = 1;
-    emptyImage.height = 1;
-    backend.renderer.roofFallbackTexture = {
-      device,
-      texture: device.createTexture({
-        size: [1, 1],
-        format: 'rgba8unorm',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-      }),
-      sampler: device.createSampler({
-        addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge',
-      }),
-      image: emptyImage, format: 'rgba8unorm', srgb: false, uploaded: null,
-    };
-    shared._size = null;
-    canvas.className = 'leaflet-3d';
-    canvas.style.cssText = 'position:absolute;top:0;left:0;pointer-events:none';
-    canvas.setAttribute('role', 'img');
-    canvas.setAttribute('aria-label', backend.options.ariaLabel ?? '3D scene');
-    let pane = map.getPane('webgpuPane');
-    if (!pane) {
-      pane = map.createPane('webgpuPane', map.getContainer());
-      // The pitch sky uses 0 and may be inserted after this pane.
-      pane.style.zIndex = 1;
-      pane.style.pointerEvents = 'none';
-    }
-    pane.append(canvas);
-    map.on('move zoom rotate pitch resize viewreset layeradd layerremove', onMapChange, shared);
-    map.on('zoomstart', startZoom, shared);
-    map.on('zoomanim', onZoomAnim, shared);
-    map.on('zoomend', endZoom, shared);
-    backend._rendererReady.resolve();
-    delete shared._rendererReady;
-    render(shared);
-    L.Layer._renderers.set(map, shared);
-  }
-  const origin = map.options.crs.project(shared._sceneOrigin);
-  const point = map.options.crs.project(backend.location);
-  const metres = Math.cos(shared._sceneOrigin.lat * Math.PI / 180);
-  backend._terrainBaseY ??= backend.root.position[1];
-  backend.root.position[0] = (point.x - origin.x) * metres;
-  backend.root.position[1] = backend._terrainBaseY;
-  backend.root.position[2] = -(point.y - origin.y) * metres;
-  setTerrainHeight(backend);
-  // Each group's metres are measured at its own latitude, not the shared camera origin.
-  backend.root.scale.fill(metres / Math.cos(backend.location.lat * Math.PI / 180));
-  backend._shared = shared;
-  backend.renderer = shared.renderer;
-  backend.scene = shared.scene;
-  backend.camera = shared.camera;
-  shared._layers.add(backend);
-  setParent(backend.root, shared.scene);
-  traverse(backend.root, object => {
-    if (object.geometry && object.geometry.device !== shared.renderer.device) {
-      const geometry = object.geometry;
-      const material = object.program._layerMaterial;
-      // Retain packed CPU attributes, never old-context GPU buffer handles.
-      const attributes = {};
-      for (const name of ['position', 'normal', 'color', 'uv', 'index']) {
-        const attribute = geometry.attributes[name];
-        if (!attribute) continue;
-        const { data, size, count, normalized } = attribute;
-        attributes[name] = { data: data.slice(0, count * size), size, normalized };
-      }
-      const device = shared.renderer.device;
-      if (attributes.index?.data instanceof Uint8Array) {
-        attributes.index.data = Uint16Array.from(attributes.index.data);
-      }
-      for (const [name, attribute] of Object.entries(attributes)) {
-        attribute.size ||= 1;
-        attribute.count = attribute.data.length / attribute.size;
-        attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';
-        attribute.buffer = device.createBuffer({
-          size: Math.max(4, attribute.data.byteLength),
-          usage: name === 'index'
-            ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST
-            : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-        });
-        device.queue.writeBuffer(attribute.buffer, 0, attribute.data);
-      }
-      object.geometry = {
-        device,
-        attributes,
-        drawRange: { start: 0, count: attributes.index?.count || attributes.position.count },
-      };
-      for (const attribute of Object.values(geometry.attributes)) attribute.buffer.destroy();
-      object.bindGroup = null;
-      object.boundTextures = [];
-      for (const key of ['baseTexture', 'metalTexture', 'emissiveTexture', 'occlusionTexture']) {
-        const texture = material[key];
-        if (!texture || texture.device === device) continue;
-        material[key] = {
-          ...texture,
-          device,
-          texture: device.createTexture({
-            size: [texture.image.width, texture.image.height],
-            format: texture.format,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-          }),
-          sampler: device.createSampler(texture.samplerOptions),
-          uploaded: null,
-        };
-      }
-      object.program.pipelineCache.clear();
-      object.program = createProgram(backend, material);
-      object.device = device;
-    }
-    if (object.texture && object.texture.device !== shared.renderer.device) {
-      object.texture = {
-        ...object.texture,
-        device: shared.renderer.device,
-        texture: shared.renderer.device.createTexture({
-          size: [object.texture.image.width, object.texture.image.height],
-          format: object.texture.format,
-          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
-        }),
-        sampler: shared.renderer.device.createSampler(object.texture.samplerOptions),
-        uploaded: null,
-      };
-    }
-  });
-  update(shared);
-  if ((backend.header && backend._type !== 'pmtiles') || backend._geojson) updateArea(backend);
-}

package/src/utils/bindSunlight.js

@@ -1,12 +0,0 @@
-
-export function bindSunlight(backend) {
-  const sun = backend.renderer.sunlight;
-  sun.bindGroup = backend.renderer.device.createBindGroup({
-    layout: sun.layout, entries: [
-      { binding: 0, resource: { buffer: sun.buffer } },
-      { binding: 1, resource: sun.texture.createView() },
-      { binding: 2, resource: sun.sampler },
-      { binding: 3, resource: { buffer: sun.lights } },
-    ]
-  });
-}

package/src/utils/box.js

@@ -1 +0,0 @@
-export const box = (x0, x1, z0, z1) => [[x0, z0], [x1, z0], [x1, z1], [x0, z1]];