leaflet-city-mapper 0.0.6 → 0.0.7

package/src/vector-tiles/prepareVectorLabel.js

@@ -0,0 +1,43 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { vectorLabelProperty } from './vectorLabelProperty.js';
+import { vectorStyleValue } from './vectorStyleValue.js';
+import { vectorLabelAnchors } from './vectorLabelAnchors.js';
+
+export function prepareVectorLabel(job, layer, entry, feature, order) {
+  let text = entry.layout?.['text-field'];
+  const { properties } = feature, { zoom } = job;
+  const icon = entry.layout?.['symbol-placement'] === 'line' ? null
+    : evaluateStyle(entry.layout?.['icon-image'], properties, zoom);
+  if (Array.isArray(text)) text = evaluateStyle(text, properties, zoom);
+  if (typeof text !== 'string') text = '';
+  text = text.replace(/\{([^}]+)\}/g, vectorLabelProperty.bind(null, properties));
+  if (!text.trim() && typeof icon !== 'string') return;
+  if (entry.layout?.['text-transform'] === 'uppercase') text = text.toUpperCase();
+  const size = vectorStyleValue(entry.layout, 'text-size', 12, properties, zoom), line = feature.type === 2 && text.trim();
+  const spacing = layer.extent / 16, anchors = /* alloc */ [];
+  let path, anchor;
+  for (path of line ? feature.geometry : feature.geometry.slice(0, 1)) {
+    if (!path?.length) continue;
+    if (!line) anchors.push(/* alloc */ { point: path[Math.floor(path.length / 2)], a: null });
+    else for (anchor of vectorLabelAnchors(path, spacing)) anchors.push(anchor);
+  }
+  for (anchor of anchors) {
+    if (anchor.point[0] < 0 || anchor.point[0] >= layer.extent || anchor.point[1] < 0 || anchor.point[1] >= layer.extent) continue;
+    job.labels.push(/* alloc */ { text, latlng: projectVectorPoint(anchor.point, job.coords, layer.extent),
+    order, entry, properties, size, pixelBase: anchor.length * 256 / layer.extent / 2 ** job.coords.z,
+    along: anchor.a ? /* alloc */ [
+      projectVectorPoint(anchor.a, job.coords, layer.extent),
+      projectVectorPoint(anchor.b, job.coords, layer.extent),
+    ] : null,
+    icon: text.trim() ? null : icon,
+    iconOffset: evaluateStyle(entry.layout?.['icon-offset'], properties, zoom) || /* alloc */ [0, 0],
+    allowOverlap: entry.layout?.['icon-allow-overlap'] === true,
+    color: vectorStyleValue(entry.paint, 'text-color', '#000', properties, zoom),
+    halo: vectorStyleValue(entry.paint, 'text-halo-color', '#fff', properties, zoom),
+    haloWidth: vectorStyleValue(entry.paint, 'text-halo-width', 0, properties, zoom),
+    priority: /* alloc */ ['place_labels', 'place'].includes(entry['source-layer']) ? 0
+      : /* alloc */ ['street_labels', 'transportation_name'].includes(entry['source-layer']) ? 1 : 2,
+        });
+      }
+    }

package/src/vector-tiles/prepareVectorStyleLayer.js

@@ -0,0 +1,30 @@
+import { vectorStyleDependencies } from './vectorStyleDependencies.js';
+import { vectorFeatureZoom } from './vectorFeatureZoom.js';
+import { prepareVectorLabel } from './prepareVectorLabel.js';
+import { vectorFeaturePaint } from './vectorFeaturePaint.js';
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { appendVectorBatch } from './appendVectorBatch.js';
+
+export function prepareVectorStyleLayer(job, layer, entry, order) {
+  const batches = /* alloc */ new Map(), dependencies = vectorStyleDependencies(entry);
+  const outlineColor = entry.type === 'fill' ? entry.paint?.['fill-outline-color'] : null;
+  const outline = outlineColor ? /* alloc */ { ...entry, type: 'line',
+    paint: /* alloc */ { 'line-color': outlineColor, 'line-width': 1 } } : null;
+  let feature, sampleZoom, paint, batch;
+  for (feature of layer.features) {
+    sampleZoom = vectorFeatureZoom(entry, feature.properties, job.zoom, job.maxZoom);
+    if (sampleZoom < 0) continue;
+    if (entry.type === 'symbol') {
+      prepareVectorLabel(job, layer, entry, feature, order);
+      continue;
+    }
+    paint = vectorFeaturePaint(entry, feature, sampleZoom, job.maxZoom);
+    if (!paint) continue;
+    appendVectorBatch(job, layer, entry, feature, order, batches, dependencies, paint);
+    if (outline && feature.type === 3) {
+      appendVectorBatch(job, layer, outline, feature, order, batches, dependencies,
+        vectorPaint(outline, feature.properties, sampleZoom));
+    }
+  }
+  for (batch of batches.values()) if (batch.paths.length) job.output.push(batch);
+}

