leaflet-city-mapper 0.0.6 → 0.0.7

package/src/models/prepareModelGeometry.js

@@ -0,0 +1,25 @@
+import { geometryEmpty } from '../globals/geometryEmpty.js';
+import { prepareModelPrimitive } from './prepareModelPrimitive.js';
+
+export function prepareModelGeometry(description, scene) {
+  const pending = scene.nodes.slice(), visited = /* alloc */ new Set();
+  const meshes = /* alloc */ new Set(), transfers = /* alloc */ new Set();
+  let index, spec, primitive, attribute, child;
+  while (pending.length) {
+    index = pending.pop();
+    if (visited.has(index)) continue;
+    visited.add(index);
+    spec = description.nodes[index];
+    if (!spec) throw /* alloc */ new Error('Invalid glTF node');
+    if (spec.mesh !== undefined) meshes.add(spec.mesh);
+    for (child of spec.children || geometryEmpty) pending.push(child);
+  }
+  for (index of meshes) {
+    for (primitive of description.meshes[index].primitives) {
+      for (attribute of Object.values(prepareModelPrimitive(description, primitive))) {
+        transfers.add(attribute.data.buffer);
+      }
+    }
+  }
+  return /* alloc */ [...transfers];
+}

package/src/models/prepareModelPrimitive.js

@@ -0,0 +1,17 @@
+import { readModelAttributes } from './readModelAttributes.js';
+import { readModelIndices } from './readModelIndices.js';
+import { vertexNormals } from '../geometry/vertexNormals.js';
+
+export function prepareModelPrimitive(description, primitive) {
+  const { attributes, vertexCount } = readModelAttributes(description, primitive);
+  readModelIndices(description, primitive, attributes, vertexCount);
+  if (!attributes.normal) {
+    attributes.normal = /* alloc */ { size: 3,
+      data: vertexNormals(attributes.position.data, attributes.index?.data) };
+  }
+  if (attributes.index?.data instanceof Uint8Array) {
+    attributes.index.data = Uint16Array.from(attributes.index.data);
+  }
+  primitive.preparedAttributes = attributes;
+  return attributes;
+}

package/src/mvt/addMvtCrossings.js

@@ -0,0 +1,17 @@
+import { mvtEdgeX } from './mvtEdgeX.js';
+
+export function addMvtCrossings(edges, levels) {
+  let i = 0, j, a, b, top, bottom, start, end;
+  for (; i < edges.length; i++) {
+    a = edges[i];
+    for (j = i + 1; j < edges.length; j++) {
+      b = edges[j];
+      top = Math.max(a[0][1], b[0][1]);
+      bottom = Math.min(a[1][1], b[1][1]);
+      if (top >= bottom) continue;
+      start = mvtEdgeX(a, top) - mvtEdgeX(b, top);
+      end = mvtEdgeX(a, bottom) - mvtEdgeX(b, bottom);
+      if (start * end < 0) levels.add(top + (bottom - top) * start / (start - end));
+    }
+  }
+}

package/src/mvt/appendMvtBandTriangles.js

