leaflet-city-mapper 0.0.1 → 0.0.2

package/dist/utils/geometry.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../../src/utils/geometry.js"],
-  "sourcesContent": ["/**\r\n * HSL inputs are linear-space to preserve the original building styling.\r\n * Numeric/CSS/RGB inputs are already sRGB; CSS alpha is not used for extrusion.\r\n * @param {number|string|Object} value 0xRRGGBB, CSS color, {r,g,b}, or {h,s,l} in 0..1.\r\n * @returns {Object} sRGB {r,g,b} components in 0..1.\r\n */\r\nexport function parseColor(value) {\r\n  if (value && typeof value === 'object' && 'h' in value) {\r\n    const { h, s, l } = value;\r\n    const a = s * Math.min(l, 1 - l);\r\n    const channel = n => {\r\n      const k = (n + h * 12) % 12;\r\n      return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));\r\n    };\r\n    const toSRGB = value => value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055;\r\n    return { r: toSRGB(channel(0)), g: toSRGB(channel(8)), b: toSRGB(channel(4)) };\r\n  }\r\n  if (value && typeof value === 'object' && 'r' in value) return value;\r\n  if (typeof value === 'number') return {\r\n    r: (value >> 16 & 255) / 255, g: (value >> 8 & 255) / 255, b: (value & 255) / 255,\r\n  };\r\n  if (typeof value !== 'string' || !CSS.supports('color', value)) throw new Error('Invalid 3D color');\r\n  const context = document.createElement('canvas').getContext('2d');\r\n  context.fillStyle = value;\r\n  context.fillRect(0, 0, 1, 1);\r\n  const [r, g, b] = context.getImageData(0, 0, 1, 1).data;\r\n  return { r: r / 255, g: g / 255, b: b / 255 };\r\n}\r\n\r\n/**\r\n * Paints the vertices `[start, end)` of a mesh and marks its color buffer dirty.\r\n * @param {Object} mesh Layer-created mesh with a color attribute.\r\n * @param {number} start Inclusive vertex index, not an offset into the RGB array.\r\n * @param {number} end Exclusive vertex index.\r\n * @param {Object} color sRGB {r,g,b}, typically from parseColor().\r\n */\r\nexport function setVertexColor(mesh, start, end, color) {\r\n  for (let i = start; i < end; i++) {\r\n    mesh.geometry.attributes.color.data.set([color.r, color.g, color.b], i * 3);\r\n  }\r\n  mesh.geometry.attributes.color.needsUpdate = true;\r\n}\r\n\r\n/**\r\n * Triangulates a polygon given as `{x, y}` points.\r\n * Rings omit the repeated closing point; winding is normalized internally.\r\n * Vertex indices remain relative to the original inputs after duplicate/collinear\r\n * cleanup. Hole bridges duplicate endpoints, not source vertices.\r\n * @param {Object[]} contour Outer boundary.\r\n * @param {Object[][]} [holes] Interior boundaries.\r\n *\r\n * @returns {number[][]} Triangles as indices in `[...contour, ...holes.flat()]`.\r\n */\r\nexport function triangulate(contour, holes = []) {\r\n  const points = [contour, ...holes].flat();\r\n  if (points.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y))) throw new Error('Invalid polygon coordinates');\r\n  // Translate near the origin to avoid cancellation with geographic coordinates.\r\n  const vertices = points.map((p, index) => ({ x: p.x - contour[0].x, y: p.y - contour[0].y, index }));\r\n  const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);\r\n  const equal = (a, b) => a.x === b.x && a.y === b.y;\r\n  // Remove zero-area corners before connecting holes; keep original vertex indices.\r\n  const clean = ring => {\r\n    let changed = true;\r\n    while (changed && ring.length > 3) {\r\n      changed = false;\r\n      for (let i = 0; i < ring.length; i++) {\r\n        const a = ring[(i + ring.length - 1) % ring.length], b = ring[i], c = ring[(i + 1) % ring.length];\r\n        if (equal(a, b) || Math.abs(cross(a, b, c)) < 1e-10) {\r\n          ring.splice(i, 1); changed = true; break;\r\n        }\r\n      }\r\n    }\r\n    if (ring.length < 3) throw new Error('Degenerate polygon ring');\r\n    return ring;\r\n  };\r\n  let offset = 0;\r\n  const rings = [contour, ...holes].map((path, index) => {\r\n    const ring = clean(vertices.slice(offset, offset += path.length));\r\n    if (isClockWise(ring) !== Boolean(index)) ring.reverse();\r\n    return ring;\r\n  });\r\n  const inside = (point, ring) => {\r\n    let result = false;\r\n    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {\r\n      const a = ring[i], b = ring[j];\r\n      if ((a.y > point.y) !== (b.y > point.y) &&\r\n        point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) result = !result;\r\n    }\r\n    return result;\r\n  };\r\n  const intersects = (a, b, c, d) => {\r\n    if (equal(a, c) || equal(a, d) || equal(b, c) || equal(b, d)) return false;\r\n    const abC = cross(a, b, c), abD = cross(a, b, d), cdA = cross(c, d, a), cdB = cross(c, d, b);\r\n    const on = (p, q, r) => Math.min(p.x, q.x) <= r.x && r.x <= Math.max(p.x, q.x) &&\r\n      Math.min(p.y, q.y) <= r.y && r.y <= Math.max(p.y, q.y);\r\n    return abC * abD < 0 && cdA * cdB < 0 ||\r\n      abC === 0 && on(a, b, c) || abD === 0 && on(a, b, d) ||\r\n      cdA === 0 && on(c, d, a) || cdB === 0 && on(c, d, b);\r\n  };\r\n  let polygon = rings[0].slice();\r\n  // A bridge must stay inside the outer boundary, outside every hole, and cross no edge.\r\n  // ponytail: quadratic ear clipping for building footprints; use spatial indexing for large rings.\r\n  for (const hole of rings.slice(1).sort((a, b) => Math.min(...a.map(p => p.x)) - Math.min(...b.map(p => p.x)))) {\r\n    let bridge, distance = Infinity;\r\n    for (let h = 0; h < hole.length; h++) for (let p = 0; p < polygon.length; p++) {\r\n      const a = hole[h], b = polygon[p], d = (a.x - b.x) ** 2 + (a.y - b.y) ** 2;\r\n      if (d >= distance) continue;\r\n      const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };\r\n      if (!inside(mid, rings[0]) || rings.slice(1).some(r => inside(mid, r))) continue;\r\n      if ([polygon, ...rings.slice(1)].some(r => r.some((c, i) => intersects(a, b, c, r[(i + 1) % r.length])))) continue;\r\n      bridge = [h, p]; distance = d;\r\n    }\r\n    if (!bridge) throw new Error('Unable to connect polygon hole');\r\n    const [h, p] = bridge;\r\n    polygon = [...polygon.slice(0, p + 1), ...hole.slice(h), ...hole.slice(0, h + 1),\r\n    polygon[p], ...polygon.slice(p + 1)];\r\n  }\r\n  // Clip a convex corner only when no other vertex is inside/on its triangle.\r\n  const result = [];\r\n  while (polygon.length > 3) {\r\n    let clipped = false;\r\n    for (let i = 0; i < polygon.length; i++) {\r\n      const a = polygon[(i + polygon.length - 1) % polygon.length], b = polygon[i], c = polygon[(i + 1) % polygon.length];\r\n      if (cross(a, b, c) <= 1e-10) continue;\r\n      if (polygon.some(p => !equal(p, a) && !equal(p, b) && !equal(p, c) &&\r\n        cross(a, b, p) >= 0 && cross(b, c, p) >= 0 && cross(c, a, p) >= 0)) continue;\r\n      result.push([a.index, b.index, c.index]); polygon.splice(i, 1); clipped = true; break;\r\n    }\r\n    if (!clipped) throw new Error('Unable to triangulate polygon: invalid or self-intersecting rings');\r\n  }\r\n  if (cross(...polygon) > 1e-10) result.push(polygon.map(p => p.index));\r\n  const area = ring => Math.abs(ring.reduce((sum, p, i) => {\r\n    const q = ring[(i + 1) % ring.length]; return sum + p.x * q.y - q.x * p.y;\r\n  }, 0)) / 2;\r\n  // Reject incomplete coverage instead of silently emitting a partial roof.\r\n  const expected = area(rings[0]) - rings.slice(1).reduce((sum, ring) => sum + area(ring), 0);\r\n  const actual = result.reduce((sum, triangle) => sum + cross(...triangle.map(i => vertices[i])) / 2, 0);\r\n  if (expected <= 0 || Math.abs(actual - expected) > Math.max(1e-7, expected * 1e-8)) throw new Error('Polygon triangulation area mismatch');\r\n  return result;\r\n}\r\n\r\n/**\r\n * @returns {boolean} Whether the `{x, y}` points are in clockwise order.\r\n */\r\nexport function isClockWise(points) {\r\n  let area = 0;\r\n  for (let i = 0; i < points.length; i++) {\r\n    const a = points[i], b = points[(i + 1) % points.length];\r\n    area += a.x * b.y - b.x * a.y;\r\n  }\r\n  return area < 0;\r\n}\r\n\r\n/** Low-poly tree, sharing the source block's buffers, picking and terrain offset. */\r\nexport function treeGeometry(point, style, addTriangle) {\r\n  const { top, bottom = 0, trunkRadius, crownRadius, crownBottom, crownShape = 'round' } = style;\r\n  if (![trunkRadius, crownRadius, crownBottom].every(Number.isFinite) ||\r\n    trunkRadius <= 0 || crownRadius < trunkRadius || crownBottom <= bottom || crownBottom >= top ||\r\n    !['round', 'cone'].includes(crownShape)) {\r\n      throw new Error('Invalid tree dimensions or crown shape');\r\n    }\r\n  const trunk = parseColor(style.trunkColor ?? 0x72513a);\r\n  const crown = parseColor(style.color ?? 0x4f823b);\r\n  const ring = radius => Array.from({ length: 8 }, (_, i) => ({\r\n    x: point.x + Math.cos(i * Math.PI / 4) * radius,\r\n    y: point.y + Math.sin(i * Math.PI / 4) * radius,\r\n    ground: point.ground,\r\n  }));\r\n  const surface = (lowRadius, low, highRadius, high, color) => {\r\n    const lower = ring(lowRadius), upper = ring(highRadius);\r\n    for (let i = 0; i < 8; i++) {\r\n      const next = (i + 1) % 8;\r\n      const angle = (i + 0.5) * Math.PI / 4;\r\n      const slope = (lowRadius - highRadius) / (high - low);\r\n      const length = Math.hypot(1, slope);\r\n      const nx = Math.cos(angle) / length, ny = slope / length, nz = -Math.sin(angle) / length;\r\n      if (lowRadius) addTriangle(lower[i], low, lower[next], low, upper[next], high, nx, ny, nz, color);\r\n      if (highRadius) addTriangle(lower[i], low, upper[next], high, upper[i], high, nx, ny, nz, color);\r\n    }\r\n  };\r\n  surface(trunkRadius, bottom, trunkRadius, crownBottom + (top - crownBottom) * 0.25, trunk);\r\n  if (crownShape === 'cone') {\r\n    const base = ring(crownRadius);\r\n    for (let i = 0; i < 8; i++) addTriangle(point, crownBottom, base[i], crownBottom,\r\n      base[(i + 1) % 8], crownBottom, 0, -1, 0, crown);\r\n    surface(crownRadius, crownBottom, 0, top, crown);\r\n  } else {\r\n    const profile = [[0, 0], [0.35, 0.8], [0.6, 1], [0.85, 0.7], [1, 0]];\r\n    for (let i = 1; i < profile.length; i++) {\r\n      const [low, lr] = profile[i - 1], [high, hr] = profile[i];\r\n      surface(lr * crownRadius, crownBottom + low * (top - crownBottom),\r\n        hr * crownRadius, crownBottom + high * (top - crownBottom), crown);\r\n    }\r\n  }\r\n}\r\n\r\n/** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */\r\nexport function lightGeometry(point, style, addTriangle) {\r\n  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw new Error('Invalid light radius');\r\n  const color = parseColor(style.color);\r\n  const quad = (a, b, c, d, height, normal) => {\r\n    addTriangle(a, height, b, height, c, height, ...normal, color);\r\n    addTriangle(a, height, c, height, d, height, ...normal, color);\r\n  };\r\n  const r = 0.65;\r\n  const emitter = (u, v, axis) => ({\r\n    x: point.x + (axis === 2 ? 0 : u * r),\r\n    y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),\r\n    ground: point.ground + (axis === 0 ? 0 : v * r), uv: [u, v],\r\n  });\r\n  for (let axis = 0; axis < 3; axis++) {\r\n    quad(emitter(-1, -1, axis), emitter(1, -1, axis), emitter(1, 1, axis), emitter(-1, 1, axis),\r\n      style.top, axis === 0 ? [0, 1, 0] : axis === 1 ? [0, 0, 1] : [1, 0, 0]);\r\n  }\r\n}\r\n\r\n/** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */\r\nexport function lampPostGeometry(point, style, addTriangle) {\r\n  const color = parseColor(0x50565a), radius = style.poleRadius;\r\n  if (!Number.isFinite(radius) || radius <= 0) throw new Error('Invalid lamp pole radius');\r\n  const ring = r => Array.from({ length: 6 }, (_, i) => ({\r\n    x: point.x + Math.cos(i * Math.PI / 3) * r,\r\n    y: point.y + Math.sin(i * Math.PI / 3) * r, ground: point.ground, uv: [3, 3],\r\n  }));\r\n  const center = { ...point, uv: [3, 3] };\r\n  for (const [r, low, high] of [[radius, 0, style.top], [radius * 2.5, style.top - 0.25, style.top + 0.15]]) {\r\n    const points = ring(r);\r\n    for (let i = 0; i < 6; i++) {\r\n      const a = points[i], b = points[(i + 1) % 6], angle = (i + 0.5) * Math.PI / 3;\r\n      const nx = Math.cos(angle), nz = -Math.sin(angle);\r\n      addTriangle(a, low, b, low, b, high, nx, 0, nz, color);\r\n      addTriangle(a, low, b, high, a, high, nx, 0, nz, color);\r\n      addTriangle(center, high, a, high, b, high, 0, 1, 0, color);\r\n      addTriangle(center, low, b, low, a, low, 0, -1, 0, color);\r\n    }\r\n  }\r\n}\r\n\r\n/** Cache local AABB and center for ray picking and transparent mesh sorting. */\r\nexport function computeBounds(geometry) {\r\n  const min = [Infinity, Infinity, Infinity],\r\n        max = [-Infinity, -Infinity, -Infinity],\r\n        data = geometry.attributes.position.data;\r\n  for (let i = 0; i < data.length; i++) {\r\n    min[i % 3] = Math.min(min[i % 3], data[i]);\r\n    max[i % 3] = Math.max(max[i % 3], data[i]);\r\n  }\r\n  const center = min.map((v, i) => (v + max[i]) / 2);\r\n  let radius = 0;\r\n  for (let i = 0; i < data.length; i += 3) {\r\n    radius = Math.max(radius, Math.hypot(\r\n      data[i] - center[0], data[i + 1] - center[1], data[i + 2] - center[2]\r\n    ));\r\n  }\r\n  geometry.bounds = { min, max, center, radius };\r\n}\r\n"],
-  "mappings": "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",
-  "names": ["parseColor", "value", "h", "s", "l", "a", "channel", "n", "k", "toSRGB", "context", "r", "g", "b", "setVertexColor", "mesh", "start", "end", "color", "i", "triangulate", "contour", "holes", "points", "p", "vertices", "index", "cross", "c", "equal", "clean", "ring", "changed", "offset", "rings", "path", "isClockWise", "inside", "point", "result", "j", "intersects", "d", "abC", "abD", "cdA", "cdB", "on", "q", "polygon", "hole", "bridge", "distance", "mid", "clipped", "area", "sum", "expected", "actual", "triangle", "treeGeometry", "style", "addTriangle", "top", "bottom", "trunkRadius", "crownRadius", "crownBottom", "crownShape", "trunk", "crown", "radius", "_", "surface", "lowRadius", "low", "highRadius", "high", "lower", "upper", "next", "angle", "slope", "length", "nx", "ny", "nz", "base", "profile", "lr", "hr", "lightGeometry", "quad", "height", "normal", "emitter", "u", "v", "axis", "lampPostGeometry", "center", "computeBounds", "geometry", "min", "max", "data"]
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
 }

package/dist/utils/getElevation.js

@@ -0,0 +1,2 @@
+import{bridgeElevation as e}from"./bridgeElevation.js";import{terrainElevation as o}from"./terrainElevation.js";function p(r,t){if(!r._map||!r._terrainReady)return null;const i=t instanceof L.Point?t:r._map.project(t,r._terrainZoom);return e(i,r._bridges)??o(i,r._terrainTiles)}export{p as getElevation};
+//# sourceMappingURL=getElevation.js.map