package/src/vector-tiles/prepareVectorTile.js

@@ -0,0 +1,16 @@
+import { decodeVectorTile } from '../mvt/decodeVectorTile.js';
+import { prepareVectorStyleLayer } from './prepareVectorStyleLayer.js';
+
+export function prepareVectorTile(buffer, coords, style, zoom, source, maxZoom = 19, mapZoom = zoom) {
+  const layers = decodeVectorTile(buffer), byName = /* alloc */ new Map();
+  const job = /* alloc */ { coords, zoom, mapZoom, maxZoom, output: /* alloc */ [], labels: /* alloc */ [],
+    triangles: /* alloc */ new WeakMap(), projected: /* alloc */ new WeakMap() };
+  let layer, order, entry;
+  for (layer of layers) byName.set(layer.name, layer);
+  for ([order, entry] of style.entries()) {
+    layer = byName.get(entry['source-layer']);
+    if (!layer || source !== undefined && entry.source !== source) continue;
+    prepareVectorStyleLayer(job, layer, entry, order);
+  }
+  return /* alloc */ { batches: job.output, labels: job.labels };
+}

package/src/vector-tiles/projectVectorPaths.js

@@ -0,0 +1,15 @@
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { simplifyVectorPath } from './simplifyVectorPath.js';
+
+export function projectVectorPaths(geometry, coords, extent, tolerance) {
+  const paths = /* alloc */ [];
+  let path, simplified, projected, point;
+  for (path of geometry) {
+    simplified = simplifyVectorPath(path, tolerance);
+    if (simplified.length < 3 && Math.hypot(simplified.at(-1)[0] - simplified[0][0], simplified.at(-1)[1] - simplified[0][1]) < tolerance * 2) continue;
+    projected = /* alloc */ [];
+    for (point of simplified) projected.push(projectVectorPoint(point, coords, extent));
+    paths.push(projected);
+  }
+  return paths;
+}

package/src/vector-tiles/projectVectorPoint.js

@@ -0,0 +1,6 @@
+export function projectVectorPoint(point, coords, extent) {
+  const size = 2 ** coords.z;
+  const x = (coords.x + point[0] / extent) / size;
+  const y = (coords.y + point[1] / extent) / size;
+  return /* alloc */ [Math.atan(Math.sinh(Math.PI * (1 - 2 * y))) * 180 / Math.PI, x * 360 - 180];
+}

package/src/vector-tiles/projectVectorTriangles.js

@@ -0,0 +1,18 @@
+import { triangulateVectorRings } from '../mvt/triangulateVectorRings.js';
+import { projectVectorPoint } from './projectVectorPoint.js';
+import { simplifyVectorPath } from './simplifyVectorPath.js';
+
+export function projectVectorTriangles(geometry, coords, extent, tolerance) {
+  const paths = /* alloc */ [], rings = /* alloc */ [];
+  let triangle, projected, point, ring;
+  for (ring of geometry) {
+    ring = simplifyVectorPath(ring, tolerance);
+    if (ring.length >= 4) rings.push(ring);
+  }
+  for (triangle of triangulateVectorRings(rings)) {
+    projected = /* alloc */ [];
+    for (point of triangle) projected.push(projectVectorPoint(point, coords, extent));
+    paths.push(/* alloc */ [projected]);
+  }
+  return paths;
+}

package/src/vector-tiles/pruneVectorTiles.js