@@ -0,0 +1,31 @@
+import { mvtEdgeX } from './mvtEdgeX.js';
+import { sortMvtActiveEdges } from './sortMvtActiveEdges.js';
+
+export function appendMvtBandTriangles(edges, top, bottom, triangles) {
+  const mid = (top + bottom) / 2, active = /* alloc */ [];
+  let edge, i = 0, leftTop, leftBottom, rightTop, rightBottom;
+  for (edge of edges) {
+    if (edge[0][1] < mid && edge[1][1] > mid) {
+      active.push(/* alloc */ { edge, x: mvtEdgeX(edge, mid) });
+    }
+  }
+  sortMvtActiveEdges(active);
+  if (active.length % 2) throw /* alloc */ new Error('Unbalanced MVT polygon edges');
+  for (; i < active.length; i += 2) {
+    leftTop = mvtEdgeX(active[i].edge, top);
+    leftBottom = mvtEdgeX(active[i].edge, bottom);
+    rightTop = mvtEdgeX(active[i + 1].edge, top);
+    rightBottom = mvtEdgeX(active[i + 1].edge, bottom);
+    if (rightTop < leftTop - 1e-8 || rightBottom < leftBottom - 1e-8) {
+      throw /* alloc */ new Error('Crossing MVT polygon edges');
+    }
+    if ((rightTop - leftTop) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [leftTop, top], /* alloc */ [rightTop, top],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+    if ((rightBottom - leftBottom) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [rightTop, top], /* alloc */ [rightBottom, bottom],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+  }
+}

package/src/mvt/appendMvtCoordinates.js

@@ -0,0 +1,11 @@
+export function appendMvtCoordinates(commands, state, count) {
+  let i = 0, dx, dy;
+  for (; i < count; i++) {
+    dx = commands[state.index++];
+    dy = commands[state.index++];
+    if (dx > 0xffffffff || dy > 0xffffffff) throw /* alloc */ new Error('Invalid MVT coordinate');
+    state.x += dx % 2 ? -(dx + 1) / 2 : dx / 2;
+    state.y += dy % 2 ? -(dy + 1) / 2 : dy / 2;
+    state.path.push(/* alloc */ [state.x, state.y]);
+  }
+}

package/src/mvt/appendMvtPolygonTriangles.js

@@ -0,0 +1,19 @@
+import { tessellateVectorRings } from './tessellateVectorRings.js';
+import { triangulate } from '../triangulation/triangulate.js';
+import { isMvtFallbackError } from './isMvtFallbackError.js';
+
+export function appendMvtPolygonTriangles(rings, paths, vertices, triangles) {
+  let indices, index, triangle, points, i = 0;
+  try {
+    indices = triangulate(paths[0], paths.slice(1));
+    for (triangle of indices) {
+      points = /* alloc */ [];
+      for (index of triangle) points.push(/* alloc */ [vertices[index].x, vertices[index].y]);
+      triangles.push(points);
+    }
+  } catch (error) {
+    if (!isMvtFallbackError(error)) throw error;
+    indices = tessellateVectorRings(rings);
+    for (; i < indices.length; i++) triangles.push(indices[i]);
+  }
+}

package/src/mvt/beginMvtPath.js

@@ -0,0 +1,9 @@
+import { finishMvtPath } from './finishMvtPath.js';
+
+export function beginMvtPath(state, paths, type, count) {
+  finishMvtPath(state.path, type, state.closed);
+  if (type !== 1 && count !== 1) throw /* alloc */ new Error('Invalid MVT MoveTo');
+  state.path = /* alloc */ [];
+  paths.push(state.path);
+  state.closed = false;
+}

package/src/mvt/closeMvtPath.js

@@ -0,0 +1,7 @@
+export function closeMvtPath(state, type, count) {
+  if (type !== 3 || count !== 1 || !state.path || state.closed || state.path.length < 3) {
+    throw /* alloc */ new Error('Invalid MVT ClosePath');
+  }
+  state.path.push(/* alloc */ [...state.path[0]]);
+  state.closed = true;
+}

package/src/mvt/collectMvtEdges.js

@@ -0,0 +1,19 @@
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+export function collectMvtEdges(rings, edges, levels) {
+  let ring, i, a, b;
+  for (ring of rings) {
+    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
+      throw /* alloc */ new Error('MVT tessellation requires closed rings');
+    }
+    for (i = 1; i < ring.length; i++) {
+      a = ring[i - 1];
+      b = ring[i];
+      if (!finiteMvtCoordinate(a) || !finiteMvtCoordinate(b)) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      levels.add(a[1]);
+      if (a[1] !== b[1]) edges.push(/* alloc */ [a[1] < b[1] ? a : b, a[1] < b[1] ? b : a]);
+    }
+  }
+}

package/src/mvt/createMvtReader.js

@@ -0,0 +1,7 @@
+export function createMvtReader(bytes) {
+  return /* alloc */ {
+    bytes,
+    view: /* alloc */ new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+    pos: 0,
+  };
+}

package/src/mvt/decodeVectorTile.js

@@ -0,0 +1,32 @@
+import { createMvtReader } from './createMvtReader.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtLayer } from './readMvtLayer.js';
+import { readMvtMessage } from './readMvtMessage.js';
+import { skipMvtField } from './skipMvtField.js';
+
+/**
+ * Decode an uncompressed MVT ArrayBuffer/Uint8Array into tile-local layers.
+ * Feature types: 0 unknown, 1 points, 2 lines, 3 polygon rings (including holes).
+ * Integers outside JavaScript's safe range are returned as decimal strings.
+ */
+export function decodeVectorTile(buffer) {
+  if (!(buffer instanceof ArrayBuffer) && !(buffer instanceof Uint8Array)) {
+    throw /* alloc */ new TypeError('MVT input must be an ArrayBuffer or Uint8Array');
+  }
+  const bytes = buffer instanceof Uint8Array ? buffer : /* alloc */ new Uint8Array(buffer);
+  const reader = createMvtReader(bytes);
+  const layers = /* alloc */ [], names = /* alloc */ new Set();
+  let field, wire, layer;
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field !== 3) {
+      skipMvtField(reader, wire);
+      continue;
+    }
+    layer = readMvtLayer(readMvtMessage(reader, wire));
+    if (names.has(layer.name)) throw /* alloc */ new Error('Duplicate MVT layer name');
+    names.add(layer.name);
+    layers.push(layer);
+  }
+  return layers;
+}