package/dist/utils/getElevation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getElevation.js"],
+  "sourcesContent": ["import { bridgeElevation } from './bridgeElevation.js';\nimport { terrainElevation } from './terrainElevation.js';\n\n/** @param {L.LatLng|L.Point} location LatLng, or a pixel point at the terrain zoom. */\n\nexport function getElevation(backend, location) {\n  if (!backend._map || !backend._terrainReady) return null;\n  const point = location instanceof L.Point ? location : backend._map.project(location, backend._terrainZoom);\n  return bridgeElevation(point, backend._bridges) ?? terrainElevation(point, backend._terrainTiles);\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,uBAChC,OAAS,oBAAAC,MAAwB,wBAI1B,SAASC,EAAaC,EAASC,EAAU,CAC9C,GAAI,CAACD,EAAQ,MAAQ,CAACA,EAAQ,cAAe,OAAO,KACpD,MAAME,EAAQD,aAAoB,EAAE,MAAQA,EAAWD,EAAQ,KAAK,QAAQC,EAAUD,EAAQ,YAAY,EAC1G,OAAOH,EAAgBK,EAAOF,EAAQ,QAAQ,GAAKF,EAAiBI,EAAOF,EAAQ,aAAa,CAClG",
+  "names": ["bridgeElevation", "terrainElevation", "getElevation", "backend", "location", "point"]
+}

package/dist/utils/getHeader.js

@@ -0,0 +1,2 @@
+import{decodeHeader as e}from"./decodeHeader.js";import{read as o}from"./read.js";function p(r){return r.options.archive&&r.options.archive!==r?r.options.archive.getHeader():r._header||=o(r,0,127).then(e)}export{p as getHeader};
+//# sourceMappingURL=getHeader.js.map

package/dist/utils/getHeader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getHeader.js"],
+  "sourcesContent": ["import { decodeHeader } from './decodeHeader.js';\nimport { read } from './read.js';\n\n/** Cache header initialization; failures remain visible to all callers. */\n\nexport function getHeader(backend) {\n  if (backend.options.archive && backend.options.archive !== backend) return backend.options.archive.getHeader();\n  return backend._header ||= read(backend, 0, 127).then(decodeHeader);\n}\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB,oBAC7B,OAAS,QAAAC,MAAY,YAId,SAASC,EAAUC,EAAS,CACjC,OAAIA,EAAQ,QAAQ,SAAWA,EAAQ,QAAQ,UAAYA,EAAgBA,EAAQ,QAAQ,QAAQ,UAAU,EACtGA,EAAQ,UAAYF,EAAKE,EAAS,EAAG,GAAG,EAAE,KAAKH,CAAY,CACpE",
+  "names": ["decodeHeader", "read", "getHeader", "backend"]
+}

package/dist/utils/getZxy.js

@@ -0,0 +1,2 @@
+import{decodeDirectory as v}from"./decodeDirectory.js";import{decompress as u}from"./decompress.js";import{tileId as D}from"./tileId.js";import{read as _}from"./read.js";import{getHeader as I}from"./getHeader.js";async function M(t,h,m,p,i){if(t.options.archive&&t.options.archive!==t&&t.options.archive.getZxy)return t.options.archive.getZxy(h,m,p,i);const y=D(h,m,p);i?.throwIfAborted();const r=await I(t);if(i?.throwIfAborted(),h<r.minZoom||h>r.maxZoom)return;let s=r.rootDirectoryOffset,l=r.rootDirectoryLength;const a=new Set;for(let g=0;g<4;g++){if(a.has(s))throw new Error("Cyclic PMTiles directory");a.add(s);const f=`${s}:${l}`;if(!t._directories.has(f)){t._directories.size>=32&&t._directories.delete(t._directories.keys().next().value);const o=_(t,s,l).then(w=>u(w,r.internalCompression)).then(v).catch(w=>{throw t._directories.get(f)===o&&t._directories.delete(f),w});t._directories.set(f,o)}const c=await t._directories.get(f);i?.throwIfAborted();let d=0,n=c.length-1;for(;d<=n;){const o=d+n>>1;c[o].tileId<=y?d=o+1:n=o-1}const e=c[n];if(!e)return;if(e.runLength){if(y-e.tileId>=e.runLength)return;if(e.offset+e.length>r.tileDataLength)throw new Error("PMTiles tile outside data section");const o=await u(await _(t,r.tileDataOffset+e.offset,e.length,i),r.tileCompression);return i?.throwIfAborted(),{data:o}}if(e.offset+e.length>r.leafDirectoryLength)throw new Error("PMTiles directory outside leaf section");s=r.leafDirectoryOffset+e.offset,l=e.length}throw new Error("PMTiles directory depth exceeds four levels")}export{M as getZxy};
+//# sourceMappingURL=getZxy.js.map

package/dist/utils/getZxy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/getZxy.js"],
+  "sourcesContent": ["import { decodeDirectory } from './decodeDirectory.js';\nimport { decompress } from './decompress.js';\nimport { tileId } from './tileId.js';\nimport { read } from './read.js';\nimport { getHeader } from './getHeader.js';\n\n/** Nearest directory entry at/before the Hilbert ID, then follow leaf pointers. */\n\nexport async function getZxy(backend, z, x, y, signal) {\n  if (backend.options.archive && backend.options.archive !== backend && backend.options.archive.getZxy) {\n    return backend.options.archive.getZxy(z, x, y, signal);\n  }\n  const id = tileId(z, x, y);\n  signal?.throwIfAborted();\n  const header = await getHeader(backend);\n  signal?.throwIfAborted();\n  if (z < header.minZoom || z > header.maxZoom) {\n    return;\n  }\n  let offset = header.rootDirectoryOffset, length = header.rootDirectoryLength;\n  const visited = new Set();\n  for (let depth = 0; depth < 4; depth++) {\n    if (visited.has(offset)) {\n      throw new Error('Cyclic PMTiles directory');\n    }\n    visited.add(offset);\n    const key = `${offset}:${length}`;\n    if (!backend._directories.has(key)) {\n      if (backend._directories.size >= 32) {\n        backend._directories.delete(backend._directories.keys().next().value);\n      }\n      const pending = read(backend, offset, length)\n        .then(data => decompress(data, header.internalCompression))\n        .then(decodeDirectory)\n        .catch(error => {\n          if (backend._directories.get(key) === pending) {\n            backend._directories.delete(key);\n          }\n          throw error;\n        });\n      backend._directories.set(key, pending);\n    }\n    const entries = await backend._directories.get(key);\n    signal?.throwIfAborted();\n    let low = 0, high = entries.length - 1;\n    while (low <= high) {\n      const mid = (low + high) >> 1;\n      if (entries[mid].tileId <= id) {\n        low = mid + 1;\n      } else {\n        high = mid - 1;\n      }\n    }\n    const entry = entries[high];\n    if (!entry) {\n      return;\n    }\n    if (entry.runLength) {\n      if (id - entry.tileId >= entry.runLength) {\n        return;\n      }\n      if (entry.offset + entry.length > header.tileDataLength) {\n        throw new Error('PMTiles tile outside data section');\n      }\n      const data = await decompress(await read(backend, header.tileDataOffset + entry.offset, entry.length, signal), header.tileCompression);\n      signal?.throwIfAborted();\n      return { data };\n    }\n    if (entry.offset + entry.length > header.leafDirectoryLength) {\n      throw new Error('PMTiles directory outside leaf section');\n    }\n    offset = header.leafDirectoryOffset + entry.offset;\n    length = entry.length;\n  }\n  throw new Error('PMTiles directory depth exceeds four levels');\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,uBAChC,OAAS,cAAAC,MAAkB,kBAC3B,OAAS,UAAAC,MAAc,cACvB,OAAS,QAAAC,MAAY,YACrB,OAAS,aAAAC,MAAiB,iBAI1B,eAAsBC,EAAOC,EAASC,EAAGC,EAAGC,EAAGC,EAAQ,CACrD,GAAIJ,EAAQ,QAAQ,SAAWA,EAAQ,QAAQ,UAAYA,GAAWA,EAAQ,QAAQ,QAAQ,OAC5F,OAAOA,EAAQ,QAAQ,QAAQ,OAAOC,EAAGC,EAAGC,EAAGC,CAAM,EAEvD,MAAMC,EAAKT,EAAOK,EAAGC,EAAGC,CAAC,EACzBC,GAAQ,eAAe,EACvB,MAAME,EAAS,MAAMR,EAAUE,CAAO,EAEtC,GADAI,GAAQ,eAAe,EACnBH,EAAIK,EAAO,SAAWL,EAAIK,EAAO,QACnC,OAEF,IAAIC,EAASD,EAAO,oBAAqBE,EAASF,EAAO,oBACzD,MAAMG,EAAU,IAAI,IACpB,QAASC,EAAQ,EAAGA,EAAQ,EAAGA,IAAS,CACtC,GAAID,EAAQ,IAAIF,CAAM,EACpB,MAAM,IAAI,MAAM,0BAA0B,EAE5CE,EAAQ,IAAIF,CAAM,EAClB,MAAMI,EAAM,GAAGJ,CAAM,IAAIC,CAAM,GAC/B,GAAI,CAACR,EAAQ,aAAa,IAAIW,CAAG,EAAG,CAC9BX,EAAQ,aAAa,MAAQ,IAC/BA,EAAQ,aAAa,OAAOA,EAAQ,aAAa,KAAK,EAAE,KAAK,EAAE,KAAK,EAEtE,MAAMY,EAAUf,EAAKG,EAASO,EAAQC,CAAM,EACzC,KAAKK,GAAQlB,EAAWkB,EAAMP,EAAO,mBAAmB,CAAC,EACzD,KAAKZ,CAAe,EACpB,MAAMoB,GAAS,CACd,MAAId,EAAQ,aAAa,IAAIW,CAAG,IAAMC,GACpCZ,EAAQ,aAAa,OAAOW,CAAG,EAE3BG,CACR,CAAC,EACHd,EAAQ,aAAa,IAAIW,EAAKC,CAAO,CACvC,CACA,MAAMG,EAAU,MAAMf,EAAQ,aAAa,IAAIW,CAAG,EAClDP,GAAQ,eAAe,EACvB,IAAIY,EAAM,EAAGC,EAAOF,EAAQ,OAAS,EACrC,KAAOC,GAAOC,GAAM,CAClB,MAAMC,EAAOF,EAAMC,GAAS,EACxBF,EAAQG,CAAG,EAAE,QAAUb,EACzBW,EAAME,EAAM,EAEZD,EAAOC,EAAM,CAEjB,CACA,MAAMC,EAAQJ,EAAQE,CAAI,EAC1B,GAAI,CAACE,EACH,OAEF,GAAIA,EAAM,UAAW,CACnB,GAAId,EAAKc,EAAM,QAAUA,EAAM,UAC7B,OAEF,GAAIA,EAAM,OAASA,EAAM,OAASb,EAAO,eACvC,MAAM,IAAI,MAAM,mCAAmC,EAErD,MAAMO,EAAO,MAAMlB,EAAW,MAAME,EAAKG,EAASM,EAAO,eAAiBa,EAAM,OAAQA,EAAM,OAAQf,CAAM,EAAGE,EAAO,eAAe,EACrI,OAAAF,GAAQ,eAAe,EAChB,CAAE,KAAAS,CAAK,CAChB,CACA,GAAIM,EAAM,OAASA,EAAM,OAASb,EAAO,oBACvC,MAAM,IAAI,MAAM,wCAAwC,EAE1DC,EAASD,EAAO,oBAAsBa,EAAM,OAC5CX,EAASW,EAAM,MACjB,CACA,MAAM,IAAI,MAAM,6CAA6C,CAC/D",
+  "names": ["decodeDirectory", "decompress", "tileId", "read", "getHeader", "getZxy", "backend", "z", "x", "y", "signal", "id", "header", "offset", "length", "visited", "depth", "key", "pending", "data", "error", "entries", "low", "high", "mid", "entry"]
+}

package/dist/utils/glass.js

@@ -0,0 +1,2 @@
+const s=[.12,.15,.18],t=[.05,.05,.05];export{s as glass,t as tyre};
+//# sourceMappingURL=glass.js.map

package/dist/utils/glass.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/glass.js"],
+  "sourcesContent": ["export const glass = [0.12, 0.15, 0.18], tyre = [0.05, 0.05, 0.05];\n"],
+  "mappings": "AAAO,MAAMA,EAAQ,CAAC,IAAM,IAAM,GAAI,EAAGC,EAAO,CAAC,IAAM,IAAM,GAAI",
+  "names": ["glass", "tyre"]
+}

package/dist/utils/headlight.js

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

package/dist/utils/headlight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/headlight.js"],
+  "sourcesContent": ["export const headlight = [1.9, 1.85, 1.7];\n"],
+  "mappings": "AAAO,MAAMA,EAAY,CAAC,IAAK,KAAM,GAAG",
+  "names": ["headlight"]
+}

package/dist/utils/hit.js

@@ -0,0 +1,2 @@
+import{CELL as u}from"./CELL.js";import{collider as B}from"./collider.js";import{computeBounds as C}from"./computeBounds.js";import{horizontalRay as E}from"./horizontalRay.js";import{traverse as R}from"./traverse.js";import{updateWorldMatrix as S}from"./updateWorldMatrix.js";function F(p,g,_,y,s,l,n){const k=f=>f===p||["terrain","traffic"].includes(f._type);S(p.scene);let h=n,b=null;for(const f of p._shared._layers)k(f)||R(f.root,r=>{if(!r.visible)return!0;if(!r.geometry?.attributes?.position?.data||r.program?.depthTest===!1)return;r.geometry.bounds||C(r.geometry);const o=r.worldMatrix,{center:e,radius:v}=r.geometry.bounds;if(Math.hypot(o[0]*e[0]+o[4]*e[1]+o[8]*e[2]+o[12]-g,o[2]*e[0]+o[6]*e[1]+o[10]*e[2]+o[14]-y)>v*Math.hypot(o[0],o[1],o[2])+n)return;const t=B(r),a=g-o[12]+t.origin[0],w=_-o[13]+t.origin[1],m=y-o[14]+t.origin[2],x=new Set;for(let c=Math.floor(Math.min(a,a+s*n)/u);c<=Math.floor(Math.max(a,a+s*n)/u);c++)for(let M=Math.floor(Math.min(m,m+l*n)/u);M<=Math.floor(Math.max(m,m+l*n)/u);M++)for(const i of t.cells.get(c+","+M)||[])if(!(x.has(i)||s*t.nrm[i*2]+l*t.nrm[i*2+1]>=0)){x.add(i);for(const L of[.4,1.5]){const d=E(t.tri,i,a,w+L,m,s,l);d>=0&&d<h&&(h=d,b=[t.nrm[i*2],t.nrm[i*2+1]])}}});return b}export{F as hit};
+//# sourceMappingURL=hit.js.map

