diff --git a/.yarn/install-state.gz b/.yarn/install-state.gz
index bec3856576..1c9db79754 100644
Binary files a/.yarn/install-state.gz and b/.yarn/install-state.gz differ
diff --git a/package.json b/package.json
index 1b06b28dd8..15e43ea222 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "private": true,
   "engines": {
-    "node": "^12 || ^14 || ^16 || ^18 || ^20 || ^22.0.0"
+    "node": "^12 || ^14 || ^16 || ^18 || ^20 || ^22"
   },
   "repository": {
     "type": "git",
diff --git a/packages/stentor-models/src/Location/Location.ts b/packages/stentor-models/src/Location/Location.ts
index 807c6ab767..969625d7eb 100644
--- a/packages/stentor-models/src/Location/Location.ts
+++ b/packages/stentor-models/src/Location/Location.ts
@@ -3,24 +3,24 @@
  * The exact coordinates
  */
 export interface LocationGeocode {
-    latitude: number;
-    longitude: number;
+  latitude?: number;
+  longitude?: number;
 }
 
 /**
  * Description of a physical location
  */
 export interface Location {
-    /**
-     * The free-form street address, in the format used by the national postal service of the
-     * concerned country.  This field can then be used for geocoding with a third-party API, like
-     * the Google Maps Geocoding API, to determine latitude and longitude.
-     *
-     * For example: Washington, DC or 123 Main St, City, State
-     */
-    streetAddress?: string;
-    /**
-     * Geocoded form of the location
-     */
-    geocode?: LocationGeocode;
+  /**
+   * The free-form street address, in the format used by the national postal service of the
+   * concerned country.  This field can then be used for geocoding with a third-party API, like
+   * the Google Maps Geocoding API, to determine latitude and longitude.
+   *
+   * For example: Washington, DC or 123 Main St, City, State
+   */
+  streetAddress?: string;
+  /**
+   * Geocoded form of the location
+   */
+  geocode?: LocationGeocode;
 }
diff --git a/packages/stentor-service-event/src/__test__/EventService.test.ts b/packages/stentor-service-event/src/__test__/EventService.test.ts
index 27b7187435..93c8140d43 100644
--- a/packages/stentor-service-event/src/__test__/EventService.test.ts
+++ b/packages/stentor-service-event/src/__test__/EventService.test.ts
@@ -5,11 +5,11 @@ import * as SinonChai from "sinon-chai";
 
 import { Event, Response } from "stentor-models";
 import {
-    AudioPlayerRequestBuilder,
-    InputUnknownRequestBuilder,
-    IntentRequestBuilder,
-    LaunchRequestBuilder,
-    PlaybackControlRequestBuilder
+  AudioPlayerRequestBuilder,
+  InputUnknownRequestBuilder,
+  IntentRequestBuilder,
+  LaunchRequestBuilder,
+  PlaybackControlRequestBuilder,
 } from "stentor-request";
 import { AbstractEventStream } from "../AbstractEventStream";
 import { MESSAGE_EVENT_TYPE } from "../Constants";
@@ -24,475 +24,506 @@ const expect = Chai.expect;
  * Mocks the flush events so they do not get sent to the service
  */
 class MockEventStream extends AbstractEventStream {
-    public async flushEvents(): Promise<void> {
-        // dev null
-    }
+  public async flushEvents(): Promise<void> {
+    // dev null
+  }
 }
 
 function newService(): EventService.EventService {
-    return new EventService.EventService(new TestStream());
+  return new EventService.EventService(new TestStream());
 }
 
 const testEvent: Event = {
-    name: "Test Event",
-    type: MESSAGE_EVENT_TYPE,
-    payload: undefined
+  name: "Test Event",
+  type: MESSAGE_EVENT_TYPE,
+  payload: undefined,
 };
 
 function getSubstackLength(): number {
+  let EXPECTED_STACK_LENGTH = 13;
 
-    let EXPECTED_STACK_LENGTH = 13;
+  switch (process.version.substr(0, 3)) {
+    case "v22":
+    case "v20":
+    case "v18":
+    case "v16":
+    case "v14":
+      EXPECTED_STACK_LENGTH = 10;
+      break;
+    case "v12":
+      if (process.version === "v12.22.0") {
+        EXPECTED_STACK_LENGTH = 10;
+      } else {
+        EXPECTED_STACK_LENGTH = 11;
+      }
+      break;
+    default:
+      EXPECTED_STACK_LENGTH = 13;
+  }
 
-    switch (process.version.substr(0, 3)) {
-        case "v20":
-        case "v18":
-        case "v16":
-        case "v14":
-            EXPECTED_STACK_LENGTH = 10;
-            break;
-        case "v12":
-            if (process.version === "v12.22.0") {
-                EXPECTED_STACK_LENGTH = 10;
-            } else {
-                EXPECTED_STACK_LENGTH = 11;
-            }
-            break;
-        default:
-            EXPECTED_STACK_LENGTH = 13;
-    }
-
-    return EXPECTED_STACK_LENGTH;
+  return EXPECTED_STACK_LENGTH;
 }
 
 describe("#wrapCallback()", () => {
-    it("Tests that the callback calls the flush.", () => {
-        const callback = Sinon.stub();
-        const stream = new MockEventStream();
-        const flushSpy = Sinon.spy(stream, "flushEvents");
-        const wrappedCallback = EventService.wrapCallback(new EventService.EventService(stream), callback);
-        wrappedCallback(undefined, { param: "result" });
-        expect(flushSpy).to.have.been.called;
-    });
-    it("Tests that the original callback is called in the flush.", () => {
-        const callback = Sinon.stub();
-        const stream = new MockEventStream();
-        const wrappedCallback = EventService.wrapCallback(new EventService.EventService(stream), callback);
-        const err = new Error("Error per requirement of the test.");
-        const result = { param: "result" };
-        wrappedCallback(err, result);
-        expect(callback).to.have.been.calledWith(err, result);
-    });
+  it("Tests that the callback calls the flush.", () => {
+    const callback = Sinon.stub();
+    const stream = new MockEventStream();
+    const flushSpy = Sinon.spy(stream, "flushEvents");
+    const wrappedCallback = EventService.wrapCallback(
+      new EventService.EventService(stream),
+      callback
+    );
+    wrappedCallback(undefined, { param: "result" });
+    expect(flushSpy).to.have.been.called;
+  });
+  it("Tests that the original callback is called in the flush.", () => {
+    const callback = Sinon.stub();
+    const stream = new MockEventStream();
+    const wrappedCallback = EventService.wrapCallback(
+      new EventService.EventService(stream),
+      callback
+    );
+    const err = new Error("Error per requirement of the test.");
+    const result = { param: "result" };
+    wrappedCallback(err, result);
+    expect(callback).to.have.been.calledWith(err, result);
+  });
 });
 
 describe("EventService", () => {
-    describe("#constructor()", () => {
-        it("Tests that the event stream is included.", async () => {
-            const stream = new MockEventStream();
-            const flushSpy = Sinon.spy(stream, "flushEvents");
-            const eventService = new EventService.EventService(stream);
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(flushSpy).to.have.been.calledOnce;
-            expect(flushSpy).to.have.been.calledWith([madeEvent]);
-        });
+  describe("#constructor()", () => {
+    it("Tests that the event stream is included.", async () => {
+      const stream = new MockEventStream();
+      const flushSpy = Sinon.spy(stream, "flushEvents");
+      const eventService = new EventService.EventService(stream);
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(flushSpy).to.have.been.calledOnce;
+      expect(flushSpy).to.have.been.calledWith([madeEvent]);
+    });
 
-        it("Tests that the event stream is included as an array.", async () => {
-            const stream1 = new MockEventStream();
-            const stream2 = new MockEventStream();
-            const flushSpy1 = Sinon.spy(stream1, "flushEvents");
-            const flushSpy2 = Sinon.spy(stream2, "flushEvents");
-            const eventService = new EventService.EventService([stream1, stream2]);
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(flushSpy1).to.have.been.calledOnce;
-            expect(flushSpy1).to.have.been.calledWith([madeEvent]);
-            expect(flushSpy2).to.have.been.calledOnce;
-            expect(flushSpy2).to.have.been.calledWith([madeEvent]);
-        });
+    it("Tests that the event stream is included as an array.", async () => {
+      const stream1 = new MockEventStream();
+      const stream2 = new MockEventStream();
+      const flushSpy1 = Sinon.spy(stream1, "flushEvents");
+      const flushSpy2 = Sinon.spy(stream2, "flushEvents");
+      const eventService = new EventService.EventService([stream1, stream2]);
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(flushSpy1).to.have.been.calledOnce;
+      expect(flushSpy1).to.have.been.calledWith([madeEvent]);
+      expect(flushSpy2).to.have.been.calledOnce;
+      expect(flushSpy2).to.have.been.calledWith([madeEvent]);
+    });
 
-        it("Tests that the event stream is included if passed in the props.", async () => {
-            const stream = new MockEventStream();
-            const flushSpy = Sinon.spy(stream, "flushEvents");
-            const eventService = new EventService.EventService({ streams: stream });
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(flushSpy).to.have.been.calledOnce;
-            expect(flushSpy).to.have.been.calledWith([madeEvent]);
-        });
+    it("Tests that the event stream is included if passed in the props.", async () => {
+      const stream = new MockEventStream();
+      const flushSpy = Sinon.spy(stream, "flushEvents");
+      const eventService = new EventService.EventService({ streams: stream });
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(flushSpy).to.have.been.calledOnce;
+      expect(flushSpy).to.have.been.calledWith([madeEvent]);
+    });
 
-        it("Tests that the event stream is included as an array in the props.", async () => {
-            const stream1 = new MockEventStream();
-            const stream2 = new MockEventStream();
-            const flushSpy1 = Sinon.spy(stream1, "flushEvents");
-            const flushSpy2 = Sinon.spy(stream2, "flushEvents");
-            const eventService = new EventService.EventService([stream1, stream2]);
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(flushSpy1).to.have.been.calledOnce;
-            expect(flushSpy1).to.have.been.calledWith([madeEvent]);
-            expect(flushSpy2).to.have.been.calledOnce;
-            expect(flushSpy2).to.have.been.calledWith([madeEvent]);
-        });
+    it("Tests that the event stream is included as an array in the props.", async () => {
+      const stream1 = new MockEventStream();
+      const stream2 = new MockEventStream();
+      const flushSpy1 = Sinon.spy(stream1, "flushEvents");
+      const flushSpy2 = Sinon.spy(stream2, "flushEvents");
+      const eventService = new EventService.EventService([stream1, stream2]);
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(flushSpy1).to.have.been.calledOnce;
+      expect(flushSpy1).to.have.been.calledWith([madeEvent]);
+      expect(flushSpy2).to.have.been.calledOnce;
+      expect(flushSpy2).to.have.been.calledWith([madeEvent]);
+    });
 
-        it("Tests that the prefixes are added.", async () => {
-            const stream = new MockEventStream();
-            const eventService = new EventService.EventService(stream, { prefix1: "Value1" });
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(madeEvent).to.have.property("prefix1", "Value1");
-        });
+    it("Tests that the prefixes are added.", async () => {
+      const stream = new MockEventStream();
+      const eventService = new EventService.EventService(stream, {
+        prefix1: "Value1",
+      });
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(madeEvent).to.have.property("prefix1", "Value1");
+    });
 
-        it("Tests that the prefixes are added if included in props.", async () => {
-            const stream = new MockEventStream();
-            const eventService = new EventService.EventService({ streams: stream, prefix: { prefix1: "Value1" } });
-            const madeEvent = eventService.event(testEvent);
-            await eventService.flush();
-            expect(madeEvent).to.have.property("prefix1", "Value1");
-        });
+    it("Tests that the prefixes are added if included in props.", async () => {
+      const stream = new MockEventStream();
+      const eventService = new EventService.EventService({
+        streams: stream,
+        prefix: { prefix1: "Value1" },
+      });
+      const madeEvent = eventService.event(testEvent);
+      await eventService.flush();
+      expect(madeEvent).to.have.property("prefix1", "Value1");
     });
-    describe("#addPrefix()", () => {
-        const testPrefix: EventService.EventPrefix = {
-            param1: "Value1",
-            param2: {
-                param3: "Value2"
-            },
-            param4: false
-        };
+  });
+  describe("#addPrefix()", () => {
+    const testPrefix: EventService.EventPrefix = {
+      param1: "Value1",
+      param2: {
+        param3: "Value2",
+      },
+      param4: false,
+    };
 
-        it("Tests that the prefix is added to every event.", () => {
-            const eventService = newService();
-            eventService.addPrefix(testPrefix);
-            const max = 10;
-            for (let i = 0; i < max; ++i) {
-                const event = eventService.event(testEvent);
-                expect(event).to.contain(testEvent);
-                expect(event).to.contain({ param1: "Value1" });
-                expect(event).to.deep.include({ param2: { param3: "Value2" } });
-                expect(event).to.contain({ param4: false });
-            }
-        });
+    it("Tests that the prefix is added to every event.", () => {
+      const eventService = newService();
+      eventService.addPrefix(testPrefix);
+      const max = 10;
+      for (let i = 0; i < max; ++i) {
+        const event = eventService.event(testEvent);
+        expect(event).to.contain(testEvent);
+        expect(event).to.contain({ param1: "Value1" });
+        expect(event).to.deep.include({ param2: { param3: "Value2" } });
+        expect(event).to.contain({ param4: false });
+      }
+    });
 
-        it("Tests that the prefix is added if it's a function.", () => {
-            const max = 10;
-            let count = 0;
-            const funcPrefix: EventService.EventPrefix = {
-                stringParam: () => {
-                    return count + "";
-                },
-                objParam: () => {
-                    return { param: count + "" };
-                }
-            };
-            const eventService = newService();
-            eventService.addPrefix(funcPrefix);
-            for (count = 0; count < max; ++count) {
-                const event = eventService.event(testEvent);
-                expect(event).to.contain(testEvent);
-                expect(event).to.contain({ stringParam: count + "" });
-                expect(event).to.deep.include({ objParam: { param: count + "" } });
-            }
-        });
+    it("Tests that the prefix is added if it's a function.", () => {
+      const max = 10;
+      let count = 0;
+      const funcPrefix: EventService.EventPrefix = {
+        stringParam: () => {
+          return count + "";
+        },
+        objParam: () => {
+          return { param: count + "" };
+        },
+      };
+      const eventService = newService();
+      eventService.addPrefix(funcPrefix);
+      for (count = 0; count < max; ++count) {
+        const event = eventService.event(testEvent);
+        expect(event).to.contain(testEvent);
+        expect(event).to.contain({ stringParam: count + "" });
+        expect(event).to.deep.include({ objParam: { param: count + "" } });
+      }
+    });
 
-        it("Tests that prefixes are merged.", () => {
-            const eventService = newService();
-            eventService.addPrefix({
-                mergePrefix1: "Value1"
-            });
-            eventService.addPrefix({
-                mergePrefix2: "Value2"
-            });
+    it("Tests that prefixes are merged.", () => {
+      const eventService = newService();
+      eventService.addPrefix({
+        mergePrefix1: "Value1",
+      });
+      eventService.addPrefix({
+        mergePrefix2: "Value2",
+      });
 
-            const max = 10;
-            for (let i = 0; i < max; ++i) {
-                const event = eventService.event(testEvent);
-                expect(event).to.contain(testEvent);
-                expect(event).to.contain({ mergePrefix1: "Value1" });
-                expect(event).to.deep.include({ mergePrefix2: "Value2" });
-            }
-        });
-        it("overwrites previous values", () => {
-            const eventService = newService();
-            eventService.addPrefix({
-                environment: "first"
-            });
-            eventService.addPrefix({
-                environment: "second"
-            });
+      const max = 10;
+      for (let i = 0; i < max; ++i) {
+        const event = eventService.event(testEvent);
+        expect(event).to.contain(testEvent);
+        expect(event).to.contain({ mergePrefix1: "Value1" });
+        expect(event).to.deep.include({ mergePrefix2: "Value2" });
+      }
+    });
+    it("overwrites previous values", () => {
+      const eventService = newService();
+      eventService.addPrefix({
+        environment: "first",
+      });
+      eventService.addPrefix({
+        environment: "second",
+      });
 
-            const max = 10;
-            for (let i = 0; i < max; ++i) {
-                const event = eventService.event(testEvent);
-                expect(event).to.contain(testEvent);
-                expect(event).to.contain({ environment: "second" });
-            }
-        });
+      const max = 10;
+      for (let i = 0; i < max; ++i) {
+        const event = eventService.event(testEvent);
+        expect(event).to.contain(testEvent);
+        expect(event).to.contain({ environment: "second" });
+      }
+    });
+  });
+  describe("#message()", () => {
+    it("Tests that a message event is returned when just a message parameter.", () => {
+      const eventService = newService();
+      const event = eventService.message("Test Message");
+      expect(event).to.deep.include({
+        name: "INFO",
+        type: "MessageEvent",
+        payload: "Test Message",
+      });
     });
-    describe("#message()", () => {
-        it("Tests that a message event is returned when just a message parameter.", () => {
-            const eventService = newService();
-            const event = eventService.message("Test Message");
-            expect(event).to.deep.include({
-                name: "INFO",
-                type: "MessageEvent",
-                payload: "Test Message"
-            });
-        });
 
-        it("Tests that a message event is returned when the message contains a name inside the message.", () => {
-            const eventService = newService();
-            const event = eventService.message("Test: Message");
-            expect(event).to.deep.include({
-                name: "Test",
-                type: "MessageEvent",
-                payload: "Message"
-            });
-        });
+    it("Tests that a message event is returned when the message contains a name inside the message.", () => {
+      const eventService = newService();
+      const event = eventService.message("Test: Message");
+      expect(event).to.deep.include({
+        name: "Test",
+        type: "MessageEvent",
+        payload: "Message",
+      });
+    });
 
-        it("Tests that a message event is returned to the message contains a name and message parameter.", () => {
-            const eventService = newService();
-            const event = eventService.message("Test", "Message");
-            expect(event).to.deep.include({
-                name: "Test",
-                type: "MessageEvent",
-                payload: "Message"
-            });
-        });
+    it("Tests that a message event is returned to the message contains a name and message parameter.", () => {
+      const eventService = newService();
+      const event = eventService.message("Test", "Message");
+      expect(event).to.deep.include({
+        name: "Test",
+        type: "MessageEvent",
+        payload: "Message",
+      });
     });
-    describe("#request()", () => {
-        let eventService: EventService.EventService;
-        beforeEach(() => {
-            eventService = newService();
-        });
-        describe("for an AudioPlayerRequest", () => {
-            it("sets the name", () => {
-                const request = new AudioPlayerRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.name).to.equal(request.type);
-            });
-            it("sets the type", () => {
-                const request = new AudioPlayerRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.type).to.equal("REQUEST");
-            });
-            it("sets the payload", () => {
-                const request = new AudioPlayerRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.equal({ event: request.event, token: request.token });
-            });
-        });
-        describe("for a IntentRequest", () => {
-            it("sets the name", () => {
-                const request = new IntentRequestBuilder().withIntentId("HelloIntent").build();
-                const event = eventService.request(request);
-                expect(event.name).to.equal(request.type);
-            });
-            it("sets the type", () => {
-                const request = new IntentRequestBuilder().withIntentId("HelloIntent").build();
-                const event = eventService.request(request);
-                expect(event.type).to.equal("REQUEST");
-            });
-            it("sets the payload", () => {
-                const request = new IntentRequestBuilder().withIntentId("HelloIntent").build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.include({ intent: request.intentId });
-            });
-            it("sets the rawQuery", () => {
-                const request = new IntentRequestBuilder()
-                    .withIntentId("HelloIntent")
-                    .withRawQuery("hiya")
-                    .build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.include({ intent: request.intentId, rawQuery: "hiya" });
-            });
-            it("sets the matchConfidence", () => {
-                const request = new IntentRequestBuilder()
-                    .withIntentId("HelloIntent")
-                    .withRawQuery("hiya")
-                    .withMatchConfidence(44)
-                    .build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.include({ intent: request.intentId, rawQuery: "hiya", matchConfidence: 44 });
-            });
-            describe("with slots", () => {
-                it("adds the slots", () => {
-                    const request = new IntentRequestBuilder()
-                        .withSlots({
-                            ["foo"]: {
-                                name: "foo",
-                                value: 1
-                            }
-                        })
-                        .withIntentId("HelloIntent")
-                        .build();
-                    const event = eventService.request(request);
-                    expect(event.payload).to.deep.include({
-                        intent: request.intentId,
-                        slots: {
-                            ["foo"]: {
-                                name: "foo",
-                                value: 1
-                            }
-                        }
-                    });
-                });
-            });
+  });
+  describe("#request()", () => {
+    let eventService: EventService.EventService;
+    beforeEach(() => {
+      eventService = newService();
+    });
+    describe("for an AudioPlayerRequest", () => {
+      it("sets the name", () => {
+        const request = new AudioPlayerRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.name).to.equal(request.type);
+      });
+      it("sets the type", () => {
+        const request = new AudioPlayerRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.type).to.equal("REQUEST");
+      });
+      it("sets the payload", () => {
+        const request = new AudioPlayerRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.equal({
+          event: request.event,
+          token: request.token,
         });
-        describe("for a LaunchRequest", () => {
-            it("sets the name", () => {
-                const request = new LaunchRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.name).to.equal(request.type);
-            });
-            it("sets the type", () => {
-                const request = new LaunchRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.type).to.equal("REQUEST");
-            });
-            it("sets the payload", () => {
-                const request = new LaunchRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.payload).to.be.undefined;
-            });
+      });
+    });
+    describe("for a IntentRequest", () => {
+      it("sets the name", () => {
+        const request = new IntentRequestBuilder()
+          .withIntentId("HelloIntent")
+          .build();
+        const event = eventService.request(request);
+        expect(event.name).to.equal(request.type);
+      });
+      it("sets the type", () => {
+        const request = new IntentRequestBuilder()
+          .withIntentId("HelloIntent")
+          .build();
+        const event = eventService.request(request);
+        expect(event.type).to.equal("REQUEST");
+      });
+      it("sets the payload", () => {
+        const request = new IntentRequestBuilder()
+          .withIntentId("HelloIntent")
+          .build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.include({ intent: request.intentId });
+      });
+      it("sets the rawQuery", () => {
+        const request = new IntentRequestBuilder()
+          .withIntentId("HelloIntent")
+          .withRawQuery("hiya")
+          .build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.include({
+          intent: request.intentId,
+          rawQuery: "hiya",
         });
-        describe("for an InputUnknown request", () => {
-            it("sets the name", () => {
-                const request = new InputUnknownRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.name).to.equal(request.type);
-            });
-            it("sets the type", () => {
-                const request = new InputUnknownRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.type).to.equal("REQUEST");
-            });
-            it("sets the payload", () => {
-                const request = new InputUnknownRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.include({
-                    intent: "InputUnknown"
-                });
-            });
-            it("sets the rawQuery", () => {
-                const request = new InputUnknownRequestBuilder().withRawQuery("query").build();
-                const event: Event<any> = eventService.request(request);
-                expect(event.payload).to.exist;
-                expect(event.payload.rawQuery).to.equal("query");
-            });
+      });
+      it("sets the matchConfidence", () => {
+        const request = new IntentRequestBuilder()
+          .withIntentId("HelloIntent")
+          .withRawQuery("hiya")
+          .withMatchConfidence(44)
+          .build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.include({
+          intent: request.intentId,
+          rawQuery: "hiya",
+          matchConfidence: 44,
         });
-        describe("for a PlaybackControlRequest", () => {
-            it("sets the name", () => {
-                const request = new PlaybackControlRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.name).to.equal(request.type);
-            });
-            it("sets the type", () => {
-                const request = new PlaybackControlRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.type).to.equal("REQUEST");
-            });
-            it("sets the payload", () => {
-                const request = new PlaybackControlRequestBuilder().build();
-                const event = eventService.request(request);
-                expect(event.payload).to.deep.equal({ event: request.event });
-            });
+      });
+      describe("with slots", () => {
+        it("adds the slots", () => {
+          const request = new IntentRequestBuilder()
+            .withSlots({
+              ["foo"]: {
+                name: "foo",
+                value: 1,
+              },
+            })
+            .withIntentId("HelloIntent")
+            .build();
+          const event = eventService.request(request);
+          expect(event.payload).to.deep.include({
+            intent: request.intentId,
+            slots: {
+              ["foo"]: {
+                name: "foo",
+                value: 1,
+              },
+            },
+          });
         });
+      });
     });
-    describe(`#${EventService.EventService.prototype.requestResponse.name}()`, () => {
-        let eventService: EventService.EventService;
-        beforeEach(() => {
-            eventService = newService();
-
+    describe("for a LaunchRequest", () => {
+      it("sets the name", () => {
+        const request = new LaunchRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.name).to.equal(request.type);
+      });
+      it("sets the type", () => {
+        const request = new LaunchRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.type).to.equal("REQUEST");
+      });
+      it("sets the payload", () => {
+        const request = new LaunchRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.payload).to.be.undefined;
+      });
+    });
+    describe("for an InputUnknown request", () => {
+      it("sets the name", () => {
+        const request = new InputUnknownRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.name).to.equal(request.type);
+      });
+      it("sets the type", () => {
+        const request = new InputUnknownRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.type).to.equal("REQUEST");
+      });
+      it("sets the payload", () => {
+        const request = new InputUnknownRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.include({
+          intent: "InputUnknown",
         });
-        it("creates the correct event", () => {
-            const request = new LaunchRequestBuilder().build();
-            const response: Response = {
-                outputSpeech: "Foo"
-            };
-            const event = eventService.requestResponse(request, response);
+      });
+      it("sets the rawQuery", () => {
+        const request = new InputUnknownRequestBuilder()
+          .withRawQuery("query")
+          .build();
+        const event: Event<any> = eventService.request(request);
+        expect(event.payload).to.exist;
+        expect(event.payload.rawQuery).to.equal("query");
+      });
+    });
+    describe("for a PlaybackControlRequest", () => {
+      it("sets the name", () => {
+        const request = new PlaybackControlRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.name).to.equal(request.type);
+      });
+      it("sets the type", () => {
+        const request = new PlaybackControlRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.type).to.equal("REQUEST");
+      });
+      it("sets the payload", () => {
+        const request = new PlaybackControlRequestBuilder().build();
+        const event = eventService.request(request);
+        expect(event.payload).to.deep.equal({ event: request.event });
+      });
+    });
+  });
+  describe(`#${EventService.EventService.prototype.requestResponse.name}()`, () => {
+    let eventService: EventService.EventService;
+    beforeEach(() => {
+      eventService = newService();
+    });
+    it("creates the correct event", () => {
+      const request = new LaunchRequestBuilder().build();
+      const response: Response = {
+        outputSpeech: "Foo",
+      };
+      const event = eventService.requestResponse(request, response);
 
-            expect(event.type).to.equal("AnalyticsEvent");
-            expect(event.name).to.equal("REQUEST_RESPONSE");
-            expect(event.payload).to.exist;
-            if (event.payload) {
-                expect(event.payload.request).to.equal(request);
-                expect(event.payload.response).to.equal(response);
-            }
-        });
-        describe("with a response that has a tag", () => {
-            it("creates the correct event", () => {
-                const request = new LaunchRequestBuilder().build();
-                const response: Response = {
-                    outputSpeech: "Foo",
-                    tag: "RESPONSE_TAG"
-                };
-                const event = eventService.requestResponse(request, response);
+      expect(event.type).to.equal("AnalyticsEvent");
+      expect(event.name).to.equal("REQUEST_RESPONSE");
+      expect(event.payload).to.exist;
+      if (event.payload) {
+        expect(event.payload.request).to.equal(request);
+        expect(event.payload.response).to.equal(response);
+      }
+    });
+    describe("with a response that has a tag", () => {
+      it("creates the correct event", () => {
+        const request = new LaunchRequestBuilder().build();
+        const response: Response = {
+          outputSpeech: "Foo",
+          tag: "RESPONSE_TAG",
+        };
+        const event = eventService.requestResponse(request, response);
 
-                expect(event.type).to.equal("AnalyticsEvent");
-                expect(event.name).to.equal("REQUEST_RESPONSE");
-                expect(event.tag).to.equal("RESPONSE_TAG");
+        expect(event.type).to.equal("AnalyticsEvent");
+        expect(event.name).to.equal("REQUEST_RESPONSE");
+        expect(event.tag).to.equal("RESPONSE_TAG");
 
-                expect(event.payload).to.exist;
-                if (event.payload) {
-                    expect(event.payload.request).to.equal(request);
-                    expect(event.payload.response).to.equal(response);
-                }
-            });
-        });
+        expect(event.payload).to.exist;
+        if (event.payload) {
+          expect(event.payload.request).to.equal(request);
+          expect(event.payload.response).to.equal(response);
+        }
+      });
     });
-    describe("#error()", () => {
-        let eventService: EventService.EventService;
-        beforeEach(() => {
-            eventService = new EventService.EventService();
-        });
-        describe("for an error", () => {
-            it("translates to an event", () => {
-                const error = new Error("Standard error");
-                const event = eventService.error(error);
-                expect(event).to.exist;
-                expect(event.type).to.equal("ERROR");
-                expect(event.name).to.equal("Error");
-                expect(event.payload).to.be.an("object");
-                expect(event.payload.message).to.equal("Standard error");
-                expect(event.payload.stack).to.exist;
-                // This wildly varies by node version. sigh.)
-                const EXPECTED_STACK_LENGTH: number = getSubstackLength();
-                expect(event.payload.stack).to.have.length(EXPECTED_STACK_LENGTH);
-            });
-        });
-        describe("for a type error", () => {
-            it("translates to an event", () => {
-                const error = new TypeError("Standard error");
-                const event = eventService.error(error);
-                expect(event).to.exist;
-                expect(event.type).to.equal("ERROR");
-                expect(event.name).to.equal("TypeError");
-                expect(event.payload).to.be.an("object");
-                expect(event.payload.message).to.equal("Standard error");
-                expect(event.payload.stack).to.exist;
-                // This wildly varies by node version. sigh.)
-                const EXPECTED_STACK_LENGTH: number = getSubstackLength();
-                expect(event.payload.stack).to.have.length(EXPECTED_STACK_LENGTH);
-            });
-        });
+  });
+  describe("#error()", () => {
+    let eventService: EventService.EventService;
+    beforeEach(() => {
+      eventService = new EventService.EventService();
+    });
+    describe("for an error", () => {
+      it("translates to an event", () => {
+        const error = new Error("Standard error");
+        const event = eventService.error(error);
+        expect(event).to.exist;
+        expect(event.type).to.equal("ERROR");
+        expect(event.name).to.equal("Error");
+        expect(event.payload).to.be.an("object");
+        expect(event.payload.message).to.equal("Standard error");
+        expect(event.payload.stack).to.exist;
+        // This wildly varies by node version. sigh.)
+        const EXPECTED_STACK_LENGTH: number = getSubstackLength();
+        expect(event.payload.stack).to.have.length(EXPECTED_STACK_LENGTH);
+      });
     });
-    describe("#event()", () => {
-        describe("for incomplete event", () => {
-            let eventService: EventService.EventService;
-            beforeEach(() => {
-                eventService = newService();
-            });
-            it("throws an error", () => {
-                // @ts-ignore Testing bad input
-                expect(eventService.event.bind(eventService, {
-                    type: "REQUEST"
-                })).to.throw("Unable to process event, event name was invalid.");
+    describe("for a type error", () => {
+      it("translates to an event", () => {
+        const error = new TypeError("Standard error");
+        const event = eventService.error(error);
+        expect(event).to.exist;
+        expect(event.type).to.equal("ERROR");
+        expect(event.name).to.equal("TypeError");
+        expect(event.payload).to.be.an("object");
+        expect(event.payload.message).to.equal("Standard error");
+        expect(event.payload.stack).to.exist;
+        // This wildly varies by node version. sigh.)
+        const EXPECTED_STACK_LENGTH: number = getSubstackLength();
+        expect(event.payload.stack).to.have.length(EXPECTED_STACK_LENGTH);
+      });
+    });
+  });
+  describe("#event()", () => {
+    describe("for incomplete event", () => {
+      let eventService: EventService.EventService;
+      beforeEach(() => {
+        eventService = newService();
+      });
+      it("throws an error", () => {
+        // @ts-ignore Testing bad input
+        expect(
+          eventService.event.bind(eventService, {
+            type: "REQUEST",
+          })
+        ).to.throw("Unable to process event, event name was invalid.");
 
-                // @ts-ignore Testing bad input
-                expect(eventService.event.bind(eventService, {
-                    name: "foo"
-                })).to.throw("Unable to process event, event type was invalid.");
-            });
-        });
+        // @ts-ignore Testing bad input
+        expect(
+          eventService.event.bind(eventService, {
+            name: "foo",
+          })
+        ).to.throw("Unable to process event, event type was invalid.");
+      });
     });
+  });
 });
-
diff --git a/packages/stentor-utils/src/__test__/address.test.ts b/packages/stentor-utils/src/__test__/address.test.ts
index 23990a0d8c..f0d04f68de 100644
--- a/packages/stentor-utils/src/__test__/address.test.ts
+++ b/packages/stentor-utils/src/__test__/address.test.ts
@@ -4,6 +4,8 @@ import {
   parseAddress,
   formAddressFromSlots,
   parseAddressAsSlots,
+  getAddressComponents,
+  ParsedAddress,
 } from "../address";
 
 describe(`#${parseAddress.name}()`, () => {
@@ -170,3 +172,81 @@ describe(`#${parseAddressAsSlots.name}()`, () => {
     });
   });
 });
+
+describe(`#${getAddressComponents.name}()`, () => {
+  describe("when passed a string", () => {
+    describe("that is valid", () => {
+      it("returns correctly", () => {
+        const address = "1600 Pennsylvania Avenue NW, Washington, DC 20500";
+        const components = getAddressComponents(address);
+        expect(components).to.deep.equal({
+          streetNumber: "1600",
+          formattedAddress: "1600 Pennsylvania Ave NW, Washington, DC 20500",
+          addressLine1: "1600 Pennsylvania Ave NW",
+          placeName: "Washington",
+          stateAbbreviation: "DC",
+          streetDirection: "NW",
+          streetName: "Pennsylvania",
+          streetSuffix: "Ave",
+          stateName: "District Of Columbia",
+          zipCode: "20500",
+          id: "1600-Pennsylvania-Ave-NW,-Washington,-DC-20500",
+        });
+      });
+    });
+  });
+  describe("when passed an object", () => {
+    describe("without an address and no state", () => {
+      it("returns correctly", () => {
+        const formatted: Partial<ParsedAddress> = {
+          formattedAddress: "2328 West Sebring Dr, Tucson, Arizona",
+        };
+
+        // expected parsed address
+        const parsed: ParsedAddress = {
+          stateName: "Arizona",
+          stateAbbreviation: "AZ",
+          placeName: "Tucson",
+          addressLine1: "2328 West Sebring Dr",
+          id: "2328-West-Sebring-Dr,-Tucson,-Arizona",
+          streetNumber: "2328",
+          streetSuffix: "Dr",
+          streetName: "West Sebring",
+        };
+
+        const components = getAddressComponents(formatted);
+        expect(components).to.include({ ...parsed });
+
+        // Try passing it through to itself
+        const components2 = getAddressComponents({ ...parsed, ...formatted });
+        expect(components2).to.include({ ...parsed });
+      });
+    });
+    describe("when passed a full object", () => {
+      it("returns correctly", () => {
+        const formatted: Partial<ParsedAddress> = {
+          formattedAddress: "2328 West Sebring Dr, Tucson, Arizona",
+          stateAbbreviation: "AZ",
+          placeName: "Tucson",
+          addressLine1: "2328 West Sebring Dr",
+          streetNumber: "2328",
+          streetSuffix: "Dr",
+          streetName: "West Sebring",
+        };
+        expect(getAddressComponents(formatted)).to.include({ ...formatted });
+      });
+    });
+    describe("when passed incomplete data", () => {
+      it("returns correctly", () => {
+        const formatted: Partial<ParsedAddress> = {
+          placeName: "Tucson",
+          addressLine1: "2328 West Sebring Dr",
+          streetNumber: "2328",
+          streetSuffix: "Dr",
+          streetName: "West Sebring",
+        };
+        expect(getAddressComponents(formatted)).to.include({ ...formatted });
+      });
+    });
+  });
+});
diff --git a/packages/stentor-utils/src/address.ts b/packages/stentor-utils/src/address.ts
index e6f3cc6944..9dd9278085 100644
--- a/packages/stentor-utils/src/address.ts
+++ b/packages/stentor-utils/src/address.ts
@@ -1,8 +1,30 @@
 /*! Copyright (c) 2025, XAPP AI */
 import { AddressIntentRequestSlotMap } from "stentor-models";
 import * as addresser from "addresser";
-
-export type ParsedAddress = addresser.IParsedAddress;
+import { pruneEmpty } from "./json";
+
+export interface ParsedAddress
+  extends Omit<addresser.IParsedAddress, "id" | "zipCode"> {
+  formattedAddress?: string;
+  /**
+   * Direction such as NW, SE, etc.
+   */
+  streetDirection?: string;
+  /**
+   * Zip/Postal Code
+   */
+  zipCode?: string;
+  /**
+   * Place name, typically the city or town.
+   */
+  placeName: string;
+  /**
+   * An ID for the address.
+   *
+   * @note It is not recommended to use this.
+   */
+  id?: string;
+}
 
 /**
  * Custom fallback parser for address strings.
@@ -94,7 +116,7 @@ export function parseAddress(address: string): ParsedAddress | undefined {
 }
 
 /**
- * Forms an address tring from from the slots.
+ * Forms an address string from from the slots.
  *
  * @param slots
  * @returns
@@ -174,7 +196,7 @@ export function parseAddressAsSlots(
     addressed = addresser.parseAddress(address);
   } catch (e) {
     // not a valid address
-    console.warn(`Unabled to parse address string "${address}"`);
+    console.warn(`Unable to parse address string "${address}"`);
   }
 
   if (addressed) {
@@ -220,3 +242,54 @@ export function parseAddressAsSlots(
 
   return slots;
 }
+
+/**
+ * Takes an input and attempts to parse out all the components
+ *
+ * It can be passed a partial address object and will attempt to fill in the missing components if a fullAddress is provided
+ *
+ * @param input
+ */
+export function getAddressComponents(
+  input: string | Partial<ParsedAddress>
+): ParsedAddress {
+  let parsedAddress: ParsedAddress;
+
+  if (typeof input === "string") {
+    parsedAddress = parseAddress(input);
+  } else {
+    parsedAddress = input as ParsedAddress;
+  }
+
+  // do some tests to make sure we have all the components
+  if (!parsedAddress.stateAbbreviation || !parsedAddress.stateName) {
+    // attempt to parse the address section and merge it in
+    const parsedFormattedAddress = parseAddress(
+      parsedAddress.formattedAddress || parsedAddress.addressLine1
+    );
+    // clean off the parsedFormattedAddress to remove any empty strings & values
+    const pruned = pruneEmpty(parsedFormattedAddress);
+    parsedAddress = { ...parsedAddress, ...pruned };
+  }
+
+  if (!parsedAddress.id) {
+    // id is just concatenation of the address
+    let id = "";
+    if (parsedAddress.addressLine1) {
+      id += `${parsedAddress.addressLine1},`;
+    }
+    if (parsedAddress.placeName) {
+      id += `-${parsedAddress.placeName},`;
+    }
+    if (parsedAddress.stateName) {
+      id += `-${parsedAddress.stateName}`;
+    }
+    if (parsedAddress.zipCode) {
+      id += `-${parsedAddress.zipCode}`;
+    }
+
+    parsedAddress.id = id.replace(/\s+/g, "-");
+  }
+
+  return parsedAddress;
+}
diff --git a/yarn.lock b/yarn.lock
index 189f4d566c..1ff3b6cbc6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -15,7 +15,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.25.9, @babel/code-frame@npm:^7.26.0, @babel/code-frame@npm:^7.26.2":
+"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.26.2":
   version: 7.26.2
   resolution: "@babel/code-frame@npm:7.26.2"
   dependencies:
@@ -26,59 +26,59 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/compat-data@npm:^7.25.9":
-  version: 7.26.3
-  resolution: "@babel/compat-data@npm:7.26.3"
-  checksum: 10c0/d63e71845c34dfad8d7ff8c15b562e620dbf60e68e3abfa35681d24d612594e8e5ec9790d831a287ecd79ce00f48e7ffddc85c5ce94af7242d45917b9c1a5f90
+"@babel/compat-data@npm:^7.26.5":
+  version: 7.26.8
+  resolution: "@babel/compat-data@npm:7.26.8"
+  checksum: 10c0/66408a0388c3457fff1c2f6c3a061278dd7b3d2f0455ea29bb7b187fa52c60ae8b4054b3c0a184e21e45f0eaac63cf390737bc7504d1f4a088a6e7f652c068ca
   languageName: node
   linkType: hard
 
 "@babel/core@npm:^7.0.0, @babel/core@npm:^7.23.9":
-  version: 7.26.0
-  resolution: "@babel/core@npm:7.26.0"
+  version: 7.26.9
+  resolution: "@babel/core@npm:7.26.9"
   dependencies:
     "@ampproject/remapping": "npm:^2.2.0"
-    "@babel/code-frame": "npm:^7.26.0"
-    "@babel/generator": "npm:^7.26.0"
-    "@babel/helper-compilation-targets": "npm:^7.25.9"
+    "@babel/code-frame": "npm:^7.26.2"
+    "@babel/generator": "npm:^7.26.9"
+    "@babel/helper-compilation-targets": "npm:^7.26.5"
     "@babel/helper-module-transforms": "npm:^7.26.0"
-    "@babel/helpers": "npm:^7.26.0"
-    "@babel/parser": "npm:^7.26.0"
-    "@babel/template": "npm:^7.25.9"
-    "@babel/traverse": "npm:^7.25.9"
-    "@babel/types": "npm:^7.26.0"
+    "@babel/helpers": "npm:^7.26.9"
+    "@babel/parser": "npm:^7.26.9"
+    "@babel/template": "npm:^7.26.9"
+    "@babel/traverse": "npm:^7.26.9"
+    "@babel/types": "npm:^7.26.9"
     convert-source-map: "npm:^2.0.0"
     debug: "npm:^4.1.0"
     gensync: "npm:^1.0.0-beta.2"
     json5: "npm:^2.2.3"
     semver: "npm:^6.3.1"
-  checksum: 10c0/91de73a7ff5c4049fbc747930aa039300e4d2670c2a91f5aa622f1b4868600fc89b01b6278385fbcd46f9574186fa3d9b376a9e7538e50f8d118ec13cfbcb63e
+  checksum: 10c0/ed7212ff42a9453765787019b7d191b167afcacd4bd8fec10b055344ef53fa0cc648c9a80159ae4ecf870016a6318731e087042dcb68d1a2a9d34eb290dc014b
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.26.0, @babel/generator@npm:^7.26.3":
-  version: 7.26.3
-  resolution: "@babel/generator@npm:7.26.3"
+"@babel/generator@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/generator@npm:7.26.9"
   dependencies:
-    "@babel/parser": "npm:^7.26.3"
-    "@babel/types": "npm:^7.26.3"
+    "@babel/parser": "npm:^7.26.9"
+    "@babel/types": "npm:^7.26.9"
     "@jridgewell/gen-mapping": "npm:^0.3.5"
     "@jridgewell/trace-mapping": "npm:^0.3.25"
     jsesc: "npm:^3.0.2"
-  checksum: 10c0/54f260558e3e4ec8942da3cde607c35349bb983c3a7c5121243f96893fba3e8cd62e1f1773b2051f936f8c8a10987b758d5c7d76dbf2784e95bb63ab4843fa00
+  checksum: 10c0/6b78872128205224a9a9761b9ea7543a9a7902a04b82fc2f6801ead4de8f59056bab3fd17b1f834ca7b049555fc4c79234b9a6230dd9531a06525306050becad
   languageName: node
   linkType: hard
 
-"@babel/helper-compilation-targets@npm:^7.25.9":
-  version: 7.25.9
-  resolution: "@babel/helper-compilation-targets@npm:7.25.9"
+"@babel/helper-compilation-targets@npm:^7.26.5":
+  version: 7.26.5
+  resolution: "@babel/helper-compilation-targets@npm:7.26.5"
   dependencies:
-    "@babel/compat-data": "npm:^7.25.9"
+    "@babel/compat-data": "npm:^7.26.5"
     "@babel/helper-validator-option": "npm:^7.25.9"
     browserslist: "npm:^4.24.0"
     lru-cache: "npm:^5.1.1"
     semver: "npm:^6.3.1"
-  checksum: 10c0/a6b26a1e4222e69ef8e62ee19374308f060b007828bc11c65025ecc9e814aba21ff2175d6d3f8bf53c863edd728ee8f94ba7870f8f90a37d39552ad9933a8aaa
+  checksum: 10c0/9da5c77e5722f1a2fcb3e893049a01d414124522bbf51323bb1a0c9dcd326f15279836450fc36f83c9e8a846f3c40e88be032ed939c5a9840922bed6073edfb4
   languageName: node
   linkType: hard
 
@@ -126,69 +126,69 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helpers@npm:^7.26.0":
-  version: 7.26.0
-  resolution: "@babel/helpers@npm:7.26.0"
+"@babel/helpers@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/helpers@npm:7.26.9"
   dependencies:
-    "@babel/template": "npm:^7.25.9"
-    "@babel/types": "npm:^7.26.0"
-  checksum: 10c0/343333cced6946fe46617690a1d0789346960910225ce359021a88a60a65bc0d791f0c5d240c0ed46cf8cc63b5fd7df52734ff14e43b9c32feae2b61b1647097
+    "@babel/template": "npm:^7.26.9"
+    "@babel/types": "npm:^7.26.9"
+  checksum: 10c0/3d4dbc4a33fe4181ed810cac52318b578294745ceaec07e2f6ecccf6cda55d25e4bfcea8f085f333bf911c9e1fc13320248dd1d5315ab47ad82ce1077410df05
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.23.9, @babel/parser@npm:^7.25.9, @babel/parser@npm:^7.26.0, @babel/parser@npm:^7.26.3":
-  version: 7.26.3
-  resolution: "@babel/parser@npm:7.26.3"
+"@babel/parser@npm:^7.23.9, @babel/parser@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/parser@npm:7.26.9"
   dependencies:
-    "@babel/types": "npm:^7.26.3"
+    "@babel/types": "npm:^7.26.9"
   bin:
     parser: ./bin/babel-parser.js
-  checksum: 10c0/48f736374e61cfd10ddbf7b80678514ae1f16d0e88bc793d2b505d73d9b987ea786fc8c2f7ee8f8b8c467df062030eb07fd0eb2168f0f541ca1f542775852cad
+  checksum: 10c0/4b9ef3c9a0d4c328e5e5544f50fe8932c36f8a2c851e7f14a85401487cd3da75cad72c2e1bcec1eac55599a6bbb2fdc091f274c4fcafa6bdd112d4915ff087fc
   languageName: node
   linkType: hard
 
 "@babel/runtime@npm:^7.0.0":
-  version: 7.26.0
-  resolution: "@babel/runtime@npm:7.26.0"
+  version: 7.26.9
+  resolution: "@babel/runtime@npm:7.26.9"
   dependencies:
     regenerator-runtime: "npm:^0.14.0"
-  checksum: 10c0/12c01357e0345f89f4f7e8c0e81921f2a3e3e101f06e8eaa18a382b517376520cd2fa8c237726eb094dab25532855df28a7baaf1c26342b52782f6936b07c287
+  checksum: 10c0/e8517131110a6ec3a7360881438b85060e49824e007f4a64b5dfa9192cf2bb5c01e84bfc109f02d822c7edb0db926928dd6b991e3ee460b483fb0fac43152d9b
   languageName: node
   linkType: hard
 
-"@babel/template@npm:^7.25.9":
-  version: 7.25.9
-  resolution: "@babel/template@npm:7.25.9"
+"@babel/template@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/template@npm:7.26.9"
   dependencies:
-    "@babel/code-frame": "npm:^7.25.9"
-    "@babel/parser": "npm:^7.25.9"
-    "@babel/types": "npm:^7.25.9"
-  checksum: 10c0/ebe677273f96a36c92cc15b7aa7b11cc8bc8a3bb7a01d55b2125baca8f19cae94ff3ce15f1b1880fb8437f3a690d9f89d4e91f16fc1dc4d3eb66226d128983ab
+    "@babel/code-frame": "npm:^7.26.2"
+    "@babel/parser": "npm:^7.26.9"
+    "@babel/types": "npm:^7.26.9"
+  checksum: 10c0/019b1c4129cc01ad63e17529089c2c559c74709d225f595eee017af227fee11ae8a97a6ab19ae6768b8aa22d8d75dcb60a00b28f52e9fa78140672d928bc1ae9
   languageName: node
   linkType: hard
 
-"@babel/traverse@npm:^7.25.9":
-  version: 7.26.4
-  resolution: "@babel/traverse@npm:7.26.4"
+"@babel/traverse@npm:^7.25.9, @babel/traverse@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/traverse@npm:7.26.9"
   dependencies:
     "@babel/code-frame": "npm:^7.26.2"
-    "@babel/generator": "npm:^7.26.3"
-    "@babel/parser": "npm:^7.26.3"
-    "@babel/template": "npm:^7.25.9"
-    "@babel/types": "npm:^7.26.3"
+    "@babel/generator": "npm:^7.26.9"
+    "@babel/parser": "npm:^7.26.9"
+    "@babel/template": "npm:^7.26.9"
+    "@babel/types": "npm:^7.26.9"
     debug: "npm:^4.3.1"
     globals: "npm:^11.1.0"
-  checksum: 10c0/cf25d0eda9505daa0f0832ad786b9e28c9d967e823aaf7fbe425250ab198c656085495aa6bed678b27929e095c84eea9fd778b851a31803da94c9bc4bf4eaef7
+  checksum: 10c0/51dd57fa39ea34d04816806bfead04c74f37301269d24c192d1406dc6e244fea99713b3b9c5f3e926d9ef6aa9cd5c062ad4f2fc1caa9cf843d5e864484ac955e
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.25.9, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.3":
-  version: 7.26.3
-  resolution: "@babel/types@npm:7.26.3"
+"@babel/types@npm:^7.25.9, @babel/types@npm:^7.26.9":
+  version: 7.26.9
+  resolution: "@babel/types@npm:7.26.9"
   dependencies:
     "@babel/helper-string-parser": "npm:^7.25.9"
     "@babel/helper-validator-identifier": "npm:^7.25.9"
-  checksum: 10c0/966c5242c5e55c8704bf7a7418e7be2703a0afa4d19a8480999d5a4ef13d095dd60686615fe5983cb7593b4b06ba3a7de8d6ca501c1d78bdd233a10d90be787b
+  checksum: 10c0/999c56269ba00e5c57aa711fbe7ff071cd6990bafd1b978341ea7572cc78919986e2aa6ee51dacf4b6a7a6fa63ba4eb3f1a03cf55eee31b896a56d068b895964
   languageName: node
   linkType: hard
 
@@ -1339,14 +1339,14 @@ __metadata:
   linkType: hard
 
 "@types/express-serve-static-core@npm:^5.0.0":
-  version: 5.0.2
-  resolution: "@types/express-serve-static-core@npm:5.0.2"
+  version: 5.0.6
+  resolution: "@types/express-serve-static-core@npm:5.0.6"
   dependencies:
     "@types/node": "npm:*"
     "@types/qs": "npm:*"
     "@types/range-parser": "npm:*"
     "@types/send": "npm:*"
-  checksum: 10c0/9f6ee50bd81f0aa6cc9df6ad2c2d221a3a63249da944db58ec8bb8681e77a5b3b3fdb1931bda73beb13cfaf9125731f835fe5256afb6a6da35b0eb08ccbdbfdf
+  checksum: 10c0/aced8cc88c1718adbbd1fc488756b0f22d763368d9eff2ae21b350698fab4a77d8d13c3699056dc662a887e43a8b67a3e8f6289ff76102ecc6bad4a7710d31a6
   languageName: node
   linkType: hard
 
@@ -1411,9 +1411,9 @@ __metadata:
   linkType: hard
 
 "@types/lodash@npm:*":
-  version: 4.17.13
-  resolution: "@types/lodash@npm:4.17.13"
-  checksum: 10c0/c3d0b7efe7933ac0369b99f2f7bff9240d960680fdb74b41ed4bd1b3ca60cca1e31fe4046d9abbde778f941a41bc2a75eb629abf8659fa6c27b66efbbb0802a9
+  version: 4.17.15
+  resolution: "@types/lodash@npm:4.17.15"
+  checksum: 10c0/2eb2dc6d231f5fb4603d176c08c8d7af688f574d09af47466a179cd7812d9f64144ba74bb32ca014570ffdc544eedc51b7a5657212bad083b6eecbd72223f9bb
   languageName: node
   linkType: hard
 
@@ -1454,16 +1454,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node@npm:*":
-  version: 22.10.2
-  resolution: "@types/node@npm:22.10.2"
-  dependencies:
-    undici-types: "npm:~6.20.0"
-  checksum: 10c0/2c7b71a040f1ef5320938eca8ebc946e6905caa9bbf3d5665d9b3774a8d15ea9fab1582b849a6d28c7fc80756a62c5666bc66b69f42f4d5dafd1ccb193cdb4ac
-  languageName: node
-  linkType: hard
-
-"@types/node@npm:22.13.5":
+"@types/node@npm:*, @types/node@npm:22.13.5":
   version: 22.13.5
   resolution: "@types/node@npm:22.13.5"
   dependencies:
@@ -1487,9 +1478,9 @@ __metadata:
   linkType: hard
 
 "@types/qs@npm:*":
-  version: 6.9.17
-  resolution: "@types/qs@npm:6.9.17"
-  checksum: 10c0/a183fa0b3464267f8f421e2d66d960815080e8aab12b9aadab60479ba84183b1cdba8f4eff3c06f76675a8e42fe6a3b1313ea76c74f2885c3e25d32499c17d1b
+  version: 6.9.18
+  resolution: "@types/qs@npm:6.9.18"
+  checksum: 10c0/790b9091348e06dde2c8e4118b5771ab386a8c22a952139a2eb0675360a2070d0b155663bf6f75b23f258fd0a1f7ffc0ba0f059d99a719332c03c40d9e9cd63b
   languageName: node
   linkType: hard
 
@@ -1547,7 +1538,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/sinon@npm:*, @types/sinon@npm:17.0.3":
+"@types/sinon@npm:*":
+  version: 17.0.4
+  resolution: "@types/sinon@npm:17.0.4"
+  dependencies:
+    "@types/sinonjs__fake-timers": "npm:*"
+  checksum: 10c0/7c67ae1050d98a86d8dd771f0a764e97adb9d54812bf3b001195f8cfaa1e2bdfc725d5b970b91e7b0bb6b7c1ca209f47993f2c6f84f1f868313c37441313ca5b
+  languageName: node
+  linkType: hard
+
+"@types/sinon@npm:17.0.3":
   version: 17.0.3
   resolution: "@types/sinon@npm:17.0.3"
   dependencies:
@@ -1701,9 +1701,9 @@ __metadata:
   linkType: hard
 
 "@ungap/structured-clone@npm:^1.2.0":
-  version: 1.2.1
-  resolution: "@ungap/structured-clone@npm:1.2.1"
-  checksum: 10c0/127afbcc75ff1532f7b1eb85ee992f9faa70e8d5bb2558da05355d423b966fc279d0a485bf19da2883280e7c299ae4170809a72e78eab086da71c6bcdda5d1e2
+  version: 1.3.0
+  resolution: "@ungap/structured-clone@npm:1.3.0"
+  checksum: 10c0/0fc3097c2540ada1fc340ee56d58d96b5b536a2a0dab6e3ec17d4bfc8c4c86db345f61a375a8185f9da96f01c69678f836a2b57eeaa9e4b8eeafd26428e57b0a
   languageName: node
   linkType: hard
 
@@ -1784,10 +1784,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"abbrev@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "abbrev@npm:2.0.0"
-  checksum: 10c0/f742a5a107473946f426c691c08daba61a1d15942616f300b5d32fd735be88fef5cba24201757b6c407fd564555fb48c751cfa33519b2605c8a7aadd22baf372
+"abbrev@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "abbrev@npm:3.0.0"
+  checksum: 10c0/049704186396f571650eb7b22ed3627b77a5aedf98bb83caf2eac81ca2a3e25e795394b0464cfb2d6076df3db6a5312139eac5b6a126ca296ac53c5008069c28
   languageName: node
   linkType: hard
 
@@ -1868,11 +1868,11 @@ __metadata:
   linkType: hard
 
 "agentkeepalive@npm:^4.2.1":
-  version: 4.5.0
-  resolution: "agentkeepalive@npm:4.5.0"
+  version: 4.6.0
+  resolution: "agentkeepalive@npm:4.6.0"
   dependencies:
     humanize-ms: "npm:^1.2.1"
-  checksum: 10c0/394ea19f9710f230722996e156607f48fdf3a345133b0b1823244b7989426c16019a428b56c82d3eabef616e938812981d9009f4792ecc66bd6a59e991c62612
+  checksum: 10c0/235c182432f75046835b05f239708107138a40103deee23b6a08caee5136873709155753b394ec212e49e60e94a378189562cb01347765515cff61b692c69187
   languageName: node
   linkType: hard
 
@@ -2315,8 +2315,8 @@ __metadata:
   linkType: hard
 
 "browserslist@npm:^4.24.0":
-  version: 4.24.3
-  resolution: "browserslist@npm:4.24.3"
+  version: 4.24.4
+  resolution: "browserslist@npm:4.24.4"
   dependencies:
     caniuse-lite: "npm:^1.0.30001688"
     electron-to-chromium: "npm:^1.5.73"
@@ -2324,7 +2324,7 @@ __metadata:
     update-browserslist-db: "npm:^1.1.1"
   bin:
     browserslist: cli.js
-  checksum: 10c0/bab261ef7b6e1656a719a9fa31240ae7ce4d5ba68e479f6b11e348d819346ab4c0ff6f4821f43adcc9c193a734b186775a83b37979e70a69d182965909fe569a
+  checksum: 10c0/db7ebc1733cf471e0b490b4f47e3e2ea2947ce417192c9246644e92c667dd56a71406cc58f62ca7587caf828364892e9952904a02b7aead752bc65b62a37cfe9
   languageName: node
   linkType: hard
 
@@ -2464,17 +2464,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"call-bind-apply-helpers@npm:^1.0.0, call-bind-apply-helpers@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "call-bind-apply-helpers@npm:1.0.1"
+"call-bind-apply-helpers@npm:^1.0.0, call-bind-apply-helpers@npm:^1.0.1, call-bind-apply-helpers@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "call-bind-apply-helpers@npm:1.0.2"
   dependencies:
     es-errors: "npm:^1.3.0"
     function-bind: "npm:^1.1.2"
-  checksum: 10c0/acb2ab68bf2718e68a3e895f0d0b73ccc9e45b9b6f210f163512ba76f91dab409eb8792f6dae188356f9095747512a3101646b3dea9d37fb8c7c6bf37796d18c
+  checksum: 10c0/47bd9901d57b857590431243fea704ff18078b16890a6b3e021e12d279bbf211d039155e27d7566b374d49ee1f8189344bac9833dec7a20cdec370506361c938
   languageName: node
   linkType: hard
 
-"call-bind@npm:^1.0.7":
+"call-bind@npm:^1.0.8":
   version: 1.0.8
   resolution: "call-bind@npm:1.0.8"
   dependencies:
@@ -2486,7 +2486,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"call-bound@npm:^1.0.2":
+"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3":
   version: 1.0.3
   resolution: "call-bound@npm:1.0.3"
   dependencies:
@@ -2529,9 +2529,9 @@ __metadata:
   linkType: hard
 
 "caniuse-lite@npm:^1.0.30001688":
-  version: 1.0.30001689
-  resolution: "caniuse-lite@npm:1.0.30001689"
-  checksum: 10c0/51cf99751dddfba24e13556ae0e0f38c062f76d49f2e24cce3d28e71a0325ca6fe04fe51b4a0e8467d601d94e72fea84f160bf577e7cbb5677f14ac673b6da20
+  version: 1.0.30001700
+  resolution: "caniuse-lite@npm:1.0.30001700"
+  checksum: 10c0/3d391bcdd193208166d3ad759de240b9c18ac3759dbd57195770f0fcd2eedcd47d5e853609aba1eee5a2def44b0a14eee457796bdb3451a27de0c8b27355017c
   languageName: node
   linkType: hard
 
@@ -2590,7 +2590,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chalk@npm:5.4.1":
+"chalk@npm:5.4.1, chalk@npm:^5.2.0, chalk@npm:^5.3.0":
   version: 5.4.1
   resolution: "chalk@npm:5.4.1"
   checksum: 10c0/b23e88132c702f4855ca6d25cb5538b1114343e41472d5263ee8a37cccfccd9c4216d111e1097c6a27830407a1dc81fecdf2a56f2c63033d4dbbd88c10b0dcef
@@ -2608,13 +2608,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chalk@npm:^5.2.0, chalk@npm:^5.3.0":
-  version: 5.3.0
-  resolution: "chalk@npm:5.3.0"
-  checksum: 10c0/8297d436b2c0f95801103ff2ef67268d362021b8210daf8ddbe349695333eb3610a71122172ff3b0272f1ef2cf7cc2c41fdaa4715f52e49ffe04c56340feed09
-  languageName: node
-  linkType: hard
-
 "chardet@npm:^0.7.0":
   version: 0.7.0
   resolution: "chardet@npm:0.7.0"
@@ -3090,9 +3083,9 @@ __metadata:
   linkType: hard
 
 "core-js@npm:^3.0.0":
-  version: 3.39.0
-  resolution: "core-js@npm:3.39.0"
-  checksum: 10c0/f7602069b6afb2e3298eec612a5c1e0c3e6a458930fbfc7a4c5f9ac03426507f49ce395eecdd2d9bae9024f820e44582b67ffe16f2272395af26964f174eeb6b
+  version: 3.40.0
+  resolution: "core-js@npm:3.40.0"
+  checksum: 10c0/db7946ada881e845d8b157061945b1187618fa45cf162f392a151e8a497962aed2da688c982eaa1d444c864be97a70f8be4d73385294b515d224dd164d19f1d4
   languageName: node
   linkType: hard
 
@@ -3144,7 +3137,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3":
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
   version: 7.0.6
   resolution: "cross-spawn@npm:7.0.6"
   dependencies:
@@ -3476,13 +3469,13 @@ __metadata:
   linkType: hard
 
 "domutils@npm:^3.0.1":
-  version: 3.1.0
-  resolution: "domutils@npm:3.1.0"
+  version: 3.2.2
+  resolution: "domutils@npm:3.2.2"
   dependencies:
     dom-serializer: "npm:^2.0.0"
     domelementtype: "npm:^2.3.0"
     domhandler: "npm:^5.0.3"
-  checksum: 10c0/342d64cf4d07b8a0573fb51e0a6312a88fb520c7fefd751870bf72fa5fc0f2e0cb9a3958a573610b1d608c6e2a69b8e9b4b40f0bfb8f87a71bce4f180cca1887
+  checksum: 10c0/47938f473b987ea71cd59e59626eb8666d3aa8feba5266e45527f3b636c7883cca7e582d901531961f742c519d7514636b7973353b648762b2e3bedbf235fada
   languageName: node
   linkType: hard
 
@@ -3516,7 +3509,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dunder-proto@npm:^1.0.0":
+"dunder-proto@npm:^1.0.1":
   version: 1.0.1
   resolution: "dunder-proto@npm:1.0.1"
   dependencies:
@@ -3576,9 +3569,9 @@ __metadata:
   linkType: hard
 
 "electron-to-chromium@npm:^1.5.73":
-  version: 1.5.74
-  resolution: "electron-to-chromium@npm:1.5.74"
-  checksum: 10c0/1a93119adbdeb0bba4c29e3bad5a48e6a4626ae50fbff2bc5c207f32e67ed64a5d8db6500befb44080359be3b18be7bf830fb920d5199d935be95bb9f97deb10
+  version: 1.5.104
+  resolution: "electron-to-chromium@npm:1.5.104"
+  checksum: 10c0/f58d9836607fba37b393aa86bd1bbc01721c32328b3c80e86bc39e3e636cc30ee70f97e652f611a38ab3de219cf16aca85ebda4774094bf43723e671290c344d
   languageName: node
   linkType: hard
 
@@ -3714,12 +3707,24 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es-object-atoms@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "es-object-atoms@npm:1.0.0"
+"es-object-atoms@npm:^1.0.0, es-object-atoms@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "es-object-atoms@npm:1.1.1"
   dependencies:
     es-errors: "npm:^1.3.0"
-  checksum: 10c0/1fed3d102eb27ab8d983337bb7c8b159dd2a1e63ff833ec54eea1311c96d5b08223b433060ba240541ca8adba9eee6b0a60cdbf2f80634b784febc9cc8b687b4
+  checksum: 10c0/65364812ca4daf48eb76e2a3b7a89b3f6a2e62a1c420766ce9f692665a29d94fe41fe88b65f24106f449859549711e4b40d9fb8002d862dfd7eb1c512d10be0c
+  languageName: node
+  linkType: hard
+
+"es-set-tostringtag@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "es-set-tostringtag@npm:2.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.6"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/ef2ca9ce49afe3931cb32e35da4dcb6d86ab02592cfc2ce3e49ced199d9d0bb5085fc7e73e06312213765f5efa47cc1df553a6a5154584b21448e9fb8355b1af
   languageName: node
   linkType: hard
 
@@ -4021,9 +4026,9 @@ __metadata:
   linkType: hard
 
 "exponential-backoff@npm:^3.1.1":
-  version: 3.1.1
-  resolution: "exponential-backoff@npm:3.1.1"
-  checksum: 10c0/160456d2d647e6019640bd07111634d8c353038d9fa40176afb7cd49b0548bdae83b56d05e907c2cce2300b81cae35d800ef92fefb9d0208e190fa3b7d6bb579
+  version: 3.1.2
+  resolution: "exponential-backoff@npm:3.1.2"
+  checksum: 10c0/d9d3e1eafa21b78464297df91f1776f7fbaa3d5e3f7f0995648ca5b89c069d17055033817348d9f4a43d1c20b0eab84f75af6991751e839df53e4dfd6f22e844
   languageName: node
   linkType: hard
 
@@ -4103,15 +4108,15 @@ __metadata:
   linkType: hard
 
 "fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.2":
-  version: 3.3.2
-  resolution: "fast-glob@npm:3.3.2"
+  version: 3.3.3
+  resolution: "fast-glob@npm:3.3.3"
   dependencies:
     "@nodelib/fs.stat": "npm:^2.0.2"
     "@nodelib/fs.walk": "npm:^1.2.3"
     glob-parent: "npm:^5.1.2"
     merge2: "npm:^1.3.0"
-    micromatch: "npm:^4.0.4"
-  checksum: 10c0/42baad7b9cd40b63e42039132bde27ca2cb3a4950d0a0f9abe4639ea1aa9d3e3b40f98b1fe31cbc0cc17b664c9ea7447d911a152fa34ec5b72977b125a6fc845
+    micromatch: "npm:^4.0.8"
+  checksum: 10c0/f6aaa141d0d3384cf73cbcdfc52f475ed293f6d5b65bfc5def368b09163a9f7e5ec2b3014d80f733c405f58e470ee0cc451c2937685045cddcdeaa24199c43fe
   languageName: node
   linkType: hard
 
@@ -4130,18 +4135,18 @@ __metadata:
   linkType: hard
 
 "fast-uri@npm:^3.0.1":
-  version: 3.0.3
-  resolution: "fast-uri@npm:3.0.3"
-  checksum: 10c0/4b2c5ce681a062425eae4f15cdc8fc151fd310b2f69b1f96680677820a8b49c3cd6e80661a406e19d50f0c40a3f8bffdd458791baf66f4a879d80be28e10a320
+  version: 3.0.6
+  resolution: "fast-uri@npm:3.0.6"
+  checksum: 10c0/74a513c2af0584448aee71ce56005185f81239eab7a2343110e5bad50c39ad4fb19c5a6f99783ead1cac7ccaf3461a6034fda89fffa2b30b6d99b9f21c2f9d29
   languageName: node
   linkType: hard
 
 "fastq@npm:^1.6.0":
-  version: 1.17.1
-  resolution: "fastq@npm:1.17.1"
+  version: 1.19.0
+  resolution: "fastq@npm:1.19.0"
   dependencies:
     reusify: "npm:^1.0.4"
-  checksum: 10c0/1095f16cea45fb3beff558bb3afa74ca7a9250f5a670b65db7ed585f92b4b48381445cd328b3d87323da81e43232b5d5978a8201bde84e0cd514310f1ea6da34
+  checksum: 10c0/d6a001638f1574a696660fcbba5300d017760432372c801632c325ca7c16819604841c92fd3ccadcdacec0966ca336363a5ff57bc5f0be335d8ea7ac6087b98f
   languageName: node
   linkType: hard
 
@@ -4294,9 +4299,9 @@ __metadata:
   linkType: hard
 
 "flatted@npm:^3.2.9":
-  version: 3.3.2
-  resolution: "flatted@npm:3.3.2"
-  checksum: 10c0/24cc735e74d593b6c767fe04f2ef369abe15b62f6906158079b9874bdb3ee5ae7110bb75042e70cd3f99d409d766f357caf78d5ecee9780206f5fdc5edbad334
+  version: 3.3.3
+  resolution: "flatted@npm:3.3.3"
+  checksum: 10c0/e957a1c6b0254aa15b8cce8533e24165abd98fadc98575db082b786b5da1b7d72062b81bfdcd1da2f4d46b6ed93bec2434e62333e9b4261d79ef2e75a10dd538
   languageName: node
   linkType: hard
 
@@ -4318,11 +4323,11 @@ __metadata:
   linkType: hard
 
 "for-each@npm:^0.3.3":
-  version: 0.3.3
-  resolution: "for-each@npm:0.3.3"
+  version: 0.3.5
+  resolution: "for-each@npm:0.3.5"
   dependencies:
-    is-callable: "npm:^1.1.3"
-  checksum: 10c0/22330d8a2db728dbf003ec9182c2d421fbcd2969b02b4f97ec288721cda63eb28f2c08585ddccd0f77cb2930af8d958005c9e72f47141dc51816127a118f39aa
+    is-callable: "npm:^1.2.7"
+  checksum: 10c0/0e0b50f6a843a282637d43674d1fb278dda1dd85f4f99b640024cfb10b85058aac0cc781bf689d5fe50b4b7f638e91e548560723a4e76e04fe96ae35ef039cee
   languageName: node
   linkType: hard
 
@@ -4337,23 +4342,24 @@ __metadata:
   linkType: hard
 
 "foreground-child@npm:^3.1.0, foreground-child@npm:^3.3.0":
-  version: 3.3.0
-  resolution: "foreground-child@npm:3.3.0"
+  version: 3.3.1
+  resolution: "foreground-child@npm:3.3.1"
   dependencies:
-    cross-spawn: "npm:^7.0.0"
+    cross-spawn: "npm:^7.0.6"
     signal-exit: "npm:^4.0.1"
-  checksum: 10c0/028f1d41000553fcfa6c4bb5c372963bf3d9bf0b1f25a87d1a6253014343fb69dfb1b42d9625d7cf44c8ba429940f3d0ff718b62105d4d4a4f6ef8ca0a53faa2
+  checksum: 10c0/8986e4af2430896e65bc2788d6679067294d6aee9545daefc84923a0a4b399ad9c7a3ea7bd8c0b2b80fdf4a92de4c69df3f628233ff3224260e9c1541a9e9ed3
   languageName: node
   linkType: hard
 
 "form-data@npm:^4.0.0":
-  version: 4.0.1
-  resolution: "form-data@npm:4.0.1"
+  version: 4.0.2
+  resolution: "form-data@npm:4.0.2"
   dependencies:
     asynckit: "npm:^0.4.0"
     combined-stream: "npm:^1.0.8"
+    es-set-tostringtag: "npm:^2.1.0"
     mime-types: "npm:^2.1.12"
-  checksum: 10c0/bb102d570be8592c23f4ea72d7df9daa50c7792eb0cf1c5d7e506c1706e7426a4e4ae48a35b109e91c85f1c0ec63774a21ae252b66f4eb981cb8efef7d0463c8
+  checksum: 10c0/e534b0cf025c831a0929bf4b9bbe1a9a6b03e273a8161f9947286b9b13bf8fb279c6944aae0070c4c311100c6d6dbb815cd955dc217728caf73fad8dc5b8ee9c
   languageName: node
   linkType: hard
 
@@ -4385,18 +4391,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-extra@npm:^11.1.0, fs-extra@npm:^11.1.1":
-  version: 11.2.0
-  resolution: "fs-extra@npm:11.2.0"
-  dependencies:
-    graceful-fs: "npm:^4.2.0"
-    jsonfile: "npm:^6.0.1"
-    universalify: "npm:^2.0.0"
-  checksum: 10c0/d77a9a9efe60532d2e790e938c81a02c1b24904ef7a3efb3990b835514465ba720e99a6ea56fd5e2db53b4695319b644d76d5a0e9988a2beef80aa7b1da63398
-  languageName: node
-  linkType: hard
-
-"fs-extra@npm:~11.3.0":
+"fs-extra@npm:^11.1.0, fs-extra@npm:^11.1.1, fs-extra@npm:~11.3.0":
   version: 11.3.0
   resolution: "fs-extra@npm:11.3.0"
   dependencies:
@@ -4510,20 +4505,20 @@ __metadata:
   linkType: hard
 
 "get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6":
-  version: 1.2.6
-  resolution: "get-intrinsic@npm:1.2.6"
+  version: 1.3.0
+  resolution: "get-intrinsic@npm:1.3.0"
   dependencies:
-    call-bind-apply-helpers: "npm:^1.0.1"
-    dunder-proto: "npm:^1.0.0"
+    call-bind-apply-helpers: "npm:^1.0.2"
     es-define-property: "npm:^1.0.1"
     es-errors: "npm:^1.3.0"
-    es-object-atoms: "npm:^1.0.0"
+    es-object-atoms: "npm:^1.1.1"
     function-bind: "npm:^1.1.2"
+    get-proto: "npm:^1.0.1"
     gopd: "npm:^1.2.0"
     has-symbols: "npm:^1.1.0"
     hasown: "npm:^2.0.2"
-    math-intrinsics: "npm:^1.0.0"
-  checksum: 10c0/0f1ea6d807d97d074e8a31ac698213a12757fcfa9a8f4778263d2e4702c40fe83198aadd3dba2e99aabc2e4cf8a38345545dbb0518297d3df8b00b56a156c32a
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10c0/52c81808af9a8130f581e6a6a83e1ba4a9f703359e7a438d1369a5267a25412322f03dcbd7c549edaef0b6214a0630a28511d7df0130c93cfd380f4fa0b5b66a
   languageName: node
   linkType: hard
 
@@ -4555,6 +4550,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"get-proto@npm:^1.0.0, get-proto@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "get-proto@npm:1.0.1"
+  dependencies:
+    dunder-proto: "npm:^1.0.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10c0/9224acb44603c5526955e83510b9da41baf6ae73f7398875fba50edc5e944223a89c4a72b070fcd78beb5f7bdda58ecb6294adc28f7acfc0da05f76a2399643c
+  languageName: node
+  linkType: hard
+
 "get-stream@npm:6.0.0":
   version: 6.0.0
   resolution: "get-stream@npm:6.0.0"
@@ -4853,7 +4858,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"has-tostringtag@npm:^1.0.0, has-tostringtag@npm:^1.0.2":
+"has-tostringtag@npm:^1.0.2":
   version: 1.0.2
   resolution: "has-tostringtag@npm:1.0.2"
   dependencies:
@@ -5101,12 +5106,12 @@ __metadata:
   linkType: hard
 
 "import-fresh@npm:^3.2.1, import-fresh@npm:^3.3.0":
-  version: 3.3.0
-  resolution: "import-fresh@npm:3.3.0"
+  version: 3.3.1
+  resolution: "import-fresh@npm:3.3.1"
   dependencies:
     parent-module: "npm:^1.0.0"
     resolve-from: "npm:^4.0.0"
-  checksum: 10c0/7f882953aa6b740d1f0e384d0547158bc86efbf2eea0f1483b8900a6f65c5a5123c2cf09b0d542cc419d0b98a759ecaeb394237e97ea427f2da221dc3cd80cc3
+  checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec
   languageName: node
   linkType: hard
 
@@ -5269,7 +5274,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-callable@npm:^1.1.3":
+"is-callable@npm:^1.2.7":
   version: 1.2.7
   resolution: "is-callable@npm:1.2.7"
   checksum: 10c0/ceebaeb9d92e8adee604076971dd6000d38d6afc40bb843ea8e45c5579b57671c3f3b50d7f04869618242c6cee08d1b67806a8cb8edaaaf7c0748b3720d6066f
@@ -5288,11 +5293,11 @@ __metadata:
   linkType: hard
 
 "is-core-module@npm:^2.16.0, is-core-module@npm:^2.5.0, is-core-module@npm:^2.8.1":
-  version: 2.16.0
-  resolution: "is-core-module@npm:2.16.0"
+  version: 2.16.1
+  resolution: "is-core-module@npm:2.16.1"
   dependencies:
     hasown: "npm:^2.0.2"
-  checksum: 10c0/57e3b4bf3503a5ace3e61ef030a2eefa03d27827647b22968456e3e4befffed7c7aa849eea2e029f4f74a119a2d53cc391d5bad59c9352ecc9b79be3fd2acf79
+  checksum: 10c0/898443c14780a577e807618aaae2b6f745c8538eca5c7bc11388a3f2dc6de82b9902bcc7eb74f07be672b11bbe82dd6a6edded44a00cb3d8f933d0459905eedd
   languageName: node
   linkType: hard
 
@@ -5320,11 +5325,14 @@ __metadata:
   linkType: hard
 
 "is-generator-function@npm:^1.0.7":
-  version: 1.0.10
-  resolution: "is-generator-function@npm:1.0.10"
+  version: 1.1.0
+  resolution: "is-generator-function@npm:1.1.0"
   dependencies:
-    has-tostringtag: "npm:^1.0.0"
-  checksum: 10c0/df03514df01a6098945b5a0cfa1abff715807c8e72f57c49a0686ad54b3b74d394e2d8714e6f709a71eb00c9630d48e73ca1796c1ccc84ac95092c1fecc0d98b
+    call-bound: "npm:^1.0.3"
+    get-proto: "npm:^1.0.0"
+    has-tostringtag: "npm:^1.0.2"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10c0/fdfa96c8087bf36fc4cd514b474ba2ff404219a4dd4cfa6cf5426404a1eed259bdcdb98f082a71029a48d01f27733e3436ecc6690129a7ec09cb0434bee03a2a
   languageName: node
   linkType: hard
 
@@ -5409,12 +5417,24 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-regex@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-regex@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10c0/1d3715d2b7889932349241680032e85d0b492cfcb045acb75ffc2c3085e8d561184f1f7e84b6f8321935b4aea39bc9c6ba74ed595b57ce4881a51dfdbc214e04
+  languageName: node
+  linkType: hard
+
 "is-ssh@npm:^1.4.0":
-  version: 1.4.0
-  resolution: "is-ssh@npm:1.4.0"
+  version: 1.4.1
+  resolution: "is-ssh@npm:1.4.1"
   dependencies:
     protocols: "npm:^2.0.1"
-  checksum: 10c0/3eb30d1bcb4507cd25562e7ac61a1c0aa31772134c67cec9c3afe6f4d57ec17e8c2892600a608e8e583f32f53f36465b8968c0305f2855cfbff95acfd049e113
+  checksum: 10c0/021a7355cb032625d58db3cc8266ad9aa698cbabf460b71376a0307405577fd7d3aa0826c0bf1951d7809f134c0ee80403306f6d7633db94a5a3600a0106b398
   languageName: node
   linkType: hard
 
@@ -5449,11 +5469,11 @@ __metadata:
   linkType: hard
 
 "is-typed-array@npm:^1.1.3":
-  version: 1.1.14
-  resolution: "is-typed-array@npm:1.1.14"
+  version: 1.1.15
+  resolution: "is-typed-array@npm:1.1.15"
   dependencies:
     which-typed-array: "npm:^1.1.16"
-  checksum: 10c0/1dc1aee98fcdc016b941491f32327b6f651580efe8e0e0fe9a659f7f8a901c0047f9929de4fad08eb4a7f2b9ae42551c08fa054bfb6bfa16109e80b9abab66b2
+  checksum: 10c0/415511da3669e36e002820584e264997ffe277ff136643a3126cc949197e6ca3334d0f12d084e83b1994af2e9c8141275c741cf2b7da5a2ff62dd0cac26f76c4
   languageName: node
   linkType: hard
 
@@ -6412,11 +6432,11 @@ __metadata:
   linkType: hard
 
 "marked@npm:*":
-  version: 15.0.4
-  resolution: "marked@npm:15.0.4"
+  version: 15.0.7
+  resolution: "marked@npm:15.0.7"
   bin:
     marked: bin/marked.js
-  checksum: 10c0/e2bfd9178e5242cc814aaf8020f3c2e954c047652c498dac0732f4b711d5e3ab80dbc54b964799d80470d6c515a24905e554c4a40f87b05dedc26e4e36cfdfdb
+  checksum: 10c0/0b9d07bace37bbf0548bae356c4184765afa4d2296ed0be4418aa4bb0ce703f323dc1a475125d536581f9fe264797e6265dd0b57499d97c0fe0f29bc6d016343
   languageName: node
   linkType: hard
 
@@ -6429,10 +6449,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"math-intrinsics@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "math-intrinsics@npm:1.0.0"
-  checksum: 10c0/470ee2f267b4b3698eb9faa7f0bcf88696d87e2eeab25bba867dc676c09ddbae9b6f2e8ac7a2c1f0c9c2c5299c2a89f4f1f6d0e70d682725e2e7fca7507eef9f
+"math-intrinsics@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "math-intrinsics@npm:1.1.0"
+  checksum: 10c0/7579ff94e899e2f76ab64491d76cf606274c874d8f2af4a442c016bd85688927fcfca157ba6bf74b08e9439dc010b248ce05b96cc7c126a354c3bae7fcb48b7f
   languageName: node
   linkType: hard
 
@@ -6508,7 +6528,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"micromatch@npm:^4.0.4":
+"micromatch@npm:^4.0.8":
   version: 4.0.8
   resolution: "micromatch@npm:4.0.8"
   dependencies:
@@ -6959,7 +6979,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nanoid@npm:^3.3.7":
+"nanoid@npm:^3.3.8":
   version: 3.3.8
   resolution: "nanoid@npm:3.3.8"
   bin:
@@ -6968,10 +6988,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"napi-build-utils@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "napi-build-utils@npm:1.0.2"
-  checksum: 10c0/37fd2cd0ff2ad20073ce78d83fd718a740d568b225924e753ae51cb69d68f330c80544d487e5e5bd18e28702ed2ca469c2424ad948becd1862c1b0209542b2e9
+"napi-build-utils@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "napi-build-utils@npm:2.0.0"
+  checksum: 10c0/5833aaeb5cc5c173da47a102efa4680a95842c13e0d9cc70428bd3ee8d96bb2172f8860d2811799b5daa5cbeda779933601492a2028a6a5351c6d0fcf6de83db
   languageName: node
   linkType: hard
 
@@ -7031,11 +7051,11 @@ __metadata:
   linkType: hard
 
 "node-abi@npm:^3.3.0":
-  version: 3.71.0
-  resolution: "node-abi@npm:3.71.0"
+  version: 3.74.0
+  resolution: "node-abi@npm:3.74.0"
   dependencies:
     semver: "npm:^7.3.5"
-  checksum: 10c0/dbd0792ea729329cd9d099f28a5681ff9e8a6db48cf64e1437bf6a7fd669009d1e758a784619a1c4cc8bfd1ed17162f042c787654edf19a1f64b5018457c9c1f
+  checksum: 10c0/a6c83c448d5e8b591f749a0157c9ec02f653021cdf3415c1a44fcb5fc8afc124acad186bc1ec76cb4db2485cc2dcdda187aacd382c54b6e3093ffc0389603643
   languageName: node
   linkType: hard
 
@@ -7109,8 +7129,8 @@ __metadata:
   linkType: hard
 
 "node-gyp@npm:latest":
-  version: 11.0.0
-  resolution: "node-gyp@npm:11.0.0"
+  version: 11.1.0
+  resolution: "node-gyp@npm:11.1.0"
   dependencies:
     env-paths: "npm:^2.2.0"
     exponential-backoff: "npm:^3.1.1"
@@ -7124,7 +7144,7 @@ __metadata:
     which: "npm:^5.0.0"
   bin:
     node-gyp: bin/node-gyp.js
-  checksum: 10c0/a3b885bbee2d271f1def32ba2e30ffcf4562a3db33af06b8b365e053153e2dd2051b9945783c3c8e852d26a0f20f65b251c7e83361623383a99635c0280ee573
+  checksum: 10c0/c38977ce502f1ea41ba2b8721bd5b49bc3d5b3f813eabfac8414082faf0620ccb5211e15c4daecc23ed9f5e3e9cc4da00e575a0bcfc2a95a069294f2afa1e0cd
   languageName: node
   linkType: hard
 
@@ -7175,13 +7195,13 @@ __metadata:
   linkType: hard
 
 "nopt@npm:^8.0.0":
-  version: 8.0.0
-  resolution: "nopt@npm:8.0.0"
+  version: 8.1.0
+  resolution: "nopt@npm:8.1.0"
   dependencies:
-    abbrev: "npm:^2.0.0"
+    abbrev: "npm:^3.0.0"
   bin:
     nopt: bin/nopt.js
-  checksum: 10c0/19cb986f79abaca2d0f0b560021da7b32ee6fcc3de48f3eaeb0c324d36755c17754f886a754c091f01f740c17caf7d6aea8237b7fbaf39f476ae5e30a249f18f
+  checksum: 10c0/62e9ea70c7a3eb91d162d2c706b6606c041e4e7b547cbbb48f8b3695af457dd6479904d7ace600856bf923dd8d1ed0696f06195c8c20f02ac87c1da0e1d315ef
   languageName: node
   linkType: hard
 
@@ -7512,9 +7532,9 @@ __metadata:
   linkType: hard
 
 "object-inspect@npm:^1.13.3":
-  version: 1.13.3
-  resolution: "object-inspect@npm:1.13.3"
-  checksum: 10c0/cc3f15213406be89ffdc54b525e115156086796a515410a8d390215915db9f23c8eab485a06f1297402f440a33715fe8f71a528c1dcbad6e1a3bcaf5a46921d4
+  version: 1.13.4
+  resolution: "object-inspect@npm:1.13.4"
+  checksum: 10c0/d7f8711e803b96ea3191c745d6f8056ce1f2496e530e6a19a0e92d89b0fa3c76d910c31f0aa270432db6bd3b2f85500a376a83aaba849a8d518c8845b3211692
   languageName: node
   linkType: hard
 
@@ -7874,11 +7894,11 @@ __metadata:
   linkType: hard
 
 "parse-path@npm:^7.0.0":
-  version: 7.0.0
-  resolution: "parse-path@npm:7.0.0"
+  version: 7.0.1
+  resolution: "parse-path@npm:7.0.1"
   dependencies:
     protocols: "npm:^2.0.0"
-  checksum: 10c0/e7646f6b998b083bbd40102643d803557ce4ae18ae1704e6cc7ae2525ea7c5400f4a3635aca3244cfe65ce4dd0ff77db1142dde4d080e8a80c364c4b3e8fe8d2
+  checksum: 10c0/687804bbd216bf45f3942a5a0a3cd74da0eb9cdaf40d32020fa05a590b3c84c985bab0dc18cb13569db4cf3294c560d3a657be06698c323b32423210e488164b
   languageName: node
   linkType: hard
 
@@ -8001,7 +8021,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"picocolors@npm:^1.0.0, picocolors@npm:^1.1.0, picocolors@npm:^1.1.1":
+"picocolors@npm:^1.0.0, picocolors@npm:^1.1.1":
   version: 1.1.1
   resolution: "picocolors@npm:1.1.1"
   checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58
@@ -8060,33 +8080,33 @@ __metadata:
   linkType: hard
 
 "possible-typed-array-names@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "possible-typed-array-names@npm:1.0.0"
-  checksum: 10c0/d9aa22d31f4f7680e20269db76791b41c3a32c01a373e25f8a4813b4d45f7456bfc2b6d68f752dc4aab0e0bb0721cb3d76fb678c9101cb7a16316664bc2c73fd
+  version: 1.1.0
+  resolution: "possible-typed-array-names@npm:1.1.0"
+  checksum: 10c0/c810983414142071da1d644662ce4caebce890203eb2bc7bf119f37f3fe5796226e117e6cca146b521921fa6531072674174a3325066ac66fce089a53e1e5196
   languageName: node
   linkType: hard
 
 "postcss@npm:^8.3.11":
-  version: 8.4.49
-  resolution: "postcss@npm:8.4.49"
+  version: 8.5.3
+  resolution: "postcss@npm:8.5.3"
   dependencies:
-    nanoid: "npm:^3.3.7"
+    nanoid: "npm:^3.3.8"
     picocolors: "npm:^1.1.1"
     source-map-js: "npm:^1.2.1"
-  checksum: 10c0/f1b3f17aaf36d136f59ec373459f18129908235e65dbdc3aee5eef8eba0756106f52de5ec4682e29a2eab53eb25170e7e871b3e4b52a8f1de3d344a514306be3
+  checksum: 10c0/b75510d7b28c3ab728c8733dd01538314a18c52af426f199a3c9177e63eb08602a3938bfb66b62dc01350b9aed62087eabbf229af97a1659eb8d3513cec823b3
   languageName: node
   linkType: hard
 
 "prebuild-install@npm:^7.1.2":
-  version: 7.1.2
-  resolution: "prebuild-install@npm:7.1.2"
+  version: 7.1.3
+  resolution: "prebuild-install@npm:7.1.3"
   dependencies:
     detect-libc: "npm:^2.0.0"
     expand-template: "npm:^2.0.3"
     github-from-package: "npm:0.0.0"
     minimist: "npm:^1.2.3"
     mkdirp-classic: "npm:^0.5.3"
-    napi-build-utils: "npm:^1.0.1"
+    napi-build-utils: "npm:^2.0.0"
     node-abi: "npm:^3.3.0"
     pump: "npm:^3.0.0"
     rc: "npm:^1.2.7"
@@ -8095,7 +8115,7 @@ __metadata:
     tunnel-agent: "npm:^0.6.0"
   bin:
     prebuild-install: bin.js
-  checksum: 10c0/e64868ba9ef2068fd7264f5b03e5298a901e02a450acdb1f56258d88c09dea601eefdb3d1dfdff8513fdd230a92961712be0676192626a3b4d01ba154d48bdd3
+  checksum: 10c0/25919a42b52734606a4036ab492d37cfe8b601273d8dfb1fa3c84e141a0a475e7bad3ab848c741d2f810cef892fcf6059b8c7fe5b29f98d30e0c29ad009bedff
   languageName: node
   linkType: hard
 
@@ -8184,9 +8204,9 @@ __metadata:
   linkType: hard
 
 "protocols@npm:^2.0.0, protocols@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "protocols@npm:2.0.1"
-  checksum: 10c0/016cc58a596e401004a028a2f7005e3444bf89ee8f606409c411719374d1e8bba0464fc142a065cce0d19f41669b2f7ffe25a8bde4f16ce3b6eb01fabc51f2e7
+  version: 2.0.2
+  resolution: "protocols@npm:2.0.2"
+  checksum: 10c0/b87d78c1fcf038d33691da28447ce94011d5c7f0c7fd25bcb5fb4d975991c99117873200c84f4b6a9d7f8b9092713a064356236960d1473a7d6fcd4228897b60
   languageName: node
   linkType: hard
 
@@ -8580,28 +8600,28 @@ __metadata:
   linkType: hard
 
 "resolve@npm:^1.10.0, resolve@npm:^1.22.1, resolve@npm:~1.22.1, resolve@npm:~1.22.2":
-  version: 1.22.9
-  resolution: "resolve@npm:1.22.9"
+  version: 1.22.10
+  resolution: "resolve@npm:1.22.10"
   dependencies:
     is-core-module: "npm:^2.16.0"
     path-parse: "npm:^1.0.7"
     supports-preserve-symlinks-flag: "npm:^1.0.0"
   bin:
     resolve: bin/resolve
-  checksum: 10c0/314cea2c47f956743f106256854203bd43a60a3ec6fb85ee6894e75cf4b16004952e4280319bfeb4c6fb1246e3ecd27f2699abb2e2b316b7c5727ec6491505c9
+  checksum: 10c0/8967e1f4e2cc40f79b7e080b4582b9a8c5ee36ffb46041dccb20e6461161adf69f843b43067b4a375de926a2cd669157e29a29578191def399dd5ef89a1b5203
   languageName: node
   linkType: hard
 
 "resolve@patch:resolve@npm%3A^1.10.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.1#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A~1.22.1#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A~1.22.2#optional!builtin<compat/resolve>":
-  version: 1.22.9
-  resolution: "resolve@patch:resolve@npm%3A1.22.9#optional!builtin<compat/resolve>::version=1.22.9&hash=c3c19d"
+  version: 1.22.10
+  resolution: "resolve@patch:resolve@npm%3A1.22.10#optional!builtin<compat/resolve>::version=1.22.10&hash=c3c19d"
   dependencies:
     is-core-module: "npm:^2.16.0"
     path-parse: "npm:^1.0.7"
     supports-preserve-symlinks-flag: "npm:^1.0.0"
   bin:
     resolve: bin/resolve
-  checksum: 10c0/dadd8c85040784fdc18d6edc0cc27f7f35776c5d904b030ea67485ab9a5607568187afcfaf157e6fa9db9274481d155356bc42ca578c5578be25965b880d1e80
+  checksum: 10c0/52a4e505bbfc7925ac8f4cd91fd8c4e096b6a89728b9f46861d3b405ac9a1ccf4dcbf8befb4e89a2e11370dacd0160918163885cbc669369590f2f31f4c58939
   languageName: node
   linkType: hard
 
@@ -8633,9 +8653,9 @@ __metadata:
   linkType: hard
 
 "reusify@npm:^1.0.4":
-  version: 1.0.4
-  resolution: "reusify@npm:1.0.4"
-  checksum: 10c0/c19ef26e4e188f408922c46f7ff480d38e8dfc55d448310dfb518736b23ed2c4f547fb64a6ed5bdba92cd7e7ddc889d36ff78f794816d5e71498d645ef476107
+  version: 1.1.0
+  resolution: "reusify@npm:1.1.0"
+  checksum: 10c0/4eff0d4a5f9383566c7d7ec437b671cc51b25963bd61bf127c3f3d3f68e44a026d99b8d2f1ad344afff8d278a8fe70a8ea092650a716d22287e8bef7126bb2fa
   languageName: node
   linkType: hard
 
@@ -8729,11 +8749,11 @@ __metadata:
   linkType: hard
 
 "rxjs@npm:^7.5.5":
-  version: 7.8.1
-  resolution: "rxjs@npm:7.8.1"
+  version: 7.8.2
+  resolution: "rxjs@npm:7.8.2"
   dependencies:
     tslib: "npm:^2.1.0"
-  checksum: 10c0/3c49c1ecd66170b175c9cacf5cef67f8914dcbc7cd0162855538d365c83fea631167cacb644b3ce533b2ea0e9a4d0b12175186985f89d75abe73dbd8f7f06f68
+  checksum: 10c0/1fcd33d2066ada98ba8f21fcbbcaee9f0b271de1d38dc7f4e256bfbc6ffcdde68c8bfb69093de7eeb46f24b1fb820620bf0223706cff26b4ab99a7ff7b2e2c45
   languageName: node
   linkType: hard
 
@@ -8751,6 +8771,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"safe-regex-test@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "safe-regex-test@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-regex: "npm:^1.2.1"
+  checksum: 10c0/f2c25281bbe5d39cddbbce7f86fca5ea9b3ce3354ea6cd7c81c31b006a5a9fff4286acc5450a3b9122c56c33eba69c56b9131ad751457b2b4a585825e6a10665
+  languageName: node
+  linkType: hard
+
 "safe-stable-stringify@npm:^2.3.1":
   version: 2.5.0
   resolution: "safe-stable-stringify@npm:2.5.0"
@@ -8832,11 +8863,11 @@ __metadata:
   linkType: hard
 
 "semver@npm:^7.0.0, semver@npm:^7.1.1, semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.3.8, semver@npm:^7.5.3, semver@npm:^7.5.4":
-  version: 7.6.3
-  resolution: "semver@npm:7.6.3"
+  version: 7.7.1
+  resolution: "semver@npm:7.7.1"
   bin:
     semver: bin/semver.js
-  checksum: 10c0/88f33e148b210c153873cb08cfe1e281d518aaa9a666d4d148add6560db5cd3c582f3a08ccb91f38d5f379ead256da9931234ed122057f40bb5766e65e58adaf
+  checksum: 10c0/fd603a6fb9c399c6054015433051bdbe7b99a940a8fb44b85c2b524c4004b023d7928d47cb22154f8d054ea7ee8597f586605e05b52047f048278e4ac56ae958
   languageName: node
   linkType: hard
 
@@ -9146,12 +9177,12 @@ __metadata:
   linkType: hard
 
 "socks@npm:^2.6.2, socks@npm:^2.8.3":
-  version: 2.8.3
-  resolution: "socks@npm:2.8.3"
+  version: 2.8.4
+  resolution: "socks@npm:2.8.4"
   dependencies:
     ip-address: "npm:^9.0.5"
     smart-buffer: "npm:^4.2.0"
-  checksum: 10c0/d54a52bf9325165770b674a67241143a3d8b4e4c8884560c4e0e078aace2a728dffc7f70150660f51b85797c4e1a3b82f9b7aa25e0a0ceae1a243365da5c51a7
+  checksum: 10c0/00c3271e233ccf1fb83a3dd2060b94cc37817e0f797a93c560b9a7a86c4a0ec2961fb31263bdd24a3c28945e24868b5f063cd98744171d9e942c513454b50ae5
   languageName: node
   linkType: hard
 
@@ -9231,9 +9262,9 @@ __metadata:
   linkType: hard
 
 "spdx-license-ids@npm:^3.0.0":
-  version: 3.0.20
-  resolution: "spdx-license-ids@npm:3.0.20"
-  checksum: 10c0/bdff7534fad6ef59be49becda1edc3fb7f5b3d6f296a715516ab9d972b8ad59af2c34b2003e01db8970d4c673d185ff696ba74c6b61d3bf327e2b3eac22c297c
+  version: 3.0.21
+  resolution: "spdx-license-ids@npm:3.0.21"
+  checksum: 10c0/ecb24c698d8496aa9efe23e0b1f751f8a7a89faedcdfcbfabae772b546c2db46ccde8f3bc447a238eb86bbcd4f73fea88720ef3b8394f7896381bec3d7736411
   languageName: node
   linkType: hard
 
@@ -10235,14 +10266,14 @@ __metadata:
   linkType: hard
 
 "tar-fs@npm:^2.0.0":
-  version: 2.1.1
-  resolution: "tar-fs@npm:2.1.1"
+  version: 2.1.2
+  resolution: "tar-fs@npm:2.1.2"
   dependencies:
     chownr: "npm:^1.1.1"
     mkdirp-classic: "npm:^0.5.2"
     pump: "npm:^3.0.0"
     tar-stream: "npm:^2.1.4"
-  checksum: 10c0/871d26a934bfb7beeae4c4d8a09689f530b565f79bd0cf489823ff0efa3705da01278160da10bb006d1a793fa0425cf316cec029b32a9159eacbeaff4965fb6d
+  checksum: 10c0/9c704bd4a53be7565caf34ed001d1428532457fe3546d8fc1233f0f0882c3d2403f8602e8046e0b0adeb31fe95336572a69fb28851a391523126b697537670fc
   languageName: node
   linkType: hard
 
@@ -10639,7 +10670,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.7.2, typescript@npm:>=3 < 6":
+"typescript@npm:5.7.2":
   version: 5.7.2
   resolution: "typescript@npm:5.7.2"
   bin:
@@ -10649,7 +10680,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.7.3":
+"typescript@npm:5.7.3, typescript@npm:>=3 < 6":
   version: 5.7.3
   resolution: "typescript@npm:5.7.3"
   bin:
@@ -10659,7 +10690,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A5.7.2#optional!builtin<compat/typescript>, typescript@patch:typescript@npm%3A>=3 < 6#optional!builtin<compat/typescript>":
+"typescript@patch:typescript@npm%3A5.7.2#optional!builtin<compat/typescript>":
   version: 5.7.2
   resolution: "typescript@patch:typescript@npm%3A5.7.2#optional!builtin<compat/typescript>::version=5.7.2&hash=5786d5"
   bin:
@@ -10669,7 +10700,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A5.7.3#optional!builtin<compat/typescript>":
+"typescript@patch:typescript@npm%3A5.7.3#optional!builtin<compat/typescript>, typescript@patch:typescript@npm%3A>=3 < 6#optional!builtin<compat/typescript>":
   version: 5.7.3
   resolution: "typescript@patch:typescript@npm%3A5.7.3#optional!builtin<compat/typescript>::version=5.7.3&hash=5786d5"
   bin:
@@ -10785,16 +10816,16 @@ __metadata:
   linkType: hard
 
 "update-browserslist-db@npm:^1.1.1":
-  version: 1.1.1
-  resolution: "update-browserslist-db@npm:1.1.1"
+  version: 1.1.2
+  resolution: "update-browserslist-db@npm:1.1.2"
   dependencies:
     escalade: "npm:^3.2.0"
-    picocolors: "npm:^1.1.0"
+    picocolors: "npm:^1.1.1"
   peerDependencies:
     browserslist: ">= 4.21.0"
   bin:
     update-browserslist-db: cli.js
-  checksum: 10c0/536a2979adda2b4be81b07e311bd2f3ad5e978690987956bc5f514130ad50cac87cd22c710b686d79731e00fbee8ef43efe5fcd72baa241045209195d43dcc80
+  checksum: 10c0/9cb353998d6d7d6ba1e46b8fa3db888822dd972212da4eda609d185eb5c3557a93fd59780ceb757afd4d84240518df08542736969e6a5d6d6ce2d58e9363aac6
   languageName: node
   linkType: hard
 
@@ -11012,15 +11043,16 @@ __metadata:
   linkType: hard
 
 "which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.2":
-  version: 1.1.16
-  resolution: "which-typed-array@npm:1.1.16"
+  version: 1.1.18
+  resolution: "which-typed-array@npm:1.1.18"
   dependencies:
     available-typed-arrays: "npm:^1.0.7"
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     for-each: "npm:^0.3.3"
-    gopd: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
     has-tostringtag: "npm:^1.0.2"
-  checksum: 10c0/a9075293200db4fbce7c24d52731843542c5a19edfc66e31aa2cbefa788b5caa7ef05008f6e60d2c38d8198add6b92d0ddc2937918c5c308be398b1ebd8721af
+  checksum: 10c0/0412f4a91880ca1a2a63056187c2e3de6b129b2b5b6c17bc3729f0f7041047ae48fb7424813e51506addb2c97320003ee18b8c57469d2cde37983ef62126143c
   languageName: node
   linkType: hard