@mswjs/interceptors 0.25.0 → 0.25.2

package/src/Interceptor.ts

@@ -1,6 +1,5 @@
 import { Logger } from '@open-draft/logger'
-import { Listener } from 'strict-event-emitter'
-import { AsyncEventEmitter } from './utils/AsyncEventEmitter'
+import { Emitter, EventMap, Listener } from 'strict-event-emitter'
 
 export type InterceptorEventMap = Record<string, any>
 export type InterceptorSubscription = () => void
@@ -34,7 +33,7 @@ export type ExtractEventNames<Events extends Record<string, any>> =
   Events extends Record<infer EventName, any> ? EventName : never
 
 export class Interceptor<Events extends InterceptorEventMap> {
-  protected emitter: AsyncEventEmitter<Events>
+  protected emitter: Emitter<Events>
   protected subscriptions: Array<InterceptorSubscription>
   protected logger: Logger
 
@@ -43,7 +42,7 @@ export class Interceptor<Events extends InterceptorEventMap> {
   constructor(private readonly symbol: symbol) {
     this.readyState = InterceptorReadyState.INACTIVE
 
-    this.emitter = new AsyncEventEmitter()
+    this.emitter = new Emitter()
     this.subscriptions = []
     this.logger = new Logger(symbol.description!)
 
@@ -84,12 +83,6 @@ export class Interceptor<Events extends InterceptorEventMap> {
 
     this.readyState = InterceptorReadyState.APPLYING
 
-    // Always activate the emitter when applying the interceptor.
-    // This will ensure the interceptor can process events after it's
-    // been disposed and re-applied again (it may be a singleton).
-    this.emitter.activate()
-    logger.info('activated the emiter!', this.emitter.readyState)
-
     // Whenever applying a new interceptor, check if it hasn't been applied already.
     // This enables to apply the same interceptor multiple times, for example from a different
     // interceptor, only proxying events but keeping the stubs in a single place.
@@ -112,6 +105,8 @@ export class Interceptor<Events extends InterceptorEventMap> {
           runningInstance.emitter.removeListener(event, listener)
           logger.info('removed proxied "%s" listener!', event)
         })
+
+        return this
       }
 
       this.readyState = InterceptorReadyState.APPLIED
@@ -141,9 +136,9 @@ export class Interceptor<Events extends InterceptorEventMap> {
    * Listen to the interceptor's public events.
    */
   public on<EventName extends ExtractEventNames<Events>>(
-    eventName: EventName,
+    event: EventName,
     listener: Listener<Events[EventName]>
-  ): void {
+  ): this {
     const logger = this.logger.extend('on')
 
     if (
@@ -151,12 +146,36 @@ export class Interceptor<Events extends InterceptorEventMap> {
       this.readyState === InterceptorReadyState.DISPOSED
     ) {
       logger.info('cannot listen to events, already disposed!')
-      return
+      return this
     }
 
-    logger.info('adding "%s" event listener:', eventName, listener.name)
+    logger.info('adding "%s" event listener:', event, listener.name)
+
+    this.emitter.on(event, listener)
+    return this
+  }
+
+  public once<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    this.emitter.once(event, listener)
+    return this
+  }
+
+  public off<EventName extends ExtractEventNames<Events>>(
+    event: EventName,
+    listener: Listener<Events[EventName]>
+  ): this {
+    this.emitter.off(event, listener)
+    return this
+  }
 
-    this.emitter.on(eventName, listener)
+  public removeAllListeners<EventName extends ExtractEventNames<Events>>(
+    event?: EventName
+  ): this {
+    this.emitter.removeAllListeners(event)
+    return this
   }
 
   /**
@@ -196,7 +215,7 @@ export class Interceptor<Events extends InterceptorEventMap> {
       logger.info('disposed of all subscriptions!', this.subscriptions.length)
     }
 
-    this.emitter.deactivate()
+    this.emitter.removeAllListeners()
     logger.info('destroyed the listener!')
 
     this.readyState = InterceptorReadyState.DISPOSED

package/src/RemoteHttpInterceptor.ts

@@ -5,6 +5,7 @@ import { BatchInterceptor } from './BatchInterceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
 import { toInteractiveRequest } from './utils/toInteractiveRequest'
+import { emitAsync } from './utils/emitAsync'
 
 export interface SerializedRequest {
   id: string
@@ -166,20 +167,21 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
         body: requestJson.body,
       })
 
-      const interactiveRequest = toInteractiveRequest(capturedRequest)
+      const { interactiveRequest, requestController } =
+        toInteractiveRequest(capturedRequest)
 
-      this.emitter.emit('request', {
+      this.emitter.once('request', () => {
+        if (requestController.responsePromise.state === 'pending') {
+          requestController.respondWith(undefined)
+        }
+      })
+
+      await emitAsync(this.emitter, 'request', {
         request: interactiveRequest,
         requestId: requestJson.id,
       })
 
-      await this.emitter.untilIdle(
-        'request',
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          return pendingRequestId === requestJson.id
-        }
-      )
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked()
+      const mockedResponse = await requestController.responsePromise
 
       if (!mockedResponse) {
         return

package/src/interceptors/ClientRequest/NodeClientRequest.test.ts

@@ -1,13 +1,13 @@
 import { vi, it, expect, beforeAll, afterAll } from 'vitest'
 import express from 'express'
 import { IncomingMessage } from 'http'
+import { Emitter } from 'strict-event-emitter'
 import { Logger } from '@open-draft/logger'
 import { HttpServer } from '@open-draft/test-server/http'
 import { DeferredPromise } from '@open-draft/deferred-promise'
 import { NodeClientRequest } from './NodeClientRequest'
 import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { sleep } from '../../../test/helpers'
 import { HttpRequestEventMap } from '../../glossary'
 
@@ -37,7 +37,7 @@ afterAll(async () => {
 })
 
 it('gracefully finishes the request when it has a mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://any.thing', {
       method: 'PUT',
@@ -88,7 +88,7 @@ it('gracefully finishes the request when it has a mocked response', async () =>
 })
 
 it('responds with a mocked response when requesting an existing hostname', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/comment')),
     {
@@ -116,7 +116,7 @@ it('responds with a mocked response when requesting an existing hostname', async
 })
 
 it('performs the request as-is given resolver returned no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/comment'), {
       method: 'POST',
@@ -147,7 +147,7 @@ it('performs the request as-is given resolver returned no mocked response', asyn
 })
 
 it('emits the ENOTFOUND error connecting to a non-existing hostname given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
     { emitter, logger }
@@ -165,7 +165,7 @@ it('emits the ENOTFOUND error connecting to a non-existing hostname given no moc
 })
 
 it('emits the ECONNREFUSED error connecting to an inactive server given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://127.0.0.1:12345'),
     {
@@ -191,7 +191,7 @@ it('emits the ECONNREFUSED error connecting to an inactive server given no mocke
 })
 
 it('does not emit ENOTFOUND error connecting to an inactive server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const handleError = vi.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
@@ -221,7 +221,7 @@ it('does not emit ENOTFOUND error connecting to an inactive server given mocked
 })
 
 it('does not emit ECONNREFUSED error connecting to an inactive server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const handleError = vi.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://localhost:9876'),
@@ -253,7 +253,7 @@ it('does not emit ECONNREFUSED error connecting to an inactive server given mock
 })
 
 it('sends the request body to the server given no mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',
@@ -284,7 +284,7 @@ it('sends the request body to the server given no mocked response', async () =>
 })
 
 it('does not send request body to the original server given mocked response', async () => {
-  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+  const emitter = new Emitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',

package/src/interceptors/ClientRequest/NodeClientRequest.ts

@@ -1,6 +1,7 @@
 import { ClientRequest, IncomingMessage } from 'http'
 import type { Logger } from '@open-draft/logger'
 import { until } from '@open-draft/until'
+import { DeferredPromise } from '@open-draft/deferred-promise'
 import type { ClientRequestEmitter } from '.'
 import {
   ClientRequestEndCallback,
@@ -17,7 +18,7 @@ import { createResponse } from './utils/createResponse'
 import { createRequest } from './utils/createRequest'
 import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
 import { uuidv4 } from '../../utils/uuid'
-import { DeferredPromise } from '@open-draft/deferred-promise'
+import { emitAsync } from '../../utils/emitAsync'
 
 export type Protocol = 'http' | 'https'
 
@@ -138,7 +139,17 @@ export class NodeClientRequest extends ClientRequest {
     this.writeRequestBodyChunk(chunk, encoding || undefined)
 
     const capturedRequest = createRequest(this)
-    const interactiveRequest = toInteractiveRequest(capturedRequest)
+    const { interactiveRequest, requestController } =
+      toInteractiveRequest(capturedRequest)
+
+    /**
+     * @todo Remove this modification of the original request
+     * and expose the controller alongside it in the "request"
+     * listener argument.
+     */
+    Object.defineProperty(capturedRequest, 'respondWith', {
+      value: requestController.respondWith.bind(requestController),
+    })
 
     // Prevent handling this request if it has already been handled
     // in another (parent) interceptor (like XMLHttpRequest -> ClientRequest).
@@ -155,28 +166,34 @@ export class NodeClientRequest extends ClientRequest {
       'emitting the "request" event for %d listener(s)...',
       this.emitter.listenerCount('request')
     )
-    this.emitter.emit('request', {
-      request: interactiveRequest,
-      requestId,
+
+    // Add the last "request" listener that always resolves
+    // the pending response Promise. This way if the consumer
+    // hasn't handled the request themselves, we will prevent
+    // the response Promise from pending indefinitely.
+    this.emitter.once('request', ({ requestId: pendingRequestId }) => {
+      /**
+       * @note Ignore request events emitted by irrelevant
+       * requests. This happens when response patching.
+       */
+      if (pendingRequestId !== requestId) {
+        return
+      }
+
+      if (requestController.responsePromise.state === 'pending') {
+        requestController.responsePromise.resolve(undefined)
+      }
     })
 
     // Execute the resolver Promise like a side-effect.
     // Node.js 16 forces "ClientRequest.end" to be synchronous and return "this".
     until(async () => {
-      await this.emitter.untilIdle(
-        'request',
-        ({ args: [{ requestId: pendingRequestId }] }) => {
-          /**
-           * @note Await only those listeners that are relevant to this request.
-           * This prevents extraneous parallel request from blocking the resolution
-           * of another, unrelated request. For example, during response patching,
-           * when request resolution is nested.
-           */
-          return pendingRequestId === requestId
-        }
-      )
+      await emitAsync(this.emitter, 'request', {
+        request: interactiveRequest,
+        requestId,
+      })
 
-      const [mockedResponse] = await interactiveRequest.respondWith.invoked()
+      const mockedResponse = await requestController.responsePromise
       this.logger.info('event.respondWith called with:', mockedResponse)
 
       return mockedResponse

package/src/interceptors/ClientRequest/index.test.ts

@@ -57,14 +57,13 @@ it('forbids calling "respondWith" multiple times for the same request', async ()
   expect(response.statusMessage).toBe('')
 })
 
-
 it('abort the request if the abort signal is emitted', async () => {
   const requestUrl = httpServer.http.url('/')
 
   const requestEmitted = new DeferredPromise<void>()
   interceptor.on('request', async function delayedResponse({ request }) {
     requestEmitted.resolve()
-    await sleep(10000)
+    await sleep(10_000)
     request.respondWith(new Response())
   })
 
@@ -76,7 +75,7 @@ it('abort the request if the abort signal is emitted', async () => {
   abortController.abort()
 
   const requestAborted = new DeferredPromise<void>()
-  request.on('error', function(err) {
+  request.on('error', function (err) {
     expect(err.name).toEqual('AbortError')
     requestAborted.resolve()
   })

package/src/interceptors/ClientRequest/index.ts

@@ -1,13 +1,13 @@
 import http from 'http'
 import https from 'https'
+import type { Emitter } from 'strict-event-emitter'
 import { HttpRequestEventMap } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
-import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { get } from './http.get'
 import { request } from './http.request'
 import { NodeClientOptions, Protocol } from './NodeClientRequest'
 
-export type ClientRequestEmitter = AsyncEventEmitter<HttpRequestEventMap>
+export type ClientRequestEmitter = Emitter<HttpRequestEventMap>
 
 export type ClientRequestModules = Map<Protocol, typeof http | typeof https>
 

package/src/interceptors/ClientRequest/utils/createRequest.test.ts

@@ -1,11 +1,11 @@
 import { it, expect } from 'vitest'
 import { Logger } from '@open-draft/logger'
 import { HttpRequestEventMap } from '../../..'
-import { AsyncEventEmitter } from '../../../utils/AsyncEventEmitter'
 import { NodeClientRequest } from '../NodeClientRequest'
 import { createRequest } from './createRequest'
+import { Emitter } from 'strict-event-emitter'
 
-const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
+const emitter = new Emitter<HttpRequestEventMap>()
 const logger = new Logger('test')
 
 it('creates a fetch Request with a JSON body', async () => {

package/src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts

@@ -2,6 +2,7 @@ import { until } from '@open-draft/until'
 import type { Logger } from '@open-draft/logger'
 import { XMLHttpRequestEmitter } from '.'
 import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
+import { emitAsync } from '../../utils/emitAsync'
 import { XMLHttpRequestController } from './XMLHttpRequestController'
 
 export interface XMLHttpRequestProxyOptions {
@@ -42,38 +43,41 @@ export function createXMLHttpRequestProxy({
         )
       }
 
-      const requestController = new XMLHttpRequestController(
+      const xhrRequestController = new XMLHttpRequestController(
         originalRequest,
         logger
       )
 
-      requestController.onRequest = async function ({ request, requestId }) {
-        // Notify the consumer about a new request.
-        const interactiveRequest = toInteractiveRequest(request)
-
-        this.logger.info(
-          'emitting the "request" event for %s listener(s)...',
-          emitter.listenerCount('request')
-        )
-        emitter.emit('request', {
-          request: interactiveRequest,
-          requestId,
-        })
+      xhrRequestController.onRequest = async function ({ request, requestId }) {
+        const { interactiveRequest, requestController } =
+          toInteractiveRequest(request)
 
         this.logger.info('awaiting mocked response...')
 
+        emitter.once('request', ({ requestId: pendingRequestId }) => {
+          if (pendingRequestId !== requestId) {
+            return
+          }
+
+          if (requestController.responsePromise.state === 'pending') {
+            requestController.respondWith(undefined)
+          }
+        })
+
         const resolverResult = await until(async () => {
-          await emitter.untilIdle(
-            'request',
-            ({ args: [{ requestId: pendingRequestId }] }) => {
-              return pendingRequestId === requestId
-            }
+          this.logger.info(
+            'emitting the "request" event for %s listener(s)...',
+            emitter.listenerCount('request')
           )
 
+          await emitAsync(emitter, 'request', {
+            request: interactiveRequest,
+            requestId,
+          })
+
           this.logger.info('all "request" listeners settled!')
 
-          const [mockedResponse] =
-            await interactiveRequest.respondWith.invoked()
+          const mockedResponse = await requestController.responsePromise
 
           this.logger.info('event.respondWith called with:', mockedResponse)
 
@@ -91,7 +95,7 @@ export function createXMLHttpRequestProxy({
            * since not all consumers are expecting to handle errors.
            * If they don't, this error will be swallowed.
            */
-          requestController.errorWith(resolverResult.error)
+          xhrRequestController.errorWith(resolverResult.error)
           return
         }
 
@@ -109,11 +113,11 @@ export function createXMLHttpRequestProxy({
               'received a network error response, rejecting the request promise...'
             )
 
-            requestController.errorWith(new TypeError('Network error'))
+            xhrRequestController.errorWith(new TypeError('Network error'))
             return
           }
 
-          return requestController.respondWith(mockedResponse)
+          return xhrRequestController.respondWith(mockedResponse)
         }
 
         this.logger.info(
@@ -121,7 +125,7 @@ export function createXMLHttpRequestProxy({
         )
       }
 
-      requestController.onResponse = async function ({
+      xhrRequestController.onResponse = async function ({
         response,
         isMockedResponse,
         request,
@@ -143,7 +147,7 @@ export function createXMLHttpRequestProxy({
       // Return the proxied request from the controller
       // so that the controller can react to the consumer's interactions
       // with this request (opening/sending/etc).
-      return requestController.request
+      return xhrRequestController.request
     },
   })
 

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,8 +1,8 @@
 import { invariant } from 'outvariant'
+import { Emitter } from 'strict-event-emitter'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
 import { InteractiveRequest } from '../../utils/toInteractiveRequest'
 import { Interceptor } from '../../Interceptor'
-import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
 
 export type XMLHttpRequestEventListener = (args: {
@@ -10,7 +10,7 @@ export type XMLHttpRequestEventListener = (args: {
   requestId: string
 }) => Promise<void> | void
 
-export type XMLHttpRequestEmitter = AsyncEventEmitter<HttpRequestEventMap>
+export type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>
 
 export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {
   static interceptorSymbol = Symbol('xhr')

package/src/interceptors/fetch/index.ts

@@ -1,10 +1,11 @@
-import { DeferredPromise } from '@open-draft/deferred-promise'
 import { invariant } from 'outvariant'
+import { DeferredPromise } from '@open-draft/deferred-promise'
 import { until } from '@open-draft/until'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
 import { uuidv4 } from '../../utils/uuid'
 import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
+import { emitAsync } from '../../utils/emitAsync'
 
 export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol('fetch')
@@ -34,15 +35,22 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
 
       this.logger.info('[%s] %s', request.method, request.url)
 
-      const interactiveRequest = toInteractiveRequest(request)
+      const { interactiveRequest, requestController } =
+        toInteractiveRequest(request)
 
       this.logger.info(
         'emitting the "request" event for %d listener(s)...',
         this.emitter.listenerCount('request')
       )
-      this.emitter.emit('request', {
-        request: interactiveRequest,
-        requestId,
+
+      this.emitter.once('request', ({ requestId: pendingRequestId }) => {
+        if (pendingRequestId !== requestId) {
+          return
+        }
+
+        if (requestController.responsePromise.state === 'pending') {
+          requestController.responsePromise.resolve(undefined)
+        }
       })
 
       this.logger.info('awaiting for the mocked response...')
@@ -59,18 +67,23 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
       )
 
       const resolverResult = await until(async () => {
-        const allListenersResolved = this.emitter.untilIdle(
-          'request',
-          ({ args: [{ requestId: pendingRequestId }] }) => {
-            return pendingRequestId === requestId
-          }
-        )
+        const listenersFinished = emitAsync(this.emitter, 'request', {
+          request: interactiveRequest,
+          requestId,
+        })
 
-        await Promise.race([requestAborted, allListenersResolved])
+        await Promise.race([
+          requestAborted,
+          // Put the listeners invocation Promise in the same race condition
+          // with the request abort Promise because otherwise awaiting the listeners
+          // would always yield some response (or undefined).
+          listenersFinished,
+          requestController.responsePromise,
+        ])
 
         this.logger.info('all request listeners have been resolved!')
 
-        const [mockedResponse] = await interactiveRequest.respondWith.invoked()
+        const mockedResponse = await requestController.responsePromise
         this.logger.info('event.respondWith called with:', mockedResponse)
 
         return mockedResponse

package/src/utils/RequestController.ts

@@ -0,0 +1,21 @@
+import { invariant } from 'outvariant'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+
+export class RequestController {
+  public responsePromise: DeferredPromise<Response | undefined>
+
+  constructor(protected request: Request) {
+    this.responsePromise = new DeferredPromise()
+  }
+
+  public respondWith(response?: Response): void {
+    invariant(
+      this.responsePromise.state === 'pending',
+      'Failed to respond to "%s %s" request: the "request" event has already been responded to.',
+      this.request.method,
+      this.request.url
+    )
+
+    this.responsePromise.resolve(response)
+  }
+}

package/src/utils/emitAsync.ts

@@ -0,0 +1,25 @@
+import { Emitter, EventMap } from 'strict-event-emitter'
+
+/**
+ * Emits an event on the given emitter but executes
+ * the listeners sequentially. This accounts for asynchronous
+ * listeners (e.g. those having "sleep" and handling the request).
+ */
+export async function emitAsync<
+  Events extends EventMap,
+  EventName extends keyof Events
+>(
+  emitter: Emitter<Events>,
+  eventName: EventName,
+  ...data: Events[EventName]
+): Promise<void> {
+  const listners = emitter.listeners(eventName)
+
+  if (listners.length === 0) {
+    return
+  }
+
+  for (const listener of listners) {
+    await listener.apply(emitter, data)
+  }
+}