package/dist/utils/hit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/hit.js"],
+  "sourcesContent": ["import { CELL } from './CELL.js';\nimport { collider } from './collider.js';\nimport { computeBounds } from './computeBounds.js';\nimport { horizontalRay } from './horizontalRay.js';\nimport { traverse } from './traverse.js';\nimport { updateWorldMatrix } from './updateWorldMatrix.js';\n\n// Horizontal normal of the nearest wall faced within `reach` metres of the feet at world (x, y, z), walking along\n// the unit (dx, dz); knee and chest rays, so arches and tree crowns above the head let the walker through.\n// ponytail: traffic vehicles and boats move on the GPU and are not obstacles.\n\nexport function hit(layer, x, y, z, dx, dz, reach) {\n  const skip = other => other === layer || ['terrain', 'traffic'].includes(other._type);\n  updateWorldMatrix(layer.scene);\n  let best = reach, found = null;\n  for (const other of layer._shared._layers) {\n    if (skip(other)) continue;\n    traverse(other.root, mesh => {\n      if (!mesh.visible) return true;\n      if (!mesh.geometry?.attributes?.position?.data || mesh.program?.depthTest === false) return;\n      if (!mesh.geometry.bounds) computeBounds(mesh.geometry);\n      const m = mesh.worldMatrix, { center: k, radius } = mesh.geometry.bounds;\n      if (Math.hypot(m[0] * k[0] + m[4] * k[1] + m[8] * k[2] + m[12] - x, m[2] * k[0] + m[6] * k[1] + m[10] * k[2] + m[14] - z) >\n        radius * Math.hypot(m[0], m[1], m[2]) + reach) return;\n      const c = collider(mesh), ox = x - m[12] + c.origin[0], oy = y - m[13] + c.origin[1], oz = z - m[14] + c.origin[2];\n      const seen = new Set();\n      for (let ix = Math.floor(Math.min(ox, ox + dx * reach) / CELL); ix <= Math.floor(Math.max(ox, ox + dx * reach) / CELL); ix++)\n        for (let iz = Math.floor(Math.min(oz, oz + dz * reach) / CELL); iz <= Math.floor(Math.max(oz, oz + dz * reach) / CELL); iz++)\n          for (const t of c.cells.get(ix + ',' + iz) || []) {\n            // Walls are one-way: walking out of a building (e.g. starting inside one) is allowed.\n            if (seen.has(t) || dx * c.nrm[t * 2] + dz * c.nrm[t * 2 + 1] >= 0) continue;\n            seen.add(t);\n            for (const height of [0.4, 1.5]) {\n              const d = horizontalRay(c.tri, t, ox, oy + height, oz, dx, dz);\n              if (d >= 0 && d < best) { best = d; found = [c.nrm[t * 2], c.nrm[t * 2 + 1]]; }\n            }\n          }\n    });\n  }\n  return found;\n}\n"],
+  "mappings": "AAAA,OAAS,QAAAA,MAAY,YACrB,OAAS,YAAAC,MAAgB,gBACzB,OAAS,iBAAAC,MAAqB,qBAC9B,OAAS,iBAAAC,MAAqB,qBAC9B,OAAS,YAAAC,MAAgB,gBACzB,OAAS,qBAAAC,MAAyB,yBAM3B,SAASC,EAAIC,EAAOC,EAAGC,EAAGC,EAAGC,EAAIC,EAAIC,EAAO,CACjD,MAAMC,EAAOC,GAASA,IAAUR,GAAS,CAAC,UAAW,SAAS,EAAE,SAASQ,EAAM,KAAK,EACpFV,EAAkBE,EAAM,KAAK,EAC7B,IAAIS,EAAOH,EAAOI,EAAQ,KAC1B,UAAWF,KAASR,EAAM,QAAQ,QAC5BO,EAAKC,CAAK,GACdX,EAASW,EAAM,KAAMG,GAAQ,CAC3B,GAAI,CAACA,EAAK,QAAS,MAAO,GAC1B,GAAI,CAACA,EAAK,UAAU,YAAY,UAAU,MAAQA,EAAK,SAAS,YAAc,GAAO,OAChFA,EAAK,SAAS,QAAQhB,EAAcgB,EAAK,QAAQ,EACtD,MAAMC,EAAID,EAAK,YAAa,CAAE,OAAQE,EAAG,OAAAC,CAAO,EAAIH,EAAK,SAAS,OAClE,GAAI,KAAK,MAAMC,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,EAAE,EAAIX,EAAGW,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,EAAE,EAAIC,EAAE,CAAC,EAAID,EAAE,EAAE,EAAIT,CAAC,EACtHW,EAAS,KAAK,MAAMF,EAAE,CAAC,EAAGA,EAAE,CAAC,EAAGA,EAAE,CAAC,CAAC,EAAIN,EAAO,OACjD,MAAMS,EAAIrB,EAASiB,CAAI,EAAGK,EAAKf,EAAIW,EAAE,EAAE,EAAIG,EAAE,OAAO,CAAC,EAAGE,EAAKf,EAAIU,EAAE,EAAE,EAAIG,EAAE,OAAO,CAAC,EAAGG,EAAKf,EAAIS,EAAE,EAAE,EAAIG,EAAE,OAAO,CAAC,EAC3GI,EAAO,IAAI,IACjB,QAASC,EAAK,KAAK,MAAM,KAAK,IAAIJ,EAAIA,EAAKZ,EAAKE,CAAK,EAAIb,CAAI,EAAG2B,GAAM,KAAK,MAAM,KAAK,IAAIJ,EAAIA,EAAKZ,EAAKE,CAAK,EAAIb,CAAI,EAAG2B,IACtH,QAASC,EAAK,KAAK,MAAM,KAAK,IAAIH,EAAIA,EAAKb,EAAKC,CAAK,EAAIb,CAAI,EAAG4B,GAAM,KAAK,MAAM,KAAK,IAAIH,EAAIA,EAAKb,EAAKC,CAAK,EAAIb,CAAI,EAAG4B,IACtH,UAAWC,KAAKP,EAAE,MAAM,IAAIK,EAAK,IAAMC,CAAE,GAAK,CAAC,EAE7C,GAAI,EAAAF,EAAK,IAAIG,CAAC,GAAKlB,EAAKW,EAAE,IAAIO,EAAI,CAAC,EAAIjB,EAAKU,EAAE,IAAIO,EAAI,EAAI,CAAC,GAAK,GAChE,CAAAH,EAAK,IAAIG,CAAC,EACV,UAAWC,IAAU,CAAC,GAAK,GAAG,EAAG,CAC/B,MAAM,EAAI3B,EAAcmB,EAAE,IAAKO,EAAGN,EAAIC,EAAKM,EAAQL,EAAId,EAAIC,CAAE,EACzD,GAAK,GAAK,EAAII,IAAQA,EAAO,EAAGC,EAAQ,CAACK,EAAE,IAAIO,EAAI,CAAC,EAAGP,EAAE,IAAIO,EAAI,EAAI,CAAC,CAAC,EAC7E,EAER,CAAC,EAEH,OAAOZ,CACT",
+  "names": ["CELL", "collider", "computeBounds", "horizontalRay", "traverse", "updateWorldMatrix", "hit", "layer", "x", "y", "z", "dx", "dz", "reach", "skip", "other", "best", "found", "mesh", "m", "k", "radius", "c", "ox", "oy", "oz", "seen", "ix", "iz", "t", "height"]
+}

package/dist/utils/horizontalPosition.js

@@ -0,0 +1,2 @@
+function e(M,i,c,u,s){const t=Math.PI/180,o=(280.16+360.9856235*M+c)*t-u,a=i*t,h=Math.asin(Math.sin(a)*Math.sin(s)+Math.cos(a)*Math.cos(s)*Math.cos(o)),n=(Math.atan2(Math.sin(o),Math.cos(o)*Math.sin(a)-Math.tan(s)*Math.cos(a))/t+180+360)%360;return{altitude:h/t,azimuth:n,direction:[Math.sin(n*t)*Math.cos(h),Math.sin(h),-Math.cos(n*t)*Math.cos(h)]}}export{e as horizontalPosition};
+//# sourceMappingURL=horizontalPosition.js.map

package/dist/utils/horizontalPosition.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/horizontalPosition.js"],
+  "sourcesContent": ["\nexport function horizontalPosition(d, lat, lng, ascension, declination) {\n  const rad = Math.PI / 180;\n  const hourAngle = (280.16 + 360.9856235 * d + lng) * rad - ascension;\n  const latitude = lat * rad;\n  const altitude = Math.asin(Math.sin(latitude) * Math.sin(declination) +\n    Math.cos(latitude) * Math.cos(declination) * Math.cos(hourAngle));\n  const southAzimuth = Math.atan2(Math.sin(hourAngle),\n    Math.cos(hourAngle) * Math.sin(latitude) - Math.tan(declination) * Math.cos(latitude));\n  const azimuth = (southAzimuth / rad + 180 + 360) % 360;\n  return {\n    altitude: altitude / rad, azimuth,\n    direction: [Math.sin(azimuth * rad) * Math.cos(altitude), Math.sin(altitude),\n    -Math.cos(azimuth * rad) * Math.cos(altitude)]\n  };\n}\n"],
+  "mappings": "AACO,SAASA,EAAmBC,EAAGC,EAAKC,EAAKC,EAAWC,EAAa,CACtE,MAAMC,EAAM,KAAK,GAAK,IAChBC,GAAa,OAAS,YAAcN,EAAIE,GAAOG,EAAMF,EACrDI,EAAWN,EAAMI,EACjBG,EAAW,KAAK,KAAK,KAAK,IAAID,CAAQ,EAAI,KAAK,IAAIH,CAAW,EAClE,KAAK,IAAIG,CAAQ,EAAI,KAAK,IAAIH,CAAW,EAAI,KAAK,IAAIE,CAAS,CAAC,EAG5DG,GAFe,KAAK,MAAM,KAAK,IAAIH,CAAS,EAChD,KAAK,IAAIA,CAAS,EAAI,KAAK,IAAIC,CAAQ,EAAI,KAAK,IAAIH,CAAW,EAAI,KAAK,IAAIG,CAAQ,CAAC,EACvDF,EAAM,IAAM,KAAO,IACnD,MAAO,CACL,SAAUG,EAAWH,EAAK,QAAAI,EAC1B,UAAW,CAAC,KAAK,IAAIA,EAAUJ,CAAG,EAAI,KAAK,IAAIG,CAAQ,EAAG,KAAK,IAAIA,CAAQ,EAC3E,CAAC,KAAK,IAAIC,EAAUJ,CAAG,EAAI,KAAK,IAAIG,CAAQ,CAAC,CAC/C,CACF",
+  "names": ["horizontalPosition", "d", "lat", "lng", "ascension", "declination", "rad", "hourAngle", "latitude", "altitude", "azimuth"]
+}

package/dist/utils/horizontalRay.js

@@ -0,0 +1,2 @@
+function A(t,R,g,j,k,r,o){const n=R*9,f=t[n+3]-t[n],c=t[n+4]-t[n+1],i=t[n+5]-t[n+2],x=t[n+6]-t[n],s=t[n+7]-t[n+1],z=t[n+8]-t[n+2],q=-o*s,h=o*x-r*z,b=r*s,e=f*q+c*h+i*b;if(Math.abs(e)<1e-9)return-1;const u=g-t[n],y=j-t[n+1],a=k-t[n+2],p=(u*q+y*h+a*b)/e;if(p<0||p>1)return-1;const l=y*i-a*c,m=a*f-u*i,w=u*c-y*f,M=(r*l+o*w)/e;return M<0||p+M>1?-1:(x*l+s*m+z*w)/e}export{A as horizontalRay};
+//# sourceMappingURL=horizontalRay.js.map

package/dist/utils/horizontalRay.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/horizontalRay.js"],
+  "sourcesContent": ["// M\u00F6ller-Trumbore for the horizontal ray (ox, oy, oz) + d\u00B7(dx, 0, dz) against triangle t; returns d or -1.\nexport function horizontalRay(v, t, ox, oy, oz, dx, dz) {\n  const i = t * 9, ex = v[i + 3] - v[i], ey = v[i + 4] - v[i + 1], ez = v[i + 5] - v[i + 2];\n  const fx = v[i + 6] - v[i], fy = v[i + 7] - v[i + 1], fz = v[i + 8] - v[i + 2];\n  const px = -dz * fy, py = dz * fx - dx * fz, pz = dx * fy, det = ex * px + ey * py + ez * pz;\n  if (Math.abs(det) < 1e-9) return -1;\n  const tx = ox - v[i], ty = oy - v[i + 1], tz = oz - v[i + 2], u = (tx * px + ty * py + tz * pz) / det;\n  if (u < 0 || u > 1) return -1;\n  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex, w = (dx * qx + dz * qz) / det;\n  if (w < 0 || u + w > 1) return -1;\n  return (fx * qx + fy * qy + fz * qz) / det;\n}\n"],
+  "mappings": "AACO,SAASA,EAAcC,EAAGC,EAAGC,EAAIC,EAAIC,EAAIC,EAAIC,EAAI,CACtD,MAAMC,EAAIN,EAAI,EAAGO,EAAKR,EAAEO,EAAI,CAAC,EAAIP,EAAEO,CAAC,EAAGE,EAAKT,EAAEO,EAAI,CAAC,EAAIP,EAAEO,EAAI,CAAC,EAAGG,EAAKV,EAAEO,EAAI,CAAC,EAAIP,EAAEO,EAAI,CAAC,EAClFI,EAAKX,EAAEO,EAAI,CAAC,EAAIP,EAAEO,CAAC,EAAGK,EAAKZ,EAAEO,EAAI,CAAC,EAAIP,EAAEO,EAAI,CAAC,EAAGM,EAAKb,EAAEO,EAAI,CAAC,EAAIP,EAAEO,EAAI,CAAC,EACvEO,EAAK,CAACR,EAAKM,EAAIG,EAAKT,EAAKK,EAAKN,EAAKQ,EAAIG,EAAKX,EAAKO,EAAIK,EAAMT,EAAKM,EAAKL,EAAKM,EAAKL,EAAKM,EAC1F,GAAI,KAAK,IAAIC,CAAG,EAAI,KAAM,MAAO,GACjC,MAAMC,EAAKhB,EAAKF,EAAEO,CAAC,EAAGY,EAAKhB,EAAKH,EAAEO,EAAI,CAAC,EAAGa,EAAKhB,EAAKJ,EAAEO,EAAI,CAAC,EAAGc,GAAKH,EAAKJ,EAAKK,EAAKJ,EAAKK,EAAKJ,GAAMC,EAClG,GAAII,EAAI,GAAKA,EAAI,EAAG,MAAO,GAC3B,MAAMC,EAAKH,EAAKT,EAAKU,EAAKX,EAAIc,EAAKH,EAAKZ,EAAKU,EAAKR,EAAIc,EAAKN,EAAKT,EAAKU,EAAKX,EAAIiB,GAAKpB,EAAKiB,EAAKhB,EAAKkB,GAAMP,EACxG,OAAIQ,EAAI,GAAKJ,EAAII,EAAI,EAAU,IACvBd,EAAKW,EAAKV,EAAKW,EAAKV,EAAKW,GAAMP,CACzC",
+  "names": ["horizontalRay", "v", "t", "ox", "oy", "oz", "dx", "dz", "i", "ex", "ey", "ez", "fx", "fy", "fz", "px", "py", "pz", "det", "tx", "ty", "tz", "u", "qx", "qy", "qz", "w"]
+}

package/dist/utils/hull.js

@@ -0,0 +1,2 @@
+const l=[[-5.5,30],[5.5,30],[5.5,-20],[4,-26],[1.5,-30],[-1.5,-30],[-4,-26],[-5.5,-20]];export{l as hull};
+//# sourceMappingURL=hull.js.map

package/dist/utils/hull.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/hull.js"],
+  "sourcesContent": ["export const hull = [[-5.5, 30], [5.5, 30], [5.5, -20], [4, -26], [1.5, -30], [-1.5, -30], [-4, -26], [-5.5, -20]];\n"],
+  "mappings": "AAAO,MAAMA,EAAO,CAAC,CAAC,KAAM,EAAE,EAAG,CAAC,IAAK,EAAE,EAAG,CAAC,IAAK,GAAG,EAAG,CAAC,EAAG,GAAG,EAAG,CAAC,IAAK,GAAG,EAAG,CAAC,KAAM,GAAG,EAAG,CAAC,GAAI,GAAG,EAAG,CAAC,KAAM,GAAG,CAAC",
+  "names": ["hull"]
+}

package/dist/utils/initSunlight.js

@@ -0,0 +1,2 @@
+import{onAddSun as i}from"./onAddSun.js";import{onRemoveSun as m}from"./onRemoveSun.js";function u(o,n){L.Util.setOptions(o,n),o.onAdd=t=>i(o,t),o.onRemove=()=>m(o)}export{u as initSunlight};
+//# sourceMappingURL=initSunlight.js.map

package/dist/utils/initSunlight.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/initSunlight.js"],
+  "sourcesContent": ["import { onAddSun } from './onAddSun.js';\nimport { onRemoveSun } from './onRemoveSun.js';\n\n// Sun/moon clock control and sky colours; the control is created on first add (`layer.control`).\nexport function initSunlight(layer, options) {\n  L.Util.setOptions(layer, options);\n  layer.onAdd = map => onAddSun(layer, map);\n  layer.onRemove = () => onRemoveSun(layer);\n}"],
+  "mappings": "AAAA,OAAS,YAAAA,MAAgB,gBACzB,OAAS,eAAAC,MAAmB,mBAGrB,SAASC,EAAaC,EAAOC,EAAS,CAC3C,EAAE,KAAK,WAAWD,EAAOC,CAAO,EAChCD,EAAM,MAAQE,GAAOL,EAASG,EAAOE,CAAG,EACxCF,EAAM,SAAW,IAAMF,EAAYE,CAAK,CAC1C",
+  "names": ["onAddSun", "onRemoveSun", "initSunlight", "layer", "options", "map"]
+}

package/dist/utils/initTerrain.js

@@ -0,0 +1,2 @@
+import{onTerrainRemove as t}from"./onTerrainRemove.js";import{onTerrainAdd as d}from"./onTerrainAdd.js";function a(n,e){const o=e.url,i={...e};delete i.url,n._init3D(i),n.terrainSource=o,n._terrainTiles=new Map,n._rasterTiles=new Map,n._terrainReady=!1,n.onAdd=r=>d(n,r),n.onRemove=r=>t(n,r)}export{a as initTerrain};
+//# sourceMappingURL=initTerrain.js.map

package/dist/utils/initTerrain.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/initTerrain.js"],
+  "sourcesContent": ["import { onTerrainRemove } from './onTerrainRemove.js';\nimport { onTerrainAdd } from './onTerrainAdd.js';\n\n/**\n * Renders IGN Float32 DEM tiles and PMTiles raster basemaps in the shared WebGPU scene.\n * Source options: `url` (single-zoom Float32 PMTiles DEM); `bridges` (optional GeoJSON deck polygons with Z, see _addBridges).\n */\nexport function initTerrain(layer, options) {\n  const terrainSource = options.url;\n  const layerOptions = { ...options };\n  delete layerOptions.url;\n  layer._init3D(layerOptions);\n  layer.terrainSource = terrainSource;\n  layer._terrainTiles = new Map();\n  layer._rasterTiles = new Map();\n  layer._terrainReady = false;\n  layer.onAdd = map => onTerrainAdd(layer, map);\n  layer.onRemove = map => onTerrainRemove(layer, map);\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,uBAChC,OAAS,gBAAAC,MAAoB,oBAMtB,SAASC,EAAYC,EAAOC,EAAS,CAC1C,MAAMC,EAAgBD,EAAQ,IACxBE,EAAe,CAAE,GAAGF,CAAQ,EAClC,OAAOE,EAAa,IACpBH,EAAM,QAAQG,CAAY,EAC1BH,EAAM,cAAgBE,EACtBF,EAAM,cAAgB,IAAI,IAC1BA,EAAM,aAAe,IAAI,IACzBA,EAAM,cAAgB,GACtBA,EAAM,MAAQI,GAAON,EAAaE,EAAOI,CAAG,EAC5CJ,EAAM,SAAWI,GAAOP,EAAgBG,EAAOI,CAAG,CACpD",
+  "names": ["onTerrainRemove", "onTerrainAdd", "initTerrain", "layer", "options", "terrainSource", "layerOptions", "map"]
+}

