leaflet-city-mapper 0.0.3 → 0.0.5

package/src/collision/triangleDistance.js

@@ -0,0 +1,21 @@
+import { hiddenLightHit } from './hiddenLightHit.js';
+
+/** Moller-Trumbore with the renderer's culling and light-halo rules. */
+export function triangleDistance(mesh, i, a, b, c, origin, direction, night) {
+  const ex = b[0] - a[0], ey = b[1] - a[1], ez = b[2] - a[2];
+  const fx = c[0] - a[0], fy = c[1] - a[1], fz = c[2] - a[2];
+  const px = direction[1] * fz - direction[2] * fy;
+  const py = direction[2] * fx - direction[0] * fz;
+  const pz = direction[0] * fy - direction[1] * fx;
+  const det = ex * px + ey * py + ez * pz;
+  if (mesh.program.cullMode === 'none' || mesh.program.cullFace === null
+    ? Math.abs(det) < 1e-9 : det < 1e-9) return Infinity;
+  const tx = origin[0] - a[0], ty = origin[1] - a[1], tz = origin[2] - a[2];
+  const u = (tx * px + ty * py + tz * pz) / det;
+  if (u < 0 || u > 1) return Infinity;
+  const qx = ty * ez - tz * ey, qy = tz * ex - tx * ez, qz = tx * ey - ty * ex;
+  const v = (direction[0] * qx + direction[1] * qy + direction[2] * qz) / det;
+  if (v < 0 || u + v > 1) return Infinity;
+  if (hiddenLightHit(mesh, i, u, v, night)) return Infinity;
+  return (fx * qx + fy * qy + fz * qz) / det;
+}

package/src/collision/worldHit.js

@@ -0,0 +1,18 @@
+export function worldHit(ray, mesh, origin, direction, closest, faceIndex) {
+  const x = direction[0] * closest + origin[0];
+  const y = direction[1] * closest + origin[1];
+  const z = direction[2] * closest + origin[2];
+  const matrix = mesh.worldMatrix;
+  const w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+  const worldPoint = /* alloc */ [
+    (matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12]) / w,
+    (matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13]) / w,
+    (matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]) / w,
+  ];
+  return /* alloc */ {
+    faceIndex,
+    object: mesh,
+    point: worldPoint,
+    distance: Math.hypot(worldPoint[0] - ray.origin[0], worldPoint[1] - ray.origin[1], worldPoint[2] - ray.origin[2])
+  };
+}

package/src/colors/formatRGB.js

@@ -0,0 +1,8 @@
+export function rgb(values) {
+  let rounded = '', i;
+  for (i = 0; i < values.length; i++) {
+    if (i) rounded += ', ';
+    rounded += Math.round(values[i]);
+  }
+  return `rgb(${rounded})`;
+}

package/src/colors/mixColor.js

@@ -0,0 +1,7 @@
+export function mix(a, b, t, values) {
+  values ||= /* alloc */ [];
+  values.length = a.length;
+  let i;
+  for (i = 0; i < a.length; i++) values[i] = a[i] + (b[i] - a[i]) * t;
+  return values;
+}

package/src/{utils → colors}/parseColor.js

@@ -1,5 +1,5 @@
 import { toSRGB } from "./toSRGB.js";