package/src/mvt/expectMvtWire.js

@@ -0,0 +1,3 @@
+export function expectMvtWire(wire, expected) {
+  if (wire !== expected) throw /* alloc */ new Error('Invalid MVT wire type');
+}

package/src/mvt/finishMvtPath.js

@@ -0,0 +1,5 @@
+export function finishMvtPath(path, type, closed) {
+  if (path && (type === 2 && path.length < 2 || type === 3 && !closed)) {
+    throw /* alloc */ new Error('Incomplete MVT geometry');
+  }
+}

package/src/mvt/finiteMvtCoordinate.js

@@ -0,0 +1,7 @@
+export function finiteMvtCoordinate(point) {
+  let i = 0;
+  for (; i < point.length; i++) {
+    if (!Number.isFinite(point[i])) return false;
+  }
+  return true;
+}

package/src/mvt/groupMvtPolygons.js

@@ -0,0 +1,25 @@
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+export function groupMvtPolygons(rings) {
+  const polygons = /* alloc */ [];
+  let polygon, exteriorSign, ring, area, i;
+  for (ring of rings) {
+    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
+      throw /* alloc */ new Error('MVT tessellation requires closed rings');
+    }
+    area = 0;
+    for (i = 1; i < ring.length; i++) {
+      if (!finiteMvtCoordinate(ring[i]) || !finiteMvtCoordinate(ring[i - 1])) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      area += ring[i - 1][0] * ring[i][1] - ring[i][0] * ring[i - 1][1];
+    }
+    if (!polygon || area && Math.sign(area) === exteriorSign) {
+      polygon = /* alloc */ [];
+      polygons.push(polygon);
+      exteriorSign = Math.sign(area);
+    }
+    polygon.push(ring);
+  }
+  return polygons;
+}

package/src/mvt/isMvtFallbackError.js

@@ -0,0 +1,6 @@
+export function isMvtFallbackError(error) {
+  return error.message === 'Polygon triangulation area mismatch' ||
+    error.message === 'Degenerate polygon ring' ||
+    error.message === 'Unable to triangulate polygon: invalid or self-intersecting rings' ||
+    error.message === 'Unable to connect polygon hole';
+}

package/src/mvt/mergeMvtActiveEdges.js

@@ -0,0 +1,9 @@
+export function mergeMvtActiveEdges(active, sorted, left, mid, right) {
+  let i = left, j = mid, k = left;
+  while (i < mid && j < right) {
+    if (active[j].x < active[i].x) sorted[k++] = active[j++];
+    else sorted[k++] = active[i++];
+  }
+  while (i < mid) sorted[k++] = active[i++];
+  while (j < right) sorted[k++] = active[j++];
+}