@@ -0,0 +1,11 @@
+import { reportError } from '../scene/reportLayerError.js';
+import { vectorTileAwaited } from './vectorTileAwaited.js';
+
+export function pruneVectorTiles() {
+  let tile, key;
+  for ([key, tile] of this.tiles) {
+    if (tile.needed || tile.group && vectorTileAwaited(this, tile)) continue;
+    tile.controller.abort(); this.tiles.delete(key);
+    if (tile.group) this.retire(tile.group).catch(reportError.bind(null, this));
+  }
+}

package/src/vector-tiles/pumpVectorTiles.js

@@ -0,0 +1,18 @@
+import { compareVectorTileDistance } from './compareVectorTileDistance.js';
+
+export function pumpVectorTiles() {
+  if (!this.session) return;
+  const center = this._map.getCenter(), pending = /* alloc */ [];
+  let tile, point;
+  for (tile of this.tiles.values()) {
+    if (!tile.needed || tile.started) continue;
+    point = this._map.project(center, tile.coords.z).divideBy(256);
+    tile.distance = (tile.coords.x - point.x) ** 2 + (tile.coords.y - point.y) ** 2;
+    pending.push(tile);
+  }
+  pending.sort(compareVectorTileDistance);
+  for (tile of pending) {
+    if (this.inflight >= 4) break;
+    tile.started = true; this.inflight++; this.load(tile);
+  }
+}

package/src/vector-tiles/readTileJSON.js

@@ -0,0 +1,17 @@
+export async function readTileJSON(options) {
+  const url = /* alloc */ new URL(options.tileJSON, document.baseURI).href;
+  const response = await fetch(url);
+  if (!response.ok) throw /* alloc */ new Error(`TileJSON: HTTP ${response.status}`);
+  const metadata = await response.json();
+  if (!metadata || !Array.isArray(metadata.tiles) || !metadata.tiles.length ||
+      typeof metadata.tiles[0] !== 'string') {
+    throw /* alloc */ new Error('TileJSON requires a tile URL template');
+  }
+  return /* alloc */ {
+    ...options,
+    url: /* alloc */ new URL(metadata.tiles[0], url).href,
+    minNativeZoom: options.minNativeZoom ?? metadata.minzoom,
+    maxNativeZoom: options.maxNativeZoom ?? metadata.maxzoom,
+    attribution: options.attribution ?? metadata.attribution,
+  };
+}

package/src/vector-tiles/readVectorStyle.js

@@ -0,0 +1,17 @@
+import { parseVectorStyle } from '../vector-style/parseVectorStyle.js';
+
+export async function readVectorStyle(style) {
+  if (typeof style === 'string') {
+    const response = await fetch(style);
+    if (!response.ok) throw /* alloc */ new Error(`Vector style: HTTP ${response.status}`);
+    style = parseVectorStyle(await response.text());
+  } else style = style?.layers ?? style;
+  if (!Array.isArray(style)) throw /* alloc */ new Error('Invalid vector style layers');
+  let entry;
+  for (entry of style) {
+    if (!entry || typeof entry.id !== 'string' || typeof entry.type !== 'string') {
+      throw /* alloc */ new Error('Invalid vector style layers');
+    }
+  }
+  return style;
+}

package/src/vector-tiles/refreshVectorTiles.js

@@ -0,0 +1,5 @@
+export function refreshVectorTiles() {
+  clearTimeout(this.timer);
+  this.changedAt = performance.now();
+  this.timer = setTimeout(this.update.bind(this), 180);
+}

package/src/vector-tiles/reserveVectorLabelCells.js

@@ -0,0 +1,6 @@
+export function reserveVectorLabelCells(cells, occupied) {
+  let cell;
+  for (cell of cells) if (occupied.has(cell)) return false;
+  for (cell of cells) occupied.add(cell);
+  return true;
+}

package/src/vector-tiles/retireVectorTileGroup.js

@@ -0,0 +1,13 @@
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function retireVectorTileGroup(group) {
+  const session = this.session;
+  this.retiring.add(group);
+  let removed = 0, layer;
+  for (layer of group.getLayers()) {
+    if (this.session !== session) return;
+    group.removeLayer(layer);
+    if (++removed % 8 === 0) await yieldTask();
+  }
+  group.remove(); this.retiring.delete(group);
+}

package/src/vector-tiles/revokeVectorWorkerUrl.js