package/dist/utils/initTraffic.js

@@ -0,0 +1,40 @@
+import{build as x}from"./build.js";import{tooltip as y}from"./tooltip.js";import{speed as w}from"./speed.js";import{vehicles as k}from"./vehicles.js";import{addTraffic as z,placeTraffic as T,removeTraffic as _,readyTraffic as A,tickTraffic as D,updateTraffic as I,updateTrafficTerrain as B}from"./traffic.js";function C(t,{url:l,vehicle:u="car",side:i,outline:c,speed:f=w,...p}={}){const{model:r,lights:n,side:m}=k[u];i??=m,t._init3D({tooltip:y,nightLight:!!n,...p});const o=L.DomUtil.create("small","traffic-status");o.style.cssText="display:block;max-width:200px;margin:0 0 4px 20px;color:#555;";const s=x(r(0)),d=s.position.length,v=d/3,a=new ArrayBuffer(16),b=new Float32Array(a),g=new Uint32Array(a),e={layer:t,url:l,model:r,lights:n,side:i,outline:c,velocity:f,status:o,template:s,stride:d,vertices:v,params:a,paramFloats:b,paramInts:g,ready:!1,frame:void 0,request:void 0,lanes:[],tripsKey:void 0,mesh:void 0,route:void 0,litAt:-1/0,trips:[],rebasedAt:0,nextCheck:-1/0,elapsed:0,gpu:null,lanesDirty:!0,stale:!1,loaded:void 0,file:void 0},h=`
+    struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }
+    struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }
+    @group(0) @binding(0) var<uniform> params: Params;
+    @group(0) @binding(1) var<storage, read> model: array<f32>;
+    @group(0) @binding(2) var<storage, read> points: array<vec4f>;
+    @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;
+    @group(0) @binding(4) var<storage, read_write> position: array<f32>;
+    @group(0) @binding(5) var<storage, read_write> normal: array<f32>;
+    @compute @workgroup_size(64)
+    fn main(@builtin(global_invocation_id) id: vec3u) {
+      let v = id.x;
+      if (v >= params.total) { return; }
+      let vehicle = vehicles[v / params.vertices];
+      let last = vehicle.start + vehicle.count - 1u;
+      let length = points[last].w;
+      var s = vehicle.base + params.seconds * vehicle.speed;
+      s -= length * floor(s / length);
+      var i = vehicle.start + 1u;
+      while (i < last && points[i].w < s) { i++; }
+      let a = points[i - 1u];
+      let b = points[i];
+      let d = select(b.w - a.w, 1.0, b.w == a.w);
+      let t = (s - a.w) / d;
+      let dx = (b.x - a.x) / d;
+      let dz = (b.y - a.y) / d;
+      let cx = a.x + (b.x - a.x) * t - dz * params.side;
+      let cz = a.y + (b.y - a.y) * t + dx * params.side;
+      let y = a.z + (b.z - a.z) * t;
+      let k = (v % params.vertices) * 3u;
+      let n = params.vertices * 3u + k;
+      let o = v * 3u;
+      position[o] = cx - model[k] * dz - model[k + 2u] * dx;
+      position[o + 1u] = y + model[k + 1u];
+      position[o + 2u] = cz + model[k] * dx - model[k + 2u] * dz;
+      normal[o] = -model[n] * dz - model[n + 2u] * dx;
+      normal[o + 1u] = model[n + 1u];
+      normal[o + 2u] = model[n] * dx - model[n + 2u] * dz;
+    }`;e.shader=h,e.tick=D.bind(null,e),e.update=I.bind(null,e),e.terrain=B.bind(null,e),t._beforeRaycast=T.bind(null,e),t.on("ready",A.bind(null,e)),t.on("add",z.bind(null,e)),t.on("remove",_.bind(null,e))}export{C as initTraffic};
+//# sourceMappingURL=initTraffic.js.map

package/dist/utils/initTraffic.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/initTraffic.js"],
+  "sourcesContent": ["\uFEFF/**\r\n * Vehicles moving along GeoJSON lanes; a compute pass places them on the GPU every frame.\r\n * Source options:\r\n * - `url`: GeoJSON (Multi)LineStrings, or a JS module whose default export `(time, layer, signal)` returns them (time-dependent data);\r\n * - `vehicle`: 'car' (default) or 'boat'; `side`: offset right of the lane centreline in metres (vehicle default);\r\n * - `speed`: m/s of `flow` lanes; `outline`: draw the lanes.\r\n * Lane properties: `flow` (vehicles/h) or `timetable` (see scheduledTrips.js), optional fixed `elevation`\r\n * in metres, `name`/`description` for the default tooltip. The status line (vehicle count, then the FeatureCollection `note`) sits under the layer's entry in the layers control.\r\n * The 'sunlight' layer on the same map drives the time; without one, vehicles run live.\r\n */\r\nimport { build } from './build.js';\r\nimport { tooltip } from './tooltip.js';\r\nimport { speed } from './speed.js';\r\nimport { vehicles } from './vehicles.js';\r\nimport {\r\n  addTraffic,\r\n  placeTraffic,\r\n  removeTraffic,\r\n  readyTraffic,\r\n  tickTraffic,\r\n  updateTraffic,\r\n  updateTrafficTerrain,\r\n} from './traffic.js';\r\n\r\nexport function initTraffic(layer, { url, vehicle = 'car', side, outline, speed: velocity = speed, ...options } = {}) {\r\n  const { model, lights, side: defaultSide } = vehicles[vehicle];\r\n  side ??= defaultSide;\r\n  layer._init3D({\r\n    tooltip,\r\n    nightLight: Boolean(lights),\r\n    ...options,\r\n  });\r\n  const status = L.DomUtil.create('small', 'traffic-status');\r\n  status.style.cssText = 'display:block;max-width:200px;margin:0 0 4px 20px;color:#555;';\r\n  const template = build(model(0)), stride = template.position.length, vertices = stride / 3;\r\n  const params = new ArrayBuffer(16), paramFloats = new Float32Array(params), paramInts = new Uint32Array(params);\r\n  const state = {\r\n    layer, url, model, lights, side, outline, velocity, status, template, stride, vertices,\r\n    params, paramFloats, paramInts,\r\n    ready: false, frame: undefined, request: undefined, lanes: [], tripsKey: undefined,\r\n    mesh: undefined, route: undefined, litAt: -Infinity,\r\n    trips: [], rebasedAt: 0, nextCheck: -Infinity, elapsed: 0, gpu: null,\r\n    lanesDirty: true, stale: false, loaded: undefined, file: undefined,\r\n  };\r\n  // Lane points are [x, z, ground, cumulative length]. Mirrors along() and place().\r\n  const shader = `\r\n    struct Params { seconds: f32, side: f32, vertices: u32, total: u32 }\r\n    struct Vehicle { start: u32, count: u32, base: f32, speed: f32 }\r\n    @group(0) @binding(0) var<uniform> params: Params;\r\n    @group(0) @binding(1) var<storage, read> model: array<f32>;\r\n    @group(0) @binding(2) var<storage, read> points: array<vec4f>;\r\n    @group(0) @binding(3) var<storage, read> vehicles: array<Vehicle>;\r\n    @group(0) @binding(4) var<storage, read_write> position: array<f32>;\r\n    @group(0) @binding(5) var<storage, read_write> normal: array<f32>;\r\n    @compute @workgroup_size(64)\r\n    fn main(@builtin(global_invocation_id) id: vec3u) {\r\n      let v = id.x;\r\n      if (v >= params.total) { return; }\r\n      let vehicle = vehicles[v / params.vertices];\r\n      let last = vehicle.start + vehicle.count - 1u;\r\n      let length = points[last].w;\r\n      var s = vehicle.base + params.seconds * vehicle.speed;\r\n      s -= length * floor(s / length);\r\n      var i = vehicle.start + 1u;\r\n      while (i < last && points[i].w < s) { i++; }\r\n      let a = points[i - 1u];\r\n      let b = points[i];\r\n      let d = select(b.w - a.w, 1.0, b.w == a.w);\r\n      let t = (s - a.w) / d;\r\n      let dx = (b.x - a.x) / d;\r\n      let dz = (b.y - a.y) / d;\r\n      let cx = a.x + (b.x - a.x) * t - dz * params.side;\r\n      let cz = a.y + (b.y - a.y) * t + dx * params.side;\r\n      let y = a.z + (b.z - a.z) * t;\r\n      let k = (v % params.vertices) * 3u;\r\n      let n = params.vertices * 3u + k;\r\n      let o = v * 3u;\r\n      position[o] = cx - model[k] * dz - model[k + 2u] * dx;\r\n      position[o + 1u] = y + model[k + 1u];\r\n      position[o + 2u] = cz + model[k] * dx - model[k + 2u] * dz;\r\n      normal[o] = -model[n] * dz - model[n + 2u] * dx;\r\n      normal[o + 1u] = model[n + 1u];\r\n      normal[o + 2u] = model[n] * dx - model[n + 2u] * dz;\r\n    }`;\r\n  state.shader = shader;\r\n  state.tick = tickTraffic.bind(null, state);\r\n  state.update = updateTraffic.bind(null, state);\r\n  state.terrain = updateTrafficTerrain.bind(null, state);\r\n  layer._beforeRaycast = placeTraffic.bind(null, state);\r\n  layer.on('ready', readyTraffic.bind(null, state));\r\n  layer.on('add', addTraffic.bind(null, state));\r\n  layer.on('remove', removeTraffic.bind(null, state));\r\n}\r\n"],
+  "mappings": "AAUA,OAAS,SAAAA,MAAa,aACtB,OAAS,WAAAC,MAAe,eACxB,OAAS,SAAAC,MAAa,aACtB,OAAS,YAAAC,MAAgB,gBACzB,OACE,cAAAC,EACA,gBAAAC,EACA,iBAAAC,EACA,gBAAAC,EACA,eAAAC,EACA,iBAAAC,EACA,wBAAAC,MACK,eAEA,SAASC,EAAYC,EAAO,CAAE,IAAAC,EAAK,QAAAC,EAAU,MAAO,KAAAC,EAAM,QAAAC,EAAS,MAAOC,EAAWf,EAAO,GAAGgB,CAAQ,EAAI,CAAC,EAAG,CACpH,KAAM,CAAE,MAAAC,EAAO,OAAAC,EAAQ,KAAMC,CAAY,EAAIlB,EAASW,CAAO,EAC7DC,IAASM,EACTT,EAAM,QAAQ,CACZ,QAAAX,EACA,WAAY,EAAQmB,EACpB,GAAGF,CACL,CAAC,EACD,MAAMI,EAAS,EAAE,QAAQ,OAAO,QAAS,gBAAgB,EACzDA,EAAO,MAAM,QAAU,gEACvB,MAAMC,EAAWvB,EAAMmB,EAAM,CAAC,CAAC,EAAGK,EAASD,EAAS,SAAS,OAAQE,EAAWD,EAAS,EACnFE,EAAS,IAAI,YAAY,EAAE,EAAGC,EAAc,IAAI,aAAaD,CAAM,EAAGE,EAAY,IAAI,YAAYF,CAAM,EACxGG,EAAQ,CACZ,MAAAjB,EAAO,IAAAC,EAAK,MAAAM,EAAO,OAAAC,EAAQ,KAAAL,EAAM,QAAAC,EAAS,SAAAC,EAAU,OAAAK,EAAQ,SAAAC,EAAU,OAAAC,EAAQ,SAAAC,EAC9E,OAAAC,EAAQ,YAAAC,EAAa,UAAAC,EACrB,MAAO,GAAO,MAAO,OAAW,QAAS,OAAW,MAAO,CAAC,EAAG,SAAU,OACzE,KAAM,OAAW,MAAO,OAAW,MAAO,KAC1C,MAAO,CAAC,EAAG,UAAW,EAAG,UAAW,KAAW,QAAS,EAAG,IAAK,KAChE,WAAY,GAAM,MAAO,GAAO,OAAQ,OAAW,KAAM,MAC3D,EAEME,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,OAuCfD,EAAM,OAASC,EACfD,EAAM,KAAOrB,EAAY,KAAK,KAAMqB,CAAK,EACzCA,EAAM,OAASpB,EAAc,KAAK,KAAMoB,CAAK,EAC7CA,EAAM,QAAUnB,EAAqB,KAAK,KAAMmB,CAAK,EACrDjB,EAAM,eAAiBP,EAAa,KAAK,KAAMwB,CAAK,EACpDjB,EAAM,GAAG,QAASL,EAAa,KAAK,KAAMsB,CAAK,CAAC,EAChDjB,EAAM,GAAG,MAAOR,EAAW,KAAK,KAAMyB,CAAK,CAAC,EAC5CjB,EAAM,GAAG,SAAUN,EAAc,KAAK,KAAMuB,CAAK,CAAC,CACpD",
+  "names": ["build", "tooltip", "speed", "vehicles", "addTraffic", "placeTraffic", "removeTraffic", "readyTraffic", "tickTraffic", "updateTraffic", "updateTrafficTerrain", "initTraffic", "layer", "url", "vehicle", "side", "outline", "velocity", "options", "model", "lights", "defaultSide", "status", "template", "stride", "vertices", "params", "paramFloats", "paramInts", "state", "shader"]
+}

package/dist/utils/initWalk.js

@@ -0,0 +1,2 @@
+import{controlOnAdd as b,onBlur as p,onKey as u,onLayerAdd as g,onLayerRemove as f,onPointer as m,onReady as x,onTerrain as y,start as h,step as k,stop as A,toggle as v}from"./walk.js";function D(e,{speed:r=70,distance:a=20,position:l="bottomright",...s}={}){e._init3D(s);const c=new Set,d=new L.Control({position:l}),o=L.DomUtil.create("div","leaflet-bar leaflet-control");o.style.cssText="display:flex;align-items:center;background:#fff;";const t=L.DomUtil.create("button","",o);t.type="button",t.title="Walk",t.setAttribute("aria-label","Walk"),t.setAttribute("aria-pressed","false"),t.textContent="\u{1F6B6}",t.style.cssText="width:30px;height:30px;padding:0;border:0;border-radius:4px;background:#fff;font-size:18px;line-height:30px;cursor:pointer;";const i=L.DomUtil.create("small","",o);i.style.cssText="display:none;padding:0 8px;color:#333;white-space:nowrap;",i.textContent="W/S: run \xB7 A/D: turn \xB7 drag: look around \xB7 Esc: exit",L.DomEvent.disableClickPropagation(o);const n={layer:e,speed:r,distance:a,keys:c,control:d,container:o,button:t,hint:i,meshes:null,frame:null,last:void 0,swing:0,saved:null,drag:null,ready:!1,state:e.walker={latlng:null,heading:0,phase:0}};n.step=k.bind(n),n.onKey=u.bind(n),n.onBlur=p.bind(n),n.onPointer=m.bind(n),n.onTerrain=y.bind(n),n.start=h.bind(n),n.stop=A.bind(n),n.toggle=v.bind(n),n.controlOnAdd=b.bind(n),n.onReady=x.bind(n),n.onLayerAdd=g.bind(n),n.onLayerRemove=f.bind(n),d.onAdd=n.controlOnAdd,L.DomEvent.on(t,"click",n.toggle),e.on("ready",n.onReady),e.on("add",n.onLayerAdd),e.on("remove",n.onLayerRemove)}export{D as initWalk};
+//# sourceMappingURL=initWalk.js.map