package/src/mvt/mvtEdgeX.js

@@ -0,0 +1,4 @@
+export function mvtEdgeX(edge, y) {
+  return edge[0][0] + (y - edge[0][1]) *
+    (edge[1][0] - edge[0][0]) / (edge[1][1] - edge[0][1]);
+}

package/src/mvt/mvtPathsVertices.js

@@ -0,0 +1,8 @@
+export function mvtPathsVertices(paths) {
+  const vertices = /* alloc */ [];
+  let path, point;
+  for (path of paths) {
+    for (point of path) vertices.push(point);
+  }
+  return vertices;
+}

package/src/mvt/mvtPolygonPaths.js

@@ -0,0 +1,12 @@
+export function mvtPolygonPaths(rings) {
+  const paths = /* alloc */ [];
+  let ring, i, path;
+  for (ring of rings) {
+    path = /* alloc */ [];
+    for (i = 0; i < ring.length - 1; i++) {
+      path.push(/* alloc */ { x: ring[i][0], y: ring[i][1] });
+    }
+    paths.push(path);
+  }
+  return paths;
+}

package/src/mvt/numericMvtValue.js

@@ -0,0 +1,4 @@
+export function numericMvtValue(value) {
+  return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)
+    ? Number(value) : value.toString();
+}

package/src/mvt/readMvtFeature.js

@@ -0,0 +1,34 @@
+import { expectMvtWire } from './expectMvtWire.js';
+import { numericMvtValue } from './numericMvtValue.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtGeometry } from './readMvtGeometry.js';
+import { readMvtInteger } from './readMvtInteger.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { readMvtNumbers } from './readMvtNumbers.js';
+import { skipMvtField } from './skipMvtField.js';
+
+export function readMvtFeature(reader, keys, values) {
+  let id, type = 0, field, wire, i = 0;
+  const tags = /* alloc */ [], commands = /* alloc */ [];
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field === 1) {
+      expectMvtWire(wire, 0);
+      id = numericMvtValue(readMvtInteger(reader));
+    } else if (field === 2) readMvtNumbers(reader, wire, tags);
+    else if (field === 3) {
+      expectMvtWire(wire, 0);
+      type = readMvtNumber(reader);
+    } else if (field === 4) readMvtNumbers(reader, wire, commands);
+    else skipMvtField(reader, wire);
+  }
+  if (tags.length % 2 || type > 3) throw /* alloc */ new Error('Invalid MVT feature');
+  const properties = Object.create(null);
+  for (; i < tags.length; i += 2) {
+    if (tags[i] >= keys.length || tags[i + 1] >= values.length) {
+      throw /* alloc */ new Error('Invalid MVT property index');
+    }
+    properties[keys[tags[i]]] = values[tags[i + 1]];
+  }
+  return /* alloc */ { id, type, properties, geometry: type ? readMvtGeometry(commands, type) : /* alloc */ [] };
+}

package/src/mvt/readMvtField.js

@@ -0,0 +1,8 @@
+import { readMvtNumber } from './readMvtNumber.js';
+
+export function readMvtField(reader) {
+  const tag = readMvtNumber(reader);
+  const field = Math.floor(tag / 8), wire = tag % 8;
+  if (!field || field > 536870911) throw /* alloc */ new Error('Invalid MVT field number');
+  return /* alloc */ [field, wire];
+}

package/src/mvt/readMvtGeometry.js