@@ -0,0 +1,9 @@
+import { vectorWorkerByLayer } from '../weakmaps/vectorWorkerByLayer.js';
+
+export function revokeVectorWorkerUrl(layer) {
+  const entry = vectorWorkerByLayer.get(layer);
+  if (entry?.blobUrl) {
+    URL.revokeObjectURL(entry.blobUrl);
+    entry.blobUrl = null;
+  }
+}

package/src/vector-tiles/rotateVectorLabel.js

@@ -0,0 +1,12 @@
+import { radians } from '../globals/radians.js';
+import { markerSetRotation } from '../core/markerSetRotation.js';
+
+export function rotateVectorLabel(map, marker, label) {
+  if (!label.along) return;
+  const a = map.latLngToContainerPoint(label.along[0]), b = map.latLngToContainerPoint(label.along[1]);
+  let angle = Math.atan2(b.y - a.y, b.x - a.x) / radians;
+  if (angle > 90) angle -= 180;
+  else if (angle < -90) angle += 180;
+  if (marker.options.rotation === angle * radians) return;
+  markerSetRotation(marker, angle * radians);
+}

package/src/vector-tiles/rotateVectorLabels.js

@@ -0,0 +1,6 @@
+import { rotateVectorLabel } from './rotateVectorLabel.js';
+
+export function rotateVectorLabels() {
+  let marker;
+  for (marker of this.labels.values()) if (marker._mvtLabel) rotateVectorLabel(this._map, marker, marker._mvtLabel);
+}

package/src/vector-tiles/simplifyVectorPath.js

@@ -0,0 +1,21 @@
+export function simplifyVectorPath(path, tolerance) {
+  if (path.length < 3) return path;
+  const keep = /* alloc */ new Uint8Array(path.length);
+  const stack = /* alloc */ [/* alloc */ [0, path.length - 1]], output = /* alloc */ [];
+  keep[0] = keep[path.length - 1] = 1;
+  let start, end, a, b, dx, dy, length, index, distance, i, p, t, squared;
+  while (stack.length) {
+    [start, end] = stack.pop(); a = path[start]; b = path[end];
+    dx = b[0] - a[0]; dy = b[1] - a[1]; length = dx * dx + dy * dy;
+    index = -1; distance = tolerance * tolerance;
+    for (i = start + 1; i < end; i++) {
+      p = path[i];
+      t = length ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / length)) : 0;
+      squared = (p[0] - a[0] - t * dx) ** 2 + (p[1] - a[1] - t * dy) ** 2;
+      if (squared > distance) { distance = squared; index = i; }
+    }
+    if (index >= 0) { keep[index] = 1; stack.push(/* alloc */ [start, index], /* alloc */ [index, end]); }
+  }
+  for (i = 0; i < path.length; i++) if (keep[i]) output.push(path[i]);
+  return output;
+}

package/src/vector-tiles/updateVectorLabelMarker.js

@@ -0,0 +1,27 @@
+import { L } from '../globals/L.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorLabelIcon } from './vectorLabelIcon.js';
+import { rotateVectorLabel } from './rotateVectorLabel.js';
+import { forwardVectorTileError } from './forwardVectorTileError.js';
+
+export function updateVectorLabelMarker(owner, label, key) {
+  const appearance = JSON.stringify(/* alloc */ [label.size, label.color, label.halo, label.haloWidth, label.icon]);
+  const sheet = vectorTileOptionsByLayer.get(owner).spriteSheet;
+  let marker = owner.labels.get(key);
+  if (marker) {
+    marker._mvtLabel = label;
+    if (marker._mvtLabelStyle === appearance) { rotateVectorLabel(owner._map, marker, label); return false; }
+    marker.setIcon(vectorLabelIcon(label, sheet));
+  } else {
+    const { pane } = vectorTileOptionsByLayer.get(owner);
+    marker = /* alloc */ new L.Marker(label.latlng, /* alloc */ {
+      icon: vectorLabelIcon(label, sheet), pane: `${pane}-${label.order}`, title: label.text,
+      alt: label.text, interactive: false, keyboard: false, rotateWithView: false,
+    }).on('error', forwardVectorTileError, owner).addTo(owner._map);
+    owner.labels.set(key, marker);
+  }
+  marker._mvtLabelStyle = appearance;
+  marker._mvtLabel = label;
+  rotateVectorLabel(owner._map, marker, label);
+  return true;
+}

