diff --git a/test/geocoder.spec.ts b/test/geocoder.spec.ts
index c1f1c87..5e150f9 100644
--- a/test/geocoder.spec.ts
+++ b/test/geocoder.spec.ts
@@ -1,5 +1,4 @@
 import MaplibreGeocoder from "../lib/index";
-import once from "lodash.once";
 import Features from "./mockFeatures";
 import { createMarkerMock, createPopupMock, LngLatBoundsMock, MapMock, init, createMockGeocoderApiWithSuggestions } from "./utils";
 
@@ -32,7 +31,6 @@ describe("geocoder", () => {
     });
 
     test("Selected value is reset after a result is selected", async () => {
-        expect.assertions(2);
         setup({
             proximity: { longitude: -79.45, latitude: 43.65 },
             features: [Features.QUEEN_STREET],
@@ -82,7 +80,6 @@ describe("geocoder", () => {
       });
 
       test("options.reverseGeocode - true", async () => {
-        expect.assertions(4);
         setup({
           reverseGeocode: true,
           features: [Features.TANZANIA],
@@ -95,21 +92,15 @@ describe("geocoder", () => {
         expect(e.config.limit).toBe(1);
       });
 
-      test("options.reverseGeocode - false by default", () => {
-        expect.assertions(2);
+      test("options.reverseGeocode - false by default", async () => {
         setup();
         geocoder.query("-6.1933875, 34.5177548");
         expect(geocoder.options.reverseGeocode).toBeFalsy();
-        geocoder.on(
-          "results",
-          once((e) =>{
-            expect(e.features.length).toBe(0);
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.features.length).toBe(0);
       });
 
-      test("options.reverseGeocode: true with trackProximity: true", () => {
-        expect.assertions(1);
+      test("options.reverseGeocode: true with trackProximity: true", async () => {
           setup({
             reverseGeocode: true,
             trackProximity: true,
@@ -119,17 +110,12 @@ describe("geocoder", () => {
             center: [10, 10],
           });
           geocoder.query("-6.1933875, 34.5177548");
-            geocoder.on(
-                "results",
-                once((e) => {
-                expect(e.features.length).toBe(0);
-                })
-            );
+          const e = await geocoder.once("results");
+          expect(e.features.length).toBe(0);
         }
       );
 
-      test("parses options correctly", () => {
-        expect.assertions(3);
+      test("parses options correctly", async () => {
         setup({
           language: "en,es,zh",
           types: "district, locality, neighborhood, postcode",
@@ -137,47 +123,34 @@ describe("geocoder", () => {
         });
     
         geocoder.query("Hartford");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.config.language).toEqual(["en", "es", "zh"]);
-            expect(e.config.types).toEqual(["district", "locality", "neighborhood", "postcode"]);
-            expect(e.config.countries).toEqual(["us", "mx"]);
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.config.language).toEqual(["en", "es", "zh"]);
+        expect(e.config.types).toEqual(["district", "locality", "neighborhood", "postcode"]);
+        expect(e.config.countries).toEqual(["us", "mx"]);
       });
 
-      test("options.limit", () => {
-        expect.assertions(1);
+      test("options.limit", async () => {
         setup({
           flyTo: false,
           limit: 2,
         });
     
         geocoder.query("London");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.config.limit).toBe(2);
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.config.limit).toBe(2);
       });
 
-      test("options:zoom", () => {
-        expect.assertions(1);
+      test("options:zoom", async () => {
         setup({ zoom: 12, features: [Features.BELLINGHAM] });
-        geocoder.query("1714 14th St NW");
+        const q = geocoder.query("1714 14th St NW");
         var mapMoveSpy = jest.spyOn(map, "flyTo");
-        geocoder.on(
-          "result",
-          once(() => {
-            var mapMoveArgs = mapMoveSpy.mock.calls[0][0];
-            expect(mapMoveArgs.zoom).toBe(12);
-          })
-        );
+        await geocoder.once("results");
+        await q;
+        const mapMoveArgs = mapMoveSpy.mock.calls[0][0];
+        expect(mapMoveArgs.zoom).toBe(12);
       });
 
-      test("options.localGeocoder", (done) => {
+      test("options.localGeocoder", async () => {
         setup({
           flyTo: false,
           limit: 6,
@@ -185,31 +158,21 @@ describe("geocoder", () => {
             return [{text: q}];
           },
         });
-        geocoder.query("-30,150");
-        geocoder.on(
-            "results",
-            once((e) => {
-                expect(e.features).toHaveLength(1);
-                geocoder.query("London");
-                geocoder.on(
-                    "results",
-                    once((e) => {
-                        expect(e.features).toHaveLength(1);
-                        geocoder.query("London");
-                        geocoder.on(
-                            "results",
-                            once((e) => {
-                                expect(e.features[0].text).toBe("London");
-                                done();
-                            })
-                        );
-                    })
-                );
-            })
-        );
+        let q = geocoder.query("-30,150");
+        let e = await geocoder.once("results");
+        await q;
+        expect(e.features).toHaveLength(1);
+        q = geocoder.query("London");
+        e = await geocoder.once("results");
+        await q;
+        expect(e.features).toHaveLength(1);
+        q = geocoder.query("London");
+        e = await geocoder.once("results");
+        await q;
+        expect(e.features[0].text).toBe("London");
     });
 
-    test("options.externalGeocoder", (done) => {
+    test("options.externalGeocoder", async () => {
         setup({
           flyTo: false,
           limit: 6,
@@ -226,85 +189,65 @@ describe("geocoder", () => {
           },
         });
     
-        geocoder.query("Washington, DC");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.features.length).toBe(1);
+        let q = geocoder.query("Washington, DC");
+        let e = await geocoder.once("results");
+        await q;
+        expect(e.features.length).toBe(1);
+
     
-            geocoder.query("DC");
-            geocoder.on(
-              "results",
-              once((e) => {
-                expect(e.features.length).toBe(1);
+        q = geocoder.query("DC");
+        e = await geocoder.once("results");
+        await q;
+        expect(e.features.length).toBe(1);
     
-                geocoder.query("District of Columbia");
-                geocoder.on(
-                  "results",
-                  once((e) => {
-                    expect(e.features[0].place_name).toBe(
-                      "Promise: Washington, District of Columbia, United States of America",
-                    );
-                    done();
-                  })
-                );
-              })
-            );
-          })
-        );
+        q = geocoder.query("District of Columbia");
+        e = await geocoder.once("results");
+        expect(e.features[0].place_name).toBe(
+          "Promise: Washington, District of Columbia, United States of America");
       });
 
-      test("country bbox", () => {
-        expect.assertions(5);
+      test("country bbox", async () => {
         setup({ features: [Features.CANADA] });
-        geocoder.query("Canada");
+        const q = geocoder.query("Canada");
         const fitBoundsSpy = jest.spyOn(map, "fitBounds");
-        geocoder.on(
-          "result",
-          once((e) => {
-            expect(fitBoundsSpy).toHaveBeenCalledTimes(2);
-            var fitBoundsArgs = fitBoundsSpy.mock.calls[1][0];
-            // flatten
-            var mapBBox = [
-              fitBoundsArgs[0][0],
-              fitBoundsArgs[0][1],
-              fitBoundsArgs[1][0],
-              fitBoundsArgs[1][1],
-            ];
-            for (let i = 0; i <  mapBBox.length; i++) {
-                expect(mapBBox[i]).toBeCloseTo(Features.CANADA.bbox[i]);
-            }
-          })
-        );
+        await geocoder.once("results");
+        await q;
+        expect(fitBoundsSpy).toHaveBeenCalledTimes(2);
+        var fitBoundsArgs = fitBoundsSpy.mock.calls[1][0];
+        // flatten
+        var mapBBox = [
+          fitBoundsArgs[0][0],
+          fitBoundsArgs[0][1],
+          fitBoundsArgs[1][0],
+          fitBoundsArgs[1][1],
+        ];
+        for (let i = 0; i <  mapBBox.length; i++) {
+            expect(mapBBox[i]).toBeCloseTo(Features.CANADA.bbox[i]);
+        }
       });
 
-      test("country bbox exception", () => {
-        expect.assertions(5);
+      test("country bbox exception", async () => {
         setup({ features: [Features.CANADA] });
-        geocoder.query("Canada");
+        const q = geocoder.query("Canada");
         const fitBoundsSpy = jest.spyOn(map, "fitBounds");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(fitBoundsSpy).toHaveBeenCalledTimes(2);
-            var fitBoundsArgs = fitBoundsSpy.mock.calls[1][0];
-            // flatten
-            var mapBBox = [
-              fitBoundsArgs[0][0],
-              fitBoundsArgs[0][1],
-              fitBoundsArgs[1][0],
-              fitBoundsArgs[1][1],
-            ];
-            var expectedBBoxFlat = [-140.99778, 41.675105, -52.648099, 83.23324];
-            for (let i = 0; i <  mapBBox.length; i++) {
-                expect(mapBBox[i]).toBeCloseTo(expectedBBoxFlat[i]);
-            }
-          })
-        );
+        await geocoder.once("results");
+        await q;
+        expect(fitBoundsSpy).toHaveBeenCalledTimes(2);
+        var fitBoundsArgs = fitBoundsSpy.mock.calls[1][0];
+        // flatten
+        var mapBBox = [
+          fitBoundsArgs[0][0],
+          fitBoundsArgs[0][1],
+          fitBoundsArgs[1][0],
+          fitBoundsArgs[1][1],
+        ];
+        var expectedBBoxFlat = [-140.99778, 41.675105, -52.648099, 83.23324];
+        for (let i = 0; i <  mapBBox.length; i++) {
+            expect(mapBBox[i]).toBeCloseTo(expectedBBoxFlat[i]);
+        }
       });
 
-      test("options.filter", () => {
-        expect.assertions(2);
+      test("options.filter", async () => {
         var features = [
           {
             geometry: {
@@ -355,13 +298,9 @@ describe("geocoder", () => {
         });
     
         geocoder.query("Heathcote");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.features.some(f => f.place_name === "Heathcote, Sydney, New South Wales, AUS")).toBeTruthy();
-            expect(e.features.some(f => f.place_name === "Heathcote, Victoria, AUS")).toBeFalsy();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.features.some(f => f.place_name === "Heathcote, Sydney, New South Wales, AUS")).toBeTruthy();
+        expect(e.features.some(f => f.place_name === "Heathcote, Victoria, AUS")).toBeFalsy();
       });
 
       test("options.trackProximity", () => {
@@ -378,7 +317,6 @@ describe("geocoder", () => {
       });
 
       test("options.trackProximity=false", () => {
-        expect.assertions(2);
     
         setup({
           trackProximity: false,
@@ -387,8 +325,7 @@ describe("geocoder", () => {
         expect(geocoder.getProximity()).toBeUndefined();
       });
 
-      test("options.setProximity", () => {
-        expect.assertions(2);
+      test("options.setProximity", async () => {
         var features = [];
         setup({ features });
     
@@ -397,17 +334,12 @@ describe("geocoder", () => {
         geocoder.setProximity({ longitude: -79.4512, latitude: 43.6568 });
     
         geocoder.query("high");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.config.proximity[0]).toBe(-79.4512);
-            expect(e.config.proximity[1]).toBe(43.6568);
-          }
-        ));
+        const e = await geocoder.once("results");
+        expect(e.config.proximity[0]).toBe(-79.4512);
+        expect(e.config.proximity[1]).toBe(43.6568);
       });
 
       test("options.render", () => {
-        expect.assertions(3);
         setup({
           render: (feature) => {
             return "feature id is " + feature.id;
@@ -425,7 +357,6 @@ describe("geocoder", () => {
       });
 
       test("setRenderFunction with no input", () => {
-        expect.assertions(2);
         setup({});
         var result = geocoder.setRenderFunction();
         expect(typeof geocoder._typeahead.render).toBe("function");
@@ -433,7 +364,6 @@ describe("geocoder", () => {
       });
 
       test("setRenderFunction with function input", () => {
-        expect.assertions(2);
         setup({});
         var result = geocoder.setRenderFunction(function (item) {
           return item.place_name;
@@ -443,7 +373,6 @@ describe("geocoder", () => {
       });
 
       test("getRenderFunction default", () => {
-        expect.assertions(2);
         setup({});
         var result = geocoder.getRenderFunction();
         expect(result).toBeDefined();
@@ -451,7 +380,6 @@ describe("geocoder", () => {
       });
 
       test("getRenderFunction", () => {
-        expect.assertions(2);
         setup({
           render: (item) => {
             return item.place_name;
@@ -492,45 +420,35 @@ describe("geocoder", () => {
         expect(geocoder._typeahead.getItemValue(fixture)).toBe("San Francisco, California");
       });
 
-      test("options.flyTo [false]", () => {
-        expect.assertions(1);
+      test("options.flyTo [false]", async () => {
         setup({
           flyTo: false,
           features: [Features.GOLDEN_GATE_BRIDGE],
         });
         const mapFlyMethod = jest.spyOn(map, "flyTo");
         geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(mapFlyMethod).not.toHaveBeenCalled();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(mapFlyMethod).not.toHaveBeenCalled();
       });
  
-      test("options.flyTo [true]", () => {
-        expect.assertions(4);
+      test("options.flyTo [true]", async () => {
         setup({
           flyTo: true,
           features: [Features.GOLDEN_GATE_BRIDGE],
         });
     
         const mapFlyMethod = jest.spyOn(map, "flyTo");
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(mapFlyMethod).toHaveBeenCalledTimes(1);
-            var calledWithArgs = mapFlyMethod.mock.calls[0][0];
-            expect(calledWithArgs.center[0]).toBeCloseTo(-122.4785);
-            expect(calledWithArgs.center[1]).toBeCloseTo(37.8191);
-            expect(calledWithArgs.zoom).toBe(16);
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(mapFlyMethod).toHaveBeenCalledTimes(1);
+        var calledWithArgs = mapFlyMethod.mock.calls[0][0];
+        expect(calledWithArgs.center[0]).toBeCloseTo(-122.4785);
+        expect(calledWithArgs.center[1]).toBeCloseTo(37.8191);
+        expect(calledWithArgs.zoom).toBe(16);
       });
 
-      test("options.flyTo [object]", () => {
-        expect.assertions(5);
+      test("options.flyTo [object]", async () => {
         setup({
           flyTo: {
             speed: 5,
@@ -540,22 +458,18 @@ describe("geocoder", () => {
           features: [Features.GOLDEN_GATE_BRIDGE],
         });
         const mapFlyMethod = jest.spyOn(map, "flyTo");
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(mapFlyMethod).toHaveBeenCalledTimes(1);
-            var calledWithArgs = mapFlyMethod.mock.calls[0][0];
-            expect(calledWithArgs.center[0]).toBeCloseTo(-122.4785);
-            expect(calledWithArgs.center[1]).toBeCloseTo(37.8191);
-            expect(calledWithArgs.zoom).toBe(4);
-            expect(calledWithArgs.speed).toBe(5);
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(mapFlyMethod).toHaveBeenCalledTimes(1);
+        var calledWithArgs = mapFlyMethod.mock.calls[0][0];
+        expect(calledWithArgs.center[0]).toBeCloseTo(-122.4785);
+        expect(calledWithArgs.center[1]).toBeCloseTo(37.8191);
+        expect(calledWithArgs.zoom).toBe(4);
+        expect(calledWithArgs.speed).toBe(5);
       });
                
-      test("options.flyTo object on feature with bounding box", () => {
-        expect.assertions(2);
+      test("options.flyTo object on feature with bounding box", async () => {
         setup({
           features: [Features.CANADA],
           flyTo: {
@@ -563,19 +477,15 @@ describe("geocoder", () => {
           },
         });
         const mapFlyMethod = jest.spyOn(map, "fitBounds");
-        geocoder.query("Brazil");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(mapFlyMethod).toHaveBeenCalledTimes(2);
-            var calledWithArgs = mapFlyMethod.mock.calls[1][1];
-            expect(calledWithArgs.speed).toBe(5);
-          })
-        );
+        const q = geocoder.query("Brazil");
+        await geocoder.once("results");
+        await q;
+        expect(mapFlyMethod).toHaveBeenCalledTimes(2);
+        var calledWithArgs = mapFlyMethod.mock.calls[1][1];
+        expect(calledWithArgs.speed).toBe(5);
       });
     
-      test("options.flyTo object on bounding box excepted feature", () => {
-          expect.assertions(2);
+      test("options.flyTo object on bounding box excepted feature", async () => {
           setup({
             features: [Features.CANADA],
             flyTo: {
@@ -583,20 +493,16 @@ describe("geocoder", () => {
             },
           });
           const mapFlyMethod = jest.spyOn(map, "fitBounds");
-          geocoder.query("Canada");
-          geocoder.on(
-            "result",
-            once(() => {
-                expect(mapFlyMethod).toHaveBeenCalledTimes(2);
-                var calledWithArgs = mapFlyMethod.mock.calls[1][1];
-                expect(calledWithArgs.speed).toBe(5);
-            })
-          );
+          const q = geocoder.query("Canada");
+          await geocoder.once("results");
+          await q;
+          expect(mapFlyMethod).toHaveBeenCalledTimes(2);
+          var calledWithArgs = mapFlyMethod.mock.calls[1][1];
+          expect(calledWithArgs.speed).toBe(5);
         }
       );
     
-      test("options.marker [true]", () => {
-        expect.assertions(2);
+      test("options.marker [true]", async () => {
         const markerConstructorSpy = createMarkerMock();
         setup({
           features: [Features.GOLDEN_GATE_BRIDGE],
@@ -604,19 +510,15 @@ describe("geocoder", () => {
           maplibregl: { Marker: markerConstructorSpy, LngLatBounds: LngLatBoundsMock }
         });
     
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(markerConstructorSpy).toHaveBeenCalledTimes(2);
-            var calledWithOptions = markerConstructorSpy.mock.calls[1][0];
-            expect(calledWithOptions.color).toBe("#4668F2");
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(markerConstructorSpy).toHaveBeenCalledTimes(2);
+        var calledWithOptions = markerConstructorSpy.mock.calls[1][0];
+        expect(calledWithOptions.color).toBe("#4668F2");
       });
 
-      test("options.marker  [constructor properties]", () => {
-        expect.assertions(4);
+      test("options.marker  [constructor properties]", async () => {
         const markerConstructorSpy = createMarkerMock();
         setup({
           features: [Features.GOLDEN_GATE_BRIDGE],
@@ -628,21 +530,17 @@ describe("geocoder", () => {
           maplibregl: { Marker: markerConstructorSpy, LngLatBounds: LngLatBoundsMock },
         });
     
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(markerConstructorSpy).toHaveBeenCalledTimes(2);
-            var calledWithOptions = markerConstructorSpy.mock.calls[1][0];
-            expect(calledWithOptions.color).toBe("purple");
-            expect(calledWithOptions.draggable).toBe(true);
-            expect(calledWithOptions.anchor).toBe("top");
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(markerConstructorSpy).toHaveBeenCalledTimes(2);
+        var calledWithOptions = markerConstructorSpy.mock.calls[1][0];
+        expect(calledWithOptions.color).toBe("purple");
+        expect(calledWithOptions.draggable).toBe(true);
+        expect(calledWithOptions.anchor).toBe("top");
       });
         
-      test("options.marker [false]", () => {
-        expect.assertions(1);
+      test("options.marker [false]", async () => {
         const markerConstructorSpy = createMarkerMock();
         setup({
           features: [Features.GOLDEN_GATE_BRIDGE],
@@ -650,16 +548,11 @@ describe("geocoder", () => {
         });
     
         geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(markerConstructorSpy).not.toHaveBeenCalled();
-          })
-        );
+        await geocoder.once("results");
+        expect(markerConstructorSpy).not.toHaveBeenCalled();
       });
      
-      test("options.popup [true]", () => {
-        expect.assertions(1);
+      test("options.popup [true]", async () => {
         const popupConstructorSpy = createPopupMock();
         setup({
           marker: true,
@@ -668,17 +561,13 @@ describe("geocoder", () => {
           features: [Features.GOLDEN_GATE_BRIDGE],
         });
     
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(popupConstructorSpy).toHaveBeenCalledTimes(2);
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(popupConstructorSpy).toHaveBeenCalledTimes(2);
       });
   
-      test("options.popup  [constructor properties]", () => {
-        expect.assertions(2);
+      test("options.popup  [constructor properties]", async () => {
         const popupConstructorSpy = createPopupMock();
         setup({
           marker: true,
@@ -689,19 +578,15 @@ describe("geocoder", () => {
           features: [Features.GOLDEN_GATE_BRIDGE],
         });
     
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(popupConstructorSpy).toHaveBeenCalledTimes(2);
-            var calledWithOptions = popupConstructorSpy.mock.calls[1][0];
-            expect(calledWithOptions.closeOnMove).toBe(true);
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        expect(popupConstructorSpy).toHaveBeenCalledTimes(2);
+        var calledWithOptions = popupConstructorSpy.mock.calls[1][0];
+        expect(calledWithOptions.closeOnMove).toBe(true);
       });
       
-      test("options.popup [false]", () => {
-        expect.assertions(1);
+      test("options.popup [false]", async () => {
         const popupConstructorSpy = createPopupMock();
         setup({
           popup: false,
@@ -709,12 +594,8 @@ describe("geocoder", () => {
         });
     
         geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            expect(popupConstructorSpy).not.toHaveBeenCalled();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(popupConstructorSpy).not.toHaveBeenCalled();
       });
        
       test("geocode#onRemove", () => {
@@ -856,74 +737,58 @@ describe("geocoder", () => {
         expect(nextFiltered).toEqual([]);
       });
       
-      test("geocoder#_renderMessage", (done) => {
+      test("geocoder#_renderMessage", async () => {
         setup({ features: [Features.GOLDEN_GATE_BRIDGE] });
         const typeaheadRenderErrorSpy = jest.spyOn(geocoder._typeahead, "renderError");
     
-        geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            setTimeout(() => {
-                expect(geocoder._typeahead.data.length).not.toBe(0);
-                geocoder._renderMessage("<h1>This is a test</h1>");
-                expect(geocoder._typeahead.data.length).toBe(0);
-                expect(geocoder._typeahead.selected).toBeNull();
-                expect(typeaheadRenderErrorSpy).toHaveBeenCalledTimes(1);
-                var calledWithArgs = typeaheadRenderErrorSpy.mock.calls[0][0];
-                expect(calledWithArgs).toBe("<h1>This is a test</h1>");
-                done();
-            }, 0);
-          })
-        );
+        const q = geocoder.query("Golden Gate Bridge");
+        await geocoder.once("results");
+        await q;
+        // setTimeout
+        expect(geocoder._typeahead.data.length).not.toBe(0);
+        geocoder._renderMessage("<h1>This is a test</h1>");
+        expect(geocoder._typeahead.data.length).toBe(0);
+        expect(geocoder._typeahead.selected).toBeNull();
+        expect(typeaheadRenderErrorSpy).toHaveBeenCalledTimes(1);
+        var calledWithArgs = typeaheadRenderErrorSpy.mock.calls[0][0];
+        expect(calledWithArgs).toBe("<h1>This is a test</h1>");
       });
       
-      test("geocoder#_renderError", () => {
+      test("geocoder#_renderError", async () => {
         setup({ features: [Features.GOLDEN_GATE_BRIDGE] });
         const renderMessageSpy = jest.spyOn(geocoder, "_renderMessage");
     
         geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            geocoder._renderError();
-            expect(renderMessageSpy).toHaveBeenCalledTimes(1);
-            var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
-            expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();            
-          })
-        );
+        await geocoder.once("results");
+        geocoder._renderError();
+        expect(renderMessageSpy).toHaveBeenCalledTimes(1);
+        var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
+        expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();
       });
       
-      test("geocoder#_renderNoResults", () => {
+      test("geocoder#_renderNoResults", async () => {
         setup({ features: [Features.GOLDEN_GATE_BRIDGE] });
         const renderMessageSpy = jest.spyOn(geocoder, "_renderMessage");
     
         geocoder.query("Golden Gate Bridge");
-        geocoder.on(
-          "result",
-          once(() => {
-            geocoder._renderNoResults();
-            expect(renderMessageSpy).toHaveBeenCalledTimes(1);
-            var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
-            expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();
-            expect(calledWithArgs.indexOf("maplibre-gl-geocoder--no-results") > -1).toBeTruthy();
-          })
-        );
+        const e = await geocoder.once("results");
+        geocoder._renderNoResults();
+        expect(renderMessageSpy).toHaveBeenCalledTimes(1);
+        var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
+        expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();
+        expect(calledWithArgs.indexOf("maplibre-gl-geocoder--no-results") > -1).toBeTruthy();
       });
 
       test("error is shown after an error occurred", async () => {
         setup({ errorMessage: "A mock error message" });
         const renderMessageSpy = jest.spyOn(geocoder, "_renderMessage");
-        geocoder.on(
-          "error",
-          once(() => {
-            expect(renderMessageSpy).toHaveBeenCalledTimes(1);
-            var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
-            expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();
-            expect(calledWithArgs.indexOf("There was an error reaching the server") > -1).toBeTruthy();
-          })
-        );
-        await expect(geocoder.query("12,")).rejects.toBe("A mock error message");
+        const q = geocoder.query("12,");
+        await geocoder.once("error");
+        expect(renderMessageSpy).toHaveBeenCalledTimes(1);
+        var calledWithArgs = renderMessageSpy.mock.calls[0][0] as any;
+        expect(calledWithArgs.indexOf("maplibre-gl-geocoder--error") > -1).toBeTruthy();
+        expect(calledWithArgs.indexOf("There was an error reaching the server") > -1).toBeTruthy();
+        await expect(q).rejects.toBe("A mock error message");
       });
 
       test("error is shown after an error occurred [with local geocoder]", async () => {
@@ -943,23 +808,19 @@ describe("geocoder", () => {
             },
           });
           var renderErrorSpy = jest.spyOn(geocoder, "_renderError");
-          geocoder.on("error", once(() => {
-              expect(renderErrorSpy).not.toHaveBeenCalled();
-          }));
-          await expect(geocoder.query("12,")).rejects.toBe("mock error");
+          const q = geocoder.query("12,");
+          await geocoder.once("error");
+          expect(renderErrorSpy).not.toHaveBeenCalled();
+          await expect(q).rejects.toBe("mock error");
         }
       );
 
-      test("message is shown if no results are returned", () => {
+      test("message is shown if no results are returned", async () => {
         setup({});
         const renderMessageSpy = jest.spyOn(geocoder, "_renderNoResults");
         geocoder.query("abcdefghijkl"); //this will return no results
-        geocoder.on(
-          "results",
-          once(() => {
-            expect(renderMessageSpy).toHaveBeenCalledTimes(1);
-          })
-        );
+        await geocoder.once("results");
+        expect(renderMessageSpy).toHaveBeenCalledTimes(1);
       });
       
     
@@ -1023,8 +884,7 @@ describe("geocoder", () => {
         expect(searchMock).not.toHaveBeenCalled();
       });
     
-      test("query with suggestions", () => {
-        expect.assertions(2);
+      test("query with suggestions", async () => {
         
         setup({
           geocoderApi: createMockGeocoderApiWithSuggestions(
@@ -1036,18 +896,13 @@ describe("geocoder", () => {
         });
         
         geocoder.query("Queen Street");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.features).not.toBeNull();
-            expect(e.suggestions).not.toBeNull();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.features).not.toBeNull();
+        expect(e.suggestions).not.toBeNull();
       });
 
       
-      test("set input with suggestions", () => {
-        expect.assertions(2);
+      test("set input with suggestions", async () => {
         setup({
           geocoderApi: createMockGeocoderApiWithSuggestions(
             [Features.QUEEN_STREET],
@@ -1058,17 +913,12 @@ describe("geocoder", () => {
           showResultsWhileTyping: true,
         });
         geocoder.setInput("anything");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.features).toBeDefined();
-            expect(e.suggestions).toBeDefined();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.features).toBeDefined();
+        expect(e.suggestions).toBeDefined();
       });
     
-      test("query with suggestions", () => {
-        expect.assertions(2);
+      test("query with suggestions", async () => {
         setup({
           geocoderApi: createMockGeocoderApiWithSuggestions(
             [Features.QUEEN_STREET],
@@ -1079,12 +929,8 @@ describe("geocoder", () => {
           showResultsWhileTyping: false,
         });
         geocoder.query("anything");
-        geocoder.on(
-          "results",
-          once((e) => {
-            expect(e.features).toBeDefined();
-            expect(e.suggestions).toBeDefined();
-          })
-        );
+        const e = await geocoder.once("results");
+        expect(e.features).toBeDefined();
+        expect(e.suggestions).toBeDefined();
       });
 });