@@ -0,0 +1,29 @@
+import { finishMvtPath } from './finishMvtPath.js';
+import { appendMvtCoordinates } from './appendMvtCoordinates.js';
+import { beginMvtPath } from './beginMvtPath.js';
+import { closeMvtPath } from './closeMvtPath.js';
+
+export function readMvtGeometry(commands, type) {
+  const paths = /* alloc */ [];
+  const state = /* alloc */ { x: 0, y: 0, path: null, closed: false, index: 0 };
+  let command, id, count;
+  while (state.index < commands.length) {
+    command = commands[state.index++];
+    id = command % 8;
+    count = Math.floor(command / 8);
+    if (!count || command > 0xffffffff) throw /* alloc */ new Error('Invalid MVT geometry command');
+    if (id === 7) {
+      closeMvtPath(state, type, count);
+      continue;
+    }
+    if (id !== 1 && id !== 2 || count > Math.floor((commands.length - state.index) / 2)) {
+      throw /* alloc */ new Error('Invalid MVT geometry parameters');
+    }
+    if (id === 1) beginMvtPath(state, paths, type, count);
+    else if (type === 1 || !state.path || state.closed) throw /* alloc */ new Error('Invalid MVT LineTo');
+    appendMvtCoordinates(commands, state, count);
+  }
+  finishMvtPath(state.path, type, state.closed);
+  if (!paths.length) throw /* alloc */ new Error('Empty MVT geometry');
+  return paths;
+}

package/src/mvt/readMvtInteger.js

@@ -0,0 +1,12 @@
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+export function readMvtInteger(reader) {
+  let value = 0n, i = 0, byte;
+  for (; i < 10; i++) {
+    byte = reader.bytes[takeMvtBytes(reader, 1)];
+    if (i === 9 && byte > 1) throw /* alloc */ new Error('Invalid MVT varint');
+    value |= BigInt(byte & 127) << BigInt(i * 7);
+    if (byte < 128) return value;
+  }
+  throw /* alloc */ new Error('Invalid MVT varint');
+}

package/src/mvt/readMvtKnownValue.js

@@ -0,0 +1,21 @@
+import { expectMvtWire } from './expectMvtWire.js';
+import { numericMvtValue } from './numericMvtValue.js';
+import { readMvtInteger } from './readMvtInteger.js';
+import { readMvtString } from './readMvtString.js';
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+export function readMvtKnownValue(reader, field, wire) {
+  let offset, integer;
+  if (field === 1) return readMvtString(reader, wire);
+  if (field === 2 || field === 3) {
+    expectMvtWire(wire, field === 2 ? 5 : 1);
+    offset = takeMvtBytes(reader, field === 2 ? 4 : 8);
+    return field === 2 ? reader.view.getFloat32(offset, true) : reader.view.getFloat64(offset, true);
+  }
+  expectMvtWire(wire, 0);
+  integer = readMvtInteger(reader);
+  if (field === 4) return numericMvtValue(BigInt.asIntN(64, integer));
+  if (field === 5) return numericMvtValue(integer);
+  if (field === 6) return numericMvtValue((integer >> 1n) ^ -(integer & 1n));
+  return integer !== 0n;
+}

package/src/mvt/readMvtLayer.js

@@ -0,0 +1,31 @@
+import { expectMvtWire } from './expectMvtWire.js';
+import { readMvtFeature } from './readMvtFeature.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtMessage } from './readMvtMessage.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { readMvtString } from './readMvtString.js';
+import { readMvtValue } from './readMvtValue.js';
+import { skipMvtField } from './skipMvtField.js';
+
+export function readMvtLayer(reader) {
+  let name, version, extent = 4096, field, wire, value, i = 0;
+  const keys = /* alloc */ [], values = /* alloc */ [], features = /* alloc */ [];
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field === 1) name = readMvtString(reader, wire);
+    else if (field === 2) features.push(readMvtMessage(reader, wire));
+    else if (field === 3) keys.push(readMvtString(reader, wire));
+    else if (field === 4) values.push(readMvtValue(readMvtMessage(reader, wire)));
+    else if (field === 5 || field === 15) {
+      expectMvtWire(wire, 0);
+      value = readMvtNumber(reader);
+      if (field === 5) extent = value;
+      else version = value;
+    } else skipMvtField(reader, wire);
+  }
+  if (!name || !/* alloc */ [1, 2].includes(version) || !extent || extent > 0xffffffff) {
+    throw /* alloc */ new Error('Invalid MVT layer metadata');
+  }
+  for (; i < features.length; i++) features[i] = readMvtFeature(features[i], keys, values);
+  return /* alloc */ { name, extent, features };
+}

