maplibre-gl 6.2.0 → 6.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "maplibre-gl",
   "description": "BSD licensed community fork of mapbox-gl, a WebGL interactive maps library",
-  "version": "6.2.0",
+  "version": "6.4.0",
   "module": "dist/maplibre-gl.mjs",
   "style": "dist/maplibre-gl.css",
   "license": "BSD-3-Clause",
@@ -51,7 +51,6 @@
     "@mapbox/mapbox-gl-rtl-text": "^0.4.0",
     "@mapbox/mvt-fixtures": "^4.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "@types/benchmark": "^2.1.5",
     "@types/d3": "^7.4.3",
     "@types/earcut": "^3.0.0",
     "@types/eslint": "^9.6.1",
@@ -60,39 +59,36 @@
     "@types/minimist": "^1.2.5",
     "@types/murmurhash-js": "^1.0.7",
     "@types/nise": "^1.4.5",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@types/offscreencanvas": "^2019.7.3",
     "@types/pixelmatch": "^5.2.6",
     "@types/pngjs": "^6.0.5",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.4",
     "@types/request": "^2.48.13",
     "@types/shuffle-seed": "^1.1.3",
     "@types/window-or-global": "^1.0.6",
-    "@typescript-eslint/eslint-plugin": "^8.65.0",
+    "@typescript-eslint/eslint-plugin": "^8.67.0",
     "@typescript-eslint/parser": "^8.59.3",
     "@typescript/native-preview": "beta",
     "@unicode/unicode-17.0.0": "^1.6.17",
     "@vitest/coverage-v8": "4.1.10",
-    "@vitest/eslint-plugin": "^1.6.24",
+    "@vitest/eslint-plugin": "^1.6.27",
     "@vitest/ui": "4.1.10",
     "address": "^2.0.3",
     "autoprefixer": "^10.5.4",
-    "benchmark": "^2.1.4",
     "canvas": "^3.2.3",
     "cross-env": "^10.1.0",
     "cspell": "^10.0.1",
-    "cssnano": "^8.0.2",
+    "cssnano": "^8.0.5",
     "d3": "^7.9.0",
     "d3-queue": "^3.0.7",
-    "devtools-protocol": "^0.0.1672245",
+    "devtools-protocol": "^0.0.1676914",
     "diff": "^9.0.0",
-    "eslint": "^10.8.0",
+    "eslint": "^10.8.1",
     "eslint-plugin-html": "^8.1.4",
     "eslint-plugin-tsdoc": "0.5.2",
     "expect": "^30.4.1",
     "glob": "^13.0.6",
-    "globals": "^17.8.0",
+    "globals": "^17.9.0",
     "is-builtin-module": "^5.0.0",
     "jsdom": "^30.0.1",
     "minimist": "^1.2.8",
@@ -108,11 +104,9 @@
     "postcss-cli": "^11.0.1",
     "postcss-inline-svg": "^6.0.0",
     "pretty-bytes": "^7.1.1",
-    "puppeteer": "^25.4.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "puppeteer": "^25.5.0",
     "regenerate": "^1.4.2",
-    "rolldown": "^1.2.1",
+    "rolldown": "^1.2.3",
     "rolldown-plugin-dts": "^0.27.8",
     "rw": "^1.3.3",
     "semver": "^7.8.5",
@@ -125,7 +119,7 @@
     "typedoc": "^0.28.20",
     "typedoc-plugin-markdown": "^4.11.0",
     "typescript": "^6.0.3",
-    "vite": "^8.2.0",
+    "vite": "^8.2.1",
     "vitest": "^4.1.5",
     "vitest-webgl-canvas-mock": "^1.1.0"
   },
@@ -143,14 +137,11 @@
     "build-prod": "cross-env BUILD=production rolldown -c rolldown.config.ts",
     "build-css": "postcss -o dist/maplibre-gl.css src/css/maplibre-gl.css",
     "watch-css": "postcss --watch -o dist/maplibre-gl.css src/css/maplibre-gl.css",