package/dist/utils/initWalk.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/initWalk.js"],
+  "sourcesContent": ["import {\r\n  controlOnAdd, onBlur, onKey, onLayerAdd, onLayerRemove, onPointer, onReady, onTerrain, start, step, stop, toggle\r\n} from './walk.js';\r\n\r\n/**\r\n * Third-person walk mode, toggled by a map button (and Esc): a pedestrian at the map centre runs with W/S (or \u2191/\u2193) and\r\n * turns with A/D (or \u2190/\u2192); the camera swings back behind it while it moves. Dragging the map only turns the camera\r\n * (bearing, pitch); the wheel changes the camera distance.\r\n * The walker follows the terrain, bridges included, and `layer.walker` exposes `{ latlng, heading, phase }`.\r\n * Source options: `speed` (m/s, default 6), `distance` (camera distance in metres, default 20), `position` (button corner, default 'topleft').\r\n * Visible meshes of the other 3D layers (buildings, trees, models, streetlights) are solid; terrain and traffic are not.\r\n */\r\nexport function initWalk(layer, {\r\n  speed = 70,\r\n  distance = 20,\r\n  position = 'bottomright',\r\n  ...options\r\n} = {}) {\r\n  layer._init3D(options);\r\n  const keys = new Set();\r\n  const control = new L.Control({ position });\r\n  const container = L.DomUtil.create('div', 'leaflet-bar leaflet-control');\r\n  container.style.cssText = 'display:flex;align-items:center;background:#fff;';\r\n  const button = L.DomUtil.create('button', '', container);\r\n  button.type = 'button';\r\n  button.title = 'Walk';\r\n  button.setAttribute('aria-label', 'Walk');\r\n  button.setAttribute('aria-pressed', 'false');\r\n  button.textContent = '\uD83D\uDEB6';\r\n  button.style.cssText = 'width:30px;height:30px;padding:0;border:0;border-radius:4px;background:#fff;font-size:18px;line-height:30px;cursor:pointer;';\r\n  const hint = L.DomUtil.create('small', '', container);\r\n  hint.style.cssText = 'display:none;padding:0 8px;color:#333;white-space:nowrap;';\r\n  hint.textContent = 'W/S: run \u00B7 A/D: turn \u00B7 drag: look around \u00B7 Esc: exit';\r\n  L.DomEvent.disableClickPropagation(container);\r\n\r\n  const context = {\r\n    layer,\r\n    speed,\r\n    distance,\r\n    keys,\r\n    control,\r\n    container,\r\n    button,\r\n    hint,\r\n    meshes: null,\r\n    frame: null,\r\n    last: undefined,\r\n    swing: 0,\r\n    saved: null,\r\n    drag: null,\r\n    ready: false,\r\n    state: layer.walker = { latlng: null, heading: 0, phase: 0 }\r\n  }\r\n  context.step = step.bind(context);\r\n  context.onKey = onKey.bind(context);\r\n  context.onBlur = onBlur.bind(context);\r\n  context.onPointer = onPointer.bind(context);\r\n  context.onTerrain = onTerrain.bind(context);\r\n  context.start = start.bind(context);\r\n  context.stop = stop.bind(context);\r\n  context.toggle = toggle.bind(context);\r\n  context.controlOnAdd = controlOnAdd.bind(context);\r\n  context.onReady = onReady.bind(context);\r\n  context.onLayerAdd = onLayerAdd.bind(context);\r\n  context.onLayerRemove = onLayerRemove.bind(context);\r\n\r\n  control.onAdd = context.controlOnAdd;\r\n  L.DomEvent.on(button, 'click', context.toggle);\r\n  layer.on('ready', context.onReady);\r\n  layer.on('add', context.onLayerAdd);\r\n  layer.on('remove', context.onLayerRemove);\r\n};\r\n"],
+  "mappings": "AAAA,OACE,gBAAAA,EAAc,UAAAC,EAAQ,SAAAC,EAAO,cAAAC,EAAY,iBAAAC,EAAe,aAAAC,EAAW,WAAAC,EAAS,aAAAC,EAAW,SAAAC,EAAO,QAAAC,EAAM,QAAAC,EAAM,UAAAC,MACrG,YAUA,SAASC,EAASC,EAAO,CAC9B,MAAAC,EAAQ,GACR,SAAAC,EAAW,GACX,SAAAC,EAAW,cACX,GAAGC,CACL,EAAI,CAAC,EAAG,CACNJ,EAAM,QAAQI,CAAO,EACrB,MAAMC,EAAO,IAAI,IACXC,EAAU,IAAI,EAAE,QAAQ,CAAE,SAAAH,CAAS,CAAC,EACpCI,EAAY,EAAE,QAAQ,OAAO,MAAO,6BAA6B,EACvEA,EAAU,MAAM,QAAU,mDAC1B,MAAMC,EAAS,EAAE,QAAQ,OAAO,SAAU,GAAID,CAAS,EACvDC,EAAO,KAAO,SACdA,EAAO,MAAQ,OACfA,EAAO,aAAa,aAAc,MAAM,EACxCA,EAAO,aAAa,eAAgB,OAAO,EAC3CA,EAAO,YAAc,YACrBA,EAAO,MAAM,QAAU,8HACvB,MAAMC,EAAO,EAAE,QAAQ,OAAO,QAAS,GAAIF,CAAS,EACpDE,EAAK,MAAM,QAAU,4DACrBA,EAAK,YAAc,gEACnB,EAAE,SAAS,wBAAwBF,CAAS,EAE5C,MAAMG,EAAU,CACd,MAAAV,EACA,MAAAC,EACA,SAAAC,EACA,KAAAG,EACA,QAAAC,EACA,UAAAC,EACA,OAAAC,EACA,KAAAC,EACA,OAAQ,KACR,MAAO,KACP,KAAM,OACN,MAAO,EACP,MAAO,KACP,KAAM,KACN,MAAO,GACP,MAAOT,EAAM,OAAS,CAAE,OAAQ,KAAM,QAAS,EAAG,MAAO,CAAE,CAC7D,EACAU,EAAQ,KAAOd,EAAK,KAAKc,CAAO,EAChCA,EAAQ,MAAQrB,EAAM,KAAKqB,CAAO,EAClCA,EAAQ,OAAStB,EAAO,KAAKsB,CAAO,EACpCA,EAAQ,UAAYlB,EAAU,KAAKkB,CAAO,EAC1CA,EAAQ,UAAYhB,EAAU,KAAKgB,CAAO,EAC1CA,EAAQ,MAAQf,EAAM,KAAKe,CAAO,EAClCA,EAAQ,KAAOb,EAAK,KAAKa,CAAO,EAChCA,EAAQ,OAASZ,EAAO,KAAKY,CAAO,EACpCA,EAAQ,aAAevB,EAAa,KAAKuB,CAAO,EAChDA,EAAQ,QAAUjB,EAAQ,KAAKiB,CAAO,EACtCA,EAAQ,WAAapB,EAAW,KAAKoB,CAAO,EAC5CA,EAAQ,cAAgBnB,EAAc,KAAKmB,CAAO,EAElDJ,EAAQ,MAAQI,EAAQ,aACxB,EAAE,SAAS,GAAGF,EAAQ,QAASE,EAAQ,MAAM,EAC7CV,EAAM,GAAG,QAASU,EAAQ,OAAO,EACjCV,EAAM,GAAG,MAAOU,EAAQ,UAAU,EAClCV,EAAM,GAAG,SAAUU,EAAQ,aAAa,CAC1C",
+  "names": ["controlOnAdd", "onBlur", "onKey", "onLayerAdd", "onLayerRemove", "onPointer", "onReady", "onTerrain", "start", "step", "stop", "toggle", "initWalk", "layer", "speed", "distance", "position", "options", "keys", "control", "container", "button", "hint", "context"]
+}

package/dist/utils/intersectMeshes.js

@@ -0,0 +1,2 @@
+import{computeBounds as H}from"./computeBounds.js";const q=(n,e)=>n.map((w,u)=>w-e[u]),G=(n,e)=>[n[1]*e[2]-n[2]*e[1],n[2]*e[0]-n[0]*e[2],n[0]*e[1]-n[1]*e[0]],I=(n,e)=>n.reduce((w,u,r)=>w+u*e[r],0);function Q(n,e,w=0){const u=[],r=[0,0,0],v=[0,0,0],D=[0,0,0];for(const o of e){const y=new DOMMatrix(o.worldMatrix).inverse();if(![...y.toFloat64Array()].every(Number.isFinite))throw new Error("Singular 3D transform");const m=new DOMPoint(...n.origin,1).matrixTransform(y),c=[m.x/m.w,m.y/m.w,m.z/m.w],P=new DOMPoint(...n.direction,0).matrixTransform(y),a=[P.x,P.y,P.z],F=Math.hypot(...a)||1;a[0]/=F,a[1]/=F,a[2]/=F,o.geometry.bounds||H(o.geometry);let T=0,z=1/0;for(let t=0;t<3;t++)if(Math.abs(a[t])<1e-12){if(c[t]<o.geometry.bounds.min[t]||c[t]>o.geometry.bounds.max[t]){z=-1/0;break}}else{const l=(o.geometry.bounds.min[t]-c[t])/a[t],g=(o.geometry.bounds.max[t]-c[t])/a[t];T=Math.max(T,Math.min(l,g)),z=Math.min(z,Math.max(l,g))}if(z<T)continue;const{position:i,index:s}=o.geometry.attributes;let p=1/0,L;for(let t=0;t<(s?.count||i.count);t+=3){const l=(s?s.data[t]:t)*i.size,g=(s?s.data[t+1]:t+1)*i.size,V=(s?s.data[t+2]:t+2)*i.size;r[0]=i.data[l],r[1]=i.data[l+1],r[2]=i.data[l+2],v[0]=i.data[g],v[1]=i.data[g+1],v[2]=i.data[g+2],D[0]=i.data[V],D[1]=i.data[V+1],D[2]=i.data[V+2];const A=q(v,r),B=q(D,r),E=G(a,B),b=I(A,E);if(o.program.cullMode==="none"||o.program.cullFace===null?Math.abs(b)<1e-9:b<1e-9)continue;const N=q(c,r),d=I(N,E)/b;if(d<0||d>1)continue;const S=G(N,A),M=I(a,S)/b;if(M<0||d+M>1)continue;if(o.program.nightLight){const h=o.geometry.attributes.uv.data,x=s?[s.data[t],s.data[t+1],s.data[t+2]]:[t,t+1,t+2],k=h[x[0]*2]*(1-d-M)+h[x[1]*2]*d+h[x[2]*2]*M,C=h[x[0]*2+1]*(1-d-M)+h[x[1]*2+1]*d+h[x[2]*2+1]*M;if(k<=2&&(!w||k*k+C*C>.9))continue}const j=I(B,S)/b;j>0&&j<p&&(p=j,L=t/3)}if(L===void 0)continue;const f=new DOMPoint(a[0]*p+c[0],a[1]*p+c[1],a[2]*p+c[2],1).matrixTransform(new DOMMatrix(o.worldMatrix)),O=[f.x/f.w,f.y/f.w,f.z/f.w];u.push({faceIndex:L,object:o,point:O,distance:Math.hypot(O[0]-n.origin[0],O[1]-n.origin[1],O[2]-n.origin[2])})}return u.sort((o,y)=>o.distance-y.distance)}export{Q as intersectMeshes};
+//# sourceMappingURL=intersectMeshes.js.map

package/dist/utils/intersectMeshes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/intersectMeshes.js"],
+  "sourcesContent": ["import { computeBounds } from \"./computeBounds.js\";\n\nconst sub = (a, b) => a.map((v, i) => v - b[i]);\nconst cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];\nconst dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);\n\n/** Nearest triangle hit per mesh, sorted by world-space distance. */\n\nexport function intersectMeshes(ray, meshes, night = 0) {\n  const hits = [],\n  a = [0, 0, 0],\n  b = [0, 0, 0],\n  c = [0, 0, 0];\n  for (const mesh of meshes) {\n    // Test in mesh-local space; compare distances only after returning to shared world space.\n    const inverse = new DOMMatrix(mesh.worldMatrix).inverse();\n    const inverseValues = inverse.toFloat64Array();\n    if (![...inverseValues].every(Number.isFinite)) {\n      throw new Error('Singular 3D transform');\n    }\n    const localOrigin = new DOMPoint(...ray.origin, 1).matrixTransform(inverse);\n    const origin = [\n      localOrigin.x / localOrigin.w,\n      localOrigin.y / localOrigin.w,\n      localOrigin.z / localOrigin.w\n    ];\n    const localDirection = new DOMPoint(...ray.direction, 0).matrixTransform(inverse);\n    const direction = [\n      localDirection.x,\n      localDirection.y,\n      localDirection.z\n    ];\n    const directionLength = Math.hypot(...direction) || 1;\n    direction[0] /= directionLength;\n    direction[1] /= directionLength;\n    direction[2] /= directionLength;\n    // AABB slab test reuses the same local ray as the triangle test.\n    if (!mesh.geometry.bounds) {\n      computeBounds(mesh.geometry);\n    }\n    let near = 0, far = Infinity;\n    for (let i = 0; i < 3; i++) {\n      if (Math.abs(direction[i]) < 1e-12) {\n        if (origin[i] < mesh.geometry.bounds.min[i] || origin[i] > mesh.geometry.bounds.max[i]) {\n          far = -Infinity;\n          break;\n        }\n      } else {\n        const a = (mesh.geometry.bounds.min[i] - origin[i]) / direction[i], b = (mesh.geometry.bounds.max[i] - origin[i]) / direction[i];\n        near = Math.max(near, Math.min(a, b));\n        far = Math.min(far, Math.max(a, b));\n      }\n    }\n    if (far < near) {\n      continue;\n    }\n    const { position, index } = mesh.geometry.attributes;\n    let closest = Infinity, faceIndex;\n    for (let i = 0; i < (index?.count || position.count); i += 3) {\n      const ai = (index ? index.data[i] : i) * position.size;\n      const bi = (index ? index.data[i + 1] : i + 1) * position.size;\n      const ci = (index ? index.data[i + 2] : i + 2) * position.size;\n      a[0] = position.data[ai];\n      a[1] = position.data[ai + 1];\n      a[2] = position.data[ai + 2];\n      b[0] = position.data[bi];\n      b[1] = position.data[bi + 1];\n      b[2] = position.data[bi + 2];\n      c[0] = position.data[ci];\n      c[1] = position.data[ci + 1];\n      c[2] = position.data[ci + 2];\n      // Moller-Trumbore: barycentric triangle coordinates and local ray distance.\n      const e = sub(b, a),\n            f = sub(c, a),\n            p = cross(direction, f),\n            det = dot(e, p);\n      if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null\n        ? Math.abs(det) < 1e-9 : det < 1e-9) {\n        continue;\n      }\n      const t = sub(origin, a), u = dot(t, p) / det;\n      if (u < 0 || u > 1) {\n        continue;\n      }\n      const q = cross(t, e), v = dot(direction, q) / det;\n      if (v < 0 || u + v > 1) {\n        continue;\n      }\n      if (mesh.program.nightLight) {\n        const uv = mesh.geometry.attributes.uv.data;\n        const ids = index ? [index.data[i], index.data[i + 1], index.data[i + 2]] : [i, i + 1, i + 2];\n        const x = uv[ids[0] * 2] * (1 - u - v) + uv[ids[1] * 2] * u + uv[ids[2] * 2] * v;\n        const y = uv[ids[0] * 2 + 1] * (1 - u - v) + uv[ids[1] * 2 + 1] * u + uv[ids[2] * 2 + 1] * v;\n        if (x <= 2 && (!night || x * x + y * y > 0.9)) continue;\n      }\n      const distance = dot(f, q) / det;\n      if (distance > 0 && distance < closest) {\n        closest = distance; faceIndex = i / 3;\n      }\n    }\n    if (faceIndex === undefined) continue;\n    const point = new DOMPoint(\n      direction[0] * closest + origin[0],\n      direction[1] * closest + origin[1],\n      direction[2] * closest + origin[2],\n      1\n    ).matrixTransform(new DOMMatrix(mesh.worldMatrix));\n    const worldPoint = [point.x / point.w, point.y / point.w, point.z / point.w];\n    hits.push({\n      faceIndex,\n      object: mesh,\n      point: worldPoint,\n      distance: Math.hypot(\n        worldPoint[0] - ray.origin[0],\n        worldPoint[1] - ray.origin[1],\n        worldPoint[2] - ray.origin[2]\n      )\n    });\n  }\n  return hits.sort((a, b) => a.distance - b.distance);\n}\n"],
+  "mappings": "AAAA,OAAS,iBAAAA,MAAqB,qBAE9B,MAAMC,EAAM,CAACC,EAAGC,IAAMD,EAAE,IAAI,CAACE,EAAGC,IAAMD,EAAID,EAAEE,CAAC,CAAC,EACxCC,EAAQ,CAACJ,EAAGC,IAAM,CAACD,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAGD,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAGD,EAAE,CAAC,EAAIC,EAAE,CAAC,EAAID,EAAE,CAAC,EAAIC,EAAE,CAAC,CAAC,EAClGI,EAAM,CAACL,EAAGC,IAAMD,EAAE,OAAO,CAACM,EAAKJ,EAAGC,IAAMG,EAAMJ,EAAID,EAAEE,CAAC,EAAG,CAAC,EAIxD,SAASI,EAAgBC,EAAKC,EAAQC,EAAQ,EAAG,CACtD,MAAMC,EAAO,CAAC,EACdX,EAAI,CAAC,EAAG,EAAG,CAAC,EACZC,EAAI,CAAC,EAAG,EAAG,CAAC,EACZW,EAAI,CAAC,EAAG,EAAG,CAAC,EACZ,UAAWC,KAAQJ,EAAQ,CAEzB,MAAMK,EAAU,IAAI,UAAUD,EAAK,WAAW,EAAE,QAAQ,EAExD,GAAI,CAAC,CAAC,GADgBC,EAAQ,eAAe,CACvB,EAAE,MAAM,OAAO,QAAQ,EAC3C,MAAM,IAAI,MAAM,uBAAuB,EAEzC,MAAMC,EAAc,IAAI,SAAS,GAAGP,EAAI,OAAQ,CAAC,EAAE,gBAAgBM,CAAO,EACpEE,EAAS,CACbD,EAAY,EAAIA,EAAY,EAC5BA,EAAY,EAAIA,EAAY,EAC5BA,EAAY,EAAIA,EAAY,CAC9B,EACME,EAAiB,IAAI,SAAS,GAAGT,EAAI,UAAW,CAAC,EAAE,gBAAgBM,CAAO,EAC1EI,EAAY,CAChBD,EAAe,EACfA,EAAe,EACfA,EAAe,CACjB,EACME,EAAkB,KAAK,MAAM,GAAGD,CAAS,GAAK,EACpDA,EAAU,CAAC,GAAKC,EAChBD,EAAU,CAAC,GAAKC,EAChBD,EAAU,CAAC,GAAKC,EAEXN,EAAK,SAAS,QACjBf,EAAce,EAAK,QAAQ,EAE7B,IAAIO,EAAO,EAAGC,EAAM,IACpB,QAASlB,EAAI,EAAGA,EAAI,EAAGA,IACrB,GAAI,KAAK,IAAIe,EAAUf,CAAC,CAAC,EAAI,OAC3B,GAAIa,EAAOb,CAAC,EAAIU,EAAK,SAAS,OAAO,IAAIV,CAAC,GAAKa,EAAOb,CAAC,EAAIU,EAAK,SAAS,OAAO,IAAIV,CAAC,EAAG,CACtFkB,EAAM,KACN,KACF,MACK,CACL,MAAMrB,GAAKa,EAAK,SAAS,OAAO,IAAIV,CAAC,EAAIa,EAAOb,CAAC,GAAKe,EAAUf,CAAC,EAAGF,GAAKY,EAAK,SAAS,OAAO,IAAIV,CAAC,EAAIa,EAAOb,CAAC,GAAKe,EAAUf,CAAC,EAC/HiB,EAAO,KAAK,IAAIA,EAAM,KAAK,IAAIpB,EAAGC,CAAC,CAAC,EACpCoB,EAAM,KAAK,IAAIA,EAAK,KAAK,IAAIrB,EAAGC,CAAC,CAAC,CACpC,CAEF,GAAIoB,EAAMD,EACR,SAEF,KAAM,CAAE,SAAAE,EAAU,MAAAC,CAAM,EAAIV,EAAK,SAAS,WAC1C,IAAIW,EAAU,IAAUC,EACxB,QAAStB,EAAI,EAAGA,GAAKoB,GAAO,OAASD,EAAS,OAAQnB,GAAK,EAAG,CAC5D,MAAMuB,GAAMH,EAAQA,EAAM,KAAKpB,CAAC,EAAIA,GAAKmB,EAAS,KAC5CK,GAAMJ,EAAQA,EAAM,KAAKpB,EAAI,CAAC,EAAIA,EAAI,GAAKmB,EAAS,KACpDM,GAAML,EAAQA,EAAM,KAAKpB,EAAI,CAAC,EAAIA,EAAI,GAAKmB,EAAS,KAC1DtB,EAAE,CAAC,EAAIsB,EAAS,KAAKI,CAAE,EACvB1B,EAAE,CAAC,EAAIsB,EAAS,KAAKI,EAAK,CAAC,EAC3B1B,EAAE,CAAC,EAAIsB,EAAS,KAAKI,EAAK,CAAC,EAC3BzB,EAAE,CAAC,EAAIqB,EAAS,KAAKK,CAAE,EACvB1B,EAAE,CAAC,EAAIqB,EAAS,KAAKK,EAAK,CAAC,EAC3B1B,EAAE,CAAC,EAAIqB,EAAS,KAAKK,EAAK,CAAC,EAC3Bf,EAAE,CAAC,EAAIU,EAAS,KAAKM,CAAE,EACvBhB,EAAE,CAAC,EAAIU,EAAS,KAAKM,EAAK,CAAC,EAC3BhB,EAAE,CAAC,EAAIU,EAAS,KAAKM,EAAK,CAAC,EAE3B,MAAMC,EAAI9B,EAAIE,EAAGD,CAAC,EACZ8B,EAAI/B,EAAIa,EAAGZ,CAAC,EACZ+B,EAAI3B,EAAMc,EAAWY,CAAC,EACtBE,EAAM3B,EAAIwB,EAAGE,CAAC,EACpB,GAAIlB,EAAK,QAAQ,WAAa,QAAUA,EAAK,QAAQ,WAAa,KAC9D,KAAK,IAAImB,CAAG,EAAI,KAAOA,EAAM,KAC/B,SAEF,MAAMC,EAAIlC,EAAIiB,EAAQhB,CAAC,EAAGkC,EAAI7B,EAAI4B,EAAGF,CAAC,EAAIC,EAC1C,GAAIE,EAAI,GAAKA,EAAI,EACf,SAEF,MAAMC,EAAI/B,EAAM6B,EAAGJ,CAAC,EAAG3B,EAAIG,EAAIa,EAAWiB,CAAC,EAAIH,EAC/C,GAAI9B,EAAI,GAAKgC,EAAIhC,EAAI,EACnB,SAEF,GAAIW,EAAK,QAAQ,WAAY,CAC3B,MAAMuB,EAAKvB,EAAK,SAAS,WAAW,GAAG,KACjCwB,EAAMd,EAAQ,CAACA,EAAM,KAAKpB,CAAC,EAAGoB,EAAM,KAAKpB,EAAI,CAAC,EAAGoB,EAAM,KAAKpB,EAAI,CAAC,CAAC,EAAI,CAACA,EAAGA,EAAI,EAAGA,EAAI,CAAC,EACtFmC,EAAIF,EAAGC,EAAI,CAAC,EAAI,CAAC,GAAK,EAAIH,EAAIhC,GAAKkC,EAAGC,EAAI,CAAC,EAAI,CAAC,EAAIH,EAAIE,EAAGC,EAAI,CAAC,EAAI,CAAC,EAAInC,EACzEqC,EAAIH,EAAGC,EAAI,CAAC,EAAI,EAAI,CAAC,GAAK,EAAIH,EAAIhC,GAAKkC,EAAGC,EAAI,CAAC,EAAI,EAAI,CAAC,EAAIH,EAAIE,EAAGC,EAAI,CAAC,EAAI,EAAI,CAAC,EAAInC,EAC3F,GAAIoC,GAAK,IAAM,CAAC5B,GAAS4B,EAAIA,EAAIC,EAAIA,EAAI,IAAM,QACjD,CACA,MAAMC,EAAWnC,EAAIyB,EAAGK,CAAC,EAAIH,EACzBQ,EAAW,GAAKA,EAAWhB,IAC7BA,EAAUgB,EAAUf,EAAYtB,EAAI,EAExC,CACA,GAAIsB,IAAc,OAAW,SAC7B,MAAMgB,EAAQ,IAAI,SAChBvB,EAAU,CAAC,EAAIM,EAAUR,EAAO,CAAC,EACjCE,EAAU,CAAC,EAAIM,EAAUR,EAAO,CAAC,EACjCE,EAAU,CAAC,EAAIM,EAAUR,EAAO,CAAC,EACjC,CACF,EAAE,gBAAgB,IAAI,UAAUH,EAAK,WAAW,CAAC,EAC3C6B,EAAa,CAACD,EAAM,EAAIA,EAAM,EAAGA,EAAM,EAAIA,EAAM,EAAGA,EAAM,EAAIA,EAAM,CAAC,EAC3E9B,EAAK,KAAK,CACR,UAAAc,EACA,OAAQZ,EACR,MAAO6B,EACP,SAAU,KAAK,MACbA,EAAW,CAAC,EAAIlC,EAAI,OAAO,CAAC,EAC5BkC,EAAW,CAAC,EAAIlC,EAAI,OAAO,CAAC,EAC5BkC,EAAW,CAAC,EAAIlC,EAAI,OAAO,CAAC,CAC9B,CACF,CAAC,CACH,CACA,OAAOG,EAAK,KAAK,CAACX,EAAGC,IAAMD,EAAE,SAAWC,EAAE,QAAQ,CACpD",
+  "names": ["computeBounds", "sub", "a", "b", "v", "i", "cross", "dot", "sum", "intersectMeshes", "ray", "meshes", "night", "hits", "c", "mesh", "inverse", "localOrigin", "origin", "localDirection", "direction", "directionLength", "near", "far", "position", "index", "closest", "faceIndex", "ai", "bi", "ci", "e", "f", "p", "det", "t", "u", "q", "uv", "ids", "x", "y", "distance", "point", "worldPoint"]
+}

