From: 
Subject: Debian changes

The Debian packaging of node-maplibre-geojson-vt is maintained in git, using a workflow
similar to the one described in dgit-maint-merge(7).
The Debian delta is represented by this one combined patch; there isn't a
patch queue that can be represented as a quilt series.

A detailed breakdown of the changes is available from their canonical
representation -- git commits in the packaging repository.
For example, to see the changes made by the Debian maintainer in the first
upload of upstream version 1.2.3, you could use:

    % git clone https://git.dgit.debian.org/node-maplibre-geojson-vt
    % cd node-maplibre-geojson-vt
    % git log --oneline 1.2.3..debian/1.2.3-1 -- . ':!debian'

(If you have dgit, use `dgit clone node-maplibre-geojson-vt`, rather than plain `git clone`.)

We don't use debian/source/options single-debian-patch because it has bugs.
Therefore, NMUs etc. may nevertheless have made additional patches.

---

diff --git a/package.json b/package.json
index 5497f9f..dae5393 100644
--- a/package.json
+++ b/package.json
@@ -19,7 +19,7 @@
   ],
   "author": "Vladimir Agafonkin",
   "module": "dist/geojson-vt.mjs",
-  "main": "dist/geojson-vt.js",
+  "main": "dist/geojson-vt.cjs",
   "typings": "dist/index.d.ts",
   "jsdelivr": "dist/geojson-vt.js",
   "unpkg": "dist/geojson-vt.js",
diff --git a/src/clip.test.ts b/src/clip.test.ts
index e9f2add..1d2d370 100644
--- a/src/clip.test.ts
+++ b/src/clip.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {clip} from './clip';
 import type { GeoJSONVTInternalFeature, GeoJSONVTInternalLineStringFeature, GeoJSONVTInternalMultiPointFeature } from './definitions';
 
@@ -32,17 +33,17 @@ test('clips polylines', () => {
         {geometry: ring(geom2), type: 'LineString', tags: { "2": 2}, minX: 0, minY: 0, maxX: 50, maxY: 10, worldOffset: 0}
     ], 1, 10, 40, 0, -Infinity, Infinity, {});
 
