leaflet-city-mapper 0.0.5 → 0.0.6

package/libs/leaflet-lens.js

@@ -8,6 +8,9 @@
 
     initialize(outerLayer, innerLayer, options) {
       L.Util.setOptions(this, options);
+      if (options?.enabled === undefined) {
+        this.options.enabled = !matchMedia('(hover: none) and (pointer: coarse)').matches;
+      }
       if (!outerLayer?.options || !innerLayer?.options || outerLayer === innerLayer) {
         throw new TypeError('Lens requires two distinct raster layers');
       }
@@ -40,14 +43,15 @@
       this._button = L.DomUtil.create('button', '', container);
       this._button.type = 'button';
       this._button.textContent = '🔍';
-      this._button.title = 'Toggle lens; move the pointer over the map to reveal the layer underneath';
+      this._button.title = 'Toggle lens; touch or move the pointer over the map to reveal the layer underneath';
       this._button.setAttribute('aria-label', 'Toggle lens');
       this._button.style.cssText = 'display:block;border:0;border-radius:2px;padding:0 8px;min-width:30px;height:30px;background:white;color:#222;font:inherit;cursor:pointer';
       L.DomEvent.disableClickPropagation(container);
       L.DomEvent.disableScrollPropagation(container);
       L.DomEvent.on(this._button, 'click', this._toggle, this);
       this._events = {
-        pointermove: this._onPointerMove.bind(this), pointerleave: this._hide.bind(this),
+        pointerdown: this._onPointerDown.bind(this), pointermove: this._onPointerMove.bind(this),
+        pointerleave: this._onPointerLeave.bind(this), pointercancel: this._hide.bind(this),
         focus: this._onFocus.bind(this), blur: this._hide.bind(this), keydown: this._onKeyDown.bind(this),
       };
       for (const [type, handler] of Object.entries(this._events)) {
@@ -111,8 +115,16 @@
       });
     },
 