package/dist/utils/isClockWise.js

@@ -0,0 +1,2 @@
+function c(e){let r=0;for(let l=0;l<e.length;l++){const t=e[l],a=e[(l+1)%e.length];r+=t.x*a.y-a.x*t.y}return r<0}export{c as isClockWise};
+//# sourceMappingURL=isClockWise.js.map

package/dist/utils/isClockWise.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/isClockWise.js"],
+  "sourcesContent": ["/**\n * @returns {boolean} Whether the `{x, y}` points are in clockwise order.\n */\n\nexport function isClockWise(points) {\n  let area = 0;\n  for (let i = 0; i < points.length; i++) {\n    const a = points[i], b = points[(i + 1) % points.length];\n    area += a.x * b.y - b.x * a.y;\n  }\n  return area < 0;\n}\n"],
+  "mappings": "AAIO,SAASA,EAAYC,EAAQ,CAClC,IAAIC,EAAO,EACX,QAASC,EAAI,EAAGA,EAAIF,EAAO,OAAQE,IAAK,CACtC,MAAMC,EAAIH,EAAOE,CAAC,EAAGE,EAAIJ,GAAQE,EAAI,GAAKF,EAAO,MAAM,EACvDC,GAAQE,EAAE,EAAIC,EAAE,EAAIA,EAAE,EAAID,EAAE,CAC9B,CACA,OAAOF,EAAO,CAChB",
+  "names": ["isClockWise", "points", "area", "i", "a", "b"]
+}

package/dist/utils/lampPostGeometry.js

@@ -0,0 +1,2 @@
+import{parseColor as I}from"./parseColor.js";function g(a,c,h){const i=I(5264986),u=c.poleRadius;if(!Number.isFinite(u)||u<=0)throw new Error("Invalid lamp pole radius");const x=e=>Array.from({length:6},(t,o)=>({x:a.x+Math.cos(o*Math.PI/3)*e,y:a.y+Math.sin(o*Math.PI/3)*e,ground:a.ground,uv:[3,3]})),p={...a,uv:[3,3]};for(const[e,t,o]of[[u,0,c.top],[u*2.5,c.top-.25,c.top+.15]]){const f=x(e);for(let r=0;r<6;r++){const n=f[r],s=f[(r+1)%6],m=(r+.5)*Math.PI/3,M=Math.cos(m),l=-Math.sin(m);h(n,t,s,t,s,o,M,0,l,i),h(n,t,s,o,n,o,M,0,l,i),h(p,o,n,o,s,o,0,1,0,i),h(p,t,s,t,n,t,0,-1,0,i)}}}export{g as lampPostGeometry};
+//# sourceMappingURL=lampPostGeometry.js.map

package/dist/utils/lampPostGeometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/lampPostGeometry.js"],
+  "sourcesContent": ["import { parseColor } from \"./parseColor.js\";\n\n/** Schematic support and lamp head; wall-mounted fixtures do not get an invented pole. */\n\nexport function lampPostGeometry(point, style, addTriangle) {\n  const color = parseColor(0x50565a), radius = style.poleRadius;\n  if (!Number.isFinite(radius) || radius <= 0) {\n    throw new Error('Invalid lamp pole radius');\n  }\n  const ring = r => Array.from({ length: 6 }, (_, i) => ({\n    x: point.x + Math.cos(i * Math.PI / 3) * r,\n    y: point.y + Math.sin(i * Math.PI / 3) * r, ground: point.ground, uv: [3, 3],\n  }));\n  const center = { ...point, uv: [3, 3] };\n  for (const [r, low, high] of [[radius, 0, style.top], [radius * 2.5, style.top - 0.25, style.top + 0.15]]) {\n    const points = ring(r);\n    for (let i = 0; i < 6; i++) {\n      const a = points[i], b = points[(i + 1) % 6], angle = (i + 0.5) * Math.PI / 3;\n      const nx = Math.cos(angle), nz = -Math.sin(angle);\n      addTriangle(a, low, b, low, b, high, nx, 0, nz, color);\n      addTriangle(a, low, b, high, a, high, nx, 0, nz, color);\n      addTriangle(center, high, a, high, b, high, 0, 1, 0, color);\n      addTriangle(center, low, b, low, a, low, 0, -1, 0, color);\n    }\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,cAAAA,MAAkB,kBAIpB,SAASC,EAAiBC,EAAOC,EAAOC,EAAa,CAC1D,MAAMC,EAAQL,EAAW,OAAQ,EAAGM,EAASH,EAAM,WACnD,GAAI,CAAC,OAAO,SAASG,CAAM,GAAKA,GAAU,EACxC,MAAM,IAAI,MAAM,0BAA0B,EAE5C,MAAMC,EAAOC,GAAK,MAAM,KAAK,CAAE,OAAQ,CAAE,EAAG,CAACC,EAAGC,KAAO,CACrD,EAAGR,EAAM,EAAI,KAAK,IAAIQ,EAAI,KAAK,GAAK,CAAC,EAAIF,EACzC,EAAGN,EAAM,EAAI,KAAK,IAAIQ,EAAI,KAAK,GAAK,CAAC,EAAIF,EAAG,OAAQN,EAAM,OAAQ,GAAI,CAAC,EAAG,CAAC,CAC7E,EAAE,EACIS,EAAS,CAAE,GAAGT,EAAO,GAAI,CAAC,EAAG,CAAC,CAAE,EACtC,SAAW,CAACM,EAAGI,EAAKC,CAAI,GAAK,CAAC,CAACP,EAAQ,EAAGH,EAAM,GAAG,EAAG,CAACG,EAAS,IAAKH,EAAM,IAAM,IAAMA,EAAM,IAAM,GAAI,CAAC,EAAG,CACzG,MAAMW,EAASP,EAAKC,CAAC,EACrB,QAASE,EAAI,EAAGA,EAAI,EAAGA,IAAK,CAC1B,MAAMK,EAAID,EAAOJ,CAAC,EAAGM,EAAIF,GAAQJ,EAAI,GAAK,CAAC,EAAGO,GAASP,EAAI,IAAO,KAAK,GAAK,EACtEQ,EAAK,KAAK,IAAID,CAAK,EAAGE,EAAK,CAAC,KAAK,IAAIF,CAAK,EAChDb,EAAYW,EAAGH,EAAKI,EAAGJ,EAAKI,EAAGH,EAAMK,EAAI,EAAGC,EAAId,CAAK,EACrDD,EAAYW,EAAGH,EAAKI,EAAGH,EAAME,EAAGF,EAAMK,EAAI,EAAGC,EAAId,CAAK,EACtDD,EAAYO,EAAQE,EAAME,EAAGF,EAAMG,EAAGH,EAAM,EAAG,EAAG,EAAGR,CAAK,EAC1DD,EAAYO,EAAQC,EAAKI,EAAGJ,EAAKG,EAAGH,EAAK,EAAG,GAAI,EAAGP,CAAK,CAC1D,CACF,CACF",
+  "names": ["parseColor", "lampPostGeometry", "point", "style", "addTriangle", "color", "radius", "ring", "r", "_", "i", "center", "low", "high", "points", "a", "b", "angle", "nx", "nz"]
+}

package/dist/utils/lightGeometry.js

@@ -0,0 +1,2 @@
+import{parseColor as w}from"./parseColor.js";function b(i,u,f){if(!Number.isFinite(u.lightRadius)||u.lightRadius<=0)throw new Error("Invalid light radius");const l=w(u.color),s=(o,n,r,p,t,m)=>{f(o,t,n,t,r,t,...m,l),f(o,t,r,t,p,t,...m,l)},c=.65,d=(o,n,r)=>({x:i.x+(r===2?0:o*c),y:i.y+(r===1?0:r===2?o*c:n*c),ground:i.ground+(r===0?0:n*c),uv:[o,n]});for(let o=0;o<3;o++)s(d(-1,-1,o),d(1,-1,o),d(1,1,o),d(-1,1,o),u.top,o===0?[0,1,0]:o===1?[0,0,1]:[1,0,0])}export{b as lightGeometry};
+//# sourceMappingURL=lightGeometry.js.map

package/dist/utils/lightGeometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/lightGeometry.js"],
+  "sourcesContent": ["import { parseColor } from \"./parseColor.js\";\n\n/** Three crossed emitter discs; illumination itself is evaluated on receiving surfaces. */\n\nexport function lightGeometry(point, style, addTriangle) {\n  if (!Number.isFinite(style.lightRadius) || style.lightRadius <= 0) throw new Error('Invalid light radius');\n  const color = parseColor(style.color);\n  const quad = (a, b, c, d, height, normal) => {\n    addTriangle(a, height, b, height, c, height, ...normal, color);\n    addTriangle(a, height, c, height, d, height, ...normal, color);\n  };\n  const r = 0.65;\n  const emitter = (u, v, axis) => ({\n    x: point.x + (axis === 2 ? 0 : u * r),\n    y: point.y + (axis === 1 ? 0 : axis === 2 ? u * r : v * r),\n    ground: point.ground + (axis === 0 ? 0 : v * r), uv: [u, v],\n  });\n  for (let axis = 0; axis < 3; axis++) {\n    quad(emitter(-1, -1, axis), emitter(1, -1, axis), emitter(1, 1, axis), emitter(-1, 1, axis),\n      style.top, axis === 0 ? [0, 1, 0] : axis === 1 ? [0, 0, 1] : [1, 0, 0]);\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,cAAAA,MAAkB,kBAIpB,SAASC,EAAcC,EAAOC,EAAOC,EAAa,CACvD,GAAI,CAAC,OAAO,SAASD,EAAM,WAAW,GAAKA,EAAM,aAAe,EAAG,MAAM,IAAI,MAAM,sBAAsB,EACzG,MAAME,EAAQL,EAAWG,EAAM,KAAK,EAC9BG,EAAO,CAACC,EAAGC,EAAGC,EAAGC,EAAGC,EAAQC,IAAW,CAC3CR,EAAYG,EAAGI,EAAQH,EAAGG,EAAQF,EAAGE,EAAQ,GAAGC,EAAQP,CAAK,EAC7DD,EAAYG,EAAGI,EAAQF,EAAGE,EAAQD,EAAGC,EAAQ,GAAGC,EAAQP,CAAK,CAC/D,EACMQ,EAAI,IACJC,EAAU,CAACC,EAAGC,EAAGC,KAAU,CAC/B,EAAGf,EAAM,GAAKe,IAAS,EAAI,EAAIF,EAAIF,GACnC,EAAGX,EAAM,GAAKe,IAAS,EAAI,EAAIA,IAAS,EAAIF,EAAIF,EAAIG,EAAIH,GACxD,OAAQX,EAAM,QAAUe,IAAS,EAAI,EAAID,EAAIH,GAAI,GAAI,CAACE,EAAGC,CAAC,CAC5D,GACA,QAASC,EAAO,EAAGA,EAAO,EAAGA,IAC3BX,EAAKQ,EAAQ,GAAI,GAAIG,CAAI,EAAGH,EAAQ,EAAG,GAAIG,CAAI,EAAGH,EAAQ,EAAG,EAAGG,CAAI,EAAGH,EAAQ,GAAI,EAAGG,CAAI,EACxFd,EAAM,IAAKc,IAAS,EAAI,CAAC,EAAG,EAAG,CAAC,EAAIA,IAAS,EAAI,CAAC,EAAG,EAAG,CAAC,EAAI,CAAC,EAAG,EAAG,CAAC,CAAC,CAE5E",
+  "names": ["parseColor", "lightGeometry", "point", "style", "addTriangle", "color", "quad", "a", "b", "c", "d", "height", "normal", "r", "emitter", "u", "v", "axis"]
+}