-    expect(clipped).toMatchObject([
+    assert.partialDeepStrictEqual(clipped, [
         {id: null, type: 'MultiLineString', tags: {"1": 1}, minX: 10, minY: 0, maxX: 40, maxY: 60},
         {id: null, type: 'MultiLineString', tags: {"2": 2}, minX: 10, minY: 0, maxX: 40, maxY: 10}
     ]);
-    expect(rings(clipped[0])).toEqual([
+    assert.deepStrictEqual(rings(clipped[0]), [
         [10,0,1,40,0,1],
         [40,10,1,20,10,0,20,20,0,30,20,0,30,30,0,40,30,1],
         [40,40,1,25,40,0,25,50,0,10,50,1],
         [10,60,1,25,60,0]
     ]);
-    expect(rings(clipped[1])).toEqual([
+    assert.deepStrictEqual(rings(clipped[1]), [
         [10,0,1,40,0,1],
         [40,10,1,10,10,1]
     ]);
@@ -61,8 +62,8 @@ test('clips lines with line metrics on', () => {
     const clipped = clip([{id: 1, geometry: ring(points, size), type: 'LineString', tags: {}, minX: 0, minY: 0, maxX: 50, maxY: 60, worldOffset: 0, start: 0, end: size, size}],
         1, 10, 40, 0, -Infinity, Infinity, {lineMetrics: true});
 
-    expect(
-        clipped.map(f => [(f as GeoJSONVTInternalLineStringFeature).start, (f as GeoJSONVTInternalLineStringFeature).end])).toEqual(
+    assert.deepStrictEqual(
+        clipped.map(f => [(f as GeoJSONVTInternalLineStringFeature).start, (f as GeoJSONVTInternalLineStringFeature).end]),
         [[10, 40], [70, 130], [160, 200], [230, 245]]
     );
 });
@@ -78,12 +79,12 @@ test('clips polygons', () => {
         {geometry: closed(geom2), type: 'Polygon', tags: {"2": 2}, minX: 0, minY: 0, maxX: 50, maxY: 10, worldOffset: 0}
     ], 1, 10, 40, 0, -Infinity, Infinity, {});
 
-    expect(clipped).toMatchObject([
+    assert.partialDeepStrictEqual(clipped, [
         {id: null, type: 'Polygon', tags: {"1": 1}, minX: 10, minY: 0, maxX: 40, maxY: 60},
         {id: null, type: 'Polygon', tags: {"2": 2}, minX: 10, minY: 0, maxX: 40, maxY: 10}
     ]);
-    expect(rings(clipped[0])).toEqual([[10,0,1,40,0,1,40,10,1,20,10,0,20,20,0,30,20,0,30,30,0,40,30,1,40,40,1,25,40,0,25,50,0,10,50,1,10,60,1,25,60,0,10,24,1,10,0,1]]);
-    expect(rings(clipped[1])).toEqual([[10,0,1,40,0,1,40,10,1,10,10,1,10,0,1]]);
+    assert.deepStrictEqual(rings(clipped[0]), [[10,0,1,40,0,1,40,10,1,20,10,0,20,20,0,30,20,0,30,30,0,40,30,1,40,40,1,25,40,0,25,50,0,10,50,1,10,60,1,25,60,0,10,24,1,10,0,1]]);
+    assert.deepStrictEqual(rings(clipped[1]), [[10,0,1,40,0,1,40,10,1,10,10,1,10,0,1]]);
 });
 
 test('clips points', () => {
@@ -93,6 +94,6 @@ test('clips points', () => {
         {geometry: new Float64Array(geom2), type: 'MultiPoint', tags: {"2": 2}, minX: 0, minY: 0, maxX: 50, maxY: 10, worldOffset: 0}
     ], 1, 10, 40, 0, -Infinity, Infinity, {});
 
-    expect(clipped).toMatchObject([{id: null, type: 'MultiPoint', tags: {"1": 1}, minX: 20, minY: 10, maxX: 30, maxY: 60}]);
-    expect(Array.from((clipped[0] as GeoJSONVTInternalMultiPointFeature).geometry)).toEqual([20,10,0,20,20,0,30,20,0,30,30,0,25,40,0,25,50,0,25,60,0]);
+    assert.partialDeepStrictEqual(clipped, [{id: null, type: 'MultiPoint', tags: {"1": 1}, minX: 20, minY: 10, maxX: 30, maxY: 60}]);
+    assert.deepStrictEqual(Array.from((clipped[0] as GeoJSONVTInternalMultiPointFeature).geometry), [20,10,0,20,20,0,30,20,0,30,30,0,25,40,0,25,50,0,25,60,0]);
 });
diff --git a/src/cluster-tile-index.test.ts b/src/cluster-tile-index.test.ts
index 7feaae8..df4a6d1 100644
--- a/src/cluster-tile-index.test.ts
+++ b/src/cluster-tile-index.test.ts
@@ -1,4 +1,5 @@
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {readFileSync} from 'fs';
 import {ClusterTileIndex} from './cluster-tile-index';
 import type {ClusterProperties, GeoJSONVTTile} from './definitions';
@@ -11,28 +12,28 @@ test('generates clusters properly', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
     const tile = index.getTile(0, 0, 0);
-    expect(tile?.features).toEqual(placesTile.features);
+    assert.deepStrictEqual(tile?.features, placesTile.features);
 });
 
 test('supports minPoints option', () => {
     const index = new ClusterTileIndex({minPoints: 5});
     index.load(places.features);
     const tile = index.getTile(0, 0, 0);
-    expect(tile?.features).toEqual(placesTileMin5.features);
+    assert.deepStrictEqual(tile?.features, placesTileMin5.features);
 });
 
 test('returns children of a cluster', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
     const childCounts = index.getChildren(163).map(p => (p.properties as ClusterProperties)?.point_count || 1);
-    expect(childCounts).toEqual([6, 7, 2, 1]);
+    assert.deepStrictEqual(childCounts, [6, 7, 2, 1]);
 });
 
 test('returns leaves of a cluster', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
     const leafNames = index.getLeaves(163, 10, 5).map(p => (p.properties as {name: string} | null)?.name);
-    expect(leafNames).toEqual([
+    assert.deepStrictEqual(leafNames, [
         'Niagara Falls',
         'Cape San Blas',
         'Cape Sable',
@@ -51,7 +52,7 @@ test('generates unique ids with generateId option', () => {
     index.load(places.features);
     const tile = index.getTile(0, 0, 0)!;
     const ids = tile.features.filter(f => !(f.tags as ClusterProperties)?.cluster).map(f => f.id);
-    expect(ids).toEqual([12, 20, 21, 22, 24, 28, 30, 62, 81, 118, 119, 125, 81, 118]);
+    assert.deepStrictEqual(ids, [12, 20, 21, 22, 24, 28, 30, 62, 81, 118, 119, 125, 81, 118]);
 });
 
 test('getLeaves handles null-property features', () => {
@@ -65,17 +66,17 @@ test('getLeaves handles null-property features', () => {
         }
     }]));
     const leaves = index.getLeaves(164, 1, 6);
-    expect(leaves[0].properties).toBe(null);
+    assert.strictEqual(leaves[0].properties, null);
 });
 
 test('returns cluster expansion zoom', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
-    expect(index.getClusterExpansionZoom(163)).toBe(1);
-    expect(index.getClusterExpansionZoom(195)).toBe(1);
-    expect(index.getClusterExpansionZoom(580)).toBe(2);
-    expect(index.getClusterExpansionZoom(1156)).toBe(2);
-    expect(index.getClusterExpansionZoom(4133)).toBe(3);
+    assert.strictEqual(index.getClusterExpansionZoom(163), 1);
+    assert.strictEqual(index.getClusterExpansionZoom(195), 1);
+    assert.strictEqual(index.getClusterExpansionZoom(580), 2);
+    assert.strictEqual(index.getClusterExpansionZoom(1156), 2);
+    assert.strictEqual(index.getClusterExpansionZoom(4133), 3);
 });
 
 test('returns cluster expansion zoom for maxZoom', () => {
@@ -86,7 +87,7 @@ test('returns cluster expansion zoom for maxZoom', () => {
     });
     index.load(places.features);
 
-    expect(index.getClusterExpansionZoom(2503)).toBe(5);
+    assert.strictEqual(index.getClusterExpansionZoom(2503), 5);
 });
 
 test('aggregates cluster properties with reduce', () => {
@@ -97,10 +98,8 @@ test('aggregates cluster properties with reduce', () => {
     });
     index.load(places.features);
 
-    expect(index.getTile(1, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean)).toEqual(
-        [146, 84, 63, 23, 34, 12, 19, 29, 8, 8, 80, 35]);
-    expect(index.getTile(0, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean)).toEqual(
-        [298, 122, 12, 36, 98, 7, 24, 8, 125, 98, 125, 12, 36, 8]);
+    assert.deepStrictEqual(index.getTile(1, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean), [146, 84, 63, 23, 34, 12, 19, 29, 8, 8, 80, 35]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0)!.features.map(f => (f.tags as {sum?: number})?.sum).filter(Boolean), [298, 122, 12, 36, 98, 7, 24, 8, 125, 98, 125, 12, 36, 8]);
 });
 
 test('uses default map function with reduce', () => {
@@ -110,7 +109,7 @@ test('uses default map function with reduce', () => {
     });
     index.load(places.features);
 
-    expect(index.getTile(0, 0, 0)).toBeTruthy();
+    assert.ok(index.getTile(0, 0, 0));
 });
 
 test('returns clusters when query crosses international dateline', () => {
@@ -150,27 +149,27 @@ test('returns clusters when query crosses international dateline', () => {
     const nonCrossing = index.getClusters([-179, -10, -177, 10], 1);
     const crossing = index.getClusters([179, -10, -177, 10], 1);
 
-    expect(nonCrossing.length).toBeGreaterThan(0);
-    expect(crossing.length).toBeGreaterThan(0);
-    expect(nonCrossing.length).toBe(crossing.length);
+    assert.ok(nonCrossing.length > 0);
+    assert.ok(crossing.length > 0);
+    assert.strictEqual(nonCrossing.length, crossing.length);
 });
 
 test('does not crash on weird bbox values', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
-    expect(index.getClusters([129.426390, -103.720017, -445.930843, 114.518236], 1).length).toBe(26);
-    expect(index.getClusters([112.207836, -84.578666, -463.149397, 120.169159], 1).length).toBe(27);
-    expect(index.getClusters([129.886277, -82.332680, -445.470956, 120.390930], 1).length).toBe(26);
-    expect(index.getClusters([458.220043, -84.239039, -117.137190, 120.206585], 1).length).toBe(25);
-    expect(index.getClusters([456.713058, -80.354196, -118.644175, 120.539148], 1).length).toBe(25);
-    expect(index.getClusters([453.105328, -75.857422, -122.251904, 120.732760], 1).length).toBe(25);
-    expect(index.getClusters([-180, -90, 180, 90], 1).length).toBe(61);
+    assert.strictEqual(index.getClusters([129.426390, -103.720017, -445.930843, 114.518236], 1).length, 26);
+    assert.strictEqual(index.getClusters([112.207836, -84.578666, -463.149397, 120.169159], 1).length, 27);
+    assert.strictEqual(index.getClusters([129.886277, -82.332680, -445.470956, 120.390930], 1).length, 26);
+    assert.strictEqual(index.getClusters([458.220043, -84.239039, -117.137190, 120.206585], 1).length, 25);
+    assert.strictEqual(index.getClusters([456.713058, -80.354196, -118.644175, 120.539148], 1).length, 25);
+    assert.strictEqual(index.getClusters([453.105328, -75.857422, -122.251904, 120.732760], 1).length, 25);
+    assert.strictEqual(index.getClusters([-180, -90, 180, 90], 1).length, 61);
 });
 
 test('does not crash on non-integer zoom values', () => {
     const index = new ClusterTileIndex();
     index.load(places.features);
-    expect(index.getClusters([179, -10, -177, 10], 1.25)).toBeTruthy();
+    assert.ok(index.getClusters([179, -10, -177, 10], 1.25));
 });
 
 test('makes sure same-location points are clustered', () => {
@@ -184,7 +183,7 @@ test('makes sure same-location points are clustered', () => {
         {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [-1.426798, 53.943034]}}
     ]);
 
-    expect(index.trees[20].ids.length).toBe(1);
+    assert.strictEqual(index.trees[20].ids.length, 1);
 });
 
 test('makes sure unclustered point coords are not rounded', () => {
@@ -193,15 +192,15 @@ test('makes sure unclustered point coords are not rounded', () => {
         {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [173.19150559062456, -41.340357424709275]}}
     ]);
 
-    expect(index.getTile(20, 1028744, 656754)!.features[0].geometry[0]).toEqual([421, 281]);
+    assert.deepStrictEqual(index.getTile(20, 1028744, 656754)!.features[0].geometry[0], [421, 281]);
 });
 
 test('does not throw on zero items', () => {
-    expect(() => {
+    assert.doesNotThrow(() => {
         const index = new ClusterTileIndex();
         index.load([]);
-        expect(index.getClusters([-180, -85, 180, 85], 0)).toEqual([]);
-    }).not.toThrow();
+        assert.deepStrictEqual(index.getClusters([-180, -85, 180, 85], 0), []);
+    });
 });
 
 test('does not keep the cluster properties of an earlier load', () => {
@@ -215,7 +214,7 @@ test('does not keep the cluster properties of an earlier load', () => {
 
     index.load(places.features);
 
-    expect(index.clusterProps.length).toBe(count);
+    assert.strictEqual(index.clusterProps.length, count);
 });
 
 test('takes points and the getClusters bounding box in the unit square with unitSquare coordinates', () => {
@@ -225,7 +224,7 @@ test('takes points and the getClusters bounding box in the unit square with unit
         {type: 'Feature', properties: {name: 'b'}, geometry: {type: 'Point', coordinates: [0.75, 0.75]}}
     ]);
 
-    expect(index.getClusters([0, 0, 0.5, 0.5], 0).map(f => f.geometry.coordinates)).toEqual([[0.25, 0.25]]);
+    assert.deepStrictEqual(index.getClusters([0, 0, 0.5, 0.5], 0).map(f => f.geometry.coordinates), [[0.25, 0.25]]);
 });
 
 test('leaves points outside the world out of load in a unit square without wrap', () => {
@@ -235,7 +234,7 @@ test('leaves points outside the world out of load in a unit square without wrap'
         {type: 'Feature', properties: {name: 'outside'}, geometry: {type: 'Point', coordinates: [1.03, 0.5]}}
     ]);
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry), [[[507, 256]]]);
 });
 
 test('returns no tile outside the world in a unit square without wrap', () => {
@@ -247,7 +246,7 @@ test('returns no tile outside the world in a unit square without wrap', () => {
         {type: 'Feature', properties: {name: 'south'}, geometry: {type: 'Point', coordinates: [0.5, 0.99]}}
     ]);
 
-    expect([index.getTile(0, -1, 0), index.getTile(0, 1, 0), index.getTile(0, 0, -1), index.getTile(0, 0, 1)]).toEqual([null, null, null, null]);
+    assert.deepStrictEqual([index.getTile(0, -1, 0), index.getTile(0, 1, 0), index.getTile(0, 0, -1), index.getTile(0, 0, 1)], [null, null, null, null]);
 });
 
 test('limits minZoom and maxZoom to 30, the highest zoom level a cluster id can hold', () => {
@@ -258,9 +257,9 @@ test('limits minZoom and maxZoom to 30, the highest zoom level a cluster id can
     const cluster = index.getClusters([-180, -90, 180, 90], 30)[0];
     const clusterId = (cluster.properties as ClusterProperties).cluster_id;
 
-    expect(index.getLeaves(clusterId)).toHaveLength(3);
-    expect(index.getChildren(clusterId)).toHaveLength(3);
-    expect(index.getClusterExpansionZoom(clusterId)).toBe(31);
+    assert.strictEqual((index.getLeaves(clusterId)).length, 3);
+    assert.strictEqual((index.getChildren(clusterId)).length, 3);
+    assert.strictEqual(index.getClusterExpansionZoom(clusterId), 31);
 });
 
 test('clusters each position of a MultiPoint feature', () => {
@@ -273,7 +272,7 @@ test('clusters each position of a MultiPoint feature', () => {
     const index = new ClusterTileIndex();
     index.load([multiPoint]);
 
-    expect(index.getTile(0, 0, 0).features).toEqual([
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features, [
         {type: 1, geometry: [[284, 227]], tags: {cluster: true, cluster_id: 20, point_count: 2, point_count_abbreviated: 2}, id: 20},
         {type: 1, geometry: [[341, 227]], tags: {name: 'multi'}, id: 7}
     ]);
@@ -290,7 +289,7 @@ test('does not cluster points that are farther apart than the radius on a high z
         {type: 'Feature', properties: null, geometry: {type: 'Point', coordinates: [-1.426796, 53.943034]}}
     ]);
 
-    expect(index.getClusters([-180, -90, 180, 90], 20)).toHaveLength(2);
+    assert.strictEqual((index.getClusters([-180, -90, 180, 90], 20)).length, 2);
 });
 
 test('returns a cluster within a step of the mean of its points in a unit square without wrap', () => {
@@ -303,8 +302,8 @@ test('returns a cluster within a step of the mean of its points in a unit square
 
     const [x, y] = index.getClusters([0, 0, 1, 1], 0)[0].geometry.coordinates;
 
-    expect(x).toBeCloseTo(0.5466666667, 9);
-    expect(y).toBeCloseTo(0.4133333333, 9);
+    assert.ok(Math.abs((x) - (0.5466666667)) < 0.5 * 10 ** -(9));
+    assert.ok(Math.abs((y) - (0.4133333333)) < 0.5 * 10 ** -(9));
 });
 
 test('getClusters keeps only the part of a box inside a world that does not wrap', () => {
@@ -314,7 +313,7 @@ test('getClusters keeps only the part of a box inside a world that does not wrap
         {type: 'Feature', properties: {name: 'east'}, geometry: {type: 'Point', coordinates: [175, 0]}}
     ]);
 
-    expect(index.getClusters([170, -20, 190, 20], 17).map(f => f.properties.name)).toEqual(['east']);
+    assert.deepStrictEqual(index.getClusters([170, -20, 190, 20], 17).map(f => f.properties.name), ['east']);
 });
 
 test('getClusters repeats a box across the edge of a unit square that wraps', () => {
@@ -324,5 +323,5 @@ test('getClusters repeats a box across the edge of a unit square that wraps', ()
         {type: 'Feature', properties: {name: 'east'}, geometry: {type: 'Point', coordinates: [0.99, 0.5]}}
     ]);
 
-    expect(index.getClusters([0.95, 0, 1.05, 1], 17).map(f => f.properties.name).sort()).toEqual(['east', 'west']);
+    assert.deepStrictEqual(index.getClusters([0.95, 0, 1.05, 1], 17).map(f => f.properties.name).sort(), ['east', 'west']);
 });
diff --git a/src/convert.test.ts b/src/convert.test.ts
index 4f5a63e..d29861d 100644
--- a/src/convert.test.ts
+++ b/src/convert.test.ts
@@ -1,4 +1,5 @@
-import {test, expect, describe} from 'vitest';
+import {test, describe} from 'node:test';
+import assert from 'node:assert/strict';
 import {convertToInternal} from './convert';
 import {defaultOptions} from './geojsonvt';
 
@@ -22,19 +23,18 @@ describe('convertToInternal', () => {
     test('converts a geometry nested in GeometryCollections', () => {
         const features = convertToInternal(feature(nestGeometryCollections(3, point)), defaultOptions);
 
-        expect(features).toHaveLength(1);
-        expect(features[0].type).toBe('Point');
+        assert.strictEqual((features).length, 1);
+        assert.strictEqual(features[0].type, 'Point');
     });
 
     test('allows nesting up to the supported depth', () => {
         const features = convertToInternal(feature(nestGeometryCollections(1024, point)), defaultOptions);
 
-        expect(features).toHaveLength(1);
-        expect(features[0].type).toBe('Point');
+        assert.strictEqual((features).length, 1);
+        assert.strictEqual(features[0].type, 'Point');
     });
 
     test('throws when GeometryCollection nesting exceeds the supported depth', () => {
-        expect(() => convertToInternal(feature(nestGeometryCollections(1025, point)), defaultOptions))
-            .toThrow('GeometryCollection nesting exceeds supported depth: 1024');
+        assert.throws(() => convertToInternal(feature(nestGeometryCollections(1025, point)), defaultOptions), error => error.message.includes('GeometryCollection nesting exceeds supported depth: 1024'));
     });
 })
diff --git a/src/deconvert.test.ts b/src/deconvert.test.ts
index fdef869..276ce47 100644
--- a/src/deconvert.test.ts
+++ b/src/deconvert.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {featureToGeoJSON} from './deconvert';
 import {mercatorWorldCoordinateHelper} from './world-coordinate-helper';
 import type {GeoJSONVTInternalFeature} from './definitions';
@@ -19,8 +20,8 @@ test('project/unproject roundtrip retains precision', () => {
     ];
 
     for (const {lng, lat} of coords) {
-        expect(mercatorWorldCoordinateHelper.unprojectX(mercatorWorldCoordinateHelper.projectX(lng))).toBeCloseTo(lng, 10);
-        expect(mercatorWorldCoordinateHelper.unprojectY(mercatorWorldCoordinateHelper.projectY(lat))).toBeCloseTo(lat, 10);
+        assert.ok(Math.abs((mercatorWorldCoordinateHelper.unprojectX(mercatorWorldCoordinateHelper.projectX(lng))) - (lng)) < 0.5 * 10 ** -(10));
+        assert.ok(Math.abs((mercatorWorldCoordinateHelper.unprojectY(mercatorWorldCoordinateHelper.projectY(lat))) - (lat)) < 0.5 * 10 ** -(10));
     }
 });
 
@@ -35,11 +36,11 @@ test('featureToGeoJSON: converts Point geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.type).toBe('Feature');
-    expect(result.geometry.type).toBe('Point');
-    expect((result.geometry as GeoJSON.Point).coordinates).toEqual([0, 0]);
-    expect(result.id).toBe('point1');
-    expect(result.properties).toEqual({name: 'Test Point'});
+    assert.strictEqual(result.type, 'Feature');
+    assert.strictEqual(result.geometry.type, 'Point');
+    assert.deepStrictEqual((result.geometry as GeoJSON.Point).coordinates, [0, 0]);
+    assert.strictEqual(result.id, 'point1');
+    assert.deepStrictEqual(result.properties, {name: 'Test Point'});
 });
 
 test('featureToGeoJSON: converts MultiPoint geometry', () => {
@@ -53,8 +54,8 @@ test('featureToGeoJSON: converts MultiPoint geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.geometry.type).toBe('MultiPoint');
-    expect((result.geometry as GeoJSON.MultiPoint).coordinates.length).toBe(2);
+    assert.strictEqual(result.geometry.type, 'MultiPoint');
+    assert.strictEqual((result.geometry as GeoJSON.MultiPoint).coordinates.length, 2);
 });
 
 test('featureToGeoJSON: converts LineString geometry', () => {
@@ -68,8 +69,8 @@ test('featureToGeoJSON: converts LineString geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.geometry.type).toBe('LineString');
-    expect((result.geometry as GeoJSON.LineString).coordinates.length).toBe(3);
+    assert.strictEqual(result.geometry.type, 'LineString');
+    assert.strictEqual((result.geometry as GeoJSON.LineString).coordinates.length, 3);
 });
 
 test('featureToGeoJSON: converts MultiLineString geometry', () => {
@@ -86,8 +87,8 @@ test('featureToGeoJSON: converts MultiLineString geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.geometry.type).toBe('MultiLineString');
-    expect((result.geometry as GeoJSON.MultiLineString).coordinates.length).toBe(2);
+    assert.strictEqual(result.geometry.type, 'MultiLineString');
+    assert.strictEqual((result.geometry as GeoJSON.MultiLineString).coordinates.length, 2);
 });
 
 test('featureToGeoJSON: converts Polygon geometry', () => {
@@ -104,8 +105,8 @@ test('featureToGeoJSON: converts Polygon geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.geometry.type).toBe('Polygon');
-    expect((result.geometry as GeoJSON.Polygon).coordinates.length).toBe(2);
+    assert.strictEqual(result.geometry.type, 'Polygon');
+    assert.strictEqual((result.geometry as GeoJSON.Polygon).coordinates.length, 2);
 });
 
 test('featureToGeoJSON: converts MultiPolygon geometry', () => {
@@ -123,8 +124,8 @@ test('featureToGeoJSON: converts MultiPolygon geometry', () => {
 
     const result = featureToGeoJSON(feature);
 
-    expect(result.geometry.type).toBe('MultiPolygon');
-    expect((result.geometry as GeoJSON.MultiPolygon).coordinates.map(polygon => polygon.length)).toEqual([2, 1]);
+    assert.strictEqual(result.geometry.type, 'MultiPolygon');
+    assert.deepStrictEqual((result.geometry as GeoJSON.MultiPolygon).coordinates.map(polygon => polygon.length), [2, 1]);
 });
 
 test('featureToGeoJSON: handles various id types', () => {
@@ -132,9 +133,9 @@ test('featureToGeoJSON: handles various id types', () => {
     const stringId: GeoJSONVTInternalFeature = {type: 'Point', id: 'string-id', x: 0.5, y: 0.5, tags: {}};
     const numberId: GeoJSONVTInternalFeature = {type: 'Point', id: 42, x: 0.5, y: 0.5, tags: {}};
 
-    expect(featureToGeoJSON(noId).id).toBeUndefined();
-    expect(featureToGeoJSON(stringId).id).toBe('string-id');
-    expect(featureToGeoJSON(numberId).id).toBe(42);
+    assert.strictEqual(featureToGeoJSON(noId).id, undefined);
+    assert.strictEqual(featureToGeoJSON(stringId).id, 'string-id');
+    assert.strictEqual(featureToGeoJSON(numberId).id, 42);
 });
 
 test('featureToGeoJSON: correctly unprojects known coordinates', () => {
@@ -148,7 +149,7 @@ test('featureToGeoJSON: correctly unprojects known coordinates', () => {
     const result = featureToGeoJSON(feature);
     const coords = (result.geometry as GeoJSON.MultiPoint).coordinates;
 
-    expect(coords[0]).toEqual([0, 0]);
-    expect(coords[1]).toEqual([-180, 0]);
-    expect(coords[2]).toEqual([180, 0]);
+    assert.deepStrictEqual(coords[0], [0, 0]);
+    assert.deepStrictEqual(coords[1], [-180, 0]);
+    assert.deepStrictEqual(coords[2], [180, 0]);
 });
diff --git a/src/difference.test.ts b/src/difference.test.ts
index 78d3a97..9289808 100644
--- a/src/difference.test.ts
+++ b/src/difference.test.ts
@@ -1,4 +1,5 @@
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {applySourceDiff} from './difference';
 
 const options = {
@@ -26,8 +27,8 @@ test('applySourceDiff: adds a feature using the feature id', () => {
         add: [point]
     }, options);
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe('point');
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 'point');
 });
 
 test('applySourceDiff: adds a feature using the promoteId', () => {
@@ -46,8 +47,8 @@ test('applySourceDiff: adds a feature using the promoteId', () => {
         add: [point2]
     }, {promoteId: 'promoteId'});
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe('point2');
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 'point2');
 });
 
 test('applySourceDiff: adds a feature without properties when promoteId is set', () => {
@@ -64,8 +65,8 @@ test('applySourceDiff: adds a feature without properties when promoteId is set',
         add: [point]
     }, {promoteId: 'promoteId'});
 
-    expect(source.length).toBe(1);
-    expect(source[0]).toMatchObject({x: 0.5, y: 0.5});
+    assert.strictEqual(source.length, 1);
+    assert.partialDeepStrictEqual(source[0], {x: 0.5, y: 0.5});
 });
 
 test('applySourceDiff: removes a feature by its id', () => {
@@ -89,8 +90,8 @@ test('applySourceDiff: removes a feature by its id', () => {
         remove: ['point2'],
     }, options);
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe('point');
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 'point');
 });
 
 test('applySourceDiff: removeAll clears all features', () => {
@@ -115,8 +116,8 @@ test('applySourceDiff: removeAll clears all features', () => {
         removeAll: true
     }, options);
 
-    expect(source).toEqual(result.affected);
-    expect(result.source).toEqual([]);
+    assert.deepStrictEqual(source, result.affected);
+    assert.deepStrictEqual(result.source, []);
 });
 
 test('applySourceDiff: updates a feature geometry', () => {
@@ -138,9 +139,9 @@ test('applySourceDiff: updates a feature geometry', () => {
         }]
     }, options);
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe('point');
-    expect(source[0]).toMatchObject({x: 0.5027777777777778, y: 0.5});
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 'point');
+    assert.partialDeepStrictEqual(source[0], {x: 0.5027777777777778, y: 0.5});
 });
 
 test('applySourceDiff: keeps a generated id when updating a feature geometry', () => {
@@ -162,8 +163,8 @@ test('applySourceDiff: keeps a generated id when updating a feature geometry', (
         }]
     }, {...options, generateId: true});
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe(1);
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 1);
 });
 
 test('applySourceDiff: keeps a promoted id when updating a feature geometry and the promoted property', () => {
@@ -186,8 +187,8 @@ test('applySourceDiff: keeps a promoted id when updating a feature geometry and
         }]
     }, {...options, promoteId: 'name'});
 
