msw 2.3.0-ws.rc-1 → 2.3.0-ws.rc-2

package/src/core/bypass.test.ts

@@ -45,3 +45,25 @@ it('returns bypassed request given request instance', async () => {
     'x-msw-intention': 'bypass',
   })
 })
+
+it('allows modifying the bypassed request instance', async () => {
+  const original = new Request('http://localhost/resource', {
+    method: 'POST',
+    body: 'hello world',
+  })
+  const request = bypass(original, {
+    method: 'PUT',
+    headers: { 'x-modified-header': 'yes' },
+  })
+
+  expect(request.method).toBe('PUT')
+  expect(Object.fromEntries(request.headers.entries())).toEqual({
+    'x-msw-intention': 'bypass',
+    'x-modified-header': 'yes',
+  })
+  expect(original.bodyUsed).toBe(false)
+  expect(request.bodyUsed).toBe(false)
+
+  expect(await request.text()).toBe('hello world')
+  expect(original.bodyUsed).toBe(false)
+})

package/src/core/bypass.ts

@@ -15,7 +15,15 @@ export type BypassRequestInput = string | URL | Request
  * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
  */
 export function bypass(input: BypassRequestInput, init?: RequestInit): Request {
-  const request = input instanceof Request ? input : new Request(input, init)
+  // Always create a new Request instance.
+  // This way, the "init" modifications will propagate
+  // to the bypass request instance automatically.
+  const request = new Request(
+    // If given a Request instance, clone it not to exhaust
+    // the original request's body.
+    input instanceof Request ? input.clone() : input,
+    init,
+  )
 
   invariant(
     !request.bodyUsed,

package/src/core/getResponse.ts

@@ -1,6 +1,6 @@
+import { createRequestId } from '@mswjs/interceptors'
 import type { RequestHandler } from './handlers/RequestHandler'
 import { executeHandlers } from './utils/executeHandlers'
-import { randomId } from './utils/internal/randomId'
 
 /**
  * Finds a response for the given request instance
@@ -15,7 +15,7 @@ export const getResponse = async (
 ): Promise<Response | undefined> => {
   const result = await executeHandlers({
     request,
-    requestId: randomId(),
+    requestId: createRequestId(),
     handlers,
   })
 

package/src/core/graphql.ts

@@ -31,7 +31,10 @@ export type GraphQLRequestHandler = <
     | GraphQLHandlerNameSelector
     | DocumentNode
     | TypedDocumentNode<Query, Variables>,
-  resolver: GraphQLResponseResolver<Query, Variables>,
+  resolver: GraphQLResponseResolver<
+    [Query] extends [never] ? GraphQLQuery : Query,
+    Variables
+  >,
   options?: RequestHandlerOptions,
 ) => GraphQLHandler
 
@@ -41,7 +44,7 @@ export type GraphQLResponseResolver<
 > = ResponseResolver<
   GraphQLResolverExtras<Variables>,
   null,
-  GraphQLResponseBody<Query>
+  GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>
 >
 
 function createScopedGraphQLHandler(
@@ -61,7 +64,7 @@ function createScopedGraphQLHandler(
 
 function createGraphQLOperationHandler(url: Path) {
   return <
-    Query extends Record<string, any>,
+    Query extends GraphQLQuery = GraphQLQuery,
     Variables extends GraphQLVariables = GraphQLVariables,
   >(
     resolver: ResponseResolver<

package/src/core/handlers/GraphQLHandler.test.ts

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
-import { encodeBuffer } from '@mswjs/interceptors'
+import { createRequestId, encodeBuffer } from '@mswjs/interceptors'
 import { OperationTypeNode, parse } from 'graphql'
 import {
   GraphQLHandler,
@@ -9,7 +9,6 @@ import {
   GraphQLResolverExtras,
   isDocumentNode,
 } from './GraphQLHandler'
-import { randomId } from '../utils/internal/randomId'
 import { HttpResponse } from '../HttpResponse'
 import { ResponseResolver } from './RequestHandler'
 
@@ -737,7 +736,7 @@ describe('run', () => {
         userId: 'abc-123',
       },
     })
-    const requestId = randomId()
+    const requestId = createRequestId()
     const result = await handler.run({ request, requestId })
 
     expect(result!.handler).toEqual(handler)
@@ -779,7 +778,7 @@ describe('run', () => {
     const request = createPostGraphQLRequest({
       query: LOGIN,
     })
-    const requestId = randomId()
+    const requestId = createRequestId()
     const result = await handler.run({ request, requestId })
 
     expect(result).toBeNull()
@@ -827,7 +826,7 @@ describe('request', () => {
         `,
     })
 
-    const requestId = randomId()
+    const requestId = createRequestId()
     await handler.run({ request, requestId })
 
     expect(matchAllResolver).toHaveBeenCalledTimes(1)

package/src/core/handlers/GraphQLHandler.ts

@@ -68,10 +68,13 @@ export interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
   variables?: Variables
 }
 
-export interface GraphQLResponseBody<BodyType extends DefaultBodyType> {
-  data?: BodyType | null
-  errors?: readonly Partial<GraphQLError>[] | null
-}
+export type GraphQLResponseBody<BodyType extends DefaultBodyType> =
+  | {
+      data?: BodyType | null
+      errors?: readonly Partial<GraphQLError>[] | null
+    }
+  | null
+  | undefined
 
 export function isDocumentNode(
   value: DocumentNode | any,

package/src/core/handlers/HttpHandler.test.ts

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment jsdom
  */
-import { randomId } from '../utils/internal/randomId'
+import { createRequestId } from '@mswjs/interceptors'
 import { HttpHandler, HttpRequestResolverExtras } from './HttpHandler'
 import { HttpResponse } from '..'
 import { ResponseResolver } from './RequestHandler'
@@ -152,7 +152,7 @@ describe('run', () => {
   test('returns a mocked response given a matching request', async () => {
     const handler = new HttpHandler('GET', '/user/:userId', resolver)
     const request = new Request(new URL('/user/abc-123', location.href))
-    const requestId = randomId()
+    const requestId = createRequestId()
     const result = await handler.run({ request, requestId })
 
     expect(result!.handler).toEqual(handler)
@@ -176,7 +176,7 @@ describe('run', () => {
     const handler = new HttpHandler('POST', '/login', resolver)
     const result = await handler.run({
       request: new Request(new URL('/users', location.href)),
-      requestId: randomId(),
+      requestId: createRequestId(),
     })
 
     expect(result).toBeNull()
@@ -186,7 +186,7 @@ describe('run', () => {
     const handler = new HttpHandler('GET', '/users', resolver)
     const result = await handler.run({
       request: new Request(new URL('/users', location.href)),
-      requestId: randomId(),
+      requestId: createRequestId(),
     })
 
     expect(result?.parsedResult?.match?.params).toEqual({})
@@ -207,7 +207,7 @@ describe('run', () => {
     const run = async () => {
       const result = await handler.run({
         request: new Request(new URL('/users', location.href)),
-        requestId: randomId(),
+        requestId: createRequestId(),
       })
       return result?.response?.text()
     }

package/src/core/handlers/HttpHandler.ts

@@ -102,7 +102,7 @@ export class HttpHandler extends RequestHandler<
     })
 
     devUtils.warn(
-      `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters in the response resolver function using "req.url.searchParams".`,
+      `Found a redundant usage of query parameters in the request handler URL for "${method} ${path}". Please match against a path instead and access query parameters using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/recipes/query-parameters`,
     )
   }
 

package/src/core/handlers/WebSocketHandler.ts

@@ -1,47 +1,41 @@
 import { Emitter } from 'strict-event-emitter'
-import type {
-  WebSocketClientConnection,
-  WebSocketServerConnection,
-} from '@mswjs/interceptors/WebSocket'
+import type { WebSocketConnectionData } from '@mswjs/interceptors/WebSocket'
 import {
   type Match,
   type Path,
   type PathParams,
   matchRequestUrl,
 } from '../utils/matching/matchRequestUrl'
+import { getCallFrame } from '../utils/internal/getCallFrame'
 
 type WebSocketHandlerParsedResult = {
   match: Match
 }
 
 export type WebSocketHandlerEventMap = {
-  connection: [
-    args: {
-      client: WebSocketClientConnection
-      server: WebSocketServerConnection
-      params: PathParams
-    },
-  ]
+  connection: [args: WebSocketHandlerConnection]
 }
 
-type WebSocketHandlerIncomingEvent = MessageEvent<{
-  client: WebSocketClientConnection
-  server: WebSocketServerConnection
-}>
+interface WebSocketHandlerConnection extends WebSocketConnectionData {
+  params: PathParams
+}
 
 export const kEmitter = Symbol('kEmitter')
 export const kDispatchEvent = Symbol('kDispatchEvent')
-export const kDefaultPrevented = Symbol('kDefaultPrevented')
+export const kSender = Symbol('kSender')
 
 export class WebSocketHandler {
+  public callFrame?: string
+
   protected [kEmitter]: Emitter<WebSocketHandlerEventMap>
 
   constructor(private readonly url: Path) {
     this[kEmitter] = new Emitter()
+    this.callFrame = getCallFrame(new Error())
   }
 
   public parse(args: {
-    event: WebSocketHandlerIncomingEvent
+    event: MessageEvent<WebSocketConnectionData>
   }): WebSocketHandlerParsedResult {
     const connection = args.event.data
     const match = matchRequestUrl(connection.client.url, this.url)
@@ -52,38 +46,26 @@ export class WebSocketHandler {
   }
 
   public predicate(args: {
-    event: WebSocketHandlerIncomingEvent
+    event: MessageEvent<WebSocketConnectionData>
     parsedResult: WebSocketHandlerParsedResult
   }): boolean {
     return args.parsedResult.match.matches
   }
 
-  async [kDispatchEvent](event: MessageEvent<any>): Promise<void> {
+  async [kDispatchEvent](
+    event: MessageEvent<WebSocketConnectionData>,
+  ): Promise<void> {
     const parsedResult = this.parse({ event })
-    const shouldIntercept = this.predicate({ event, parsedResult })
-
-    if (!shouldIntercept) {
-      return
-    }
-
-    // Account for other matching event handlers that've already prevented this event.
-    if (!Reflect.get(event, kDefaultPrevented)) {
-      // At this point, the WebSocket connection URL has matched the handler.
-      // Prevent the default behavior of establishing the connection as-is.
-      // Use internal symbol because we aren't actually dispatching this
-      // event. Events can only marked as cancelable and can be prevented
-      // when dispatched on an EventTarget.
-      Reflect.set(event, kDefaultPrevented, true)
-    }
-
     const connection = event.data
 
-    // Emit the connection event on the handler.
-    // This is what the developer adds listeners for.
-    this[kEmitter].emit('connection', {
+    const resolvedConnection: WebSocketHandlerConnection = {
       client: connection.client,
       server: connection.server,
       params: parsedResult.match.params || {},
-    })
+    }
+
+    // Emit the connection event on the handler.
+    // This is what the developer adds listeners for.
+    this[kEmitter].emit('connection', resolvedConnection)
   }
 }

package/src/core/index.ts

@@ -2,15 +2,19 @@ import { checkGlobals } from './utils/internal/checkGlobals'
 
 export { SetupApi } from './SetupApi'
 
-/* Request handlers */
+/* HTTP handlers */
 export { RequestHandler } from './handlers/RequestHandler'
 export { http } from './http'
 export { HttpHandler, HttpMethods } from './handlers/HttpHandler'
 export { graphql } from './graphql'
 export { GraphQLHandler } from './handlers/GraphQLHandler'
 
-/* WebSocket */
+/* WebSocket handler */
 export { ws } from './ws/ws'
+export {
+  WebSocketHandler,
+  type WebSocketHandlerEventMap,
+} from './handlers/WebSocketHandler'
 
 /* Utils */
 export { matchRequestUrl } from './utils/matching/matchRequestUrl'

package/src/core/typeUtils.ts

@@ -8,13 +8,19 @@ export type RequiredDeep<
 > = Type extends Fn
   ? Type
   : /**
-   * @note The "Fn" type satisfies the predicate below.
-   * It must always come first, before the Record check.
-   */
-  Type extends Record<string, any>
-  ? {
-      [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U>
-        ? NonNullable<Type[Key]>
-        : RequiredDeep<NonNullable<Type[Key]>, U>
-    }
-  : Type
+     * @note The "Fn" type satisfies the predicate below.
+     * It must always come first, before the Record check.
+     */
+    Type extends Record<string, any>
+    ? {
+        [Key in keyof Type]-?: NonNullable<Type[Key]> extends NonNullable<U>
+          ? NonNullable<Type[Key]>
+          : RequiredDeep<NonNullable<Type[Key]>, U>
+      }
+    : Type
+
+/**
+ * @fixme Remove this once TS 5.4 is the lowest supported version.
+ * Because "NoInfer" is a built-in type utility there.
+ */
+export type NoInfer<T> = [T][T extends any ? 0 : never]

package/src/core/utils/HttpResponse/decorators.ts

@@ -1,5 +1,6 @@
 import statuses from '@bundled-es-modules/statuses'
 import type { HttpResponseInit } from '../../HttpResponse'
+import { Headers as HeadersPolyfill } from 'headers-polyfill'
 
 const { message } = statuses
 
@@ -40,10 +41,13 @@ export function decorateResponse(
   // Cookie forwarding is only relevant in the browser.
   if (typeof document !== 'undefined') {
     // Write the mocked response cookies to the document.
-    // Note that Fetch API Headers will concatenate multiple "Set-Cookie"
-    // headers into a single comma-separated string, just as it does
-    // with any other multi-value headers.
-    const responseCookies = init.headers.get('Set-Cookie')?.split(',') || []
+    // Use `headers-polyfill` to get the Set-Cookie header value correctly.
+    // This is an alternative until TypeScript 5.2
+    // and Node.js v20 become the minimum supported version
+    // and getSetCookie in Headers can be used directly.
+    const responseCookies = HeadersPolyfill.prototype.getSetCookie.call(
+      init.headers,
+    )
 
     for (const cookieString of responseCookies) {
       // No need to parse the cookie headers because it's defined

package/src/core/utils/handleRequest.test.ts

@@ -2,12 +2,12 @@
  * @vitest-environment jsdom
  */
 import { Emitter } from 'strict-event-emitter'
+import { createRequestId } from '@mswjs/interceptors'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequestHandler } from '../handlers/RequestHandler'
 import { http } from '../http'
 import { handleRequest, HandleRequestOptions } from './handleRequest'
 import { RequiredDeep } from '../typeUtils'
-import { randomId } from './internal/randomId'
 import { HttpResponse } from '../HttpResponse'
 import { passthrough } from '../passthrough'
 
@@ -51,7 +51,7 @@ afterEach(() => {
 test('returns undefined for a request with the "x-msw-intention" header equal to "bypass"', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'), {
     headers: new Headers({
       'x-msw-intention': 'bypass',
@@ -97,7 +97,7 @@ test('does not bypass a request with "x-msw-intention" header set to arbitrary v
 
   const result = await handleRequest(
     request,
-    randomId(),
+    createRequestId(),
     handlers,
     options,
     emitter,
@@ -112,7 +112,7 @@ test('does not bypass a request with "x-msw-intention" header set to arbitrary v
 test('reports request as unhandled when it has no matching request handlers', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const handlers: Array<RequestHandler> = []
 
@@ -145,7 +145,7 @@ test('reports request as unhandled when it has no matching request handlers', as
 test('returns undefined on a request handler that returns no response', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const handlers: Array<RequestHandler> = [
     http.get('/user', () => {
@@ -184,7 +184,7 @@ test('returns undefined on a request handler that returns no response', async ()
 test('returns the mocked response for a request with a matching request handler', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const mockedResponse = HttpResponse.json({ firstName: 'John' })
   const handlers: Array<RequestHandler> = [
@@ -242,7 +242,7 @@ test('returns the mocked response for a request with a matching request handler'
 test('returns a transformed response if the "transformResponse" option is provided', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const mockedResponse = HttpResponse.json({ firstName: 'John' })
   const handlers: Array<RequestHandler> = [
@@ -325,7 +325,7 @@ test('returns a transformed response if the "transformResponse" option is provid
 it('returns undefined without warning on a passthrough request', async () => {
   const { emitter, events } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const handlers: Array<RequestHandler> = [
     http.get('/user', () => {
@@ -358,7 +358,7 @@ it('returns undefined without warning on a passthrough request', async () => {
 it('calls the handler with the requestId', async () => {
   const { emitter } = setup()
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request(new URL('http://localhost/user'))
   const handlerFn = vi.fn()
   const handlers: Array<RequestHandler> = [http.get('/user', handlerFn)]
@@ -390,7 +390,7 @@ it('marks the first matching one-time handler as used', async () => {
   })
   const handlers: Array<RequestHandler> = [oneTimeHandler, anotherHandler]
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request('http://localhost/resource')
   const firstResult = await handleRequest(
     request,
@@ -438,7 +438,7 @@ it('does not mark non-matching one-time handlers as used', async () => {
   )
   const handlers: Array<RequestHandler> = [oneTimeHandler, anotherHandler]
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const firstResult = await handleRequest(
     new Request('http://localhost/another'),
     requestId,
@@ -481,7 +481,7 @@ it('handles parallel requests with one-time handlers', async () => {
   })
   const handlers: Array<RequestHandler> = [oneTimeHandler, anotherHandler]
 
-  const requestId = randomId()
+  const requestId = createRequestId()
   const request = new Request('http://localhost/resource')
   const firstResultPromise = handleRequest(
     request,
@@ -526,7 +526,7 @@ describe('[Private] - resolutionContext - used for extensions', () => {
 
       const handlers: Array<RequestHandler> = [handler]
 
-      const requestId = randomId()
+      const requestId = createRequestId()
       const request = new Request(new URL('/resource', baseUrl))
       const response = await handleRequest(
         request,
@@ -555,7 +555,7 @@ describe('[Private] - resolutionContext - used for extensions', () => {
 
       const handlers: Array<RequestHandler> = [handler]
 
-      const requestId = randomId()
+      const requestId = createRequestId()
       const request = new Request(
         new URL('/resource', `http://not-the-base-url.com`),
       )

package/src/core/utils/handleRequest.ts

@@ -51,7 +51,7 @@ export async function handleRequest(
 ): Promise<Response | undefined> {
   emitter.emit('request:start', { request, requestId })
 
-  // Perform bypassed requests (i.e. issued via "ctx.fetch") as-is.
+  // Perform bypassed requests (i.e. wrapped in "bypass()") as-is.
   if (request.headers.get('x-msw-intention') === 'bypass') {
     emitter.emit('request:end', { request, requestId })
     handleRequestOptions?.onPassthroughResponse?.(request)

package/src/core/utils/handleWebSocketEvent.ts

@@ -1,45 +1,55 @@
+import type { WebSocketConnectionData } from '@mswjs/interceptors/lib/browser/interceptors/WebSocket'
 import { RequestHandler } from '../handlers/RequestHandler'
-import {
-  WebSocketHandler,
-  kDefaultPrevented,
-  kDispatchEvent,
-} from '../handlers/WebSocketHandler'
+import { WebSocketHandler, kDispatchEvent } from '../handlers/WebSocketHandler'
 import { webSocketInterceptor } from '../ws/webSocketInterceptor'
 
-export function handleWebSocketEvent(
-  getCurrentHandlers: () => Array<RequestHandler | WebSocketHandler>,
-) {
+interface HandleWebSocketEventOptions {
+  getHandlers: () => Array<RequestHandler | WebSocketHandler>
+  onMockedConnection: (connection: WebSocketConnectionData) => void
+  onPassthroughConnection: (onnection: WebSocketConnectionData) => void
+}
+
+export function handleWebSocketEvent(options: HandleWebSocketEventOptions) {
   webSocketInterceptor.on('connection', (connection) => {
-    const handlers = getCurrentHandlers()
+    const handlers = options.getHandlers()
 
     const connectionEvent = new MessageEvent('connection', {
       data: connection,
-      /**
-       * @note This message event should be marked as "cancelable"
-       * to have its default prevented using "event.preventDefault()".
-       * There's a bug in Node.js that breaks the "cancelable" flag.
-       * @see https://github.com/nodejs/node/issues/51767
-       */
     })
 
-    Object.defineProperty(connectionEvent, kDefaultPrevented, {
-      enumerable: false,
-      writable: true,
-      value: false,
-    })
+    // First, filter only those WebSocket handlers that
+    // match the "ws.link()" endpoint predicate. Don't dispatch
+    // anything yet so the logger can be attached to the connection
+    // before it potentially sends events.
+    const matchingHandlers = handlers.filter<WebSocketHandler>(
+      (handler): handler is WebSocketHandler => {
+        if (handler instanceof WebSocketHandler) {
+          return handler.predicate({
+            event: connectionEvent,
+            parsedResult: handler.parse({
+              event: connectionEvent,
+            }),
+          })
+        }
 
-    // Iterate over the handlers and forward the connection
-    // event to WebSocket event handlers. This is equivalent
-    // to dispatching that event onto multiple listeners.
-    for (const handler of handlers) {
-      if (handler instanceof WebSocketHandler) {
+        return false
+      },
+    )
+
+    if (matchingHandlers.length > 0) {
+      options?.onMockedConnection(connection)
+
+      // Iterate over the handlers and forward the connection
+      // event to WebSocket event handlers. This is equivalent
+      // to dispatching that event onto multiple listeners.
+      for (const handler of matchingHandlers) {
         handler[kDispatchEvent](connectionEvent)
       }
-    }
+    } else {
+      options?.onPassthroughConnection(connection)
 
-    // If none of the "ws" handlers matched,
-    // establish the WebSocket connection as-is.
-    if (!Reflect.get(connectionEvent, kDefaultPrevented)) {
+      // If none of the "ws" handlers matched,
+      // establish the WebSocket connection as-is.
       connection.server.connect()
       connection.client.addEventListener('message', (event) => {
         connection.server.send(event.data)

package/src/core/utils/internal/mergeRight.ts

@@ -8,20 +8,23 @@ export function mergeRight(
   left: Record<string, any>,
   right: Record<string, any>,
 ) {
-  return Object.entries(right).reduce((result, [key, rightValue]) => {
-    const leftValue = result[key]
+  return Object.entries(right).reduce(
+    (result, [key, rightValue]) => {
+      const leftValue = result[key]
 
-    if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
-      result[key] = leftValue.concat(rightValue)
-      return result
-    }
+      if (Array.isArray(leftValue) && Array.isArray(rightValue)) {
+        result[key] = leftValue.concat(rightValue)
+        return result
+      }
 
-    if (isObject(leftValue) && isObject(rightValue)) {
-      result[key] = mergeRight(leftValue, rightValue)
-      return result
-    }
+      if (isObject(leftValue) && isObject(rightValue)) {
+        result[key] = mergeRight(leftValue, rightValue)
+        return result
+      }
 
-    result[key] = rightValue
-    return result
-  }, Object.assign({}, left))
+      result[key] = rightValue
+      return result
+    },
+    Object.assign({}, left),
+  )
 }