package/dist/utils/lightGrid.js

@@ -0,0 +1,2 @@
+function F(m,v){const u=m.reduce((i,l)=>i+l.length/8,0),r=32;let a=new Float32Array(8);if(u){let i=1/0,l=1/0,M=-1/0,g=-1/0;for(const t of m)for(let e=0;e<t.length;e+=8)i=Math.min(i,t[e]-t[e+3]),M=Math.max(M,t[e]+t[e+3]),l=Math.min(l,t[e+2]-t[e+3]),g=Math.max(g,t[e+2]+t[e+3]);const f=Math.ceil((M-i)/r)+1,c=Math.ceil((g-l)/r)+1,d=t=>{for(const e of m)for(let o=0;o<e.length;o+=8){const n=e[o+3],h=e[o]-i,U=e[o+2]-l;for(let x=Math.floor((U-n)/r);x<=Math.floor((U+n)/r);x++)for(let w=Math.floor((h-n)/r);w<=Math.floor((h+n)/r);w++)t(x*f+w,e,o)}},s=new Uint32Array(f*c),y=new Uint32Array(f*c);d(t=>s[t]++);const z=s.reduce((t,e)=>t+e,0),A=(2+f*c+z*2)*4;if(A*4>v)throw new Error("Streetlight grid exceeds GPU storage limit");a=new Float32Array(A),a.set([i,l,r,f,c,u,0,0]);let I=2+f*c;for(let t=0;t<s.length;t++)s[t]&&(a[(2+t)*4]=y[t]=I,a[(2+t)*4+1]=s[t],I+=s[t]*2);d((t,e,o)=>{for(let n=0,h=y[t]*4;n<8;n++)a[h+n]=e[o+n];y[t]+=2})}return{data:a,count:u}}export{F as lightGrid};
+//# sourceMappingURL=lightGrid.js.map

package/dist/utils/lightGrid.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/lightGrid.js"],
+  "sourcesContent": ["/** Pack world-space point lights into the shader's spatial grid. */\nexport function lightGrid(packed, maxBytes) {\n  const count = packed.reduce((sum, values) => sum + values.length / 8, 0), cellSize = 32;\n  let data = new Float32Array(8);\n  if (count) {\n    let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;\n    for (const values of packed) for (let i = 0; i < values.length; i += 8) {\n      minX = Math.min(minX, values[i] - values[i + 3]);\n      maxX = Math.max(maxX, values[i] + values[i + 3]);\n      minZ = Math.min(minZ, values[i + 2] - values[i + 3]);\n      maxZ = Math.max(maxZ, values[i + 2] + values[i + 3]);\n    }\n    const columns = Math.ceil((maxX - minX) / cellSize) + 1,\n             rows = Math.ceil((maxZ - minZ) / cellSize) + 1;\n    const each = callback => {\n      for (const values of packed) for (let i = 0; i < values.length; i += 8) {\n        const radius = values[i + 3],\n                   x = values[i] - minX,\n                   z = values[i + 2] - minZ;\n        for (let y = Math.floor((z - radius) / cellSize); y <= Math.floor((z + radius) / cellSize); y++) {\n          for (let c = Math.floor((x - radius) / cellSize); c <= Math.floor((x + radius) / cellSize); c++) {\n            callback(y * columns + c, values, i);\n          }\n        }\n      }\n    };\n    // Counting sort: count the lights of each cell, then fill each cell's slice.\n    const counts = new Uint32Array(columns * rows),\n            next = new Uint32Array(columns * rows);\n    each(key => counts[key]++);\n    const entries = counts.reduce((sum, value) => sum + value, 0);\n    const length = (2 + columns * rows + entries * 2) * 4;\n    if (length * 4 > maxBytes) {\n      throw new Error('Streetlight grid exceeds GPU storage limit');\n    }\n    data = new Float32Array(length);\n    data.set([minX, minZ, cellSize, columns, rows, count, 0, 0]);\n    let offset = 2 + columns * rows;\n    for (let key = 0; key < counts.length; key++) if (counts[key]) {\n      data[(2 + key) * 4] = next[key] = offset;\n      data[(2 + key) * 4 + 1] = counts[key];\n      offset += counts[key] * 2;\n    }\n    each((key, values, i) => {\n      for (let j = 0, o = next[key] * 4; j < 8; j++) data[o + j] = values[i + j];\n      next[key] += 2;\n    });\n  }\n  return { data, count };\n}\n"],
+  "mappings": "AACO,SAASA,EAAUC,EAAQC,EAAU,CAC1C,MAAMC,EAAQF,EAAO,OAAO,CAACG,EAAKC,IAAWD,EAAMC,EAAO,OAAS,EAAG,CAAC,EAAGC,EAAW,GACrF,IAAIC,EAAO,IAAI,aAAa,CAAC,EAC7B,GAAIJ,EAAO,CACT,IAAIK,EAAO,IAAUC,EAAO,IAAUC,EAAO,KAAWC,EAAO,KAC/D,UAAWN,KAAUJ,EAAQ,QAASW,EAAI,EAAGA,EAAIP,EAAO,OAAQO,GAAK,EACnEJ,EAAO,KAAK,IAAIA,EAAMH,EAAOO,CAAC,EAAIP,EAAOO,EAAI,CAAC,CAAC,EAC/CF,EAAO,KAAK,IAAIA,EAAML,EAAOO,CAAC,EAAIP,EAAOO,EAAI,CAAC,CAAC,EAC/CH,EAAO,KAAK,IAAIA,EAAMJ,EAAOO,EAAI,CAAC,EAAIP,EAAOO,EAAI,CAAC,CAAC,EACnDD,EAAO,KAAK,IAAIA,EAAMN,EAAOO,EAAI,CAAC,EAAIP,EAAOO,EAAI,CAAC,CAAC,EAErD,MAAMC,EAAU,KAAK,MAAMH,EAAOF,GAAQF,CAAQ,EAAI,EAC7CQ,EAAO,KAAK,MAAMH,EAAOF,GAAQH,CAAQ,EAAI,EAChDS,EAAOC,GAAY,CACvB,UAAWX,KAAUJ,EAAQ,QAASW,EAAI,EAAGA,EAAIP,EAAO,OAAQO,GAAK,EAAG,CACtE,MAAMK,EAASZ,EAAOO,EAAI,CAAC,EAChBM,EAAIb,EAAOO,CAAC,EAAIJ,EAChBW,EAAId,EAAOO,EAAI,CAAC,EAAIH,EAC/B,QAASW,EAAI,KAAK,OAAOD,EAAIF,GAAUX,CAAQ,EAAGc,GAAK,KAAK,OAAOD,EAAIF,GAAUX,CAAQ,EAAGc,IAC1F,QAASC,EAAI,KAAK,OAAOH,EAAID,GAAUX,CAAQ,EAAGe,GAAK,KAAK,OAAOH,EAAID,GAAUX,CAAQ,EAAGe,IAC1FL,EAASI,EAAIP,EAAUQ,EAAGhB,EAAQO,CAAC,CAGzC,CACF,EAEMU,EAAS,IAAI,YAAYT,EAAUC,CAAI,EACrCS,EAAO,IAAI,YAAYV,EAAUC,CAAI,EAC7CC,EAAKS,GAAOF,EAAOE,CAAG,GAAG,EACzB,MAAMC,EAAUH,EAAO,OAAO,CAAClB,EAAKsB,IAAUtB,EAAMsB,EAAO,CAAC,EACtDC,GAAU,EAAId,EAAUC,EAAOW,EAAU,GAAK,EACpD,GAAIE,EAAS,EAAIzB,EACf,MAAM,IAAI,MAAM,4CAA4C,EAE9DK,EAAO,IAAI,aAAaoB,CAAM,EAC9BpB,EAAK,IAAI,CAACC,EAAMC,EAAMH,EAAUO,EAASC,EAAMX,EAAO,EAAG,CAAC,CAAC,EAC3D,IAAIyB,EAAS,EAAIf,EAAUC,EAC3B,QAASU,EAAM,EAAGA,EAAMF,EAAO,OAAQE,IAAWF,EAAOE,CAAG,IAC1DjB,GAAM,EAAIiB,GAAO,CAAC,EAAID,EAAKC,CAAG,EAAII,EAClCrB,GAAM,EAAIiB,GAAO,EAAI,CAAC,EAAIF,EAAOE,CAAG,EACpCI,GAAUN,EAAOE,CAAG,EAAI,GAE1BT,EAAK,CAACS,EAAKnB,EAAQO,IAAM,CACvB,QAASiB,EAAI,EAAGC,EAAIP,EAAKC,CAAG,EAAI,EAAGK,EAAI,EAAGA,IAAKtB,EAAKuB,EAAID,CAAC,EAAIxB,EAAOO,EAAIiB,CAAC,EACzEN,EAAKC,CAAG,GAAK,CACf,CAAC,CACH,CACA,MAAO,CAAE,KAAAjB,EAAM,MAAAJ,CAAM,CACvB",
+  "names": ["lightGrid", "packed", "maxBytes", "count", "sum", "values", "cellSize", "data", "minX", "minZ", "maxX", "maxZ", "i", "columns", "rows", "each", "callback", "radius", "x", "z", "y", "c", "counts", "next", "key", "entries", "value", "length", "offset", "j", "o"]
+}

package/dist/utils/limbs.js

@@ -0,0 +1,2 @@
+const e=[["body",0,0,0],["leg",-.09,.9,1],["leg",.09,.9,-1],["arm",-.25,1.42,-1],["arm",.25,1.42,1]];export{e as limbs};
+//# sourceMappingURL=limbs.js.map

package/dist/utils/limbs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/limbs.js"],
+  "sourcesContent": ["// [part, pivot x, pivot y, swing sign]\n\nexport const limbs = [\n  ['body', 0, 0, 0],\n  ['leg', -0.09, 0.9, 1],\n  ['leg', 0.09, 0.9, -1],\n  ['arm', -0.25, 1.42, -1],\n  ['arm', 0.25, 1.42, 1]\n];\n"],
+  "mappings": "AAEO,MAAMA,EAAQ,CACnB,CAAC,OAAQ,EAAG,EAAG,CAAC,EAChB,CAAC,MAAO,KAAO,GAAK,CAAC,EACrB,CAAC,MAAO,IAAM,GAAK,EAAE,EACrB,CAAC,MAAO,KAAO,KAAM,EAAE,EACvB,CAAC,MAAO,IAAM,KAAM,CAAC,CACvB",
+  "names": ["limbs"]
+}

package/dist/utils/loadModel.js

@@ -0,0 +1,2 @@
+import{decodeModel as A}from"./decodeModel.js";import{emptyNode as E}from"./emptyNode.js";import{nodeMatrix as B}from"./nodeMatrix.js";import{readAccessor as F}from"./readAccessor.js";import{setParent as x}from"./setParent.js";import{textureSampler as I}from"./textureSampler.js";import{vertexNormals as z}from"./vertexNormals.js";import{createProgram as D}from"./createProgram.js";import{conformModelToTerrain as S}from"./conformModelToTerrain.js";async function Q(r){await r._added.promise;const T=new URL(r.modelUrl,document.baseURI).href,g=await fetch(T);if(!g.ok)throw new Error(`Unable to load model: HTTP ${g.status}`);const R=await g.arrayBuffer(),n=A(R),v=new URL(".",T).href;await Promise.all((n.buffers||[]).map(async e=>{if(e.binary)return;const t=await fetch(new URL(e.uri,v).href);if(!t.ok)throw new Error(`Unable to load model buffer: HTTP ${t.status}`);e.binary=await t.arrayBuffer()})),await r._added.promise;const _=await Promise.all((n.images||[]).map(async e=>{let t;if(e.bufferView!==void 0){const s=n.bufferViews[e.bufferView],m=n.buffers[s.buffer].binary;t=new Blob([m.slice(s.byteOffset||0,(s.byteOffset||0)+s.byteLength)],{type:e.mimeType})}else{const s=await fetch(new URL(e.uri,v).href);if(!s.ok)throw new Error(`Unable to load model texture: HTTP ${s.status}`);t=await s.blob()}return createImageBitmap(t,{premultiplyAlpha:"none",colorSpaceConversion:"none"})}));await r._map?._terrain3D?._terrainPromise;const y=new Map,p=(e,t=!1)=>{if(!e)return null;if((e.texCoord||0)!==0||e.extensions)throw new Error("Model textures currently require untransformed TEXCOORD_0 UVs");const s=r.renderer.device,m=`${e.index}:${t}`;if(!y.has(m)){const f=n.textures[e.index],l=n.samplers?.[f.sampler]||{},u=_[f.source],c=t?"rgba8unorm-srgb":"rgba8unorm",o=I(l);y.set(m,{device:s,texture:s.createTexture({size:[u.width,u.height],format:c,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT}),sampler:s.createSampler(o),samplerOptions:o,format:c,srgb:t,image:u,flipY:!1,uploaded:null})}return y.get(m)},M=(n.materials||[]).map(e=>{const t=e.pbrMetallicRoughness||{};return{color:(t.baseColorFactor||[1,1,1,1]).slice(0,3),opacity:t.baseColorFactor?.[3]??1,metallic:t.metallicFactor??1,roughness:t.roughnessFactor??1,baseTexture:p(t.baseColorTexture,!0),metalTexture:p(t.metallicRoughnessTexture),emissiveTexture:p(e.emissiveTexture,!0),occlusionTexture:p(e.occlusionTexture),emissive:e.emissiveFactor||[0,0,0],occlusionStrength:e.occlusionTexture?.strength??1,alphaMode:r.options.alphaMode||e.alphaMode||"OPAQUE",alphaCutoff:e.alphaCutoff??.5,doubleSided:e.doubleSided}});let U;{const e=new Set,t=[],s=f=>{if(e.has(f))throw new Error("Cyclic glTF nodes");const l=n.nodes[f];if(!l)throw new Error("Invalid glTF node");e.add(f);const u={...E(),name:l.name};if(u.matrix=B(l),l.mesh!==void 0)for(const c of n.meshes[l.mesh].primitives){const o={};for(const[a,i]of[["POSITION","position"],["NORMAL","normal"],["TEXCOORD_0","uv"]])c.attributes[a]!==void 0&&(o[i]=F(n,c.attributes[a]));if(!o.position)throw new Error("glTF mesh has no positions");const h=o.position.data.length/3;if(o.position.size!==3||h<3||Object.values(o).some(a=>a.data.length/a.size!==h))throw new Error("Invalid glTF vertex attributes");if(c.indices!==void 0){const a=F(n,c.indices);if(o.index={size:1,data:a.indices},![Uint8Array,Uint16Array,Uint32Array].some(i=>a.indices instanceof i)||a.size!==1||a.indices.length%3||[...a.indices].some(i=>i>=h))throw new Error("Invalid glTF triangle indices")}if(!o.index&&h%3)throw new Error("Incomplete glTF triangle");if(!o.normal){const a=z(o.position.data,o.index?.data);o.normal={size:3,data:a}}const d=M[c.material]||{color:[1,1,1],metallic:1};if([d.baseTexture,d.metalTexture,d.emissiveTexture,d.occlusionTexture].some(Boolean)&&!o.uv)throw new Error("Textured model mesh requires UV coordinates");const O=D(r,d);t.push(O);const w=r.renderer.device;o.index?.data instanceof Uint8Array&&(o.index.data=Uint16Array.from(o.index.data));for(const[a,i]of Object.entries(o))i.size||=1,i.count=i.data.length/i.size,i.indexFormat=i.data instanceof Uint32Array?"uint32":"uint16",i.buffer=w.createBuffer({size:Math.max(4,i.data.byteLength),usage:a==="index"?GPUBufferUsage.INDEX|GPUBufferUsage.COPY_DST:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST}),w.queue.writeBuffer(i.buffer,0,i.data);const C={device:w,attributes:o,drawRange:{start:0,count:o.index?.count||o.position.count}};t.push(C);const b={...E(),device:w,geometry:C,program:O,fadeDuration:250,id:L.Layer._nextId++,renderOrder:0};b.name=n.meshes[l.mesh].name,b.extras=l.extras||{},x(b,u)}for(const c of l.children||[])x(s(c),u);return e.delete(f),u},m=n.scenes?.[n.scene||0];if(!m)throw new Error("Missing glTF scene");try{U=m.nodes.map(s)}catch(f){for(const l of t)if(l.attributes)for(const u of Object.values(l.attributes))u.buffer.destroy();else l.pipelineCache.clear();throw f}}const P={...E(),id:T,extras:n.extras||{}};if(!U.length)throw new Error("Expected a glTF model with a non-empty scene");for(const e of U)x(e,P);if(r.model=P,r.options.rotation){const[e,t=e,s=e]=r.options.rotation;r.model.rotation[0]=e,r.model.rotation[1]=t,r.model.rotation[2]=s}if(r.options.scale){const[e,t=e,s=e]=r.options.scale;r.model.scale[0]=e,r.model.scale[1]=t,r.model.scale[2]=s}x(r.model,r.root),S(r,r._map?._terrain3D)}export{Q as loadModel};
+//# sourceMappingURL=loadModel.js.map