-    expect(source.length).toBe(1);
-    expect(source[0].id).toBe('point');
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(source[0].id, 'point');
 });
 
 test('applySourceDiff: adds properties', () => {
@@ -209,11 +210,11 @@ test('applySourceDiff: adds properties', () => {
         }]
     }, options);
 
-    expect(source.length).toBe(1);
+    assert.strictEqual(source.length, 1);
     const tags = source[0].tags;
-    expect(Object.keys(tags).length).toBe(2);
-    expect(tags.prop).toBe('value');
-    expect(tags.prop2).toBe('value2');
+    assert.strictEqual(Object.keys(tags).length, 2);
+    assert.strictEqual(tags.prop, 'value');
+    assert.strictEqual(tags.prop2, 'value2');
 });
 
 test('applySourceDiff: updates properties', () => {
@@ -233,12 +234,12 @@ test('applySourceDiff: updates properties', () => {
             ]
         }]
     }, options);
-    expect(source.length).toBe(1);
+    assert.strictEqual(source.length, 1);
 
     const tags2 = source[0].tags;
-    expect(Object.keys(tags2).length).toBe(2);
-    expect(tags2.prop).toBe('value');
-    expect(tags2.prop2).toBe('value3');
+    assert.strictEqual(Object.keys(tags2).length, 2);
+    assert.strictEqual(tags2.prop, 'value');
+    assert.strictEqual(tags2.prop2, 'value3');
 });
 
 test('applySourceDiff: removes properties', () => {
@@ -257,10 +258,10 @@ test('applySourceDiff: removes properties', () => {
         }]
     }, options);
 
-    expect(source.length).toBe(1);
+    assert.strictEqual(source.length, 1);
     const tags3 = source[0].tags;
-    expect(Object.keys(tags3).length).toBe(1);
-    expect(tags3.prop).toBe('value');
+    assert.strictEqual(Object.keys(tags3).length, 1);
+    assert.strictEqual(tags3.prop, 'value');
 });
 
 test('applySourceDiff: removes all properties', () => {
@@ -279,8 +280,8 @@ test('applySourceDiff: removes all properties', () => {
         }]
     }, options);
 
-    expect(source.length).toBe(1);
-    expect(Object.keys(source[0].tags).length).toBe(0);
+    assert.strictEqual(source.length, 1);
+    assert.strictEqual(Object.keys(source[0].tags).length, 0);
 });
 
 test('applySourceDiff: empty update preserves properties', () => {
@@ -296,9 +297,9 @@ test('applySourceDiff: empty update preserves properties', () => {
         update: [{id: 'point'}]
     }, options);
 
-    expect(source.length).toBe(1);
+    assert.strictEqual(source.length, 1);
     const tags2 = source[0].tags;
-    expect(Object.keys(tags2).length).toBe(2);
-    expect(tags2.prop).toBe('value');
-    expect(tags2.prop2).toBe('value2');
+    assert.strictEqual(Object.keys(tags2).length, 2);
+    assert.strictEqual(tags2.prop, 'value');
+    assert.strictEqual(tags2.prop2, 'value2');
 });