-    "build-benchmarks": "npm run build-dev && rolldown -c test/bench/rolldown_config_benchmarks.ts",
-    "watch-benchmarks": "rolldown -c test/bench/rolldown_config_benchmarks.ts --watch",
     "spellcheck": "cspell",
     "docs": "npm run generate-docs && docker compose run --rm docs",
     "start-server": "st --no-cache -H localhost --port 9966 .",
     "start-docs": "docker compose run --rm -it --service-ports docs-serve",
     "start": "run-p watch-css watch-dev start-server",
-    "start-bench": "run-p watch-css watch-benchmarks start-server",
     "lint": "eslint",
     "lint-css": "stylelint **/*.css verbose",
     "test": "run-p lint lint-css test-render test-unit test-integration test-build",
@@ -164,8 +155,7 @@
     "test-render": "vitest test/integration/render/render.test.ts",
     "codegen": "run-p --print-label generate-style-code generate-unicode-data generate-struct-arrays generate-shaders && npm run generate-typings",
     "bench": "vitest bench --run --config vitest.config.bench.ts",
-    "benchmark": "node test/bench/run-benchmarks.ts",
-    "gl-stats": "node test/bench/gl-stats.ts",
+    "bench-e2e": "node test/bench/e2e/run.ts",
     "prepare": "npm run codegen",
     "typecheck": "tsgo --noEmit && tsgo --project tsconfig.dist.json"
   },

package/src/data/bucket/fill_extrusion_bucket.ts

@@ -4,7 +4,7 @@ import {members as layoutAttributes, centroidAttributes} from './fill_extrusion_
 import {type Segment, SegmentVector} from '../segment.ts';
 import {ProgramConfigurationSet} from '../program_configuration.ts';
 import {TriangleIndexArray} from '../index_array_type.ts';
-import {EXTENT} from '../extent.ts';
+import {isBoundaryEdge, isEntirelyOutside} from '../extent_bounds.ts';
 import {VectorTileFeature} from '@mapbox/vector-tile';
 import {classifyRings} from '@maplibre/maplibre-gl-style-spec';
 const EARCUT_MAX_RINGS = 500;
@@ -335,15 +335,3 @@ function accumulatePointsToCentroid(centroid: CentroidAccumulator, geometry: Poi
 }
 
 register('FillExtrusionBucket', FillExtrusionBucket, {omit: ['layers', 'features']});
-
-function isBoundaryEdge(p1, p2) {
-    return (p1.x === p2.x && (p1.x < 0 || p1.x > EXTENT)) ||
-        (p1.y === p2.y && (p1.y < 0 || p1.y > EXTENT));
-}
-
-function isEntirelyOutside(ring) {
-    return ring.every(p => p.x < 0) ||
-        ring.every(p => p.x > EXTENT) ||
-        ring.every(p => p.y < 0) ||
-        ring.every(p => p.y > EXTENT);
-}

package/src/data/bucket/round_polygon_corners.test.ts

@@ -10,6 +10,14 @@ function round(p: Point):GeoJSON.Position {
     return [x, y];
 }
 