package/src/vector-tiles/updateVectorTileLabels.js

@@ -0,0 +1,28 @@
+import { vectorLabelCandidates } from './vectorLabelCandidates.js';
+import { vectorLabelCells } from './vectorLabelCells.js';
+import { reserveVectorLabelCells } from './reserveVectorLabelCells.js';
+import { updateVectorLabelMarker } from './updateVectorLabelMarker.js';
+import { vectorTilesIdle } from './vectorTilesIdle.js';
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function updateVectorTileLabels() {
+  const session = this.session, revision = this.labelRevision = (this.labelRevision || 0) + 1;
+  this.labelsReady = false;
+  const candidates = vectorLabelCandidates(this), size = this._map.getSize();
+  const occupied = /* alloc */ new Set(), retained = /* alloc */ new Set();
+  let visited = 0, label, key, cells, marker;
+  for (label of candidates) {
+    if (++visited % 128 === 0) await yieldTask();
+    if (!vectorTilesIdle(this, session) || this.labelRevision !== revision) return;
+    cells = vectorLabelCells(this, label, size);
+    if (!cells || !label.allowOverlap && !reserveVectorLabelCells(cells, occupied)) continue;
+    key = `${label.text}${label.icon || ''}:${label.latlng.join(':')}`;
+    retained.add(key);
+    if (updateVectorLabelMarker(this, label, key)) await yieldTask();
+  }
+  for ([key, marker] of this.labels) {
+    if (!vectorTilesIdle(this, session) || this.labelRevision !== revision) return;
+    if (!retained.has(key)) { marker.remove(); this.labels.delete(key); await yieldTask(); }
+  }
+  this.labelsReady = true;
+}

package/src/vector-tiles/updateVectorTilePaint.js

@@ -0,0 +1,20 @@
+import { paintVectorTileBatch } from './paintVectorTileBatch.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { vectorTilesIdle } from './vectorTilesIdle.js';
+import { yieldTask } from '../utils/yieldTask.js';
+
+export async function updateVectorTilePaint() {
+  const zoom = vectorStyleZoom(this), session = this.session;
+  if (this.paintZoom === zoom) return;
+  const revision = this.paintRevision = (this.paintRevision || 0) + 1;
+  let updated = 0, tile, batch;
+  for (tile of this.tiles.values()) {
+    if (!tile.rendered) continue;
+    for (batch of tile.rendered) {
+      if (!vectorTilesIdle(this, session) || this.paintRevision !== revision || vectorStyleZoom(this) !== zoom) return;
+      paintVectorTileBatch(batch, zoom);
+      if (++updated % 32 === 0) await yieldTask();
+    }
+  }
+  this.paintZoom = zoom;
+}

package/src/vector-tiles/updateVectorTiles.js

@@ -0,0 +1,29 @@
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { reportError } from '../scene/reportLayerError.js';
+
+export function updateVectorTiles() {
+  if (!this.session) return;
+  const { minNativeZoom, maxNativeZoom } = vectorTileOptionsByLayer.get(this);
+  const z = Math.max(minNativeZoom, Math.min(maxNativeZoom, Math.floor(vectorStyleZoom(this))));
+  const bounds = this._map.getBounds(), count = 2 ** z;
+  const nw = this._map.project(bounds.getNorthWest(), z).divideBy(256);
+  const se = this._map.project(bounds.getSouthEast(), z).divideBy(256);
+  let tile, x, y, key;
+  for (tile of this.tiles.values()) tile.needed = false;
+  for (x = Math.floor(nw.x); x <= Math.floor(se.x); x++) {
+    for (y = Math.max(0, Math.floor(nw.y)); y <= Math.min(count - 1, Math.floor(se.y)); y++) {
+      key = `${z}/${x}/${y}`;
+      tile = this.tiles.get(key);
+      if (!tile) {
+        tile = /* alloc */ { key, coords: /* alloc */ { z, x, y }, controller: /* alloc */ new AbortController() };
+        this.tiles.set(key, tile);
+      }
+      tile.needed = true;
+    }
+  }
+  this.prune();
+  this.pump();
+  this.updatePaint().catch(reportError.bind(null, this));
+  this.updateLabels().catch(reportError.bind(null, this));
+}