package/src/mvt/readMvtMessage.js

@@ -0,0 +1,10 @@
+import { createMvtReader } from './createMvtReader.js';
+import { expectMvtWire } from './expectMvtWire.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+export function readMvtMessage(reader, wire) {
+  expectMvtWire(wire, 2);
+  const size = readMvtNumber(reader), start = takeMvtBytes(reader, size);
+  return createMvtReader(reader.bytes.subarray(start, start + size));
+}

package/src/mvt/readMvtNumber.js

@@ -0,0 +1,9 @@
+import { readMvtInteger } from './readMvtInteger.js';
+
+export function readMvtNumber(reader) {
+  const value = readMvtInteger(reader);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw /* alloc */ new Error('MVT integer exceeds safe range');
+  }
+  return Number(value);
+}

package/src/mvt/readMvtNumbers.js

@@ -0,0 +1,11 @@
+import { readMvtMessage } from './readMvtMessage.js';
+import { readMvtNumber } from './readMvtNumber.js';
+
+export function readMvtNumbers(reader, wire, target) {
+  let packed;
+  if (wire === 0) target.push(readMvtNumber(reader));
+  else {
+    packed = readMvtMessage(reader, wire);
+    while (packed.pos < packed.bytes.length) target.push(readMvtNumber(packed));
+  }
+}

package/src/mvt/readMvtString.js

@@ -0,0 +1,6 @@
+import { mvtTextDecoder } from '../globals/mvtTextDecoder.js';
+import { readMvtMessage } from './readMvtMessage.js';
+
+export function readMvtString(reader, wire) {
+  return mvtTextDecoder.decode(readMvtMessage(reader, wire).bytes);
+}

package/src/mvt/readMvtValue.js

@@ -0,0 +1,19 @@
+import { readMvtField } from './readMvtField.js';
+import { skipMvtField } from './skipMvtField.js';
+import { readMvtKnownValue } from './readMvtKnownValue.js';
+
+export function readMvtValue(reader) {
+  let value, found = false, field, wire;
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field < 1 || field > 7) {
+      skipMvtField(reader, wire);
+      continue;
+    }
+    if (found) throw /* alloc */ new Error('Multiple MVT value types');
+    found = true;
+    value = readMvtKnownValue(reader, field, wire);
+  }
+  if (!found) throw /* alloc */ new Error('Empty MVT value');
+  return value;
+}

package/src/mvt/skipMvtField.js

@@ -0,0 +1,14 @@
+import { expectMvtWire } from './expectMvtWire.js';
+import { readMvtInteger } from './readMvtInteger.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+export function skipMvtField(reader, wire) {
+  switch (wire) {
+    case 0: readMvtInteger(reader); break;
+    case 1: takeMvtBytes(reader, 8); break;
+    case 2: takeMvtBytes(reader, readMvtNumber(reader)); break;
+    case 5: takeMvtBytes(reader, 4); break;
+    default: throw /* alloc */ new Error('Unsupported MVT wire type');
+  }
+}

package/src/mvt/sortMvtActiveEdges.js

@@ -0,0 +1,15 @@
+import { mergeMvtActiveEdges } from './mergeMvtActiveEdges.js';
+
+export function sortMvtActiveEdges(active) {
+  const sorted = /* alloc */ new Array(active.length);
+  let width = 1, left, mid, right, i;
+  while (width < active.length) {
+    for (left = 0; left < active.length; left += width * 2) {
+      mid = Math.min(left + width, active.length);
+      right = Math.min(left + width * 2, active.length);
+      mergeMvtActiveEdges(active, sorted, left, mid, right);
+    }
+    for (i = 0; i < active.length; i++) active[i] = sorted[i];
+    width *= 2;
+  }
+}

package/src/mvt/sortedMvtLevels.js