-import { channel } from "./channel.js";
+import { channel } from "./hslChannel.js";
 
 /**
  * HSL inputs are linear-space to preserve the original building styling.
@@ -11,7 +11,7 @@ import { channel } from "./channel.js";
 export function parseColor(value) {
   if (value && typeof value === 'object' && 'h' in value) {
     const a = value.s * Math.min(value.l, 1 - value.l);
-    return {
+    return /* alloc */ {
       r: toSRGB(channel(0, value.h, value.l, a)),
       g: toSRGB(channel(8, value.h, value.l, a)),
       b: toSRGB(channel(4, value.h, value.l, a))
@@ -21,20 +21,20 @@ export function parseColor(value) {
     return value;
   }
   if (typeof value === 'number') {
-    return {
+    return /* alloc */ {
       r: (value >> 16 & 255) / 255,
       g: (value >> 8 & 255) / 255,
       b: (value & 255) / 255,
     };
   }
   if (typeof value !== 'string' || !CSS.supports('color', value)) {
-    throw new Error('Invalid 3D color');
+    throw /* alloc */ new Error('Invalid 3D color');
   }
   const context = document.createElement('canvas').getContext('2d');
   context.fillStyle = value;
   context.fillRect(0, 0, 1, 1);
   const [r, g, b] = context.getImageData(0, 0, 1, 1).data;
-  return {
+  return /* alloc */ {
     r: r / 255,
     g: g / 255,
     b: b / 255

package/src/controls/addCameraHandler.js

@@ -0,0 +1,11 @@
+
+import { cameraHandlersByMap } from '../weakmaps/cameraHandlersByMap.js';
+
+export function addCameraHandler(map, name, Type) {
+  let handlers = cameraHandlersByMap.get(map);
+  if (!handlers) cameraHandlersByMap.set(map, handlers = /* alloc */ new Map());
+  const handler = /* alloc */ new Type(map);
+  handlers.set(name, handler);
+  map._handlers.push(handler);
+  if (map.options[name]) handler.enable();
+}

package/src/controls/adjustCameraDrag.js

@@ -1,9 +1,15 @@
-import { project } from '../camera/project.js';
+import { cameraDraggableByMap } from '../weakmaps/cameraDraggableByMap.js';
+
+
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
+
+import { project } from '../projections/projectCameraPoint.js';
 
 export function adjustCameraDrag() {
   const map = this;
-  const draggable = map._cameraDraggable;
-  if (!map.getPitch() && !map.getBearing()) return;
+  const draggable = cameraDraggableByMap.get(map);
+  if (!mapGetPitch(map) && !mapGetBearing(map)) return;
   const half = map.getSize().divideBy(2), delta = draggable._newPos.subtract(draggable._startPos);
   const ground = half.subtract(project(map, half.subtract(delta), true));
   draggable._newPos = draggable._startPos.add(ground);

package/src/controls/cameraControls.js

@@ -1,9 +1,20 @@
-import { ShiftRotate } from '../constants/ShiftRotate.js';
-import { PitchDrag } from '../constants/PitchDrag.js';
-import { Compass } from '../constants/Compass.js';
-import { ContainerResize } from '../constants/ContainerResize.js';
-import { TouchMode } from '../constants/TouchMode.js';
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { rotateControlByMap } from '../weakmaps/rotateControlByMap.js';
+
+import { L } from '../globals/L.js';
+import { Compass } from '../globals/Compass.js';
+import { ContainerResize } from '../globals/ContainerResize.js';
+import { PitchDrag } from '../globals/PitchDrag.js';
+import { ShiftRotate } from '../globals/ShiftRotate.js';
+import { TouchMode } from '../globals/TouchMode.js';
+import { touchByContainer } from '../weakmaps/touchByContainer.js';
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+import { cameraListenerOptions } from '../globals/cameraListenerOptions.js';
+import { cameraEmptyOptions } from '../globals/cameraEmptyOptions.js';
+import { notifyCameraTouchChange } from './notifyCameraTouchChange.js';
+
+
+
 import { rotateOnAdd } from './rotateOnAdd.js';
 import { rotateOnRemove } from './rotateOnRemove.js';
 import { rotateControl } from './rotateControl.js';
@@ -21,10 +32,32 @@ import { endCameraTouchEvent } from './endCameraTouchEvent.js';
 import { changeCameraTouch } from './changeCameraTouch.js';
 import { cleanupCameraTouch } from './cleanupCameraTouch.js';
 import { endAllCameraTouches } from './endAllCameraTouches.js';
+import { addCameraHandler } from './addCameraHandler.js';
 
-cameraControlsState.cameraDrags = new Set();
-cameraControlsState.dragStates = new WeakMap();
-cameraControlsState.cameraTouchStates = new Set();
+Compass.value = L.Handler.extend({
+  addHooks: compassAddHooks,
+  removeHooks: compassRemoveHooks,
+});
+
+ContainerResize.value = L.Handler.extend({
+  addHooks: containerResizeAddHooks,
+  removeHooks: containerResizeRemoveHooks,
+});
+
+PitchDrag.value = L.Handler.extend({
+  addHooks: pitchDragAddHooks,
+  removeHooks: pitchDragRemoveHooks,
+});
+
+ShiftRotate.value = L.Handler.extend({
+  addHooks: shiftRotateAddHooks,
+  removeHooks: shiftRotateRemoveHooks,
+});
+
+TouchMode.value = L.Handler.extend({
+  addHooks: notifyCameraTouchChange,
+  removeHooks: notifyCameraTouchChange,
+});
 
 L.Control.Rotate = L.Control.extend({
   options: { position: 'topleft', closeOnZeroBearing: true, visualizePitch: true },
@@ -35,26 +68,27 @@ L.Control.Rotate = L.Control.extend({
 if (L.control) L.control.rotate = rotateControl;
 
 export function cameraControls(map) {
-  map.addHandler('trackContainerMutation', ContainerResize);
+  addCameraHandler(map, 'trackContainerMutation', ContainerResize.value);
   if (!map.options.rotate) return;
-  map.addHandler('shiftKeyRotate', ShiftRotate);
-  map.addHandler('pitchDrag', PitchDrag);
-  map.addHandler('compassBearing', Compass);
-  map.addHandler('touchRotate', TouchMode);
-  map.addHandler('touchPitch', TouchMode);
+  addCameraHandler(map, 'shiftKeyRotate', ShiftRotate.value);
+  addCameraHandler(map, 'pitchDrag', PitchDrag.value);
+  addCameraHandler(map, 'compassBearing', Compass.value);
+  addCameraHandler(map, 'touchRotate', TouchMode.value);
+  addCameraHandler(map, 'touchPitch', TouchMode.value);
   const container = map.getContainer();
-  const state = map._cameraTouchState = { map, container, touch: null, nativeZoom: undefined };
-  container._cameraTouchState = state;
-  cameraControlsState.cameraTouchStates.add(state);
-  container.addEventListener('touchstart', startCameraTouch, { capture: true, passive: false });
-  container.addEventListener('touchmove', moveCameraTouch, { capture: true, passive: false });
+  const state = /* alloc */ { map, container, touch: null, nativeZoom: undefined };
+  cameraTouchStateByMap.set(map, state);
+  touchByContainer.set(container, state);
+  cameraTouchStates.add(state);
+  container.addEventListener('touchstart', startCameraTouch, cameraListenerOptions);
+  container.addEventListener('touchmove', moveCameraTouch, cameraListenerOptions);
   container.addEventListener('touchend', endCameraTouchEvent, true);
   container.addEventListener('touchcancel', endCameraTouchEvent, true);
   window.addEventListener('blur', endAllCameraTouches);
   map.on('cameratouchchange', changeCameraTouch, map);
   if (map.options.rotateControl) {
-    map.rotateControl = new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : {});
-    map.rotateControl.addTo(map);
+    rotateControlByMap.set(map, /* alloc */ new L.Control.Rotate(typeof map.options.rotateControl === 'object' ? map.options.rotateControl : cameraEmptyOptions));
+    rotateControlByMap.get(map).addTo(map);
   }
   map.once('unload', cleanupCameraTouch, map);
 }

package/src/controls/cameraDragClick.js

@@ -1,9 +1,10 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { dragStates } from '../weakmaps/dragStates.js';
 
-export function cameraDragClick(event) {
-  const state = cameraControlsState.dragStates.get(this);
-  if (!state.moved) return;
-  event.preventDefault();
-  event.stopPropagation();
-  state.moved = false;
+
+export function cameraDragClick(event) {
+  const state = dragStates.value.get(this);
+  if (!state.moved) return;
+  event.preventDefault();
+  event.stopPropagation();
+  state.moved = false;
 }

package/src/controls/cameraDragContextMenu.js

@@ -1,7 +1,8 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { dragStates } from '../weakmaps/dragStates.js';
+
 
 export function cameraDragContextMenu(event) {
-  const state = cameraControlsState.dragStates.get(this);
+  const state = dragStates.value.get(this);
   if (!state.drag && !state.moved) return;
   event.preventDefault();
   event.stopPropagation();

package/src/controls/cameraDragDown.js

@@ -1,20 +1,23 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
-import { editable } from './editable.js';
+import { dragStates } from '../weakmaps/dragStates.js';
+import { cameraFocusOptions } from '../globals/cameraFocusOptions.js';
 
-export function cameraDragDown(event) {
-  const state = cameraControlsState.dragStates.get(this);
-  if (state.drag || !state.accept(event) || editable(event.target)) return;
-  event.preventDefault();
-  event.stopPropagation();
-  state.moved = false;
-  const rect = state.map.getContainer().getBoundingClientRect();
-  state.drag = {
-    id: event.pointerId, x: event.clientX, y: event.clientY, cursor: state.element.style.cursor,
-    cx: rect.left + rect.width / 2, cy: rect.top + rect.height / 2,
-    dragging: state.map.dragging?.enabled(),
-  };
-  state.map.dragging?.disable();
-  state.element.focus?.({ preventScroll: true });
-  state.element.setPointerCapture(event.pointerId);
-  state.element.style.cursor = 'grabbing';
+
+import { editable } from './isEditableTarget.js';
+
+export function cameraDragDown(event) {
+  const state = dragStates.value.get(this);
+  if (state.drag || !state.accept(event) || editable(event.target)) return;
+  event.preventDefault();
+  event.stopPropagation();
+  state.moved = false;
+  const rect = state.map.getContainer().getBoundingClientRect();
+  state.drag = /* alloc */ {
+    id: event.pointerId, x: event.clientX, y: event.clientY, cursor: state.element.style.cursor,
+    cx: rect.left + rect.width / 2, cy: rect.top + rect.height / 2,
+    dragging: state.map.dragging?.enabled(),
+  };
+  state.map.dragging?.disable();
+  state.element.focus?.(cameraFocusOptions);
+  state.element.setPointerCapture(event.pointerId);
+  state.element.style.cursor = 'grabbing';
 }

package/src/controls/cameraDragEnd.js

@@ -1,6 +1,7 @@
+import { dragStates } from '../weakmaps/dragStates.js';
+
 import { finishCameraDrag } from './finishCameraDrag.js';
-import { cameraControlsState } from '../constants/cameraControlsState.js';
 
 export function cameraDragEnd(event) {
-  finishCameraDrag(cameraControlsState.dragStates.get(this), event);
+  finishCameraDrag(dragStates.value.get(this), event);
 }

package/src/controls/cameraDragMove.js

@@ -1,11 +1,17 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { degrees } from '../globals/degrees.js';
+import { dragStates } from '../weakmaps/dragStates.js';
+
+import { mapStopPitchBearingAnimation } from '../animations/mapStopPitchBearingAnimation.js';
+import { mapSetPitchAndBearing } from '../camera/mapSetPitchAndBearing.js';
+import { mapGetPitch } from '../camera/mapGetPitch.js';
+import { mapGetBearing } from '../camera/mapGetBearing.js';
 
 export function cameraDragMove(event) {
-  const state = cameraControlsState.dragStates.get(this);
+  const state = dragStates.value.get(this);
   if (!state.drag || state.drag.id !== event.pointerId) return;
   const x = event.clientX - state.drag.x, y = event.clientY - state.drag.y;
   if (Math.hypot(x, y) < 3 && !state.moved) return;
-  state.map._stopPitchBearingAnimation();
+  mapStopPitchBearingAnimation(state.map);
   state.moved = true;
   event.preventDefault();
   let bearing = x * state.sensitivity[0];
@@ -13,11 +19,10 @@ export function cameraDragMove(event) {
     if (Math.abs(state.drag.cy - state.drag.y) > 100) {
       const angle = Math.atan2(event.clientY - state.drag.cy, event.clientX - state.drag.cx) -
         Math.atan2(event.clientY - state.drag.cy, state.drag.x - state.drag.cx);
-      bearing = Math.atan2(Math.sin(angle), Math.cos(angle)) * 180 / Math.PI;
+      bearing = Math.atan2(Math.sin(angle), Math.cos(angle)) * degrees;
     } else bearing *= event.clientY < state.drag.cy ? 1 : -1;
   }
-  state.map._setPitchAndBearing(state.map.getPitch() - y * state.sensitivity[1],
-    state.map.getBearing() + bearing);
+  mapSetPitchAndBearing(state.map, mapGetPitch(state.map) - y * state.sensitivity[1], mapGetBearing(state.map) + bearing);
   state.drag.x = event.clientX;
   state.drag.y = event.clientY;
 }

package/src/controls/changeCameraTouch.js

@@ -1,8 +1,14 @@
+import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { touchPitchByMap } from '../weakmaps/touchPitchByMap.js';
+import { touchRotateByMap } from '../weakmaps/touchRotateByMap.js';
+
+
+
 import { endCameraTouch } from './endCameraTouch.js';
 
 export function changeCameraTouch() {
-  const state = this._cameraTouchState, { map, container } = state;
-  const active = map.touchRotate.enabled() || map.touchPitch.enabled();
+  const state = cameraTouchStateByMap.get(this), { map, container } = state;
+  const active = touchRotateByMap.get(map).enabled() || touchPitchByMap.get(map).enabled();
   if (active && state.nativeZoom === undefined) {
     state.nativeZoom = map.touchZoom?.enabled();
     map.touchZoom?.disable();

package/src/controls/cleanupCameraTouch.js

@@ -1,24 +1,31 @@
+import { cameraTouchStateByMap } from '../weakmaps/cameraTouchStateByMap.js';
+import { rotateControlByMap } from '../weakmaps/rotateControlByMap.js';
+
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+import { touchByContainer } from '../weakmaps/touchByContainer.js';
+
+
 import { endCameraTouch } from './endCameraTouch.js';
 import { startCameraTouch } from './startCameraTouch.js';
 import { moveCameraTouch } from './moveCameraTouch.js';
 import { endCameraTouchEvent } from './endCameraTouchEvent.js';
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+
 import { endAllCameraTouches } from './endAllCameraTouches.js';
 import { changeCameraTouch } from './changeCameraTouch.js';
 
-export function cleanupCameraTouch() {
-  const state = this._cameraTouchState;
-  if (!state) return;
-  const { container, map } = state;
-  endCameraTouch(state);
-  container.removeEventListener('touchstart', startCameraTouch, true);
-  container.removeEventListener('touchmove', moveCameraTouch, true);
-  container.removeEventListener('touchend', endCameraTouchEvent, true);
-  container.removeEventListener('touchcancel', endCameraTouchEvent, true);
-  cameraControlsState.cameraTouchStates.delete(state);
-  if (!cameraControlsState.cameraTouchStates.size) window.removeEventListener('blur', endAllCameraTouches);
-  map.off('cameratouchchange', changeCameraTouch, map);
-  map.rotateControl?.remove();
-  delete container._cameraTouchState;
-  delete map._cameraTouchState;
+export function cleanupCameraTouch() {
+  const state = cameraTouchStateByMap.get(this);
+  if (!state) return;
+  const { container, map } = state;
+  endCameraTouch(state);
+  container.removeEventListener('touchstart', startCameraTouch, true);
+  container.removeEventListener('touchmove', moveCameraTouch, true);
+  container.removeEventListener('touchend', endCameraTouchEvent, true);
+  container.removeEventListener('touchcancel', endCameraTouchEvent, true);
+  cameraTouchStates.delete(state);
+  if (!cameraTouchStates.size) window.removeEventListener('blur', endAllCameraTouches);
+  map.off('cameratouchchange', changeCameraTouch, map);
+  rotateControlByMap.get(map)?.remove();
+  touchByContainer.delete(container);
+  cameraTouchStateByMap.delete(map);
 }

package/src/controls/compassAddHooks.js

@@ -2,14 +2,17 @@ import { compassOrientation } from './compassOrientation.js';
 import { finishCompassPermission } from './finishCompassPermission.js';
 
 export function compassAddHooks() {
-  this._compassGeneration = (this._generation = (this._generation || 0) + 1);
-  this._orientation = { handler: this, handleEvent: compassOrientation };
-  const permission = window.DeviceOrientationEvent?.requestPermission;
-  let request;
-  try {
-    request = permission ? permission.call(window.DeviceOrientationEvent) : 'granted';
-  } catch (error) {
-    request = Promise.reject(error);
-  }
-  Promise.allSettled([Promise.resolve({ handler: this, generation: this._generation }), request]).then(finishCompassPermission);
+  this._compassGeneration = (this._generation = (this._generation || 0) + 1);
+  this._orientation = /* alloc */ { handler: this, handleEvent: compassOrientation };
+  const permission = window.DeviceOrientationEvent?.requestPermission;
+  let request;
+  try {
+    request = permission ? permission.call(window.DeviceOrientationEvent) : 'granted';
+  } catch (error) {
+    request = Promise.reject(error);
+  }
+  Promise.allSettled(/* alloc */ [
+    Promise.resolve(/* alloc */ { handler: this, generation: this._generation }),
+    request,
+  ]).then(finishCompassPermission);
 }

package/src/controls/compassOrientation.js

@@ -1,6 +1,7 @@
+import { mapSetBearing } from '../camera/mapSetBearing.js';
 export function compassOrientation(event) {
   const handler = this.handler;
   const bearing = Number.isFinite(event.webkitCompassHeading) ? -event.webkitCompassHeading : event.alpha;
   const orientation = event.absolute ? 0 : (screen.orientation?.angle ?? window.orientation ?? 0);
-  if (Number.isFinite(bearing)) handler._map.setBearing(bearing - orientation);
+  if (Number.isFinite(bearing)) mapSetBearing(handler._map, bearing - orientation);
 }

package/src/controls/containerResizeAddHooks.js

@@ -1,8 +1,8 @@
 import { resizeMap } from './resizeMap.js';
 
 export function containerResizeAddHooks() {
-  const container = this._map.getContainer();
-  container._containerResizeMap = this._map;
-  this._observer = new ResizeObserver(resizeMap);
+  const container = this._map.getContainer();
+  container._containerResizeMap = this._map;
+  this._observer = /* alloc */ new ResizeObserver(resizeMap);
   this._observer.observe(container);
 }

package/src/controls/dragCamera.js

@@ -1,4 +1,8 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { cameraDragSensitivity } from '../globals/cameraDragSensitivity.js';
+import { dragStates } from '../weakmaps/dragStates.js';
+import { cameraDrags } from '../globals/cameraDrags.js';
+
+
 import { cameraDragDown } from './cameraDragDown.js';
 import { cameraDragMove } from './cameraDragMove.js';
 import { cameraDragEnd } from './cameraDragEnd.js';
@@ -6,17 +10,17 @@ import { cameraDragClick } from './cameraDragClick.js';
 import { cameraDragContextMenu } from './cameraDragContextMenu.js';
 import { endAllCameraDrags } from './endAllCameraDrags.js';
 
-export function dragCamera(map, element, accept, sensitivity = [0.8, 0.5], orbit = false) {
-  const state = { map, element, accept, sensitivity, orbit, drag: null, moved: false };
-  cameraControlsState.dragStates.set(element, state);
-  cameraControlsState.cameraDrags.add(state);
-  element.addEventListener('pointerdown', cameraDragDown, true);
-  element.addEventListener('pointermove', cameraDragMove);
-  element.addEventListener('pointerup', cameraDragEnd);
-  element.addEventListener('pointercancel', cameraDragEnd);
-  element.addEventListener('lostpointercapture', cameraDragEnd);
-  element.addEventListener('click', cameraDragClick, true);
-  element.addEventListener('contextmenu', cameraDragContextMenu);
-  window.addEventListener('blur', endAllCameraDrags);
-  return state;
+export function dragCamera(map, element, accept, sensitivity = cameraDragSensitivity, orbit = false) {
+  const state = /* alloc */ { map, element, accept, sensitivity, orbit, drag: null, moved: false };
+  dragStates.value.set(element, state);
+  cameraDrags.value.add(state);
+  element.addEventListener('pointerdown', cameraDragDown, true);
+  element.addEventListener('pointermove', cameraDragMove);
+  element.addEventListener('pointerup', cameraDragEnd);
+  element.addEventListener('pointercancel', cameraDragEnd);
+  element.addEventListener('lostpointercapture', cameraDragEnd);
+  element.addEventListener('click', cameraDragClick, true);
+  element.addEventListener('contextmenu', cameraDragContextMenu);
+  window.addEventListener('blur', endAllCameraDrags);
+  return state;
 }

package/src/controls/endAllCameraDrags.js

@@ -1,7 +1,9 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { cameraDrags } from '../globals/cameraDrags.js';
+
+
 import { finishCameraDrag } from './finishCameraDrag.js';
 
 export function endAllCameraDrags() {
   let state;
-  for (state of cameraControlsState.cameraDrags) finishCameraDrag(state);
+  for (state of cameraDrags.value) finishCameraDrag(state);
 }

package/src/controls/endAllCameraTouches.js

@@ -1,7 +1,9 @@
-import { cameraControlsState } from '../constants/cameraControlsState.js';
+import { cameraTouchStates } from '../globals/cameraTouchStates.js';
+
+
 import { endCameraTouch } from './endCameraTouch.js';
 
 export function endAllCameraTouches() {
   let state;
-  for (state of cameraControlsState.cameraTouchStates) endCameraTouch(state);
+  for (state of cameraTouchStates) endCameraTouch(state);
 }

package/src/controls/endCameraTouch.js

@@ -5,7 +5,8 @@ export function endCameraTouch(state, event) {
   if (touch.dragging && container._leaflet_id) map.dragging.enable();
   map.options.zoomSnap = touch.snap;
   if (touch.zooming && touch.snap && container._leaflet_id) {
-    map.setZoom(Math.round(map.getZoom() / touch.snap) * touch.snap, { animate: false });
+    map.setZoom(Math.round(map.getZoom() / touch.snap) * touch.snap,
+      /* alloc */ { animate: false });
   }
   state.touch = null;
-}
+}

package/src/controls/endCameraTouchEvent.js

@@ -1,5 +1,8 @@
+import { touchByContainer } from '../weakmaps/touchByContainer.js';
+
+
 import { endCameraTouch } from './endCameraTouch.js';
 
-export function endCameraTouchEvent(event) {
-  endCameraTouch(this._cameraTouchState, event);
+export function endCameraTouchEvent(event) {
+  endCameraTouch(touchByContainer.get(this), event);
 }

package/src/controls/failCompassPermission.js

@@ -0,0 +1,4 @@
+export function failCompassPermission(handler, error) {
+  handler.disable();
+  handler._map.fire('error', /* alloc */ { error });
+}

package/src/controls/finishCompassPermission.js

@@ -1,16 +1,17 @@
+import { failCompassPermission } from './failCompassPermission.js';
+
 export function finishCompassPermission([handlerResult, permissionResult]) {
   const { handler, generation } = handlerResult.value;
+  if (!handler.enabled() || handler._generation !== generation) return;
+  if (!window.DeviceOrientationEvent || permissionResult.status !== 'fulfilled' ||
+    permissionResult.value !== 'granted') {
+    return failCompassPermission(handler, permissionResult.status === 'rejected' ? permissionResult.reason :
+      /* alloc */ new Error('Device compass permission unavailable or denied'));
+  }
   try {
-    if (!handler.enabled() || handler._generation !== generation) return;
-    if (!window.DeviceOrientationEvent || permissionResult.status !== 'fulfilled' ||
-      permissionResult.value !== 'granted') {
-      throw permissionResult.status === 'rejected' ? permissionResult.reason :
-        new Error('Device compass permission unavailable or denied');
-    }
     window.addEventListener('deviceorientation', handler._orientation);
     window.addEventListener('deviceorientationabsolute', handler._orientation);
   } catch (error) {
-    handler.disable();
-    handler._map.fire('error', { error });
+    failCompassPermission(handler, error);
   }
-}
+}

package/src/controls/loadCameraControls.js

@@ -3,7 +3,7 @@ export async function loadCameraControls(map) {
     const { cameraControls } = await import('./cameraControls.js');
     if (map._container?._leaflet_id) cameraControls(map);
   } catch (error) {
-    map.fire('error', { error });
+    map.fire('error', /* alloc */ { error });
     throw error;
   }
-}
+}