+const square = [
+    new Point(0, 0),
+    new Point(10, 0),
+    new Point(10, 10),
+    new Point(0, 10),
+    new Point(0, 0)
+];
+
 describe('roundPolygonCorners', () => {
     const canonical = new CanonicalTileID(10, 500, 300);
 
@@ -50,58 +58,102 @@ describe('roundPolygonCorners', () => {
         expect(output).toStrictEqual(input);
     });
 
-    test('still rounds very small rounding', () => {
-        const input = [[
-            new Point(0, 0),
-            new Point(10, 0),
-            new Point(10, 10),
-            new Point(0, 10),
-            new Point(0, 0)
-        ]];
+    test('collapses every arc back onto its corner when the distance is below one tile unit', () => {
+        const output = roundPolygonCorners([square], 0.1, canonical);
 
-        const output = roundPolygonCorners(input, 0.1, canonical);
+        expect(output[0].map(round)).toEqual(square.map(round));
+    });
+
+    test('rounds corners of a square polygon into arc vertices', () => {
+        const output = roundPolygonCorners([square], 2, canonical);
         const points = output[0].map(round);
 
         expect(points).toEqual([
-            [0, 0.04], [0.01, 0.02], [0.02, 0.01], [0.04, 0], [9.96, 0], [9.98, 0.01], [9.99, 0.02], [10, 0.04],
-            [10, 9.96], [9.99, 9.98], [9.98, 9.99], [9.96, 10], [0.04, 10], [0.02, 9.99], [0.01, 9.98], [0, 9.96], [0, 0.04]
+            [0, 1], [0, 0], [1, 0], [9, 0], [10, 0], [10, 1],
+            [10, 9], [10, 10], [9, 10], [1, 10], [0, 10], [0, 9], [0, 1]
         ]);
     });
 
-    test('rounds corners of a square polygon into arc vertices', () => {
+    test('clamps corner rounding distance to 20% of edge length when requested distance is large', () => {
+        const output = roundPolygonCorners([square], 1000, canonical);
+        const points = output[0].map(round);
+
+        expect(points).toEqual([
+            [0, 2], [0, 1], [1, 0], [2, 0], [8, 0], [9, 0], [10, 1], [10, 2],
+            [10, 8], [10, 9], [9, 10], [8, 10], [2, 10], [1, 10], [0, 9], [0, 8], [0, 2]
+        ]);
+    });
+
+    test('emits only integer tile coordinates, so that the triangulator cannot merge arc points itself', () => {
         const input = [[
             new Point(0, 0),
-            new Point(10, 0),
-            new Point(10, 10),
-            new Point(0, 10),
+            new Point(137, 41),
+            new Point(96, 158),
+            new Point(13, 111),
             new Point(0, 0)
         ]];
 
-        const output = roundPolygonCorners(input, 2, canonical);
+        for (const distance of [0.5, 1, 2, 5, 50, 1000]) {
+            for (const ring of roundPolygonCorners(input, distance, canonical)) {
+                for (const point of ring) {
+                    expect(point.x).toBe(Math.round(point.x));
+                    expect(point.y).toBe(Math.round(point.y));
+                }
+            }
+        }
+    });
+
+    test('leaves the corners of a cut sharp and rounds the rest of the same ring', () => {
+        const input = [[
+            new Point(1000, -100),
+            new Point(3000, -100),
+            new Point(3000, 4000),
+            new Point(1000, 4000),
+            new Point(1000, -100)
+        ]];
+
+        const output = roundPolygonCorners(input, 1000, canonical);
         const points = output[0].map(round);
 
         expect(points).toEqual([
-            [0, 0.82], [0.11, 0.41], [0.41, 0.11], [0.82, 0], [9.18, 0], [9.59, 0.11], [9.89, 0.41], [10, 0.82],
-            [10, 9.18], [9.89, 9.59], [9.59, 9.89], [9.18, 10], [0.82, 10], [0.41, 9.89], [0.11, 9.59], [0, 9.18], [0, 0.82]
+            [1000, -100],
+            [3000, -100],
+            [3000, 3600],
+            [2946, 3800],
+            [2800, 3946],
+            [2600, 4000],
+            [1400, 4000],
+            [1200, 3946],
+            [1054, 3800],
+            [1000, 3600],
+            [1000, -100]
         ]);
     });
 
-    test('clamps corner rounding distance to 20% of edge length when requested distance is large', () => {
+    test('rounds a corner of the feature that sits in the buffer, since only a cut stays sharp', () => {
         const input = [[
-            new Point(0, 0),
-            new Point(10, 0),
-            new Point(10, 10),
-            new Point(0, 10),
-            new Point(0, 0)
+            new Point(1200, 200),
+            new Point(2000, -100),
+            new Point(2800, 200),
+            new Point(2000, 3000),
+            new Point(1200, 200)
         ]];
 
         const output = roundPolygonCorners(input, 1000, canonical);
         const points = output[0].map(round);
 
-        expect(points).toEqual([
-            [0, 2], [0.27, 1], [1, 0.27], [2, 0], [8, 0], [9, 0.27], [9.73, 1], [10, 2],
-            [10, 8], [9.73, 9], [9, 9.73], [8, 10], [2, 10], [1, 9.73], [0.27, 9], [0, 8], [0, 2]
-        ]);
+        expect(points).not.toContainEqual([2000, -100]);
+        expect(output[0].length).toBeGreaterThan(input[0].length);
+    });
+
+    test('drops arc points that collapse onto their neighbour', () => {
+        const output = roundPolygonCorners([square], 2, canonical);
+        const ring = output[0];
+
+        for (let i = 1; i < ring.length; i++) {
+            expect([ring[i].x, ring[i].y]).not.toEqual([ring[i - 1].x, ring[i - 1].y]);
+        }
+        expect([ring[0].x, ring[0].y]).toEqual([ring[ring.length - 1].x, ring[ring.length - 1].y]);
     });
 
     test('preserves near-zero-degree spike vertex without adding arc points', () => {
@@ -115,10 +167,7 @@ describe('roundPolygonCorners', () => {
         const output = roundPolygonCorners(input, 5, canonical);
         const points = output[0].map(round);
 
-        expect(points).toEqual([
-            [0, 0.08], [0.01, 0.04], [0.04, 0.01], [0.08, 0], [100, 0], [0.08, 0.4],
-            [0.05, 0.39], [0.02, 0.38], [0.01, 0.35], [0, 0.32], [0, 0.08]
-        ]);
+        expect(points).toEqual([[0, 0], [100, 0], [0, 0.4], [0, 0]]);
     });
 
     test('preserves collinear 180-degree vertices without adding arc points', () => {
@@ -135,8 +184,8 @@ describe('roundPolygonCorners', () => {
         const points = output[0].map(round);
 
         expect(points).toEqual([
-            [0, 1], [0.13, 0.5], [0.5, 0.13], [1, 0], [5, 0], [9, 0], [9.5, 0.13], [9.87, 0.5], [10, 1],
-            [10, 8], [9.73, 9], [9, 9.73], [8, 10], [2, 10], [1, 9.73], [0.27, 9], [0, 8], [0, 1]
+            [0, 1], [0, 0], [1, 0], [5, 0], [9, 0], [10, 0], [10, 1],
+            [10, 8], [10, 9], [9, 10], [8, 10], [2, 10], [1, 10], [0, 9], [0, 8], [0, 1]
         ]);
     });
 
@@ -152,8 +201,7 @@ describe('roundPolygonCorners', () => {
         const points = output[0].map(round);
 
         expect(points).toEqual([
-            [1.91, 0.77], [1.77, 0.66], [1.68, 0.5], [1.67, 0.32], [1.75, 0.16], [1.88, 0.04], [2.06, 0], [97.94, 0], [98.12, 0.04],
-            [98.25, 0.16], [98.33, 0.32], [98.32, 0.5], [98.23, 0.66], [98.09, 0.77], [51.91, 19.23], [50, 19.6], [48.09, 19.23], [1.91, 0.77]
+            [2, 1], [2, 0], [98, 0], [98, 1], [52, 19], [50, 20], [48, 19], [2, 1]
         ]);
     });
 });

package/src/data/bucket/round_polygon_corners.ts

@@ -1,8 +1,8 @@
-import Point from '@mapbox/point-geometry';
-import {vec2} from 'gl-matrix';
 import {EXTENT} from '../extent.ts';
+import {isBoundaryEdge} from '../extent_bounds.ts';
 import {MercatorCoordinate} from '../../geo/mercator_coordinate.ts';
 import {tileCoordinatesToLocation} from '../../geo/projection/mercator_utils.ts';
+import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../tile/tile_id.ts';
 
 /**
@@ -32,6 +32,19 @@ function getTileUnitsForMeters(distanceInMeters: number, canonical: CanonicalTil
     return distanceInMeters * meterInMercator * tileUnitsPerMercator;
 }
 
+/**
+ * Rounds the corners of a single ring.
+ *
+ * Corners that tile clipping created are left sharp: they belong to the cut rather than to the
+ * feature, and the neighbouring tile cuts the same feature elsewhere, so rounding them would leave
+ * the two halves out of step. Every vertex ends up on the integer tile grid, because triangulation,
+ * subdivision and the vertex buffers snap and deduplicate vertices there - arcs finer than a tile
+ * unit would otherwise be merged only after they were triangulated, turning the mesh into spikes.
+ *
+ * A ring that collapses into fewer than three distinct vertices is returned unchanged.
+ * @param ring - Ring to round, closed or open
+ * @param distanceInTileUnits - Corner rounding distance, already converted to tile units
+ */
 function roundRing(ring: Point[], distanceInTileUnits: number): Point[] {
     if (!ring || ring.length < 3) {
         return ring;
@@ -44,49 +57,94 @@ function roundRing(ring: Point[], distanceInTileUnits: number): Point[] {
         return ring;
     }
 
-    const vertices: vec2[] = ring.map(p => vec2.fromValues(p.x,p.y));
-    const newRing: vec2[] = [];
+    const newRing: Point[] = [];
 
     for (let i = 0; i < vertexCount; i++) {
-        const prev = vertices[(i - 1 + vertexCount) % vertexCount];
-        const current = vertices[i];
-        const next = vertices[(i + 1) % vertexCount];
+        const previous = ring[(i - 1 + vertexCount) % vertexCount];
+        const current = ring[i];
+        const next = ring[(i + 1) % vertexCount];
+
+        if (isBoundaryEdge(previous, current) || isBoundaryEdge(current, next)) {
+            newRing.push(current.clone());
+            continue;
+        }
 
-        appendRoundCorner(newRing, prev, current, next, distanceInTileUnits);
+        appendRoundCorner(newRing, previous, current, next, distanceInTileUnits);
     }
 
-    if (isClosed && newRing.length > 0) {
-        newRing.push(vec2.clone(newRing[0]));
+    const snapped = snapToIntegerGrid(newRing);
+
+    if (snapped.length < 3) {
+        return ring;
     }
 
-    return newRing.map(p => new Point(p[0], p[1]));
+    if (isClosed) {
+        snapped.push(snapped[0].clone());
+    }
+
+    return snapped;
 }
 
+/**
+ * Rounds every vertex to the integer tile grid, dropping vertices that collapse onto their neighbour.
+ * The ring is treated as closed, so the wrap-around duplicate is dropped as well.
+ * @param ring - Ring to snap
+ */
+function snapToIntegerGrid(ring: Point[]): Point[] {
+    const snapped: Point[] = [];
+
+    for (const p of ring) {
+        const point = p.round();
+        const previous = snapped[snapped.length - 1];
+
+        if (previous?.x === point.x && previous?.y === point.y) {
+            continue;
+        }
+
+        snapped.push(point);
+    }
+
+    while (snapped.length > 1 && snapped[0].x === snapped[snapped.length - 1].x && snapped[0].y === snapped[snapped.length - 1].y) {
+        snapped.pop();
+    }
+
+    return snapped;
+}
+
+/**
+ * Appends the arc that replaces one corner, or the corner itself when it is too shallow or too sharp
+ * to round.
+ * @param newRing - Ring being built, the arc points are appended to it
+ * @param prev - Vertex before the corner
+ * @param current - The corner
+ * @param next - Vertex after the corner
+ * @param distanceInTileUnits - Corner rounding distance, already converted to tile units
+ */
 function appendRoundCorner(
-    newRing: vec2[],
-    prev: vec2,
-    current: vec2,
-    next: vec2,
+    newRing: Point[],
+    prev: Point,
+    current: Point,
+    next: Point,
     distanceInTileUnits: number
 ): void {
     // Unit edge vectors from the current vertex towards its neighbours
-    const ua = vec2.sub(vec2.create(), prev, current);
-    const ub = vec2.sub(vec2.create(), next, current);
-    const lenA = vec2.length(ua);
-    const lenB = vec2.length(ub);
+    const ua = prev.sub(current);
+    const ub = next.sub(current);
+    const lenA = ua.mag();
+    const lenB = ub.mag();
 
     if (lenA < 1e-6 || lenB < 1e-6) {
-        newRing.push(vec2.clone(current));
+        newRing.push(current.clone());
         return;
     }
 
-    vec2.scale(ua, ua, 1 / lenA);
-    vec2.scale(ub, ub, 1 / lenB);
+    ua._div(lenA);
+    ub._div(lenB);
 
     // Straight lines or zero-degree turns
-    const dot = vec2.dot(ua, ub);
+    const dot = ua.x * ub.x + ua.y * ub.y;
     if (Math.abs(dot) > Math.cos(5 * Math.PI / 180)) {
-        newRing.push(vec2.clone(current));
+        newRing.push(current.clone());
         return;
     }
 
@@ -95,27 +153,20 @@ function appendRoundCorner(
     const r = Math.min(distanceInTileUnits, lenA * maxEdgeLenPercent, lenB * maxEdgeLenPercent);
 
     // Tangent points on edges to prevPoint and nextPoint
-    const tangentA = vec2.scaleAndAdd(vec2.create(), current, ua, r);
-    const tangentB = vec2.scaleAndAdd(vec2.create(), current, ub, r);
-
-    const bisector = vec2.add(vec2.create(), ua, ub);
-    vec2.normalize(bisector, bisector);
+    const tangentA = current.add(ua.mult(r));
+    const tangentB = current.add(ub.mult(r));
 
     // Center of the rounding arc, at r / cos(theta/2) along the bisector
     const cosHalfTheta = Math.sqrt((1 + dot) / 2);
-    const center = vec2.scaleAndAdd(vec2.create(), current, bisector, r / cosHalfTheta);
+    const center = current.add(ua.add(ub)._unit()._mult(r / cosHalfTheta));
 
-    // Both tangent points lie on the arc circle.
-    // Rotating tangent A around the center traces the fillet onto tangent B along the shortest arc.
-    const radiusA = vec2.sub(vec2.create(), tangentA, center);
-    const radiusB = vec2.sub(vec2.create(), tangentB, center);
-    const sweepAngle = vec2.angle(radiusA, radiusB);
-    const direction = Math.sign(radiusA[0] * radiusB[1] - radiusA[1] * radiusB[0]); // 2D cross product -> winding direction
+    // Both tangent points lie on the arc circle, so rotating tangent A around the center by the angle
+    // between the two radii traces the fillet onto tangent B along the shortest arc.
+    const sweepAngle = tangentA.sub(center).angleWith(tangentB.sub(center));
 
     // ~30 deg per segment; epsilon keeps fp noise from adding one at exact multiples.
-    const numSegments = Math.max(2, Math.ceil(sweepAngle / (Math.PI / 6) - 1e-6));
+    const numSegments = Math.max(2, Math.ceil(Math.abs(sweepAngle) / (Math.PI / 6) - 1e-6));
     for (let s = 0; s <= numSegments; s++) {
-        const angle = direction * sweepAngle * (s / numSegments);
-        newRing.push(vec2.rotate(vec2.create(), tangentA, center, angle));
+        newRing.push(tangentA.rotateAround(sweepAngle * (s / numSegments), center));
     }
 }

package/src/data/extent_bounds.ts

@@ -1,8 +1,35 @@
 import Point from '@mapbox/point-geometry';
+import {type Point2D} from '@maplibre/maplibre-gl-style-spec';
 import {Bounds, type ReadOnlyBounds} from '../geo/bounds.ts';
 import {EXTENT} from './extent.ts';
 
 /**
  * The bounding box covering the entire extent of a tile.
  */
-export const EXTENT_BOUNDS = Bounds.fromPoints([new Point(0, 0), new Point(EXTENT, EXTENT)]) as ReadOnlyBounds;
+export const EXTENT_BOUNDS = Bounds.fromPoints([new Point(0, 0), new Point(EXTENT, EXTENT)]) as ReadOnlyBounds;
+
+/**
+ * Whether an edge runs along one of the lines the tile was cut out of the world at. Clipping happens
+ * on the buffer rectangle, outside the tile, so an axis parallel edge out there belongs to the cut
+ * rather than to the feature. Such an edge is shared with the neighbouring tile, which cuts the same
+ * feature somewhere else, so geometry derived from it has to stay identical in both tiles.
+ * @param p1 - First vertex of the edge
+ * @param p2 - Second vertex of the edge
+ * @returns True when the edge lies on a clip line.
+ */
+export function isBoundaryEdge(p1: Point2D, p2: Point2D): boolean {
+    return (p1.x === p2.x && (p1.x < 0 || p1.x > EXTENT)) ||
+        (p1.y === p2.y && (p1.y < 0 || p1.y > EXTENT));
+}
+
+/**
+ * Whether a ring lies completely off one side of the tile, and so cannot contribute a visible pixel.
+ * @param ring - Ring to test
+ * @returns True when every vertex is beyond the same edge of the tile.
+ */
+export function isEntirelyOutside(ring: Point2D[]): boolean {
+    return ring.every(p => p.x < 0) ||
+        ring.every(p => p.x > EXTENT) ||
+        ring.every(p => p.y < 0) ||
+        ring.every(p => p.y > EXTENT);
+}

package/src/data/feature_index.bench.ts

@@ -0,0 +1,21 @@
+import {bench} from 'vitest';
+import {FeatureIndex} from './feature_index.ts';
+import {OverscaledTileID} from '../tile/tile_id.ts';
+
+import type {FeatureFilter} from '@maplibre/maplibre-gl-style-spec';
+import type {VectorTileFeatureLike, VectorTileLayerLike} from '@maplibre/vt-pbf';
+
+const layerCount = 100;
+const filter = {needGeometry: false} as FeatureFilter;
+
+const featureIndex = new FeatureIndex(new OverscaledTileID(0, 0, 0, 0, 0));
+featureIndex.bucketLayerIDs = [Array.from({length: layerCount}, (_, i) => `layer-${i}`)];
+featureIndex.vtLayers = {
+    '0': {feature: () => ({} as VectorTileFeatureLike)} as unknown as VectorTileLayerLike
+};
+
+const layerIdsToTest = new Set(Array.from({length: layerCount}, (_, i) => `non-existing-layer-${i}`));
+
+bench('FeatureIndex.loadMatchingFeature', () => {
+    featureIndex.loadMatchingFeature({}, 0, 0, 0, filter, layerIdsToTest, [], {}, {});
+});

package/src/data/segment.test.ts

@@ -4,13 +4,13 @@ import {SegmentVector} from './segment.ts';
 
 describe('SegmentVector', () => {
     test('constructor', () => {
-        expect(new SegmentVector() instanceof SegmentVector).toBeTruthy();
+        expect(new SegmentVector()).toBeInstanceOf(SegmentVector);
     });
 
     test('simpleSegment', () => {
         SegmentVector.MAX_VERTEX_ARRAY_LENGTH = 16;
         const segmentVector = SegmentVector.simpleSegment(0, 0, 10, 0);
-        expect(segmentVector instanceof SegmentVector).toBeTruthy();
+        expect(segmentVector).toBeInstanceOf(SegmentVector);
         expect(segmentVector.segments).toHaveLength(1);
         expect(segmentVector.segments[0].vertexLength).toBe(10);
     });

package/src/geo/edge_insets.test.ts

@@ -4,7 +4,7 @@ import {EdgeInsets} from '../geo/edge_insets.ts';
 describe('EdgeInsets', () => {
     describe('constructor', () => {
         test('creates an object with default values', () => {
-            expect(new EdgeInsets() instanceof EdgeInsets).toBeTruthy();
+            expect(new EdgeInsets()).toBeInstanceOf(EdgeInsets);
         });
 
         test('invalid initialization', () => {

package/src/geo/lng_lat.test.ts

@@ -3,7 +3,7 @@ import {LngLat} from '../geo/lng_lat.ts';
 
 describe('LngLat', () => {
     test('constructor', () => {
-        expect(new LngLat(0, 0) instanceof LngLat).toBeTruthy();
+        expect(new LngLat(0, 0)).toBeInstanceOf(LngLat);
 
         expect(() => {
             new LngLat(0, -91);
@@ -15,12 +15,12 @@ describe('LngLat', () => {
     });
 
     test('convert', () => {
-        expect(LngLat.convert([0, 10]) instanceof LngLat).toBeTruthy();
-        expect(LngLat.convert({lng: 0, lat: 10}) instanceof LngLat).toBeTruthy();
-        expect(LngLat.convert({lng: 0, lat: 0}) instanceof LngLat).toBeTruthy();
-        expect(LngLat.convert({lon: 0, lat: 10}) instanceof LngLat).toBeTruthy();
-        expect(LngLat.convert({lon: 0, lat: 0}) instanceof LngLat).toBeTruthy();
-        expect(LngLat.convert(new LngLat(0, 0)) instanceof LngLat).toBeTruthy();
+        expect(LngLat.convert([0, 10])).toBeInstanceOf(LngLat);
+        expect(LngLat.convert({lng: 0, lat: 10})).toBeInstanceOf(LngLat);
+        expect(LngLat.convert({lng: 0, lat: 0})).toBeInstanceOf(LngLat);
+        expect(LngLat.convert({lon: 0, lat: 10})).toBeInstanceOf(LngLat);
+        expect(LngLat.convert({lon: 0, lat: 0})).toBeInstanceOf(LngLat);
+        expect(LngLat.convert(new LngLat(0, 0))).toBeInstanceOf(LngLat);
     });
 
     test('wrap', () => {

package/src/geo/lng_lat_bounds.test.ts

@@ -336,25 +336,25 @@ describe('LngLatBounds', () => {
             test('point is in bounds', () => {
                 const llb = new LngLatBounds([-1, -1], [1, 1]);
                 const ll = {lng: 0, lat: 0};
-                expect(llb.contains(ll)).toBeTruthy();
+                expect(llb.contains(ll)).toBe(true);
             });
 
             test('point is not in bounds', () => {
                 const llb = new LngLatBounds([-1, -1], [1, 1]);
                 const ll = {lng: 3, lat: 3};
-                expect(llb.contains(ll)).toBeFalsy();
+                expect(llb.contains(ll)).toBe(false);
             });
 
             test('point is in bounds that spans dateline', () => {
                 const llb = new LngLatBounds([190, -10], [170, 10]);
                 const ll = {lng: 180, lat: 0};
-                expect(llb.contains(ll)).toBeTruthy();
+                expect(llb.contains(ll)).toBe(true);
             });
 
             test('point is not in bounds that spans dateline', () => {
                 const llb = new LngLatBounds([190, -10], [170, 10]);
                 const ll = {lng: 0, lat: 0};
-                expect(llb.contains(ll)).toBeFalsy();
+                expect(llb.contains(ll)).toBe(false);
             });
         });
     });

package/src/geo/mercator_coordinate.test.ts

@@ -4,8 +4,8 @@ import {MercatorCoordinate, mercatorScale} from './mercator_coordinate.ts';
 
 describe('LngLat', () => {
     test('constructor', () => {
-        expect(new MercatorCoordinate(0, 0) instanceof MercatorCoordinate).toBeTruthy();
-        expect(new MercatorCoordinate(0, 0, 0) instanceof MercatorCoordinate).toBeTruthy();
+        expect(new MercatorCoordinate(0, 0)).toBeInstanceOf(MercatorCoordinate);
+        expect(new MercatorCoordinate(0, 0, 0)).toBeInstanceOf(MercatorCoordinate);
     });
 
     test('fromLngLat', () => {