package/dist/utils/loadModel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/loadModel.js"],
+  "sourcesContent": ["import { decodeModel } from './decodeModel.js';\nimport { emptyNode } from './emptyNode.js';\nimport { nodeMatrix } from './nodeMatrix.js';\nimport { readAccessor } from './readAccessor.js';\nimport { setParent } from './setParent.js';\nimport { textureSampler } from './textureSampler.js';\nimport { vertexNormals } from './vertexNormals.js';\nimport { createProgram } from './createProgram.js';\nimport { conformModelToTerrain } from './conformModelToTerrain.js';\n\n/** glTF/GLB model loading. */\n/** Load the configured GLB/glTF (static triangles) under `root`; GPU resources need attachment. */\n\nexport async function loadModel(backend) {\n  await backend._added.promise;\n  const url = new URL(backend.modelUrl, document.baseURI).href;\n  const response = await fetch(url);\n  if (!response.ok) {\n    throw new Error(`Unable to load model: HTTP ${response.status}`);\n  }\n  const data = await response.arrayBuffer();\n  const description = decodeModel(data);\n  const directory = new URL('.', url).href;\n  await Promise.all((description.buffers || []).map(async (buffer) => {\n    if (buffer.binary) {\n      return;\n    }\n    const response = await fetch(new URL(buffer.uri, directory).href);\n    if (!response.ok) {\n      throw new Error(`Unable to load model buffer: HTTP ${response.status}`);\n    }\n    buffer.binary = await response.arrayBuffer();\n  }));\n  await backend._added.promise;\n  const images = await Promise.all((description.images || []).map(async (image) => {\n    let blob;\n    if (image.bufferView !== undefined) {\n      const view = description.bufferViews[image.bufferView];\n      const buffer = description.buffers[view.buffer].binary;\n      blob = new Blob([buffer.slice(view.byteOffset || 0, (view.byteOffset || 0) + view.byteLength)],\n        { type: image.mimeType });\n    } else {\n      const response = await fetch(new URL(image.uri, directory).href);\n      if (!response.ok) throw new Error(`Unable to load model texture: HTTP ${response.status}`);\n      blob = await response.blob();\n    }\n    // Preserve straight alpha and raw samples; GPU sRGB formats do color decoding.\n    return createImageBitmap(blob, { premultiplyAlpha: 'none', colorSpaceConversion: 'none' });\n  }));\n  await backend._map?._terrain3D?._terrainPromise;\n  const textures = new Map();\n  const textureFor = (reference, color = false) => {\n    if (!reference) return null;\n    if ((reference.texCoord || 0) !== 0 || reference.extensions) {\n      throw new Error('Model textures currently require untransformed TEXCOORD_0 UVs');\n    }\n    const device = backend.renderer.device;\n    // A glTF image may serve both color and data maps: those cannot share a GPU format.\n    const key = `${reference.index}:${color}`;\n    if (!textures.has(key)) {\n      const texture = description.textures[reference.index];\n      const sampler = description.samplers?.[texture.sampler] || {};\n      const image = images[texture.source];\n      const format = color ? 'rgba8unorm-srgb' : 'rgba8unorm';\n      const samplerOptions = textureSampler(sampler);\n      textures.set(key, {\n        device,\n        texture: device.createTexture({\n          size: [image.width, image.height],\n          format,\n          usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,\n        }),\n        sampler: device.createSampler(samplerOptions),\n        samplerOptions,\n        format,\n        srgb: color,\n        image,\n        flipY: false,\n        uploaded: null,\n      });\n    }\n    return textures.get(key);\n  };\n  // Convert glTF materials directly to the shader's retained CPU styles.\n  const materials = (description.materials || []).map(material => {\n    const pbr = material.pbrMetallicRoughness || {};\n    return {\n      color: (pbr.baseColorFactor || [1, 1, 1, 1]).slice(0, 3),\n      opacity: pbr.baseColorFactor?.[3] ?? 1,\n      metallic: pbr.metallicFactor ?? 1,\n      roughness: pbr.roughnessFactor ?? 1,\n      baseTexture: textureFor(pbr.baseColorTexture, true),\n      metalTexture: textureFor(pbr.metallicRoughnessTexture),\n      emissiveTexture: textureFor(material.emissiveTexture, true),\n      occlusionTexture: textureFor(material.occlusionTexture),\n      emissive: material.emissiveFactor || [0, 0, 0],\n      occlusionStrength: material.occlusionTexture?.strength ?? 1,\n      alphaMode: backend.options.alphaMode || material.alphaMode || 'OPAQUE',\n      alphaCutoff: material.alphaCutoff ?? 0.5,\n      doubleSided: material.doubleSided,\n    };\n  });\n  let nodes;\n  {\n    // Track only the recursion path: shared mesh references are valid, cycles are not.\n    const active = new Set(), resources = [];\n    const node = index => {\n      if (active.has(index)) throw new Error('Cyclic glTF nodes');\n      const spec = description.nodes[index];\n      if (!spec) throw new Error('Invalid glTF node');\n      active.add(index);\n      const group = {\n        ...emptyNode(),\n        name: spec.name\n      };\n      group.matrix = nodeMatrix(spec);\n      if (spec.mesh !== undefined) {\n        for (const primitive of description.meshes[spec.mesh].primitives) {\n          const attributes = {};\n          for (const [semantic, name] of [['POSITION', 'position'], ['NORMAL', 'normal'], ['TEXCOORD_0', 'uv']]) {\n            if (primitive.attributes[semantic] !== undefined) attributes[name] = readAccessor(description, primitive.attributes[semantic]);\n          }\n          if (!attributes.position) throw new Error('glTF mesh has no positions');\n          const vertexCount = attributes.position.data.length / 3;\n          if (attributes.position.size !== 3 || vertexCount < 3 ||\n            Object.values(attributes).some(attribute => attribute.data.length / attribute.size !== vertexCount)) throw new Error('Invalid glTF vertex attributes');\n          if (primitive.indices !== undefined) {\n            const index = readAccessor(description, primitive.indices);\n            attributes.index = { size: 1, data: index.indices };\n            if (![Uint8Array, Uint16Array, Uint32Array].some(Type => index.indices instanceof Type) ||\n              index.size !== 1 || index.indices.length % 3 || [...index.indices].some(i => i >= vertexCount)) throw new Error('Invalid glTF triangle indices');\n          }\n          if (!attributes.index && vertexCount % 3) throw new Error('Incomplete glTF triangle');\n          if (!attributes.normal) {\n            const normals = vertexNormals(attributes.position.data, attributes.index?.data);\n            attributes.normal = { size: 3, data: normals };\n          }\n          const style = materials[primitive.material] || { color: [1, 1, 1], metallic: 1 };\n          if ([style.baseTexture, style.metalTexture, style.emissiveTexture, style.occlusionTexture].some(Boolean) && !attributes.uv) {\n            throw new Error('Textured model mesh requires UV coordinates');\n          }\n          const program = createProgram(backend, style);\n          resources.push(program);\n          const device = backend.renderer.device;\n          if (attributes.index?.data instanceof Uint8Array) {\n            attributes.index.data = Uint16Array.from(attributes.index.data);\n          }\n          for (const [name, attribute] of Object.entries(attributes)) {\n            attribute.size ||= 1;\n            attribute.count = attribute.data.length / attribute.size;\n            attribute.indexFormat = attribute.data instanceof Uint32Array ? 'uint32' : 'uint16';\n            attribute.buffer = device.createBuffer({\n              size: Math.max(4, attribute.data.byteLength),\n              usage: name === 'index'\n                ? GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST\n                : GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,\n            });\n            device.queue.writeBuffer(attribute.buffer, 0, attribute.data);\n          }\n          const geometry = {\n            device,\n            attributes,\n            drawRange: { start: 0, count: attributes.index?.count || attributes.position.count },\n          };\n          resources.push(geometry);\n          const mesh = {\n            ...emptyNode(),\n            device,\n            geometry,\n            program,\n            fadeDuration: 250,\n            id: L.Layer._nextId++,\n            renderOrder: 0\n          };\n          mesh.name = description.meshes[spec.mesh].name; mesh.extras = spec.extras || {};\n          setParent(mesh, group);\n        }\n      }\n      for (const child of spec.children || []) setParent(node(child), group);\n      active.delete(index);\n      return group;\n    };\n    const scene = description.scenes?.[description.scene || 0];\n    if (!scene) throw new Error('Missing glTF scene');\n    try {\n      nodes = scene.nodes.map(node);\n    } catch (error) {\n      // Parsing can fail after earlier primitives allocated buffers/programs.\n      for (const resource of resources) {\n        if (resource.attributes) {\n          for (const attribute of Object.values(resource.attributes)) attribute.buffer.destroy();\n        } else {\n          resource.pipelineCache.clear();\n        }\n      }\n      throw error;\n    }\n  }\n  const model = {\n    ...emptyNode(),\n    id: url,\n    extras: description.extras || {},\n  };\n  if (!nodes.length) throw new Error('Expected a glTF model with a non-empty scene');\n  for (const node of nodes) setParent(node, model);\n  backend.model = model;\n  if (backend.options.rotation) {\n    const [x, y = x, z = x] = backend.options.rotation;\n    backend.model.rotation[0] = x; backend.model.rotation[1] = y; backend.model.rotation[2] = z;\n  }\n  if (backend.options.scale) {\n    const [x, y = x, z = x] = backend.options.scale;\n    backend.model.scale[0] = x; backend.model.scale[1] = y; backend.model.scale[2] = z;\n  }\n  setParent(backend.model, backend.root);\n  conformModelToTerrain(backend, backend._map?._terrain3D);\n}\n"],
+  "mappings": "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",
+  "names": ["decodeModel", "emptyNode", "nodeMatrix", "readAccessor", "setParent", "textureSampler", "vertexNormals", "createProgram", "conformModelToTerrain", "loadModel", "backend", "url", "response", "data", "description", "directory", "buffer", "images", "image", "blob", "view", "textures", "textureFor", "reference", "color", "device", "key", "texture", "sampler", "format", "samplerOptions", "materials", "material", "pbr", "nodes", "active", "resources", "node", "index", "spec", "group", "primitive", "attributes", "semantic", "name", "vertexCount", "attribute", "Type", "normals", "style", "program", "geometry", "mesh", "child", "scene", "error", "resource", "model", "x", "y", "z"]
+}

package/dist/utils/loadSource.js

@@ -0,0 +1,2 @@
+import{getZxy as u}from"./getZxy.js";async function d(o,e){if(o._geojson){const{data:r,url:t}=o.options;if(r!==void 0&&t)throw new Error("GeoJSON source requires either data or url");if(r!==void 0)return r;if(!t)throw new Error("GeoJSON source requires either data or url");const s=await fetch(new URL(t,document.baseURI),{signal:e.request.signal});if(!s.ok)throw new Error(`Unable to load GeoJSON: HTTP ${s.status}`);return s.json()}const n=await u(o,e.coords.z,e.coords.x,e.coords.y,e.request.signal);return n?JSON.parse(new TextDecoder().decode(n.data)):{type:"FeatureCollection",features:[]}}export{d as loadSource};
+//# sourceMappingURL=loadSource.js.map

package/dist/utils/loadSource.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/loadSource.js"],
+  "sourcesContent": ["import { getZxy } from './getZxy.js';\n\nexport async function loadSource(backend, area) {\n  if (backend._geojson) {\n    const { data, url } = backend.options;\n    if (data !== undefined && url) throw new Error('GeoJSON source requires either data or url');\n    if (data !== undefined) return data;\n    if (!url) throw new Error('GeoJSON source requires either data or url');\n    const response = await fetch(new URL(url, document.baseURI), { signal: area.request.signal });\n    if (!response.ok) throw new Error(`Unable to load GeoJSON: HTTP ${response.status}`);\n    return response.json();\n  }\n  const result = await getZxy(backend, area.coords.z, area.coords.x, area.coords.y, area.request.signal);\n  return result\n    ? JSON.parse(new TextDecoder().decode(result.data))\n    : { type: 'FeatureCollection', features: [] };\n}\n"],
+  "mappings": "AAAA,OAAS,UAAAA,MAAc,cAEvB,eAAsBC,EAAWC,EAASC,EAAM,CAC9C,GAAID,EAAQ,SAAU,CACpB,KAAM,CAAE,KAAAE,EAAM,IAAAC,CAAI,EAAIH,EAAQ,QAC9B,GAAIE,IAAS,QAAaC,EAAK,MAAM,IAAI,MAAM,4CAA4C,EAC3F,GAAID,IAAS,OAAW,OAAOA,EAC/B,GAAI,CAACC,EAAK,MAAM,IAAI,MAAM,4CAA4C,EACtE,MAAMC,EAAW,MAAM,MAAM,IAAI,IAAID,EAAK,SAAS,OAAO,EAAG,CAAE,OAAQF,EAAK,QAAQ,MAAO,CAAC,EAC5F,GAAI,CAACG,EAAS,GAAI,MAAM,IAAI,MAAM,gCAAgCA,EAAS,MAAM,EAAE,EACnF,OAAOA,EAAS,KAAK,CACvB,CACA,MAAMC,EAAS,MAAMP,EAAOE,EAASC,EAAK,OAAO,EAAGA,EAAK,OAAO,EAAGA,EAAK,OAAO,EAAGA,EAAK,QAAQ,MAAM,EACrG,OAAOI,EACH,KAAK,MAAM,IAAI,YAAY,EAAE,OAAOA,EAAO,IAAI,CAAC,EAChD,CAAE,KAAM,oBAAqB,SAAU,CAAC,CAAE,CAChD",
+  "names": ["getZxy", "loadSource", "backend", "area", "data", "url", "response", "result"]
+}

package/dist/utils/loadTerrain.js

@@ -0,0 +1,2 @@
+import{addBridges as g}from"./addBridges.js";import{conformModelToTerrain as u}from"./conformModelToTerrain.js";import{getElevation as p}from"./getElevation.js";import{setTerrainHeight as w}from"./setTerrainHeight.js";import{update as _}from"./update.js";async function d(r){if(r._terrainLoading||!r._map)return;r._terrainLoading=!0,r._terrainReady=!1;const a=r._terrainController=new AbortController;try{if(!r.terrainSource)throw new Error("Terrain layer requires a PMTiles elevation archive");const n=r._terrainArchive=new L.Layer({source:{type:"pmtiles",url:r.terrainSource}});await n.ready;const e=n.header;if(e.tileType!==0||e.minZoom!==e.maxZoom)throw new Error("Expected a single-zoom Float32 PMTiles terrain archive");r._terrainZoom=e.maxZoom;const i=r._map,m=i.project([e.maxLat,e.minLon],r._terrainZoom).divideBy(256).floor(),y=i.project([e.minLat,e.maxLon],r._terrainZoom).divideBy(256).floor();r._terrainBounds=new L.Bounds(m,y);const s=[];for(let t=m.x;t<=y.x;t++)for(let o=m.y;o<=y.y;o++)s.push({z:r._terrainZoom,x:t,y:o});const l=i.project(i.getCenter(),r._terrainZoom).divideBy(256);s.sort((t,o)=>Math.hypot(t.x+.5-l.x,t.y+.5-l.y)-Math.hypot(o.x+.5-l.x,o.y+.5-l.y));let f=0;await Promise.all(Array.from({length:Math.min(4,s.length)},async()=>{for(;f<s.length;){a.signal.throwIfAborted();const t=s[f++],o=await n.getZxy(t.z,t.x,t.y,a.signal);if(!o||o.data.byteLength!==256*256*4)throw new Error(`Missing or invalid Float32 terrain tile ${t.z}/${t.x}/${t.y}`);r._terrainTiles.set(`${t.x}/${t.y}`,new Float32Array(o.data))}}));const h=r.options.bridges&&await fetch(r.options.bridges,{signal:a.signal}).then(t=>{if(!t.ok)throw new Error(`Bridges: HTTP ${t.status}`);return t.json()});if(a.signal.aborted||r._map!==i)return;r._terrainReady=!0,r._terrainOriginElevation=p(r,r.location)??0;for(const t of Object.values(i._layers))w(t),u(t,r);return h&&g(r,h),i.fire("terrainchange"),_(r),r.fire("terrainready"),!0}catch(n){return a.signal.aborted||r.fire("error",{error:n}),!1}finally{r._terrainLoading=!1}}export{d as loadTerrain};
+//# sourceMappingURL=loadTerrain.js.map