+    _onPointerDown(event) {
+      if (event.pointerType === 'touch') this._onPointerMove(event);
+    },
+
+    _onPointerLeave(event) {
+      if (event.pointerType !== 'touch') this._hide();
+    },
+
     _onFocus() {
-      this._show(this._map.getSize().divideBy(2));
+      if (this._lens.hidden) this._show(this._map.getSize().divideBy(2));
     },
 
     _onKeyDown(event) {

package/libs/leaflet.js

@@ -11,7 +11,7 @@ const openlayers = new URLSearchParams(location.search).get('engine') === 'openl
 document.write((openlayers
   ? '<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/ol@10.6.1/ol.css">' +
     '<script src="https://cdn.jsdelivr.net/npm/ol@10.6.1/dist/ol.js"><\/script>' +
-    '<script src="https://unpkg.com/leaflet-city-mapper@0.0.5/libs/openlayers-bindings.min.js"><\/script>'
+    '<script src="https://unpkg.com/leaflet-city-mapper@0.0.6/libs/openlayers-bindings.min.js"><\/script>'
   : '<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9/dist/leaflet.css"><script src="https://unpkg.com/leaflet@1.9/dist/leaflet-src.js"><\/script>'));
 
 const engineStyle = document.createElement('style');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leaflet-city-mapper",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A small 3D rendering engine for leaflet",
   "type": "module",
   "main": "dist/leaflet-city-mapper.js",

package/src/collision/collectIntersections.js

@@ -0,0 +1,16 @@
+import { CELL } from '../globals/CELL.js';
+import { horizontalRay } from './horizontalRay.js';
+
+export function collectIntersections(shape, x, y, z, seen, hits, end, iz) {
+  let ix, cell, triangle, distance;
+  for (ix = Math.floor(x / CELL); ix <= end; ix++) {
+    cell = shape.cells.get(`${ix},${iz}`);
+    if (!cell) continue;
+    for (triangle of cell) {
+      if (seen.has(triangle)) continue;
+      seen.add(triangle);
+      distance = horizontalRay(shape.tri, triangle, x, y, z, 1, 0);
+      if (distance > 1e-4) hits.push(distance);
+    }
+  }
+}

package/src/collision/collider.js

@@ -1,14 +1,15 @@
 import { colliders } from '../weakmaps/colliders.js';
 import { indexTriangle } from './indexTriangle.js';
 import { readTriangle } from './readTriangle.js';
+import { vertexCount } from './vertexCount.js';
 
 
 export function collider(mesh) {
   let c = colliders.get(mesh.geometry);
   if (c) return c;
-  const m = mesh.worldMatrix, { position: { data: p }, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
+  const m = mesh.worldMatrix, { position, index, normal, uv, instanceOffset } = mesh.geometry.attributes;
 
-  const vertices = index ? index.count : p.length / 3;
+  const vertices = vertexCount(position, index);
   const count = vertices * (instanceOffset?.count ?? 1);
   const tri = /* alloc */ [];
   const nrm = /* alloc */ [];

package/src/collision/countCrossings.js

@@ -0,0 +1,15 @@
+export function countCrossings(hits) {
+  let ix, j, distance;
+  for (ix = 1; ix < hits.length; ix++) {
+    distance = hits[ix];
+    j = ix - 1;
+    while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
+    hits[j + 1] = distance;
+  }
+  let crossings = 0, previous = -Infinity;
+  for (distance of hits) {
+    if (distance - previous > 1e-4) crossings++;
+    previous = distance;
+  }
+  return crossings;
+}

package/src/collision/insideMesh.js

@@ -1,8 +1,9 @@
 import { CELL } from '../globals/CELL.js';
 
 import { collider } from './collider.js';
-import { horizontalRay } from './horizontalRay.js';
 import { computeBounds } from '../geometry/computeBounds.js';
+import { collectIntersections } from './collectIntersections.js';
+import { countCrossings } from './countCrossings.js';
 
 export function insideMesh(mesh, x, y, z, seen, intersections) {
   const geometry = mesh.geometry;
@@ -27,27 +28,6 @@ export function insideMesh(mesh, x, y, z, seen, intersections) {
   const hits = intersections;
   hits.length = 0;
   seen.clear();
-  let ix, cell, triangle, distance;
-  for (ix = Math.floor(x / CELL); ix <= end; ix++) {
-    cell = shape.cells.get(`${ix},${iz}`);
-    if (!cell) continue;
-    for (triangle of cell) {
-      if (seen.has(triangle)) continue;
-      seen.add(triangle);
-      distance = horizontalRay(shape.tri, triangle, x, y, z, 1, 0);
-      if (distance > 1e-4) hits.push(distance);
-    }
-  }
-  for (ix = 1; ix < hits.length; ix++) {
-    distance = hits[ix];
-    let j = ix - 1;
-    while (j >= 0 && hits[j] > distance) hits[j + 1] = hits[j--];
-    hits[j + 1] = distance;
-  }
-  let crossings = 0, previous = -Infinity;
-  for (distance of hits) {
-    if (distance - previous > 1e-4) crossings++;
-    previous = distance;
-  }
-  return crossings % 2 === 1;
+  collectIntersections(shape, x, y, z, seen, hits, end, iz);
+  return countCrossings(hits) % 2 === 1;
 }

package/src/collision/insideWalker.js

@@ -20,7 +20,7 @@ export function insideWalker(context) {
   const y = root.position[1] + feet[1] * root.scale[1];
   const z = root.position[2] + feet[2] * root.scale[2];
   const layers = layersByLayer.get(shared);
-  let other, node, child;
+  let other, node, child, nodes;
   for (other of layers) {
     if (other === layer || kindByLayer.get(other) === 'terrain') continue;
     if (kindByLayer.get(other) === 'traffic') {
@@ -29,7 +29,7 @@ export function insideWalker(context) {
       if (trafficCollision(other, x, y, z, 0, 0, 0, hitData)) return true;
       continue;
     }
-    const nodes = hitData.nodes;
+    nodes = hitData.nodes;
     nodes.length = 0;
     if (rootByLayer.get(other)) nodes.push(rootByLayer.get(other));
     while (nodes.length) {

package/src/collision/readTriangle.js

@@ -1,14 +1,17 @@
+import { vertexCount } from './vertexCount.js';
+
 export function readTriangle(mesh, i, a, b, c) {
   const { position, index, instanceOffset } = mesh.geometry.attributes;
-  const vertices = index?.count || position.count;
+  const size = position.size ?? 3;
+  const vertices = vertexCount(position, index);
   const vertex = instanceOffset ? i % vertices : i;
   const offset = instanceOffset ? Math.floor(i / vertices) * instanceOffset.size : 0;
   const x = instanceOffset?.data[offset] ?? 0;
   const y = instanceOffset?.data[offset + 1] ?? 0;
   const z = instanceOffset?.data[offset + 2] ?? 0;
-  const ai = (index ? index.data[vertex] : vertex) * position.size;
-  const bi = (index ? index.data[vertex + 1] : vertex + 1) * position.size;
-  const ci = (index ? index.data[vertex + 2] : vertex + 2) * position.size;
+  const ai = (index ? index.data[vertex] : vertex) * size;
+  const bi = (index ? index.data[vertex + 1] : vertex + 1) * size;
+  const ci = (index ? index.data[vertex + 2] : vertex + 2) * size;
   a[0] = position.data[ai]; a[1] = position.data[ai + 1]; a[2] = position.data[ai + 2];
   b[0] = position.data[bi]; b[1] = position.data[bi + 1]; b[2] = position.data[bi + 2];
   c[0] = position.data[ci]; c[1] = position.data[ci + 1]; c[2] = position.data[ci + 2];

package/src/collision/setTrafficNormal.js

@@ -0,0 +1,9 @@
+export function setTrafficNormal(data, x, z, distance, dx, dz) {
+  if (distance < 1e-6) {
+    data.normal[0] = -dx;
+    data.normal[1] = -dz;
+  } else {
+    data.normal[0] = x / distance;
+    data.normal[1] = z / distance;
+  }
+}

package/src/collision/trafficCollision.js

@@ -2,13 +2,14 @@ import { rootByLayer } from '../weakmaps/rootByLayer.js';
 import { trafficByLayer } from '../weakmaps/trafficByLayer.js';
 
 import { locateTraffic } from '../traffic/locateTraffic.js';
+import { setTrafficNormal } from './setTrafficNormal.js';
 
 export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
   const state = trafficByLayer.get(layer);
   if (!state?.mesh || !state.trips.length) return false;
   let bounds = state.collisionBounds;
   if (!bounds) {
-    bounds = state.collisionBounds = { radius: 0, minY: Infinity, maxY: -Infinity };
+    bounds = state.collisionBounds = /* alloc */ { radius: 0, minY: Infinity, maxY: -Infinity };
     let i, px, py, pz;
     for (i = 0; i < state.template.position.length; i += 3) {
       px = state.template.position[i];
@@ -19,7 +20,7 @@ export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
       bounds.maxY = Math.max(bounds.maxY, py);
     }
   }
-  const root = rootByLayer.get(layer), position = state.position ||= {};
+  const root = rootByLayer.get(layer), position = state.position ||= /* alloc */ {};
   const scale = Math.max(root.scale[0], root.scale[1], root.scale[2]);
   const radius = bounds.radius * scale + 0.35;
   let trip, projection, closest, rx, rz, perpendicular, entry, distance, bottom, top, px, pz;
@@ -48,13 +49,7 @@ export function trafficCollision(layer, x, y, z, dx, dz, reach, data) {
     data.best = entry;
     data.found = true;
     distance = Math.hypot(x + entry * dx - px, z + entry * dz - pz);
-    if (distance < 1e-6) {
-      data.normal[0] = -dx;
-      data.normal[1] = -dz;
-    } else {
-      data.normal[0] = (x + entry * dx - px) / distance;
-      data.normal[1] = (z + entry * dz - pz) / distance;
-    }
+    setTrafficNormal(data, x + entry * dx - px, z + entry * dz - pz, distance, dx, dz);
   }
   return data.found;
 }

package/src/collision/vertexCount.js

@@ -0,0 +1,3 @@
+export function vertexCount(position, index) {
+  return index?.count ?? index?.data.length ?? position.count ?? position.data.length / (position.size ?? 3);
+}

package/src/controls/cameraControls.js

@@ -1,5 +1,8 @@
 import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { cameraHandlersByMap } from '../weakmaps/cameraHandlersByMap.js';
 import { rotateControlByMap } from '../weakmaps/rotateControlByMap.js';
+import { touchPitchByMap } from '../weakmaps/touchPitchByMap.js';
+import { touchRotateByMap } from '../weakmaps/touchRotateByMap.js';
 
 import { L } from '../globals/L.js';
 import { Compass } from '../globals/Compass.js';
@@ -75,6 +78,8 @@ export function cameraControls(map) {
   addCameraHandler(map, 'compassBearing', Compass.value);
   addCameraHandler(map, 'touchRotate', TouchMode.value);
   addCameraHandler(map, 'touchPitch', TouchMode.value);
+  touchRotateByMap.set(map, cameraHandlersByMap.get(map).get('touchRotate'));
+  touchPitchByMap.set(map, cameraHandlersByMap.get(map).get('touchPitch'));
   const container = map.getContainer();
   const state = /* alloc */ { map, container, touch: null, nativeZoom: undefined };
   cameraTouchStateByMap.set(map, state);
@@ -86,6 +91,7 @@ export function cameraControls(map) {
   container.addEventListener('touchcancel', endCameraTouchEvent, true);
   window.addEventListener('blur', endAllCameraTouches);
   map.on('cameratouchchange', changeCameraTouch, map);
+  changeCameraTouch.call(map);
   if (map.options.rotateControl) {
     rotateControlByMap.set(map, /* alloc */ new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : cameraEmptyOptions));
     rotateControlByMap.get(map).addTo(map);

package/src/raster/setRasterOpacity.js

@@ -9,7 +9,7 @@ export function setRasterOpacity(layer, opacity) {
   let tile, terrainMesh;
   for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.opacity = opacity;
-    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer)).get(tile);
+    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer))?.get(tile);
     if (terrainMesh) terrainMesh.opacity = opacity;
   }
   update(layer);

package/src/raster/setRasterZIndex.js

@@ -9,7 +9,7 @@ export function setRasterZIndex(layer, zIndex) {
   let tile, terrainMesh;
   for (tile of rasterTilesByLayer.get(layer).values()) {
     if (tile.mesh) tile.mesh.renderOrder = zIndex;
-    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer)).get(tile);
+    terrainMesh = rasterTilesByLayer.get(terrain3DByLayer.get(layer))?.get(tile);
     if (terrainMesh) terrainMesh.renderOrder = zIndex;
   }
   update(layer);

package/src/sources/buildArea.js

@@ -3,15 +3,14 @@ import { inflightByLayer } from '../weakmaps/inflightByLayer.js';
 import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
 
 
-import { buildAreaFeature } from './buildAreaFeature.js';
 import { attachAreaMesh } from './attachAreaMesh.js';
 import { loadSource } from '../archives/loadSource.js';
 import { sourceAreaContext } from './sourceAreaContext.js';
 import { pump } from './pumpSourceAreas.js';
 import { buildAreaInWorker } from '../workers/buildAreaInWorker.js';
+import { buildAreaFeatures } from './buildAreaFeatures.js';
 
 export async function buildArea(layer, area, map) {
-  let feature;
   try {
     await /* alloc */ new Promise(requestAnimationFrame);
     await cameraViewByMap.get(map);
@@ -29,16 +28,8 @@ export async function buildArea(layer, area, map) {
     if (layer.options.worker !== false && typeof Worker !== 'undefined' && data.features.length >= 64) {
       context.jobs = /* alloc */ [];
     }
-    let deadline = performance.now() + 4;
-    for (feature of data.features) {
-      if (area.request.signal.aborted) return;
-      if (performance.now() >= deadline) {
-        await /* alloc */ new Promise(requestAnimationFrame);
-        if (area.request.signal.aborted) return;
-        deadline = performance.now() + 4;
-      }
-      buildAreaFeature(context, feature);
-    }
+    await buildAreaFeatures(context, area, data.features);
+    if (area.request.signal.aborted) return;
     if (context.jobs) await buildAreaInWorker(context, area.request.signal);
     if (area.request.signal.aborted) return;
     attachAreaMesh(context);

package/src/sources/buildAreaFeature.js

@@ -1,10 +1,10 @@
-import { L } from '../globals/L.js';
 import { buildAreaPoint } from './buildAreaPoint.js';
 import { buildAreaPolygon } from '../geometry/buildExtrudedPolygon.js';
 import { parseColor } from '../colors/parseColor.js';
 import { featureAnchor } from './featureAnchor.js';
 import { extrusionStyle } from './extrusionStyle.js';
 import { prepareAreaGeometryJob } from './prepareAreaGeometryJob.js';
+import { matchesAreaTile } from './matchesAreaTile.js';
 
 export function buildAreaFeature(context, feature) {
   const { backend: layer, area, map } = context;
@@ -12,10 +12,7 @@ export function buildAreaFeature(context, feature) {
   const coordinates = featureAnchor(feature, layer.options.nightLight);
   const geometry = feature.geometry, isTree = geometry.type === 'Point';
   const lon = coordinates[0], lat = coordinates[1];
-  if (coords) {
-    const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
-    if (Math.floor(anchor.x / 256) !== coords.x || Math.floor(anchor.y / 256) !== coords.y) return;
-  }
+  if (!matchesAreaTile(map, coords, lon, lat)) return;
   const style = extrusionStyle(layer, feature);
   if (style === null) {
     context.skipped++;

package/src/sources/buildAreaFeatures.js

@@ -0,0 +1,14 @@
+import { buildAreaFeature } from './buildAreaFeature.js';
+
+export async function buildAreaFeatures(context, area, features) {
+  let deadline = performance.now() + 4, feature;
+  for (feature of features) {
+    if (area.request.signal.aborted) return;
+    if (performance.now() >= deadline) {
+      await /* alloc */ new Promise(requestAnimationFrame);
+      if (area.request.signal.aborted) return;
+      deadline = performance.now() + 4;
+    }
+    buildAreaFeature(context, feature);
+  }
+}

package/src/sources/matchesAreaTile.js

@@ -0,0 +1,7 @@
+import { L } from '../globals/L.js';
+
+export function matchesAreaTile(map, coords, lon, lat) {
+  if (!coords) return true;
+  const anchor = map.project(/* alloc */ new L.LatLng(lat, lon), coords.z);
+  return Math.floor(anchor.x / 256) === coords.x && Math.floor(anchor.y / 256) === coords.y;
+}

package/src/sources/prepareAreaGeometryJob.js

@@ -1,19 +1,10 @@
 import { projectedTree } from '../projections/projectTreePoint.js';
-import { projectRing } from '../projections/projectRing.js';
 import { parseColor } from '../colors/parseColor.js';
+import { projectAreaPolygons } from './projectAreaPolygons.js';
 
 export function prepareAreaGeometryJob(context, feature, lon, lat, style, baseColor) {
   const geometry = feature.geometry;
-  const polygons = /* alloc */ [];
-  const rings = geometry.type === 'Polygon' ? /* alloc */ [geometry.coordinates]
-    : geometry.type === 'MultiPolygon' ? geometry.coordinates : /* alloc */ [];
-  let polygon, ring, paths;
-  for (polygon of rings) {
-    if (!polygon.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
-    paths = /* alloc */ [];
-    for (ring of polygon) paths.push(projectRing(context, ring));
-    polygons.push(paths);
-  }
+  const polygons = projectAreaPolygons(context, geometry);
   const point = geometry.type === 'Point' ? projectedTree(context, lon, lat) : null;
   const nightLight = context.backend.options.nightLight;
   const crownColor = point ? parseColor(style.color ?? (nightLight ? undefined : 0x4f823b)) : baseColor;

package/src/sources/projectAreaPolygons.js

@@ -0,0 +1,15 @@
+import { projectRing } from '../projections/projectRing.js';
+
+export function projectAreaPolygons(context, geometry) {
+  const rings = geometry.type === 'Polygon' ? /* alloc */ [geometry.coordinates]
+    : geometry.type === 'MultiPolygon' ? geometry.coordinates : /* alloc */ [];
+  const polygons = /* alloc */ [];
+  let polygon, ring, paths;
+  for (polygon of rings) {
+    if (!polygon.length) throw /* alloc */ new Error('Empty GeoJSON polygon');
+    paths = /* alloc */ [];
+    for (ring of polygon) paths.push(projectRing(context, ring));
+    polygons.push(paths);
+  }
+  return polygons;
+}

package/src/walk/animateWalker.js

@@ -9,14 +9,10 @@ import { moves } from '../globals/moves.js';
 import * as createMesh from '../rendering/createMesh.js';
 import { build } from '../geometry/buildGeometryParts.js';
 
-import { wrap } from '../utils/wrap.js';
 import { local } from '../projections/walkerLocalPosition.js';
-import { place } from './placeWalker.js';
-import { land } from './landWalker.js';
-import { moveWalker } from './moveWalker.js';
 import { stepWalkerHeight } from './stepWalkerHeight.js';
-import { updateWalkerView } from './updateWalkerView.js';
 import { resolveWalkerPosition } from './resolveWalkerPosition.js';
+import { updateWalkerFrame } from './updateWalkerFrame.js';
 
 export function step(now) {
   const layer = this.layer;
@@ -41,12 +37,5 @@ export function step(now) {
   let forward = 0, turn = 0;
   for (key of this.keys) { forward += moves[key]?.[0] || 0; turn += moves[key]?.[1] || 0; }
   forward = Math.sign(forward); turn = Math.sign(turn);
-  if (turn) { this.state.heading = wrap(this.state.heading + turn * 2.5 * dt); changed = true; }
-  if (forward) {
-    moveWalker.call(this, forward, dt);
-    changed = true;
-  }
-  if (changed) land.call(this, previousY);
-  if (updateWalkerView.call(this, forward, turn, dt)) changed = true;
-  if (changed) place.call(this);
+  updateWalkerFrame(this, previousY, forward, turn, dt, changed);
 }

package/src/walk/updateWalkerFrame.js

@@ -0,0 +1,19 @@
+import { wrap } from '../utils/wrap.js';
+import { place } from './placeWalker.js';
+import { land } from './landWalker.js';
+import { moveWalker } from './moveWalker.js';
+import { updateWalkerView } from './updateWalkerView.js';
+
+export function updateWalkerFrame(walker, previousY, forward, turn, dt, changed) {
+  if (turn) {
+    walker.state.heading = wrap(walker.state.heading + turn * 2.5 * dt);
+    changed = true;
+  }
+  if (forward) {
+    moveWalker.call(walker, forward, dt);
+    changed = true;
+  }
+  if (changed) land.call(walker, previousY);
+  if (updateWalkerView.call(walker, forward, turn, dt)) changed = true;
+  if (changed) place.call(walker);
+}

package/src/workers/acquireGeometryWorker.js

@@ -1,5 +1,6 @@
 import { geometryWorkersByMap } from '../weakmaps/geometryWorkersByMap.js';
 import { closeGeometryWorkers } from './closeGeometryWorkers.js';
+import { createGeometryWorker } from './createGeometryWorker.js';
 
 export function acquireGeometryWorker(map, url) {
   let pool = map && geometryWorkersByMap.get(map);
@@ -24,9 +25,5 @@ export function acquireGeometryWorker(map, url) {
       pool.entries.delete(entry);
     }
   }
-  entry = /* alloc */ {
-    url, pool, worker: /* alloc */ new Worker(url, /* alloc */ { type: 'module' }),
-  };
-  if (pool) pool.entries.add(entry);
-  return entry;
+  return createGeometryWorker(url, pool);
 }

package/src/workers/buildAreaInWorker.js

@@ -31,6 +31,10 @@ export async function buildAreaInWorker(context, signal) {
       if (!entry.closed) worker.terminate();
       if (pool) pool.entries.delete(entry);
     }
+    if (entry.blobUrl) {
+      URL.revokeObjectURL(entry.blobUrl);
+      entry.blobUrl = null;
+    }
     context.jobs = null;
   }
 }

package/src/workers/createGeometryWorker.js

@@ -0,0 +1,19 @@
+export function createGeometryWorker(url, pool) {
+  let workerUrl = url, blobUrl, worker;
+  if (globalThis.location) {
+    const resolved = /* alloc */ new URL(url, location.href);
+    if ((resolved.protocol === 'https:' || resolved.protocol === 'http:') && resolved.origin !== location.origin) {
+      blobUrl = URL.createObjectURL(/* alloc */ new Blob(/* alloc */ [`import ${JSON.stringify(resolved.href)};`],
+        /* alloc */ { type: 'text/javascript' }));
+      workerUrl = blobUrl;
+    }
+  }
+  try {
+    worker = /* alloc */ new Worker(workerUrl, /* alloc */ { type: 'module' });
+  } finally {
+    if (!worker && blobUrl) URL.revokeObjectURL(blobUrl);
+  }
+  const entry = /* alloc */ { url, pool, worker, blobUrl };
+  if (pool) pool.entries.add(entry);
+  return entry;
+}