package/src/vector-tiles/validateVectorTileZooms.js

@@ -0,0 +1,6 @@
+export function validateVectorTileZooms(minNativeZoom, maxNativeZoom, maxZoom) {
+  if (!Number.isInteger(minNativeZoom) || !Number.isInteger(maxNativeZoom) || !Number.isInteger(maxZoom) ||
+      minNativeZoom < 0 || maxNativeZoom < minNativeZoom || maxZoom < maxNativeZoom || maxZoom > 24) {
+    throw /* alloc */ new Error('Invalid vector tile zoom range');
+  }
+}

package/src/vector-tiles/vectorFeaturePaint.js

@@ -0,0 +1,15 @@
+import { vectorPaint } from '../vector-style/vectorPaint.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorFeaturePaint(entry, feature, sampleZoom, maxZoom) {
+  if (entry.type === 'fill') return feature.type === 3 ? vectorPaint(entry, feature.properties, sampleZoom) : null;
+  if (entry.type !== 'line' || feature.type !== 2) return null;
+  let paint = vectorPaint(entry, feature.properties, sampleZoom), candidate;
+  if (paint.weight > 0 && paint.opacity > 0) return paint;
+  for (candidate = maxZoom; candidate >= 0; candidate--) {
+    if (!visibleStyle(entry, feature.properties, candidate)) continue;
+    paint = vectorPaint(entry, feature.properties, candidate);
+    if (paint.weight > 0 && paint.opacity > 0) return paint;
+  }
+  return null;
+}

package/src/vector-tiles/vectorFeaturePaths.js

@@ -0,0 +1,16 @@
+import { projectVectorTriangles } from './projectVectorTriangles.js';
+import { projectVectorPaths } from './projectVectorPaths.js';
+import { vectorTolerance } from './vectorTolerance.js';
+
+export function vectorFeaturePaths(job, layer, entry, feature) {
+  const cache = entry.type === 'fill' ? job.triangles : job.projected;
+  let paths = cache.get(feature);
+  if (!paths) {
+    const tolerance = vectorTolerance(job, layer);
+    paths = entry.type === 'fill'
+      ? projectVectorTriangles(feature.geometry, job.coords, layer.extent, tolerance)
+      : projectVectorPaths(feature.geometry, job.coords, layer.extent, tolerance);
+    cache.set(feature, paths);
+  }
+  return paths;
+}

package/src/vector-tiles/vectorFeatureZoom.js

@@ -0,0 +1,8 @@
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorFeatureZoom(entry, properties, zoom, maxZoom) {
+  if (visibleStyle(entry, properties, zoom)) return zoom;
+  zoom = maxZoom;
+  while (zoom >= 0 && !visibleStyle(entry, properties, zoom)) zoom--;
+  return zoom;
+}

package/src/vector-tiles/vectorLabelAnchors.js

@@ -0,0 +1,24 @@
+import { vectorStraightRun } from './vectorStraightRun.js';
+
+/** Anchors evenly spread along a path: each is a point on a segment plus that segment's ends. */
+export function vectorLabelAnchors(path, spacing) {
+  const anchors = /* alloc */ [];
+  let length = 0, i, walked, target, count, k, segment, t, point;
+  for (i = 1; i < path.length; i++) length += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
+  count = Math.max(1, Math.floor(length / spacing));
+  i = 1; walked = 0;
+  for (k = 0; k < count; k++) {
+    target = (k + 0.5) * length / count;
+    while (i < path.length - 1 && walked + Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]) < target) {
+      walked += Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]); i++;
+    }
+    segment = Math.hypot(path[i][0] - path[i - 1][0], path[i][1] - path[i - 1][1]);
+    t = segment ? Math.min(1, Math.max(0, (target - walked) / segment)) : 0;
+    point = /* alloc */ [
+      path[i - 1][0] + (path[i][0] - path[i - 1][0]) * t, path[i - 1][1] + (path[i][1] - path[i - 1][1]) * t,
+    ];
+    anchors.push(/* alloc */ { point, a: path[i - 1], b: path[i],
+      length: vectorStraightRun(path, i, point, 1) + vectorStraightRun(path, i, point, -1) });
+  }
+  return anchors;
+}

package/src/vector-tiles/vectorLabelCandidates.js