@@ -0,0 +1,22 @@
+export function sortedMvtLevels(levels) {
+  const sorted = /* alloc */ [];
+  let y, gap = 0, i = 0, j, value, count = 0;
+  for (y of levels) sorted.push(y);
+  gap = Math.floor(sorted.length / 2);
+  for (; gap > 0; gap = Math.floor(gap / 2)) {
+    for (i = gap; i < sorted.length; i++) {
+      value = sorted[i];
+      j = i;
+      while (j >= gap && sorted[j - gap] > value) {
+        sorted[j] = sorted[j - gap];
+        j -= gap;
+      }
+      sorted[j] = value;
+    }
+  }
+  for (i = 0; i < sorted.length; i++) {
+    if (!count || sorted[i] - sorted[count - 1] > 1e-8) sorted[count++] = sorted[i];
+  }
+  sorted.length = count;
+  return sorted;
+}

package/src/mvt/takeMvtBytes.js

@@ -0,0 +1,8 @@
+export function takeMvtBytes(reader, size) {
+  if (!Number.isSafeInteger(size) || size < 0 || size > reader.bytes.length - reader.pos) {
+    throw /* alloc */ new Error('Truncated MVT field');
+  }
+  const start = reader.pos;
+  reader.pos += size;
+  return start;
+}

package/src/mvt/tessellateVectorRings.js

@@ -0,0 +1,19 @@
+import { addMvtCrossings } from './addMvtCrossings.js';
+import { appendMvtBandTriangles } from './appendMvtBandTriangles.js';
+import { collectMvtEdges } from './collectMvtEdges.js';
+import { sortedMvtLevels } from './sortedMvtLevels.js';
+
+export function tessellateVectorRings(rings) {
+  const edges = /* alloc */ [], levels = /* alloc */ new Set(), triangles = /* alloc */ [];
+  let sorted, i = 1, top, bottom;
+  collectMvtEdges(rings, edges, levels);
+  addMvtCrossings(edges, levels);
+  sorted = sortedMvtLevels(levels);
+  // ponytail: quadratic edge scan; use a sweep-line index for large datasets.
+  for (; i < sorted.length; i++) {
+    top = sorted[i - 1];
+    bottom = sorted[i];
+    if (bottom > top) appendMvtBandTriangles(edges, top, bottom, triangles);
+  }
+  return triangles;
+}

package/src/mvt/triangulateVectorRings.js

@@ -0,0 +1,19 @@
+import { appendMvtPolygonTriangles } from './appendMvtPolygonTriangles.js';
+import { groupMvtPolygons } from './groupMvtPolygons.js';
+import { mvtPathsVertices } from './mvtPathsVertices.js';
+import { mvtPolygonPaths } from './mvtPolygonPaths.js';
+
+/**
+ * Reuse City Mapper's triangulator in tile space, with even-odd tessellation
+ * for quantized touching/crossing rings. Output triangles omit their closure.
+ */
+export function triangulateVectorRings(rings) {
+  const polygons = groupMvtPolygons(rings), triangles = /* alloc */ [];
+  let polygon, paths, vertices;
+  for (polygon of polygons) {
+    paths = mvtPolygonPaths(polygon);
+    vertices = mvtPathsVertices(paths);
+    appendMvtPolygonTriangles(polygon, paths, vertices, triangles);
+  }
+  return triangles;
+}

package/src/native/beforeNativeRender.js

@@ -1,8 +1,14 @@
 import { synchronizeNativeLayer } from './synchronizeNativeLayer.js';
+import { cameraViewByMap } from '../weakmaps/cameraViewByMap.js';
 
 export function beforeNativeRender(state) {
   try {
     synchronizeNativeLayer(state);
+    const uniform = state.meshes.get('stroke')?.program.uniforms.strokeScale;
+    if (uniform) {
+      const zoom = cameraViewByMap.get(state.map)?.zoom ?? state.map.getZoom();
+      uniform.value = 2 ** (state.strokeZoom - zoom) * Number(state.source.options.weight) / state.strokeWeight;
+    }
   } catch (error) {
     state.failed = true;
     state.source.fire('error', /* alloc */ { error });