diff --git a/src/geojsonvt.test.ts b/src/geojsonvt.test.ts
index 0fa2984..75f7e17 100644
--- a/src/geojsonvt.test.ts
+++ b/src/geojsonvt.test.ts
@@ -1,4 +1,6 @@
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {isDeepStrictEqual} from 'node:util';
 import {GeoJSONVT} from '.';
 
 test('publicly exposed cluster methods: getClusterExpansionZoom, getClusterChildren, getClusterLeaves', () => {
@@ -21,9 +23,9 @@ test('publicly exposed cluster methods: getClusterExpansionZoom, getClusterChild
     const cluster = tile.features.find(f => (f.tags as {cluster?: boolean})?.cluster);
     const clusterId = (cluster.tags as {cluster_id: number}).cluster_id;
 
-    expect(index.getClusterExpansionZoom(clusterId)).toBeGreaterThan(0);
-    expect(index.getClusterChildren(clusterId).length).toBeGreaterThan(0);
-    expect(index.getClusterLeaves(clusterId, 5, 0).length).toBeLessThanOrEqual(5);
+    assert.ok(index.getClusterExpansionZoom(clusterId) > 0);
+    assert.ok(index.getClusterChildren(clusterId).length > 0);
+    assert.ok(index.getClusterLeaves(clusterId, 5, 0).length <= 5);
 });
 
 test('publicly exposed cluster methods: return undefined when clustering is disabled', () => {
@@ -33,9 +35,9 @@ test('publicly exposed cluster methods: return undefined when clustering is disa
         clusterOptions: {radius: 100}
     });
 
-    expect(index.getClusterExpansionZoom(123)).toBeNull();
-    expect(index.getClusterChildren(123)).toBeNull();
-    expect(index.getClusterLeaves(123, 10, 0)).toBeNull();
+    assert.strictEqual(index.getClusterExpansionZoom(123), null);
+    assert.strictEqual(index.getClusterChildren(123), null);
+    assert.strictEqual(index.getClusterLeaves(123, 10, 0), null);
 });
 
 test('a unit square without wrap cuts a line at the buffer around the world instead of wrapping or clamping it', () => {
@@ -43,7 +45,7 @@ test('a unit square without wrap cuts a line at the buffer around the world inst
 
     const index = new GeoJSONVT(fromThreeWorldsNorthToEast, {coordinates: 'unitSquare', wrap: false});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[[2770, -64], [3072, 2048], [4160, 2048]]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry), [[[[2770, -64], [3072, 2048], [4160, 2048]]]]);
 });
 
 test('a unit square without wrap cuts the top tile at the world again on update, so a feature can move in from outside', () => {
@@ -53,7 +55,7 @@ test('a unit square without wrap cuts the top tile at the world again on update,
 
     index.updateData({update: [{id: 'moving in', newGeometry: {type: 'Point', coordinates: [0.5, 0.5]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['moving in']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.id), ['moving in']);
 });
 
 test('a unit square without wrap returns the data in the unit square', () => {
@@ -67,16 +69,16 @@ test('a unit square without wrap returns the data in the unit square', () => {
     ];
     const index = new GeoJSONVT({type: 'FeatureCollection', features}, {coordinates: 'unitSquare', wrap: false, updateable: true});
 
-    expect(index.getData()).toEqual({type: 'FeatureCollection', features});
+    assert.deepStrictEqual(index.getData(), {type: 'FeatureCollection', features});
 });
 
 test('a unit square without wrap keeps a MultiLineString it splits for lineMetrics in the unit square', () => {
     const multiLine = {type: 'MultiLineString' as const, coordinates: [[[0.25, 0.75], [0.5, 0.5]], [[0.5, 0.25], [0.75, 0.25]]]};
     const index = new GeoJSONVT(multiLine, {coordinates: 'unitSquare', wrap: false, lineMetrics: true, updateable: true});
 
-    expect(index.getData()).toEqual({type: 'FeatureCollection', features: [
-        {type: 'Feature', geometry: {type: 'LineString', coordinates: [[0.25, 0.75], [0.5, 0.5]]}},
-        {type: 'Feature', geometry: {type: 'LineString', coordinates: [[0.5, 0.25], [0.75, 0.25]]}}
+    assert.deepStrictEqual(index.getData(), {type: 'FeatureCollection', features: [
+        {type: 'Feature', properties: undefined, geometry: {type: 'LineString', coordinates: [[0.25, 0.75], [0.5, 0.5]]}},
+        {type: 'Feature', properties: undefined, geometry: {type: 'LineString', coordinates: [[0.5, 0.25], [0.75, 0.25]]}}
     ]});
 });
 
@@ -90,7 +92,7 @@ test('a unit square without wrap hands the update filter features in the unit sq
         return true;
     });
 
-    expect(filtered).toContainEqual({type: 'Point', coordinates: [0.25, 0.75]});
+    assert.ok(filtered.some(actual => isDeepStrictEqual(actual, {type: 'Point', coordinates: [0.25, 0.75]})));
 });
 
 test('a unit square without wrap leaves points outside the world out of the clusters', () => {
@@ -105,7 +107,7 @@ test('a unit square without wrap leaves points outside the world out of the clus
 
     const index = new GeoJSONVT(data, {coordinates: 'unitSquare', wrap: false, cluster: true});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry), [[[507, 256]]]);
 });
 
 test('a unit square without wrap keeps points at either edge out of the clustered tile at the other edge', () => {
@@ -119,7 +121,7 @@ test('a unit square without wrap keeps points at either edge out of the clustere
 
     const index = new GeoJSONVT(data, {coordinates: 'unitSquare', wrap: false, cluster: true});
 
-    expect(index.getTile(0, 0, 0).features).toHaveLength(2);
+    assert.strictEqual((index.getTile(0, 0, 0).features).length, 2);
 });
 
 test('a unit square without wrap returns cluster children and leaves in the unit square', () => {
@@ -138,8 +140,8 @@ test('a unit square without wrap returns cluster children and leaves in the unit
     const childPositions = index.getClusterChildren(clusterId).map(child => (child.geometry as GeoJSON.Point).coordinates);
     const leafPositions = index.getClusterLeaves(clusterId, 20, 0).map(leaf => (leaf.geometry as GeoJSON.Point).coordinates);
 
-    expect(childPositions.every(([x, y]) => Math.abs(x - 0.50001) < 0.00001 && y === 0.5)).toBe(true);
-    expect(leafPositions).toEqual(expect.arrayContaining(points.features.map(point => point.geometry.coordinates)));
+    assert.strictEqual(childPositions.every(([x, y]) => Math.abs(x - 0.50001) < 0.00001 && y === 0.5), true);
+    assert.ok(points.features.map(point => point.geometry.coordinates).every(expected => leafPositions.some(actual => isDeepStrictEqual(actual, expected))));
 });
 
 test('a unit square without wrap stays without wrap for clusters after updateData', () => {
@@ -148,29 +150,29 @@ test('a unit square without wrap stays without wrap for clusters after updateDat
 
     index.updateData({add: [point('b', 0.99)]});
 
-    expect(index.getTile(1, -1, 0)).toBeNull();
+    assert.strictEqual(index.getTile(1, -1, 0), null);
 });
 
 test('wraps positions in the unit square around the antimeridian by default', () => {
     const nearTheEastEdge = {type: 'Feature' as const, properties: {}, geometry: {type: 'Point' as const, coordinates: [0.999, 0.25]}};
     const index = new GeoJSONVT(nearTheEastEdge, {coordinates: 'unitSquare'});
 
-    expect(index.getTile(1, 0, 0).features.map(feature => feature.geometry)).toEqual([[[-8, 2048]]]);
+    assert.deepStrictEqual(index.getTile(1, 0, 0).features.map(feature => feature.geometry), [[[-8, 2048]]]);
 });
 
 test('cuts the top tile above and below for positions in a unit square that wraps', () => {
     const fromThreeBelowToThreeAbove = {type: 'Feature' as const, properties: {}, geometry: {type: 'LineString' as const, coordinates: [[0.25, -3], [0.75, 3]]}};
     const index = new GeoJSONVT(fromThreeBelowToThreeAbove, {coordinates: 'unitSquare'});
 
-    expect(index.getTile(0, 0, 0).features[0].geometry).toEqual([[[2043, -64], [2395, 4160]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features[0].geometry, [[[2043, -64], [2395, 4160]]]);
 });
 
 test('copies no lng/lat features across the antimeridian without wrap', () => {
     const nearTheAntimeridian = {type: 'Feature' as const, properties: {}, geometry: {type: 'Point' as const, coordinates: [179.9, -10]}};
     const index = new GeoJSONVT(nearTheAntimeridian, {wrap: false});
 
-    expect(index.getTile(1, 0, 1)?.features ?? []).toEqual([]);
-    expect(index.getTile(1, 1, 1).features).toHaveLength(1);
+    assert.deepStrictEqual(index.getTile(1, 0, 1)?.features ?? [], []);
+    assert.strictEqual((index.getTile(1, 1, 1).features).length, 1);
 });
 
 test('a unit square without wrap returns no tile for a column on either side of the world', () => {
@@ -178,7 +180,7 @@ test('a unit square without wrap returns no tile for a column on either side of
 
     const index = new GeoJSONVT(inTheTwoTopTiles, {coordinates: 'unitSquare', wrap: false});
 
-    expect([index.getTile(1, -1, 0), index.getTile(1, 2, 0)]).toEqual([null, null]);
+    assert.deepStrictEqual([index.getTile(1, -1, 0), index.getTile(1, 2, 0)], [null, null]);
 });
 
 const weightedPoints = {
@@ -204,7 +206,7 @@ test('updateClusterOptions aggregates cluster properties when it adds a reduce f
 
     index.updateClusterOptions(true, {maxZoom: 2, ...sumWeights});
 
-    expect(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum)).toEqual([3, 30]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum), [3, 30]);
 });
 
 test('updateClusterOptions stops aggregating cluster properties when it removes the reduce function', () => {
@@ -216,7 +218,7 @@ test('updateClusterOptions stops aggregating cluster properties when it removes
 
     index.updateClusterOptions(true, {maxZoom: 2});
 
-    expect(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum)).toEqual([undefined, undefined]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(f => (f.tags as {sum?: number}).sum), [undefined, undefined]);
 });
 
 test('skips an empty polygon of a MultiPolygon', () => {
@@ -227,7 +229,7 @@ test('skips an empty polygon of a MultiPolygon', () => {
 
     const index = new GeoJSONVT(multiPolygon, {maxZoom: 5});
 
-    expect(index.getTile(0, 0, 0).features[0].geometry).toEqual([[[2048, 2048], [2162, 1934], [2162, 2048], [2048, 2048]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features[0].geometry, [[[2048, 2048], [2162, 1934], [2162, 2048], [2048, 2048]]]);
 });
 
 test('leaves out a MultiPolygon that has only empty polygons', () => {
@@ -238,7 +240,7 @@ test('leaves out a MultiPolygon that has only empty polygons', () => {
 
     const index = new GeoJSONVT(multiPolygon, {updateable: true});
 
-    expect(index.getData()).toEqual({type: 'FeatureCollection', features: []});
+    assert.deepStrictEqual(index.getData(), {type: 'FeatureCollection', features: []});
 });
 
 test('updateData draws a feature again when an update gives back the coordinates an earlier one took away', () => {
@@ -248,7 +250,7 @@ test('updateData draws a feature again when an update gives back the coordinates
     index.updateData({update: [{id: 'line', newGeometry: {type: 'LineString', coordinates: []}}]});
     index.updateData({update: [{id: 'line', newGeometry: line.geometry}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'line'}]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.tags), [{name: 'line'}]);
 });
 
 test('updateData draws a feature loaded without a geometry once an update gives it one', () => {
@@ -257,7 +259,7 @@ test('updateData draws a feature loaded without a geometry once an update gives
 
     index.updateData({update: [{id: 'later', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'later'}]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.tags), [{name: 'later'}]);
 });
 
 test('updateData draws a feature added without coordinates once an update gives it some', () => {
@@ -266,7 +268,7 @@ test('updateData draws a feature added without coordinates once an update gives
     index.updateData({add: [{type: 'Feature', id: 'added', properties: {name: 'added'}, geometry: {type: 'Polygon', coordinates: []}}]});
     index.updateData({update: [{id: 'added', newGeometry: {type: 'Polygon', coordinates: [[[0, 0], [10, 0], [10, 10], [0, 0]]]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'added'}]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.tags), [{name: 'added'}]);
 });
 
 test('updateData leaves a feature without a geometry removed when an update gives it one', () => {
@@ -277,7 +279,7 @@ test('updateData leaves a feature without a geometry removed when an update give
     index.updateData({remove: ['removed']});
     index.updateData({update: [{id: 'removed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.id), ['kept']);
 });
 
 test('updateData leaves a feature without a geometry removed by removeAll when an update gives it one', () => {
@@ -288,7 +290,7 @@ test('updateData leaves a feature without a geometry removed by removeAll when a
     index.updateData({removeAll: true, add: [kept]});
     index.updateData({update: [{id: 'removed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.id), ['kept']);
 });
 
 test('updateData gives each feature added with generateId a new id that is not reused and can be removed', () => {
@@ -300,7 +302,7 @@ test('updateData gives each feature added with generateId a new id that is not r
     index.updateData({add: [point(4)]});
     index.updateData({remove: [2]});
 
-    expect((index.getData() as GeoJSON.FeatureCollection).features.map(feature => [feature.id, feature.properties.x])).toEqual([[1, 1], [3, 3], [4, 4]]);
+    assert.deepStrictEqual((index.getData() as GeoJSON.FeatureCollection).features.map(feature => [feature.id, feature.properties.x]), [[1, 1], [3, 3], [4, 4]]);
 });
 
 test('updateData keeps the property changes made to a feature while it has no geometry', () => {
@@ -310,7 +312,7 @@ test('updateData keeps the property changes made to a feature while it has no ge
     index.updateData({update: [{id: 'renamed', addOrUpdateProperties: [{key: 'name', value: 'after'}]}]});
     index.updateData({update: [{id: 'renamed', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags)).toEqual([{name: 'after'}]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.tags), [{name: 'after'}]);
 });
 
 test('updateData does not bring back a feature the update filter took out after an update gave it a geometry', () => {
@@ -321,7 +323,7 @@ test('updateData does not bring back a feature the update filter took out after
     index.updateData({update: [{id: 'hidden', newGeometry: {type: 'Point', coordinates: [10, 10]}}]}, feature => !feature.properties.hidden);
     index.updateData({update: [{id: 'hidden', newGeometry: {type: 'Point', coordinates: [20, 20]}}]});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.id)).toEqual(['kept']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.id), ['kept']);
 });
 
 test('updateData does not bring back a feature the update filter took out while it had no coordinates', () => {
@@ -332,7 +334,7 @@ test('updateData does not bring back a feature the update filter took out while
     index.updateData({update: [{id: 'point', newGeometry: {type: 'Point', coordinates: []}, addOrUpdateProperties: [{key: 'keep', value: false}]}]}, keepIfMarked);
     index.updateData({update: [{id: 'point', newGeometry: {type: 'Point', coordinates: [10, 10]}, addOrUpdateProperties: [{key: 'keep', value: true}]}]}, keepIfMarked);
 
-    expect(index.getData()).toEqual({type: 'FeatureCollection', features: []});
+    assert.deepStrictEqual(index.getData(), {type: 'FeatureCollection', features: []});
 });
 
 test('updateData draws a bare geometry loaded without coordinates once an update gives it some', () => {
@@ -340,7 +342,7 @@ test('updateData draws a bare geometry loaded without coordinates once an update
 
     index.updateData({update: [{id: 0, newGeometry: {type: 'LineString', coordinates: [[0, 0], [10, 10]]}}]});
 
-    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual([0]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0)?.features.map(feature => feature.id), [0]);
 });
 
 test('updateData keeps a feature loaded without a geometry away from the update filter', () => {
@@ -352,7 +354,7 @@ test('updateData keeps a feature loaded without a geometry away from the update
     index.updateData({update: [{id: 'point', addOrUpdateProperties: [{key: 'name', value: 'p'}]}]}, pointsOnly);
     index.updateData({update: [{id: 'later', newGeometry: {type: 'Point', coordinates: [10, 10]}}]}, pointsOnly);
 
-    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id).sort()).toEqual(['later', 'point']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0)?.features.map(feature => feature.id).sort(), ['later', 'point']);
 });
 
 test('updateData hands the filter a feature without coordinates with its promoted id', () => {
@@ -361,7 +363,7 @@ test('updateData hands the filter a feature without coordinates with its promote
     index.updateData({}, feature => feature.id === 'promoted');
     index.updateData({update: [{id: 'promoted', newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual(['promoted']);
+    assert.deepStrictEqual(index.getTile(0, 0, 0)?.features.map(feature => feature.id), ['promoted']);
 });
 
 test('updateData hands the filter a feature without coordinates with its generated id', () => {
@@ -370,7 +372,7 @@ test('updateData hands the filter a feature without coordinates with its generat
     index.updateData({}, feature => feature.id === 0);
     index.updateData({update: [{id: 0, newGeometry: {type: 'Point', coordinates: [10, 10]}}]});
 
-    expect(index.getTile(0, 0, 0)?.features.map(feature => feature.id)).toEqual([0]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0)?.features.map(feature => feature.id), [0]);
 });
 
 test('keeps the corner of a polygon whose vertex lies on the left edge of a tile', () => {
@@ -381,7 +383,7 @@ test('keeps the corner of a polygon whose vertex lies on the left edge of a tile
 
     const index = new GeoJSONVT(polygon, {indexMaxZoom: 0, maxZoom: 24, tolerance: 1.5, buffer: 0});
 
-    expect(index.getTile(1, 1, 1).features[0].geometry).toEqual([[[0, 4096], [0, 0], [0, 0], [2048, 4096], [0, 4096]]]);
+    assert.deepStrictEqual(index.getTile(1, 1, 1).features[0].geometry, [[[0, 4096], [0, 0], [0, 0], [2048, 4096], [0, 4096]]]);
 });
 
 test('keeps the corner of a polygon whose vertex lies on the right edge of a tile', () => {
@@ -392,7 +394,7 @@ test('keeps the corner of a polygon whose vertex lies on the right edge of a til
 
     const index = new GeoJSONVT(polygon, {maxZoom: 5, buffer: 0});
 
-    expect(index.getTile(3, 4, 3).features[0].geometry).toEqual([[[1820, 762], [4096, 1986], [4096, 3700], [1820, 3700], [1820, 762]]]);
+    assert.deepStrictEqual(index.getTile(3, 4, 3).features[0].geometry, [[[1820, 762], [4096, 1986], [4096, 3700], [1820, 3700], [1820, 762]]]);
 });
 
 test('keeps the part of a line that enters a tile exactly at a vertex', () => {
@@ -404,8 +406,8 @@ test('keeps the part of a line that enters a tile exactly at a vertex', () => {
     const index = new GeoJSONVT(line, {lineMetrics: true, buffer: 0});
 
     const feature = index.getTile(1, 1, 0).features[0];
-    expect(feature.geometry).toEqual([[[0, 3631], [2048, 3631]]]);
-    expect(feature.tags).toEqual({geojsonvt_clip_start: 0.5, geojsonvt_clip_end: 1});
+    assert.deepStrictEqual(feature.geometry, [[[0, 3631], [2048, 3631]]]);
+    assert.deepStrictEqual(feature.tags, {geojsonvt_clip_start: 0.5, geojsonvt_clip_end: 1});
 });
 
 test('clusters each position of a MultiPoint feature when clustering is on', () => {
@@ -418,7 +420,7 @@ test('clusters each position of a MultiPoint feature when clustering is on', ()
 
     const index = new GeoJSONVT(multiPoint, {cluster: true});
 
-    expect(index.getTile(0, 0, 0).features).toEqual([
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features, [
         {type: 1, geometry: [[284, 227]], tags: {cluster: true, cluster_id: 20, point_count: 2, point_count_abbreviated: 2}, id: 20},
         {type: 1, geometry: [[341, 227]], tags: {name: 'multi'}, id: 7}
     ]);
@@ -439,18 +441,18 @@ test('counts each point once in the clusters at the antimeridian', () => {
         [[[514, 256]], 2]
     ];
 
-    expect(clusters(new GeoJSONVT(data, {cluster: true}))).toEqual(expected);
+    assert.deepStrictEqual(clusters(new GeoJSONVT(data, {cluster: true})), expected);
 
     const clusteredLater = new GeoJSONVT(data, {updateable: true});
     clusteredLater.updateClusterOptions(true, {});
-    expect(clusters(clusteredLater)).toEqual(expected);
+    assert.deepStrictEqual(clusters(clusteredLater), expected);
 });
 
 test('counts each position of a MultiPoint once in the clusters at the antimeridian', () => {
     const multiPoint: GeoJSON.Feature = {type: 'Feature', properties: {}, geometry: {type: 'MultiPoint', coordinates: [[179, 0], [178, 0], [-179, 0], [-178, 0]]}};
     const index = new GeoJSONVT(multiPoint, {cluster: true});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.tags.point_count)).toEqual([2, 2, 2, 2]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.tags.point_count), [2, 2, 2, 2]);
 });
 
 test('a unit square without wrap leaves the positions of a MultiPoint outside the world out of the clusters', () => {
@@ -462,7 +464,7 @@ test('a unit square without wrap leaves the positions of a MultiPoint outside th
 
     const index = new GeoJSONVT(multiPoint, {coordinates: 'unitSquare', wrap: false, cluster: true});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([[[507, 256]]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry), [[[507, 256]]]);
 });
 
 test('leaves out the empty rings of a polygon and the empty lines of a MultiLineString', () => {
@@ -478,11 +480,11 @@ test('leaves out the empty rings of a polygon and the empty lines of a MultiLine
     const ringsOf = (index: GeoJSONVT) => (index.getData() as GeoJSON.FeatureCollection<GeoJSON.Polygon>).features.map(feature => [feature.id, feature.geometry.type, feature.geometry.coordinates.length]);
 
     const index = new GeoJSONVT(data, {updateable: true, tolerance: 0});
-    expect(ringsOf(index)).toEqual([['polygon', 'Polygon', 1], ['polygons', 'MultiPolygon', 1], ['lines', 'MultiLineString', 1]]);
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry.length)).toEqual([1, 1, 1]);
+    assert.deepStrictEqual(ringsOf(index), [['polygon', 'Polygon', 1], ['polygons', 'MultiPolygon', 1], ['lines', 'MultiLineString', 1]]);
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry.length), [1, 1, 1]);
 
     const withMetrics = new GeoJSONVT(data, {updateable: true, tolerance: 0, lineMetrics: true});
-    expect(ringsOf(withMetrics)).toEqual([['polygon', 'Polygon', 1], ['polygons', 'MultiPolygon', 1], ['lines', 'LineString', 2]]);
+    assert.deepStrictEqual(ringsOf(withMetrics), [['polygon', 'Polygon', 1], ['polygons', 'MultiPolygon', 1], ['lines', 'LineString', 2]]);
 });
 
 test('takes a polygon or a MultiLineString with only empty rings as a feature without coordinates', () => {
@@ -495,11 +497,11 @@ test('takes a polygon or a MultiLineString with only empty rings as a feature wi
     };
     const index = new GeoJSONVT(data, {updateable: true, tolerance: 0});
 
-    expect((index.getData() as GeoJSON.FeatureCollection).features).toEqual([]);
-    expect(index.getTile(0, 0, 0)).toBeNull();
+    assert.deepStrictEqual((index.getData() as GeoJSON.FeatureCollection).features, []);
+    assert.strictEqual(index.getTile(0, 0, 0), null);
 
     index.updateData({update: [{id: 'polygon', newGeometry: {type: 'Point', coordinates: [0, 0]}}]});
-    expect((index.getData() as GeoJSON.FeatureCollection).features.map(feature => feature.id)).toEqual(['polygon']);
+    assert.deepStrictEqual((index.getData() as GeoJSON.FeatureCollection).features.map(feature => feature.id), ['polygon']);
 });
 
 test('shows the positions of a MultiPoint near the antimeridian at both edges of the world', () => {
@@ -511,7 +513,7 @@ test('shows the positions of a MultiPoint near the antimeridian at both edges of
     };
     const index = new GeoJSONVT(multiPoint);
 
-    expect(index.getTile(0, 0, 0).features.map(f => f.geometry)).toEqual([
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(f => f.geometry), [
         [[4097, 1934]],
         [[4095, 2048], [4095, 1991], [1, 1934]],
         [[-1, 2048], [-1, 1991]]
@@ -524,15 +526,15 @@ test('keeps a polygon whose area is not a number as a polygon of its own', () =>
     const index = new GeoJSONVT({type: 'MultiPolygon', coordinates: [[small], [huge]]}, {coordinates: 'unitSquare', wrap: false, updateable: true});
 
     const [feature] = (index.getData() as GeoJSON.FeatureCollection<GeoJSON.MultiPolygon>).features;
-    expect(feature.geometry.coordinates.map(polygon => polygon.length)).toEqual([1, 1]);
-    expect(index.getTile(0, 0, 0).features[0].geometry).toHaveLength(1);
+    assert.deepStrictEqual(feature.geometry.coordinates.map(polygon => polygon.length), [1, 1]);
+    assert.strictEqual(index.getTile(0, 0, 0).features[0].geometry.length, 1);
 });
 
 test('closes a clipped ring whose positions are not all numbers', () => {
     const polygon: GeoJSON.Polygon = {type: 'Polygon', coordinates: [[[-100, 20], [Infinity, 30], [40, -10], [-100, 20]]]};
     const index = new GeoJSONVT(polygon, {tolerance: 0});
 
-    expect(index.getTile(1, 0, 1).features.map(feature => feature.geometry)).toEqual([
+    assert.deepStrictEqual(index.getTile(1, 0, 1).features.map(feature => feature.geometry), [
         [[[4160, -64], [4160, 45], [3661, -64], [4160, -64]]],
         [[[4160, NaN], [-64, NaN], [4160, NaN]]]
     ]);
@@ -545,6 +547,6 @@ test('drops a hole without area at a tolerance of the smallest number, like any
     };
     const index = new GeoJSONVT(polygon, {coordinates: 'unitSquare', wrap: false, indexMaxZoom: 0, tolerance: Math.sqrt(Number.MIN_VALUE) * 4096});
 
-    expect(index.getTile(0, 0, 0).features[0].geometry).toHaveLength(1);
+    assert.strictEqual(index.getTile(0, 0, 0).features[0].geometry.length, 1);
 });
 
diff --git a/src/simplify.test.ts b/src/simplify.test.ts
index e6a4cb5..0fb48b3 100644
--- a/src/simplify.test.ts
+++ b/src/simplify.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {simplify} from './simplify';
 
 const points = [
@@ -58,7 +59,7 @@ test('simplifies points correctly with the given tolerance', () => {
             result.push([coords[i], coords[i + 1]]);
         }
     }
-    expect(result).toEqual(simplified);
+    assert.deepStrictEqual(result, simplified);
 });
 
 test('does not throw max call stack error on bad long input', () => {
@@ -67,9 +68,9 @@ test('does not throw max call stack error on bad long input', () => {
         coords.push(0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0);
     }
 
-    expect(() => {
+    assert.doesNotThrow(() => {
         simplify(coords, 0, coords.length, 2e-15);
-    }).not.toThrow();
+    });
 });
 
 test('does not throw max call stack error when splitting off one vertex at a time due to zig-zag', () => {
@@ -80,12 +81,12 @@ test('does not throw max call stack error when splitting off one vertex at a tim
         coords.push(i / n, 0.5 + (i % 2 ? 1 : -1) * (1 + i * 1e-4) * 1e-3, 0);
     }
 
-    expect(() => {
+    assert.doesNotThrow(() => {
         simplify(coords, 0, coords.length - 3, 1e-12);
-    }).not.toThrow();
+    });
     let kept = 0;
     for (let i = 5; i < coords.length - 3; i += 3) {
         if (coords[i] > 0) kept++;
     }
-    expect(kept).toBe(n - 2);
+    assert.strictEqual(kept, n - 2);
 });
diff --git a/src/tile-index.test.ts b/src/tile-index.test.ts
index 29d0ed7..3009df8 100644
--- a/src/tile-index.test.ts
+++ b/src/tile-index.test.ts
@@ -1,4 +1,5 @@
-import {describe, expect, test} from "vitest";
+import {describe, test} from 'node:test';
+import assert from 'node:assert/strict';
 import {TileIndex} from "./tile-index";
 import {convertToInternal} from "./convert";
 import {applySourceDiff} from "./difference";
@@ -36,7 +37,7 @@ describe('TileIndex', () => {
         let sourceFeatures = convertToInternal(initialData, options);
         sourceFeatures = wrap(sourceFeatures, options);
         index.initialize(sourceFeatures);
-        expect(index.stats.z1).toBe(4);
+        assert.strictEqual(index.stats.z1, 4);
 
         const globalFeature = {
             type: 'Feature' as const,
@@ -49,7 +50,7 @@ describe('TileIndex', () => {
         };
         const {source, affected} = applySourceDiff(sourceFeatures, {add: [globalFeature]}, options);
         index.updateIndex(source, affected, options);
-        expect(index.stats.z1).toBe(0);
+        assert.strictEqual(index.stats.z1, 0);
     });
 
     test('updateData: invalidates tiles when feature is within the buffer edge', () => {
@@ -79,7 +80,7 @@ describe('TileIndex', () => {
     
         const tileId = toID(1, 0, 0);
         index.getTile(1, 0, 0);
-        expect(index.tiles[tileId]).toBeTruthy();
+        assert.ok(index.tiles[tileId]);
     
         const featureWithinBuffer = {
             type: 'Feature' as const,
@@ -92,7 +93,7 @@ describe('TileIndex', () => {
         };
         const {source, affected} = applySourceDiff(sourceFeatures, {add: [featureWithinBuffer]}, options);
         index.updateIndex(source, affected, options);
-        expect(index.tiles[tileId]).toBeUndefined();
+        assert.strictEqual(index.tiles[tileId], undefined);
     });
 
     test('updateData: invalidates tiles at deeper zoom', () => {
@@ -125,8 +126,8 @@ describe('TileIndex', () => {
         const tileId = toID(5, 16, 16);
     
         const tileBefore = index.tiles[tileId];
-        expect(tileBefore).toBeTruthy();
-        expect(tileBefore.numFeatures).toBe(1);
+        assert.ok(tileBefore);
+        assert.strictEqual(tileBefore.numFeatures, 1);
     
         const updatedFeature = {
             type: 'Feature' as const,
@@ -144,11 +145,11 @@ describe('TileIndex', () => {
         index.updateIndex(source, affected, options);
     
         const tileAfter = index.tiles[tileId];
-        expect(tileAfter).toBeUndefined();
+        assert.strictEqual(tileAfter, undefined);
     
         const tileRegenerated = index.getTile(5, 16, 16);
-        expect(tileRegenerated).toBeTruthy();
-        expect(tileRegenerated.features[0].tags.name).toBe('Updated');
+        assert.ok(tileRegenerated);
+        assert.strictEqual(tileRegenerated.features[0].tags.name, 'Updated');
     });
 
     test('updateData: does not invalidate unaffected tiles', () => {
@@ -193,8 +194,8 @@ describe('TileIndex', () => {
         const nwTileBefore = index.tiles[nwTileId];
         const seTileBefore = index.tiles[seTileId];
     
-        expect(nwTileBefore).toBeTruthy();
-        expect(seTileBefore).toBeTruthy();
+        assert.ok(nwTileBefore);
+        assert.ok(seTileBefore);
     
         const updatedFeature = {
             type: 'Feature' as const,
@@ -211,10 +212,10 @@ describe('TileIndex', () => {
         index.updateIndex(source, affected, options);
     
         const nwTileAfter = index.tiles[nwTileId];
-        expect(nwTileAfter).toBeUndefined();
+        assert.strictEqual(nwTileAfter, undefined);
     
         const seTileAfter = index.tiles[seTileId];
-        expect(seTileAfter).toBe(seTileBefore);
+        assert.strictEqual(seTileAfter, seTileBefore);
     });
 });
 
@@ -242,7 +243,7 @@ describe('Multiworld test', () => {
         let sourceFeatures = convertToInternal(rightPoint, defaultOptions);
         sourceFeatures = wrap(sourceFeatures, defaultOptions);
         vt.initialize(sourceFeatures);
-        expect(vt.getTile(0, 0, 0).features[0].geometry).toEqual([[4096, 2048]]);
+        assert.deepStrictEqual(vt.getTile(0, 0, 0).features[0].geometry, [[4096, 2048]]);
     });
 
     test('handle point only in the leftside world', () => {
@@ -250,7 +251,7 @@ describe('Multiworld test', () => {
         let sourceFeatures = convertToInternal(leftPoint, defaultOptions);
         sourceFeatures = wrap(sourceFeatures, defaultOptions);
         vt.initialize(sourceFeatures);
-        expect(vt.getTile(0, 0, 0).features[0].geometry).toEqual([[0, 2048]]);
+        assert.deepStrictEqual(vt.getTile(0, 0, 0).features[0].geometry, [[0, 2048]]);
     });
 
     test('handle points in the leftside world and the rightside world', () => {
@@ -259,6 +260,6 @@ describe('Multiworld test', () => {
         sourceFeatures = wrap(sourceFeatures, defaultOptions);
         vt.initialize(sourceFeatures);
 
-        expect(vt.getTile(0, 0, 0).features.map(f => f.geometry)).toEqual([[[0, 2048]], [[4096, 2048]]]);
+        assert.deepStrictEqual(vt.getTile(0, 0, 0).features.map(f => f.geometry), [[[0, 2048]], [[4096, 2048]]]);
     });
 })
\ No newline at end of file
diff --git a/src/transform.test.ts b/src/transform.test.ts
index b4f23fb..eb2b363 100644
--- a/src/transform.test.ts
+++ b/src/transform.test.ts
@@ -1,4 +1,5 @@
-import {expect, test} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {GeoJSONVT} from '.';
 import {transformTile} from './transform';
 
@@ -18,7 +19,7 @@ test('quantization preserves shell and hole winding without changing ordinary or
     };
     const index = new GeoJSONVT(data, {coordinates: 'unitSquare', wrap: false, extent: 8192, tolerance: 0});
 
-    expect(index.getTile(13, 4800, 3000).features[0].geometry).toEqual([
+    assert.deepStrictEqual(index.getTile(13, 4800, 3000).features[0].geometry, [
         outer, roundedThinHole, hole,
         [[200, 300], [250, 300], [300, 300], [200, 300]], roundedThinShell
     ]);
@@ -31,5 +32,5 @@ test('transformTile retains empty polygon rings', () => {
         features: [{type: 3, tags: null, geometry: [new Int16Array(0)]}]
     });
 
-    expect(tile.features[0].geometry).toEqual([[]]);
+    assert.deepStrictEqual(tile.features[0].geometry, [[]]);
 });
diff --git a/test/full.test.ts b/test/full.test.ts
index 8faeaee..b9b18a3 100644
--- a/test/full.test.ts
+++ b/test/full.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import fs from 'fs';
 
 import {TileIndex} from '../src/tile-index';
@@ -18,31 +19,31 @@ testTiles('ids.json', 'ids-promote-id-tiles.json', {indexMaxZoom: 0, promoteId:
 testTiles('ids.json', 'ids-generate-id-tiles.json', {indexMaxZoom: 0, generateId: true});
 
 test('throws on invalid GeoJSON type', () => {
-    expect(() => {
+    assert.throws(() => {
         genTiles({type: 'Pologon', coordinates:[[-0.26,51.45],[-0.26,51.45]]} as unknown as GeoJSON.GeoJSON);
-    }).toThrow();
+    });
 });
 
 function testTiles(inputFile: string, expectedFile: string, options: GeoJSONVTOptions) {
     test(`full tiling test: ${  expectedFile.replace('-tiles.json', '')}`, () => {
         const tiles = genTiles(getJSON(inputFile), options);
         // fs.writeFileSync(path.join(__dirname, '/fixtures/' + expectedFile), JSON.stringify(tiles));
-        expect(tiles).toEqual(getJSON(expectedFile));
+        assert.deepStrictEqual(tiles, getJSON(expectedFile));
     });
 }
 
 test('empty geojson', () => {
-    expect({}).toEqual(genTiles(getJSON('empty.json')));
+    assert.deepStrictEqual({}, genTiles(getJSON('empty.json')));
 });
 
 test('null geometry', () => {
     // should ignore features with null geometry
-    expect({}).toEqual(genTiles(getJSON('feature-null-geometry.json')));
+    assert.deepStrictEqual({}, genTiles(getJSON('feature-null-geometry.json')));
 });
 
 test('empty coordinates', () => {
     // should ignore features with empty coordinates
-    expect({}).toEqual(genTiles(getJSON('empty-coords.json')));
+    assert.deepStrictEqual({}, genTiles(getJSON('empty-coords.json')));
 });
 
 function getJSON(name: string) {
diff --git a/test/geojson-to-tile.test.ts b/test/geojson-to-tile.test.ts
index 69c54e5..5472f9a 100644
--- a/test/geojson-to-tile.test.ts
+++ b/test/geojson-to-tile.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import fs from 'fs';
 import {geoJSONToTile} from '../src/geojson-to-tile';
 
@@ -14,8 +15,8 @@ test('geoJSONToTile: converts all geometries to a single vector tile', () => {
     const geojson = getJSON('single-tile.json');
     const tile = geoJSONToTile(geojson, 12, 1171, 1566);
 
-    expect(tile.features.length).toBe(1);
-    expect(tile.features[0].tags.name).toBe('P Street Northwest - Massachusetts Avenue Northwest');
+    assert.strictEqual(tile.features.length, 1);
+    assert.strictEqual(tile.features[0].tags.name, 'P Street Northwest - Massachusetts Avenue Northwest');
 });
 
 test('geoJSONToTile: wrap features across the antimeridian', () => {
@@ -32,14 +33,14 @@ test('geoJSONToTile: wrap features across the antimeridian', () => {
     };
 
     const tileWithoutWrap = geoJSONToTile(geojson, 0, 0, 0, {wrap: false, clip: true});
-    expect(tileWithoutWrap.features).toEqual([{
+    assert.deepStrictEqual(tileWithoutWrap.features, [{
         type: 2,
         tags: {name: 'test'},
         geometry: [[[-64, 2048], [4160, 2048]]]
     }]);
 
     const tileWithWrap = geoJSONToTile(geojson, 0, 0, 0, {wrap: true, clip: true});
-    expect(tileWithWrap.features).toEqual([
+    assert.deepStrictEqual(tileWithWrap.features, [
         {type: 2, tags: {name: 'test'}, geometry: [[[3868, 2048], [4160, 2048]]]},
         {type: 2, tags: {name: 'test'}, geometry: [[[-64, 2048], [4160, 2048]]]},
         {type: 2, tags: {name: 'test'}, geometry: [[[-64, 2048], [228, 2048]]]}
@@ -60,14 +61,14 @@ test('geoJSONToTile: shouldWrap duplicates features that extend beyond world bou
     };
 
     const tileWithoutWrap = geoJSONToTile(geojson, 0, 0, 0, {wrap: false, clip: false});
-    expect(tileWithoutWrap.features).toEqual([{
+    assert.deepStrictEqual(tileWithoutWrap.features, [{
         type: 2,
         tags: {name: 'test'},
         geometry: [[[-228, 2048], [114, 2048]]]
     }]);
 
     const tileWithWrap = geoJSONToTile(geojson, 0, 0, 0, {wrap: true, clip: false});
-    expect(tileWithWrap.features).toEqual([
+    assert.deepStrictEqual(tileWithWrap.features, [
         {type: 2, tags: {name: 'test'}, geometry: [[[3868, 2048], [4160, 2048]]]},
         {type: 2, tags: {name: 'test'}, geometry: [[[-64, 2048], [114, 2048]]]}
     ]);
@@ -77,14 +78,14 @@ test('geoJSONToTile: clips geometries outside the tile', () => {
     const geojson = getJSON('us-states.json');
 
     const tile1 = geoJSONToTile(geojson, 7, 37, 48, {clip: true});
-    expect(tile1.features).toEqual(getJSON('us-states-z7-37-48.json'));
+    assert.deepStrictEqual(tile1.features, getJSON('us-states-z7-37-48.json'));
 
     const tile2 = geoJSONToTile(geojson, 9, 148, 192, {clip: true});
-    expect(tile2.features).toEqual(square);
+    assert.deepStrictEqual(tile2.features, square);
 
-    expect(geoJSONToTile(geojson, 11, 800, 400, {clip: true}).features).toEqual([]);
-    expect(geoJSONToTile(geojson, -5, 123.25, 400.25, {clip: true}).features).toEqual([]);
-    expect(geoJSONToTile(geojson, 25, 200, 200, {clip: true}).features).toEqual([]);
+    assert.deepStrictEqual(geoJSONToTile(geojson, 11, 800, 400, {clip: true}).features, []);
+    assert.deepStrictEqual(geoJSONToTile(geojson, -5, 123.25, 400.25, {clip: true}).features, []);
+    assert.deepStrictEqual(geoJSONToTile(geojson, 25, 200, 200, {clip: true}).features, []);
 });
 
 function getJSON(name: string) {
diff --git a/test/get-tile.test.ts b/test/get-tile.test.ts
index 5164f7b..64bf725 100644
--- a/test/get-tile.test.ts
+++ b/test/get-tile.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import fs from 'fs';
 
 import {GeoJSONVT} from '../src';
@@ -17,7 +18,7 @@ test('getTile: empty cluster should return null', () => {
         features: []
     }, { cluster: true });
 
-    expect(index.getTile(0, 0, 0)).toBeNull();
+    assert.strictEqual(index.getTile(0, 0, 0), null);
 });
 
 test('getTile: empty index should return null', () => {
@@ -26,20 +27,20 @@ test('getTile: empty index should return null', () => {
         features: []
     });
 
-    expect(index.getTile(0, 0, 0)).toBeNull();
+    assert.strictEqual(index.getTile(0, 0, 0), null);
 });
 
 test('getTile: us-states.json', () => {
     const index = new GeoJSONVT(getJSON('us-states.json'), {debug: 2});
 
-    expect(index.getTile(7, 37, 48).features).toEqual(getJSON('us-states-z7-37-48.json'));
-    expect(index.getTile('7', '37', '48').features).toEqual(getJSON('us-states-z7-37-48.json'));
+    assert.deepStrictEqual(index.getTile(7, 37, 48).features, getJSON('us-states-z7-37-48.json'));
+    assert.deepStrictEqual(index.getTile('7', '37', '48').features, getJSON('us-states-z7-37-48.json'));
 
-    expect(index.getTile(9, 148, 192).features).toEqual(square);
+    assert.deepStrictEqual(index.getTile(9, 148, 192).features, square);
 
-    expect(index.getTile(11, 800, 400)).toBeNull();
-    expect(index.getTile(-5, 123.25, 400.25)).toBeNull();
-    expect(index.getTile(25, 200, 200)).toBeNull();
+    assert.strictEqual(index.getTile(11, 800, 400), null);
+    assert.strictEqual(index.getTile(-5, 123.25, 400.25), null);
+    assert.strictEqual(index.getTile(25, 200, 200), null);
 });
 
 test('getTile: unbuffered tile left/right edges', () => {
@@ -50,8 +51,8 @@ test('getTile: unbuffered tile left/right edges', () => {
         buffer: 0
     });
 
-    expect(index.getTile(2, 1, 1)).toBe(null);
-    expect(index.getTile(2, 2, 1).features).toEqual([{geometry: [[[0, 0], [0, 4096]]], type: 2, tags: null}]);
+    assert.strictEqual(index.getTile(2, 1, 1), null);
+    assert.deepStrictEqual(index.getTile(2, 2, 1).features, [{geometry: [[[0, 0], [0, 4096]]], type: 2, tags: null}]);
 });
 
 test('getTile: unbuffered tile top/bottom edges', () => {
@@ -62,8 +63,8 @@ test('getTile: unbuffered tile top/bottom edges', () => {
         buffer: 0
     });
 
-    expect(index.getTile(2, 1, 0).features).toEqual([{geometry: [[[0, 4096], [4096, 4096]]], type: 2, tags: null}]);
-    expect(index.getTile(2, 1, 1).features).toEqual([]);
+    assert.deepStrictEqual(index.getTile(2, 1, 0).features, [{geometry: [[[0, 4096], [4096, 4096]]], type: 2, tags: null}]);
+    assert.deepStrictEqual(index.getTile(2, 1, 1).features, []);
 });
 
 test('getTile: polygon clipping on the boundary', () => {
@@ -80,7 +81,7 @@ test('getTile: polygon clipping on the boundary', () => {
         buffer: 1024
     });
 
-    expect(index.getTile(5, 19, 9).features).toEqual([{
+    assert.deepStrictEqual(index.getTile(5, 19, 9).features, [{
         geometry: [[[3072, 3072], [5120, 3072], [5120, 5120], [3072, 5120], [3072, 3072]]],
         type: 3,
         tags: null
@@ -96,7 +97,7 @@ test('getTile: keeps the coordinates of a line and of points far outside the til
     const points: GeoJSON.Feature = {type: 'Feature', properties: {}, geometry: {type: 'MultiPoint', coordinates: [[100, 0.5], [101, 0.5]]}};
     const index = new GeoJSONVT({type: 'FeatureCollection', features: [line, points]}, {coordinates: 'unitSquare'});
 
-    expect(index.getTile(0, 0, 0).features.map(feature => feature.geometry)).toEqual([
+    assert.deepStrictEqual(index.getTile(0, 0, 0).features.map(feature => feature.geometry), [
         [[[409600, 2048], [413696, 2048]]],
         [[409600, 2048], [413696, 2048]]
     ]);
diff --git a/test/round-trip.test.ts b/test/round-trip.test.ts
index d6ad9ce..4268f64 100644
--- a/test/round-trip.test.ts
+++ b/test/round-trip.test.ts
@@ -1,5 +1,6 @@
 
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {defaultOptions} from '../src/geojsonvt';
 import {convertToGeoJSON} from '../src/deconvert';
 import {convertToInternal} from '../src/convert';
@@ -7,8 +8,8 @@ import {convertToInternal} from '../src/convert';
 const options = {...defaultOptions, updateable: true};
 
 function checkCoord(actual: number[], expected: number[]) {
-    expect(actual[0]).toBeCloseTo(expected[0], 10);
-    expect(actual[1]).toBeCloseTo(expected[1], 10);
+    assert.ok(Math.abs((actual[0]) - (expected[0])) < 0.5 * 10 ** -(10));
+    assert.ok(Math.abs((actual[1]) - (expected[1])) < 0.5 * 10 ** -(10));
 }
 
 test('round trip: Point', () => {
@@ -96,6 +97,6 @@ test('round trip: preserves feature id and properties', () => {
     const internal = convertToInternal(input, options);
     const output = convertToGeoJSON(internal) as GeoJSON.FeatureCollection;
 
-    expect(output.features[0].id).toBe('test-id');
-    expect(output.features[0].properties).toEqual({a: 1, b: 'two', c: null});
+    assert.strictEqual(output.features[0].id, 'test-id');
+    assert.deepStrictEqual(output.features[0].properties, {a: 1, b: 'two', c: null});
 });
diff --git a/test/update.test.ts b/test/update.test.ts
index c386e68..e15d2fd 100644
--- a/test/update.test.ts
+++ b/test/update.test.ts
@@ -1,4 +1,5 @@
-import {test, expect} from 'vitest';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
 import {GeoJSONVT, type ClusterProperties } from '../src';
 
 test('updateData: requires updateable option', () => {
@@ -7,9 +8,9 @@ test('updateData: requires updateable option', () => {
         features: []
     });
 
-    expect(() => {
+    assert.throws(() => {
         index.updateData({add: [], remove: []});
-    }).toThrow();
+    });
 });
 
 test('updateData: adds features with unique promote ids to empty index', () => {
@@ -33,7 +34,7 @@ test('updateData: adds features with unique promote ids to empty index', () => {
     
     index.updateData({add: featureCollection.features});
     const tile = index.getTile(0, 0, 0);
-    expect(tile.features.length).toBe(2);
+    assert.strictEqual(tile.features.length, 2);
 });
 
 test('updateData: adds new features', () => {
@@ -61,7 +62,7 @@ test('updateData: adds new features', () => {
     index.updateData({add: [newFeature]});
 
     const tile = index.getTile(0, 0, 0);
-    expect(tile.features.length).toBe(2);
+    assert.strictEqual(tile.features.length, 2);
 });
 
 test('updateData: removes features by id', () => {
@@ -88,7 +89,7 @@ test('updateData: removes features by id', () => {
     index.updateData({remove: ['feature1']});
 
     const tile = index.getTile(0, 0, 0);
-    expect(tile.features.length).toBe(1);
+    assert.strictEqual(tile.features.length, 1);
 });
 
 test('updateData: replaces features with duplicate ids', () => {
@@ -116,9 +117,9 @@ test('updateData: replaces features with duplicate ids', () => {
     index.updateData({add: [updatedFeature]});
 
     const tile = index.getTile(0, 0, 0);
-    expect(tile.features.length).toBe(1);
-    expect(tile.features[0].id).toBe('feature1');
-    expect(tile.features[0].tags.name).toBe('Updated');
+    assert.strictEqual(tile.features.length, 1);
+    assert.strictEqual(tile.features[0].id, 'feature1');
+    assert.strictEqual(tile.features[0].tags.name, 'Updated');
 });
 
 test('updateData: updates a feature coordinates cross the antimeridian', () => {
@@ -158,7 +159,7 @@ test('updateData: updates a feature coordinates cross the antimeridian', () => {
     index.updateData({update: [updatedFeature]});
 
     const tile = index.getTile(1, 0, 1);
-    expect(tile.features.length).toBe(1);
+    assert.strictEqual(tile.features.length, 1);
 });
 
 test('updateData: updates a feature coordinates cross the antimeridian back', () => {
@@ -198,7 +199,7 @@ test('updateData: updates a feature coordinates cross the antimeridian back', ()
     index.updateData({update: [updatedFeature]});
 
     const tile = index.getTile(1, 0, 1);
-    expect(tile.features.length).toBe(1);
+    assert.strictEqual(tile.features.length, 1);
 });
 
 test('updateData: updates a feature multiple do not create duplications in returned tile', () => {
@@ -250,7 +251,7 @@ test('updateData: updates a feature multiple do not create duplications in retur
     index.updateData({update: [updatedFeature]});
 
     const tile = index.getTile(1, 0, 1);
-    expect(tile.features.length).toBe(1);
+    assert.strictEqual(tile.features.length, 1);
 });
 
 test('updateData: does nothing in case of wrong feature ID', () => {
@@ -290,8 +291,8 @@ test('updateData: does nothing in case of wrong feature ID', () => {
     index.updateData({update: [updatedFeature]});
 
     const tile = index.getTile(1, 0, 1);
-    expect(tile.features.length).toBe(1);
-    expect(tile.features[0].tags.name).toBe('Original');
+    assert.strictEqual(tile.features.length, 1);
+    assert.strictEqual(tile.features[0].tags.name, 'Original');
 });
 
 test('updateData: handles both add and remove in same call', () => {
@@ -328,10 +329,10 @@ test('updateData: handles both add and remove in same call', () => {
     });
 
     const tile = index.getTile(0, 0, 0);
-    expect(tile.features.length).toBe(2);
+    assert.strictEqual(tile.features.length, 2);
 
     const featureIds = tile.features.map(f => f.id).sort();
-    expect(featureIds).toEqual(['feature2', 'feature3']);
+    assert.deepStrictEqual(featureIds, ['feature2', 'feature3']);
 });
 
 test('updateData: works with empty diff', () => {
@@ -340,10 +341,10 @@ test('updateData: works with empty diff', () => {
         features: []
     }, {updateable: true});
 
-    expect(() => {
+    assert.doesNotThrow(() => {
         index.updateData({});
         index.updateData({add: [], remove: []});
-    }).not.toThrow();
+    });
 });
 
 test('updateData: invalidates tiles with partial intersection', () => {
@@ -381,8 +382,8 @@ test('updateData: invalidates tiles with partial intersection', () => {
     index.updateData({add: [edgeFeature]});
 
     const tile = index.getTile(2, 3, 2);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBe(2);
+    assert.ok(tile);
+    assert.strictEqual(tile.features.length, 2);
 });
 
 test('updateData: invalidates and regenerates tiles at multiple zoom levels', () => {
@@ -435,18 +436,18 @@ test('updateData: invalidates and regenerates tiles at multiple zoom levels', ()
     const newZ5Tile = index.getTile(5, 16, 16);
     const newZ7Tile = index.getTile(7, 64, 64);
 
-    expect(newZ3Tile).toBeTruthy();
-    expect(newZ5Tile).toBeTruthy();
-    expect(newZ7Tile).toBeTruthy();
+    assert.ok(newZ3Tile);
+    assert.ok(newZ5Tile);
+    assert.ok(newZ7Tile);
 
-    expect(newZ3Tile.features[0].id).toBe('feature1');
-    expect(newZ3Tile.features[0].tags.name).toBe('Updated');
+    assert.strictEqual(newZ3Tile.features[0].id, 'feature1');
+    assert.strictEqual(newZ3Tile.features[0].tags.name, 'Updated');
 
-    expect(newZ5Tile.features[0].id).toBe('feature1');
-    expect(newZ5Tile.features[0].tags.name).toBe('Updated');
+    assert.strictEqual(newZ5Tile.features[0].id, 'feature1');
+    assert.strictEqual(newZ5Tile.features[0].tags.name, 'Updated');
 
-    expect(newZ7Tile.features[0].id).toBe('feature1');
-    expect(newZ7Tile.features[0].tags.name).toBe('Updated');
+    assert.strictEqual(newZ7Tile.features[0].id, 'feature1');
+    assert.strictEqual(newZ7Tile.features[0].tags.name, 'Updated');
 });
 
 test('updateData: handles drill-down after update', () => {
@@ -483,10 +484,10 @@ test('updateData: handles drill-down after update', () => {
     index.updateData({add: [newFeature]});
 
     const highZoomTile = index.getTile(8, 128, 128);
-    expect(highZoomTile).toBeTruthy();
+    assert.ok(highZoomTile);
 
     const featureIds = highZoomTile.features.map(f => f.id).sort();
-    expect(featureIds).toEqual(['line1', 'line2']);
+    assert.deepStrictEqual(featureIds, ['line1', 'line2']);
 });
 
 test('updateData: filter keeps all features when predicate matches all', () => {
@@ -500,13 +501,13 @@ test('updateData: filter keeps all features when predicate matches all', () => {
     };
 
     const index = new GeoJSONVT(initialData, {updateable: true});
-    expect(index.getTile(0, 0, 0).features.length).toBe(3);
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 3);
 
     index.updateData({}, feature => feature.geometry.type === 'Point');
-    expect(index.getTile(0, 0, 0).features.length).toBe(3);
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 3);
 
     index.updateData({}, feature => feature.properties.population > 1);
-    expect(index.getTile(0, 0, 0).features.length).toBe(3);
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 3);
 });
 
 test('updateData: filter removes features not matching predicate', () => {
@@ -522,8 +523,8 @@ test('updateData: filter removes features not matching predicate', () => {
     const index = new GeoJSONVT(initialData, {updateable: true});
 
     index.updateData({}, feature => feature.properties.population > 500);
-    expect(index.getTile(0, 0, 0).features.length).toBe(1);
-    expect(index.getTile(0, 0, 0).features[0].id).toBe('large');
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 1);
+    assert.strictEqual(index.getTile(0, 0, 0).features[0].id, 'large');
 });
 
 test('updateData: filter removes all features when none match predicate', () => {
@@ -539,7 +540,7 @@ test('updateData: filter removes all features when none match predicate', () =>
     const index = new GeoJSONVT(initialData, {updateable: true});
 
     index.updateData({}, feature => feature.properties.population < 100);
-    expect(index.getTile(0, 0, 0).features.length).toBe(0);
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 0);
 });
 
 test('getData: returns source data when updateable', () => {
@@ -556,12 +557,12 @@ test('getData: returns source data when updateable', () => {
     const updateable = new GeoJSONVT(geojson, {updateable: true});
     const result = updateable.getData() as GeoJSON.FeatureCollection;
 
-    expect(result.type).toBe('FeatureCollection');
-    expect(result.features.length).toBe(1);
-    expect(result.features[0].id).toBe('point1');
+    assert.strictEqual(result.type, 'FeatureCollection');
+    assert.strictEqual(result.features.length, 1);
+    assert.strictEqual(result.features[0].id, 'point1');
 
     const notUpdateable = new GeoJSONVT(geojson, {updateable: false});
-    expect(() => notUpdateable.getData()).toThrow();
+    assert.throws(() => notUpdateable.getData());
 });
 
 
@@ -593,8 +594,8 @@ test('cluster option: initializes supercluster instead of tiling', () => {
     const index = new GeoJSONVT(initialData, {cluster: true});
 
     const tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBeGreaterThan(0);
+    assert.ok(tile);
+    assert.ok(tile.features.length > 0);
 });
 
 test('cluster option: updateData rebuilds supercluster', () => {
@@ -613,8 +614,8 @@ test('cluster option: updateData rebuilds supercluster', () => {
     const index = new GeoJSONVT(initialData, {cluster: true, updateable: true});
 
     let tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBe(1);
+    assert.ok(tile);
+    assert.strictEqual(tile.features.length, 1);
 
     const newFeature = {
         type: 'Feature' as const,
@@ -625,14 +626,14 @@ test('cluster option: updateData rebuilds supercluster', () => {
     index.updateData({add: [newFeature]});
 
     tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBe(2);
+    assert.ok(tile);
+    assert.strictEqual(tile.features.length, 2);
 
     index.updateData({remove: ['point1']});
 
     tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBe(1);
+    assert.ok(tile);
+    assert.strictEqual(tile.features.length, 1);
 });
 
 test('updateClusterOptions: requires updateable option and leaves the index as it was', () => {
@@ -646,11 +647,11 @@ test('updateClusterOptions: requires updateable option and leaves the index as i
     };
     const index = new GeoJSONVT(points, {cluster: true, clusterOptions: {radius: 100}});
 
-    expect(() => {
+    assert.throws(() => {
         index.updateClusterOptions(false, {radius: 100});
-    }).toThrow('to update cluster options the `updateable` option must be set to true');
+    }, {message: 'to update cluster options the `updateable` option must be set to true'});
 
-    expect(index.getTile(0, 0, 0).features.length).toBe(1);
+    assert.strictEqual(index.getTile(0, 0, 0).features.length, 1);
 });
 
 test('updateClusterOptions: rebuilds supercluster with new options', () => {
@@ -685,15 +686,15 @@ test('updateClusterOptions: rebuilds supercluster with new options', () => {
     });
 
     let tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
+    assert.ok(tile);
     const closeCount = tile.features.length;
 
     // Update with a much smaller radius - should produce more features (less clustering)
     index.updateClusterOptions(true, {radius: 1});
 
     tile = index.getTile(0, 0, 0);
-    expect(tile).toBeTruthy();
-    expect(tile.features.length).toBeGreaterThan(closeCount);
+    assert.ok(tile);
+    assert.ok(tile.features.length > closeCount);
 });
 
 test('updateClusterOptions: can toggle clustering from on to off', () => {
@@ -715,8 +716,8 @@ test('updateClusterOptions: can toggle clustering from on to off', () => {
     const clusterId = (tile.features.find(f => (f.tags as ClusterProperties)?.cluster).tags as ClusterProperties).cluster_id;
     index.updateClusterOptions(false, {radius: 100});
 
-    expect(index.getClusterExpansionZoom(clusterId)).toBeNull();
-    expect(index.getTile(0, 0, 0).features.some(f => (f.tags as ClusterProperties)?.cluster)).toBe(false);
+    assert.strictEqual(index.getClusterExpansionZoom(clusterId), null);
+    assert.strictEqual(index.getTile(0, 0, 0).features.some(f => (f.tags as ClusterProperties)?.cluster), false);
 });
 
 test('updateClusterOptions: can toggle clustering from on to off and then back on', () => {
@@ -739,6 +740,6 @@ test('updateClusterOptions: can toggle clustering from on to off and then back o
     const tile = index.getTile(0, 0, 0);
     const clusterId = (tile.features.find(f => (f.tags as ClusterProperties)?.cluster).tags as ClusterProperties).cluster_id;
 
-    expect(index.getClusterExpansionZoom(clusterId)).toBeGreaterThan(0);
-    expect(index.getTile(0, 0, 0).features.some(f => (f.tags as ClusterProperties)?.cluster)).toBe(true);
+    assert.ok(index.getClusterExpansionZoom(clusterId) > 0);
+    assert.strictEqual(index.getTile(0, 0, 0).features.some(f => (f.tags as ClusterProperties)?.cluster), true);
 });
\ No newline at end of file