@@ -0,0 +1,11 @@
+import { compareVectorLabelPriority } from './compareVectorLabelPriority.js';
+
+export function vectorLabelCandidates(layer) {
+  const candidates = /* alloc */ [];
+  let tile, label;
+  for (tile of layer.tiles.values()) {
+    if (!tile.needed || !tile.labelCandidates) continue;
+    for (label of tile.labelCandidates) candidates.push(label);
+  }
+  return candidates.sort(compareVectorLabelPriority);
+}

package/src/vector-tiles/vectorLabelCells.js

@@ -0,0 +1,26 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+import { vectorStyleZoom } from './vectorStyleZoom.js';
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+import { visibleStyle } from '../vector-style/visibleStyle.js';
+
+export function vectorLabelCells(layer, label, size) {
+  const map = layer._map, zoom = vectorStyleZoom(layer);
+  if (!visibleStyle(label.entry, label.properties, zoom)) return null;
+  label.size = evaluateStyle(label.entry.layout?.['text-size'] ?? 12, label.properties, zoom);
+  if (!(label.size > 0)) return null;
+  if (label.icon && !vectorTileOptionsByLayer.get(layer).spriteSheet?.index[label.icon]) return null;
+  label.color = evaluateStyle(label.entry.paint?.['text-color'] ?? '#000', label.properties, zoom);
+  label.halo = evaluateStyle(label.entry.paint?.['text-halo-color'] ?? '#fff', label.properties, zoom);
+  label.haloWidth = evaluateStyle(label.entry.paint?.['text-halo-width'] ?? 0, label.properties, zoom);
+  if (label.along && label.pixelBase * 2 ** map.getZoom() < label.text.length * label.size * 0.6) return null;
+  const point = map.latLngToContainerPoint(label.latlng);
+  if (point.x < 0 || point.y < 0 || point.x > size.x || point.y > size.y) return null;
+  const width = label.text.length * label.size * 0.65 + 16, cells = /* alloc */ [];
+  let x, y;
+  for (x = Math.floor((point.x - width / 2) / 32); x <= Math.floor((point.x + width / 2) / 32); x++) {
+    for (y = Math.floor((point.y - label.size) / 24); y <= Math.floor((point.y + label.size) / 24); y++) {
+      cells.push(`${x}:${y}`);
+    }
+  }
+  return cells;
+}

package/src/vector-tiles/vectorLabelIcon.js

@@ -0,0 +1,30 @@
+import { L } from '../globals/L.js';
+import { vectorSpriteIcon } from './vectorSpriteIcon.js';
+import { wrapVectorLabel } from './wrapVectorLabel.js';
+
+export function vectorLabelIcon(label, sheet) {
+  if (label.icon) return vectorSpriteIcon(label, sheet);
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  const lines = label.along ? [label.text] : wrapVectorLabel(label.text);
+  let longest = 0, line, key, text, index;
+  for (line of lines) longest = Math.max(longest, Array.from(line).length);
+  const width = Math.max(40, longest * label.size * 0.65 + 12);
+  const lineHeight = label.size * 1.2, height = lines.length * lineHeight + 12;
+  svg.setAttribute('width', width); svg.setAttribute('height', height);
+  const attributes = /* alloc */ {
+    x: width / 2, 'text-anchor': 'middle',
+    'font-family': 'sans-serif', 'font-size': label.size,
+    fill: label.color, stroke: label.halo, 'stroke-width': label.haloWidth * 2, 'paint-order': 'stroke',
+  };
+  for (index = 0; index < lines.length; index++) {
+    text = document.createElementNS(svg.namespaceURI, 'text');
+    for (key of Object.keys(attributes)) text.setAttribute(key, attributes[key]);
+    text.setAttribute('y', height / 2 + (index - (lines.length - 1) / 2) * lineHeight + label.size * 0.35);
+    text.textContent = lines[index];
+    svg.append(text);
+  }
+  return /* alloc */ new L.Icon(/* alloc */ {
+    iconUrl: `data:image/svg+xml;charset=utf-8,${encodeURIComponent((/* alloc */ new XMLSerializer()).serializeToString(svg))}`,
+    iconSize: /* alloc */ [width, height], iconAnchor: /* alloc */ [width / 2, height / 2],
+  });
+}

package/src/vector-tiles/vectorLabelProperty.js

@@ -0,0 +1,3 @@
+export function vectorLabelProperty(properties, match, key) {
+  return properties[key] ?? '';
+}

package/src/vector-tiles/vectorSpriteIcon.js

@@ -0,0 +1,11 @@
+import { L } from '../globals/L.js';
+
+export function vectorSpriteIcon(label, sheet) {
+  const { x, y, width, height } = sheet.index[label.icon], [dx, dy] = label.iconOffset;
+  return /* alloc */ new L.DivIcon(/* alloc */ {
+    className: '',
+    html: `<div style="width:${width}px;height:${height}px;background:url(${sheet.url}) -${x}px -${y}px"></div>`,
+    iconSize: /* alloc */ [width, height],
+    iconAnchor: /* alloc */ [width / 2 - dx, height / 2 - dy],
+  });
+}

package/src/vector-tiles/vectorStraightRun.js

@@ -0,0 +1,14 @@
+/** Distance from a point on segment (i-1, i) along the path until it turns more than ~45 degrees from that segment. */
+export function vectorStraightRun(path, i, point, step) {
+  const base = Math.atan2(path[i][1] - path[i - 1][1], path[i][0] - path[i - 1][0]);
+  let j = step > 0 ? i : i - 1, previous = point, run = 0, next;
+  while (j >= 0 && j < path.length) {
+    run += Math.hypot(path[j][0] - previous[0], path[j][1] - previous[1]);
+    previous = path[j];
+    next = j + step;
+    if (next < 0 || next >= path.length) break;
+    if (Math.cos(Math.atan2(path[next][1] - path[j][1], path[next][0] - path[j][0]) - base + (step < 0 ? Math.PI : 0)) < 0.7) break;
+    j = next;
+  }
+  return run;
+}

package/src/vector-tiles/vectorStyleDependencies.js

@@ -0,0 +1,15 @@
+export function vectorStyleDependencies(entry) {
+  const dependencies = /* alloc */ new Set();
+  const expressions = /* alloc */ [entry.paint, entry.filter];
+  let value, child;
+  while (expressions.length) {
+    value = expressions.pop();
+    if (!value || typeof value !== 'object') continue;
+    if (Array.isArray(value) && typeof value[1] === 'string' &&
+        /* alloc */ ['get', 'has', '==', '!=', '<', '>', '<=', '>=', 'in', '!in'].includes(value[0])) {
+      dependencies.add(value[1]);
+    }
+    for (child of Object.values(value)) expressions.push(child);
+  }
+  return dependencies;
+}

package/src/vector-tiles/vectorStyleValue.js

@@ -0,0 +1,5 @@
+import { evaluateStyle } from '../vector-style/evaluateStyle.js';
+
+export function vectorStyleValue(object, key, fallback, properties, zoom) {
+  return object?.[key] === undefined ? fallback : evaluateStyle(object[key], properties, zoom);
+}

package/src/vector-tiles/vectorStyleZoom.js

@@ -0,0 +1,6 @@
+import { vectorTileOptionsByLayer } from '../weakmaps/vectorTileOptionsByLayer.js';
+
+// Style zooms are authored for 512px tiles (MapLibre): `styleZoomOffset: -1` maps Leaflet's 256px zoom onto them.
+export function vectorStyleZoom(layer) {
+  return layer._map.getZoom() + (vectorTileOptionsByLayer.get(layer).styleZoomOffset ?? 0);
+}

package/src/vector-tiles/vectorTileAwaited.js

@@ -0,0 +1,9 @@
+import { vectorTileOverlaps } from './vectorTileOverlaps.js';
+
+export function vectorTileAwaited(layer, stale) {
+  let tile;
+  for (tile of layer.tiles.values()) {
+    if (tile.needed && !tile.group && vectorTileOverlaps(tile.coords, stale.coords)) return true;
+  }
+  return false;
+}

package/src/vector-tiles/vectorTileOverlaps.js

@@ -0,0 +1,4 @@
+export function vectorTileOverlaps(a, b) {
+  const shift = a.z - b.z;
+  return shift >= 0 ? a.x >> shift === b.x && a.y >> shift === b.y : b.x >> -shift === a.x && b.y >> -shift === a.y;
+}