修改后台权限

node_modules/msw/lib/core/HttpResponse-Be4eT3x6.d.mts

@@ -0,0 +1,338 @@
+import { FetchResponse } from '@mswjs/interceptors';
+import { Iterable, AsyncIterable } from './utils/internal/isIterable.mjs';
+import { MaybePromise, NoInfer } from './typeUtils.mjs';
+import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
+import { Match, Path } from './utils/matching/matchRequestUrl.mjs';
+
+interface HandlersExecutionResult {
+    handler: RequestHandler;
+    parsedResult?: any;
+    response?: Response;
+}
+interface ResponseResolutionContext {
+    /**
+     * A base url to use when resolving relative urls.
+     * @note This is primarily used by the `@mswjs/http-middleware`
+     * to resolve relative urls in the context of the running server
+     */
+    baseUrl?: string;
+    quiet?: boolean;
+}
+/**
+ * Executes the list of request handlers against the given request.
+ * Returns the execution result object containing any matching request
+ * handler and any mocked response it returned.
+ */
+declare const executeHandlers: <Handlers extends Array<RequestHandler>>({ request, requestId, handlers, resolutionContext, }: {
+    request: Request;
+    requestId: string;
+    handlers: Handlers;
+    resolutionContext?: ResponseResolutionContext;
+}) => Promise<HandlersExecutionResult | null>;
+
+interface ParsedGraphQLQuery {
+    operationType: OperationTypeNode;
+    operationName?: string;
+}
+type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
+    query: string;
+    variables?: VariablesType;
+}) | undefined;
+declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
+type GraphQLParsedOperationsMap = Record<string, string[]>;
+type GraphQLMultipartRequestBody = {
+    operations: string;
+    map?: string;
+} & {
+    [fileName: string]: File;
+};
+/**
+ * Determines if a given request can be considered a GraphQL request.
+ * Does not parse the query and does not guarantee its validity.
+ */
+declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
+
+interface DocumentTypeDecoration<Result = {
+    [key: string]: any;
+}, Variables = {
+    [key: string]: any;
+}> {
+    __apiType?: (variables: Variables) => Result;
+    __resultType?: Result;
+    __variablesType?: Variables;
+}
+type GraphQLOperationType = OperationTypeNode | 'all';
+type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
+type GraphQLQuery = Record<string, any> | null;
+type GraphQLVariables = Record<string, any>;
+interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
+    operationType: GraphQLOperationType;
+    operationName: GraphQLHandlerNameSelector | GraphQLCustomPredicate;
+}
+type GraphQLRequestParsedResult = {
+    match: Match;
+    cookies: Record<string, string>;
+} & (ParsedGraphQLRequest<GraphQLVariables>
+/**
+ * An empty version of the ParsedGraphQLRequest
+ * which simplifies the return type of the resolver
+ * when the request is to a non-matching endpoint
+ */
+ | {
+    operationType?: undefined;
+    operationName?: undefined;
+    query?: undefined;
+    variables?: undefined;
+});
+type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
+    query: string;
+    operationName: string;
+    variables: Variables;
+    cookies: Record<string, string>;
+};
+type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
+interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
+    query: string;
+    variables?: Variables;
+}
+type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
+    data?: BodyType | null;
+    errors?: readonly Partial<GraphQLError>[] | null;
+    extensions?: Record<string, any>;
+} | null | undefined;
+type GraphQLCustomPredicate = (args: {
+    request: Request;
+    query: string;
+    operationType: GraphQLOperationType;
+    operationName: string;
+    variables: GraphQLVariables;
+    cookies: Record<string, string>;
+}) => GraphQLCustomPredicateResult | Promise<GraphQLCustomPredicateResult>;
+type GraphQLCustomPredicateResult = boolean | {
+    matches: boolean;
+};
+type GraphQLPredicate<Query = any, Variables = any> = GraphQLHandlerNameSelector | DocumentTypeDecoration<Query, Variables> | GraphQLCustomPredicate;
+declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
+declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
+    #private;
+    private endpoint;
+    static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
+    constructor(operationType: GraphQLOperationType, predicate: GraphQLPredicate, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    /**
+     * Parses the request body, once per request, cached across all
+     * GraphQL handlers. This is done to avoid multiple parsing of the
+     * request body, which each requires a clone of the request.
+     */
+    parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
+    parse(args: {
+        request: Request;
+    }): Promise<GraphQLRequestParsedResult>;
+    predicate(args: {
+        request: Request;
+        parsedResult: GraphQLRequestParsedResult;
+    }): Promise<boolean>;
+    run(args: {
+        request: StrictRequest<any>;
+        requestId: string;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<RequestHandlerExecutionResult<GraphQLRequestParsedResult> | null>;
+    private matchOperationName;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: GraphQLRequestParsedResult;
+    }): {
+        query: string;
+        operationType: OperationTypeNode;
+        operationName: string;
+        variables: GraphQLVariables;
+        cookies: Record<string, string>;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: GraphQLRequestParsedResult;
+    }): Promise<void>;
+}
+
+type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;
+type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
+type JsonBodyType = Record<string, any> | string | number | boolean | null | undefined;
+interface RequestHandlerDefaultInfo {
+    header: string;
+}
+interface RequestHandlerInternalInfo {
+    callFrame?: string;
+}
+type ResponseResolverReturnType<ResponseBodyType extends DefaultBodyType = undefined> = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends GraphQLRequestBody<any> ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse : HttpResponse<ResponseBodyType>) | undefined | void;
+type MaybeAsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>;
+type AsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType> | Iterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>> | AsyncIterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>>>;
+type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
+    request: StrictRequest<RequestBodyType>;
+    requestId: string;
+} & ResolverExtraInfo;
+type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;
+interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
+    info: HandlerInfo;
+    resolver: ResponseResolver<any>;
+    options?: HandlerOptions;
+}
+interface RequestHandlerOptions {
+    once?: boolean;
+}
+interface RequestHandlerExecutionResult<ParsedResult extends object | undefined> {
+    handler: RequestHandler;
+    parsedResult?: ParsedResult;
+    request: Request;
+    requestId: string;
+    response?: Response;
+}
+declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, ParsedResult extends Record<string, any> | undefined = any, ResolverExtras extends Record<string, unknown> = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> {
+    static cache: WeakMap<StrictRequest<DefaultBodyType>, StrictRequest<DefaultBodyType>>;
+    private readonly __kind;
+    info: HandlerInfo & RequestHandlerInternalInfo;
+    /**
+     * Indicates whether this request handler has been used
+     * (its resolver has successfully executed).
+     */
+    isUsed: boolean;
+    protected resolver: ResponseResolver<ResolverExtras, any, any>;
+    private resolverIterator?;
+    private resolverIteratorResult?;
+    private options?;
+    constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>);
+    /**
+     * Determine if the intercepted request should be mocked.
+     */
+    abstract predicate(args: {
+        request: Request;
+        parsedResult: ParsedResult;
+        resolutionContext?: ResponseResolutionContext;
+    }): boolean | Promise<boolean>;
+    /**
+     * Print out the successfully handled request.
+     */
+    abstract log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: ParsedResult;
+    }): void;
+    /**
+     * Parse the intercepted request to extract additional information from it.
+     * Parsed result is then exposed to other methods of this request handler.
+     */
+    parse(_args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<ParsedResult>;
+    /**
+     * Test if this handler matches the given request.
+     *
+     * This method is not used internally but is exposed
+     * as a convenience method for consumers writing custom
+     * handlers.
+     */
+    test(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<boolean>;
+    protected extendResolverArgs(_args: {
+        request: Request;
+        parsedResult: ParsedResult;
+    }): ResolverExtras;
+    private cloneRequestOrGetFromCache;
+    /**
+     * Execute this request handler and produce a mocked response
+     * using the given resolver function.
+     */
+    run(args: {
+        request: StrictRequest<any>;
+        requestId: string;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<RequestHandlerExecutionResult<ParsedResult> | null>;
+    private wrapResolver;
+    private createExecutionResult;
+}
+
+interface HttpResponseInit extends ResponseInit {
+    type?: ResponseType;
+}
+declare const bodyType: unique symbol;
+type DefaultUnsafeFetchResponse = Response & {
+    [bodyType]?: never;
+};
+interface StrictRequest<BodyType extends JsonBodyType> extends Request {
+    json(): Promise<BodyType>;
+    clone(): StrictRequest<BodyType>;
+}
+/**
+ * Opaque `Response` type that supports strict body type.
+ *
+ * @deprecated Please use {@link HttpResponse} instead.
+ */
+type StrictResponse<BodyType extends DefaultBodyType> = HttpResponse<BodyType>;
+declare const kDefaultContentType: unique symbol;
+/**
+ * A drop-in replacement for the standard `Response` class
+ * to allow additional features, like mocking the response `Set-Cookie` header.
+ *
+ * @example
+ * new HttpResponse('Hello world', { status: 201 })
+ * HttpResponse.json({ name: 'John' })
+ * HttpResponse.formData(form)
+ *
+ * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
+ */
+declare class HttpResponse<BodyType extends DefaultBodyType> extends FetchResponse {
+    readonly [bodyType]: BodyType;
+    constructor(body?: NoInfer<BodyType> | null, init?: HttpResponseInit);
+    static error(): HttpResponse<any>;
+    /**
+     * Create a `Response` with a `Content-Type: "text/plain"` body.
+     * @example
+     * HttpResponse.text('hello world')
+     * HttpResponse.text('Error', { status: 500 })
+     */
+    static text<BodyType extends string>(body?: NoInfer<BodyType> | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/json"` body.
+     * @example
+     * HttpResponse.json({ firstName: 'John' })
+     * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+     */
+    static json<BodyType extends JsonBodyType>(body?: NoInfer<BodyType> | null | undefined, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/xml"` body.
+     * @example
+     * HttpResponse.xml(`<user name="John" />`)
+     * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+     */
+    static xml<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "text/html"` body.
+     * @example
+     * HttpResponse.html(`<p class="author">Jane Doe</p>`)
+     * HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+     */
+    static html<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with an `ArrayBuffer` body.
+     * @example
+     * const buffer = new ArrayBuffer(3)
+     * const view = new Uint8Array(buffer)
+     * view.set([1, 2, 3])
+     *
+     * HttpResponse.arrayBuffer(buffer)
+     */
+    static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(body?: BodyType, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `FormData` body.
+     * @example
+     * const data = new FormData()
+     * data.set('name', 'Alice')
+     *
+     * HttpResponse.formData(data)
+     */
+    static formData(body?: FormData, init?: HttpResponseInit): HttpResponse<FormData>;
+}
+
+export { type AsyncResponseResolverReturnType as A, type GraphQLHandlerNameSelector as B, type GraphQLHandlerInfo as C, type DefaultBodyType as D, type GraphQLRequestParsedResult as E, type GraphQLCustomPredicateResult as F, GraphQLHandler as G, HttpResponse as H, isDocumentNode as I, type JsonBodyType as J, type RequestHandlerInternalInfo as K, type RequestHandlerArgs as L, type MaybeAsyncResponseResolverReturnType as M, type RequestHandlerExecutionResult as N, bodyType as O, type ParsedGraphQLRequest as P, type DefaultUnsafeFetchResponse as Q, RequestHandler as R, type StrictRequest as S, kDefaultContentType as T, type ResponseResolver as a, type ResponseResolverReturnType as b, type RequestHandlerOptions as c, type DefaultRequestMultipartBody as d, type ResponseResolverInfo as e, type GraphQLQuery as f, type GraphQLVariables as g, type GraphQLRequestBody as h, type GraphQLResponseBody as i, type GraphQLJsonRequestBody as j, type GraphQLOperationType as k, type GraphQLCustomPredicate as l, type ResponseResolutionContext as m, type HttpResponseInit as n, type StrictResponse as o, type GraphQLPredicate as p, type GraphQLResolverExtras as q, type RequestHandlerDefaultInfo as r, type HandlersExecutionResult as s, executeHandlers as t, type ParsedGraphQLQuery as u, parseDocumentNode as v, type GraphQLParsedOperationsMap as w, type GraphQLMultipartRequestBody as x, parseGraphQLRequest as y, type DocumentTypeDecoration as z };

node_modules/msw/lib/core/HttpResponse-Dj6ibgFJ.d.ts

@@ -0,0 +1,338 @@
+import { FetchResponse } from '@mswjs/interceptors';
+import { Iterable, AsyncIterable } from './utils/internal/isIterable.js';
+import { MaybePromise, NoInfer } from './typeUtils.js';
+import { OperationTypeNode, DocumentNode, GraphQLError } from 'graphql';
+import { Match, Path } from './utils/matching/matchRequestUrl.js';
+
+interface HandlersExecutionResult {
+    handler: RequestHandler;
+    parsedResult?: any;
+    response?: Response;
+}
+interface ResponseResolutionContext {
+    /**
+     * A base url to use when resolving relative urls.
+     * @note This is primarily used by the `@mswjs/http-middleware`
+     * to resolve relative urls in the context of the running server
+     */
+    baseUrl?: string;
+    quiet?: boolean;
+}
+/**
+ * Executes the list of request handlers against the given request.
+ * Returns the execution result object containing any matching request
+ * handler and any mocked response it returned.
+ */
+declare const executeHandlers: <Handlers extends Array<RequestHandler>>({ request, requestId, handlers, resolutionContext, }: {
+    request: Request;
+    requestId: string;
+    handlers: Handlers;
+    resolutionContext?: ResponseResolutionContext;
+}) => Promise<HandlersExecutionResult | null>;
+
+interface ParsedGraphQLQuery {
+    operationType: OperationTypeNode;
+    operationName?: string;
+}
+type ParsedGraphQLRequest<VariablesType extends GraphQLVariables = GraphQLVariables> = (ParsedGraphQLQuery & {
+    query: string;
+    variables?: VariablesType;
+}) | undefined;
+declare function parseDocumentNode(node: DocumentNode): ParsedGraphQLQuery;
+type GraphQLParsedOperationsMap = Record<string, string[]>;
+type GraphQLMultipartRequestBody = {
+    operations: string;
+    map?: string;
+} & {
+    [fileName: string]: File;
+};
+/**
+ * Determines if a given request can be considered a GraphQL request.
+ * Does not parse the query and does not guarantee its validity.
+ */
+declare function parseGraphQLRequest(request: Request): Promise<ParsedGraphQLRequest>;
+
+interface DocumentTypeDecoration<Result = {
+    [key: string]: any;
+}, Variables = {
+    [key: string]: any;
+}> {
+    __apiType?: (variables: Variables) => Result;
+    __resultType?: Result;
+    __variablesType?: Variables;
+}
+type GraphQLOperationType = OperationTypeNode | 'all';
+type GraphQLHandlerNameSelector = DocumentNode | RegExp | string;
+type GraphQLQuery = Record<string, any> | null;
+type GraphQLVariables = Record<string, any>;
+interface GraphQLHandlerInfo extends RequestHandlerDefaultInfo {
+    operationType: GraphQLOperationType;
+    operationName: GraphQLHandlerNameSelector | GraphQLCustomPredicate;
+}
+type GraphQLRequestParsedResult = {
+    match: Match;
+    cookies: Record<string, string>;
+} & (ParsedGraphQLRequest<GraphQLVariables>
+/**
+ * An empty version of the ParsedGraphQLRequest
+ * which simplifies the return type of the resolver
+ * when the request is to a non-matching endpoint
+ */
+ | {
+    operationType?: undefined;
+    operationName?: undefined;
+    query?: undefined;
+    variables?: undefined;
+});
+type GraphQLResolverExtras<Variables extends GraphQLVariables> = {
+    query: string;
+    operationName: string;
+    variables: Variables;
+    cookies: Record<string, string>;
+};
+type GraphQLRequestBody<VariablesType extends GraphQLVariables> = GraphQLJsonRequestBody<VariablesType> | GraphQLMultipartRequestBody | Record<string, any> | undefined;
+interface GraphQLJsonRequestBody<Variables extends GraphQLVariables> {
+    query: string;
+    variables?: Variables;
+}
+type GraphQLResponseBody<BodyType extends DefaultBodyType> = {
+    data?: BodyType | null;
+    errors?: readonly Partial<GraphQLError>[] | null;
+    extensions?: Record<string, any>;
+} | null | undefined;
+type GraphQLCustomPredicate = (args: {
+    request: Request;
+    query: string;
+    operationType: GraphQLOperationType;
+    operationName: string;
+    variables: GraphQLVariables;
+    cookies: Record<string, string>;
+}) => GraphQLCustomPredicateResult | Promise<GraphQLCustomPredicateResult>;
+type GraphQLCustomPredicateResult = boolean | {
+    matches: boolean;
+};
+type GraphQLPredicate<Query = any, Variables = any> = GraphQLHandlerNameSelector | DocumentTypeDecoration<Query, Variables> | GraphQLCustomPredicate;
+declare function isDocumentNode(value: DocumentNode | any): value is DocumentNode;
+declare class GraphQLHandler extends RequestHandler<GraphQLHandlerInfo, GraphQLRequestParsedResult, GraphQLResolverExtras<any>> {
+    #private;
+    private endpoint;
+    static parsedRequestCache: WeakMap<Request, ParsedGraphQLRequest<GraphQLVariables>>;
+    constructor(operationType: GraphQLOperationType, predicate: GraphQLPredicate, endpoint: Path, resolver: ResponseResolver<GraphQLResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    /**
+     * Parses the request body, once per request, cached across all
+     * GraphQL handlers. This is done to avoid multiple parsing of the
+     * request body, which each requires a clone of the request.
+     */
+    parseGraphQLRequestOrGetFromCache(request: Request): Promise<ParsedGraphQLRequest<GraphQLVariables>>;
+    parse(args: {
+        request: Request;
+    }): Promise<GraphQLRequestParsedResult>;
+    predicate(args: {
+        request: Request;
+        parsedResult: GraphQLRequestParsedResult;
+    }): Promise<boolean>;
+    run(args: {
+        request: StrictRequest<any>;
+        requestId: string;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<RequestHandlerExecutionResult<GraphQLRequestParsedResult> | null>;
+    private matchOperationName;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: GraphQLRequestParsedResult;
+    }): {
+        query: string;
+        operationType: OperationTypeNode;
+        operationName: string;
+        variables: GraphQLVariables;
+        cookies: Record<string, string>;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: GraphQLRequestParsedResult;
+    }): Promise<void>;
+}
+
+type DefaultRequestMultipartBody = Record<string, string | File | Array<string | File>>;
+type DefaultBodyType = Record<string, any> | DefaultRequestMultipartBody | string | number | boolean | null | undefined;
+type JsonBodyType = Record<string, any> | string | number | boolean | null | undefined;
+interface RequestHandlerDefaultInfo {
+    header: string;
+}
+interface RequestHandlerInternalInfo {
+    callFrame?: string;
+}
+type ResponseResolverReturnType<ResponseBodyType extends DefaultBodyType = undefined> = ([ResponseBodyType] extends [undefined] ? Response : ResponseBodyType extends GraphQLRequestBody<any> ? HttpResponse<ResponseBodyType> | DefaultUnsafeFetchResponse : HttpResponse<ResponseBodyType>) | undefined | void;
+type MaybeAsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType>>;
+type AsyncResponseResolverReturnType<ResponseBodyType extends DefaultBodyType> = MaybePromise<ResponseResolverReturnType<ResponseBodyType> | Iterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>> | AsyncIterable<MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>, MaybeAsyncResponseResolverReturnType<ResponseBodyType>>>;
+type ResponseResolverInfo<ResolverExtraInfo extends Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType> = {
+    request: StrictRequest<RequestBodyType>;
+    requestId: string;
+} & ResolverExtraInfo;
+type ResponseResolver<ResolverExtraInfo extends Record<string, unknown> = Record<string, unknown>, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined> = (info: ResponseResolverInfo<ResolverExtraInfo, RequestBodyType>) => AsyncResponseResolverReturnType<ResponseBodyType>;
+interface RequestHandlerArgs<HandlerInfo, HandlerOptions extends RequestHandlerOptions> {
+    info: HandlerInfo;
+    resolver: ResponseResolver<any>;
+    options?: HandlerOptions;
+}
+interface RequestHandlerOptions {
+    once?: boolean;
+}
+interface RequestHandlerExecutionResult<ParsedResult extends object | undefined> {
+    handler: RequestHandler;
+    parsedResult?: ParsedResult;
+    request: Request;
+    requestId: string;
+    response?: Response;
+}
+declare abstract class RequestHandler<HandlerInfo extends RequestHandlerDefaultInfo = RequestHandlerDefaultInfo, ParsedResult extends Record<string, any> | undefined = any, ResolverExtras extends Record<string, unknown> = any, HandlerOptions extends RequestHandlerOptions = RequestHandlerOptions> {
+    static cache: WeakMap<StrictRequest<DefaultBodyType>, StrictRequest<DefaultBodyType>>;
+    private readonly __kind;
+    info: HandlerInfo & RequestHandlerInternalInfo;
+    /**
+     * Indicates whether this request handler has been used
+     * (its resolver has successfully executed).
+     */
+    isUsed: boolean;
+    protected resolver: ResponseResolver<ResolverExtras, any, any>;
+    private resolverIterator?;
+    private resolverIteratorResult?;
+    private options?;
+    constructor(args: RequestHandlerArgs<HandlerInfo, HandlerOptions>);
+    /**
+     * Determine if the intercepted request should be mocked.
+     */
+    abstract predicate(args: {
+        request: Request;
+        parsedResult: ParsedResult;
+        resolutionContext?: ResponseResolutionContext;
+    }): boolean | Promise<boolean>;
+    /**
+     * Print out the successfully handled request.
+     */
+    abstract log(args: {
+        request: Request;
+        response: Response;
+        parsedResult: ParsedResult;
+    }): void;
+    /**
+     * Parse the intercepted request to extract additional information from it.
+     * Parsed result is then exposed to other methods of this request handler.
+     */
+    parse(_args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<ParsedResult>;
+    /**
+     * Test if this handler matches the given request.
+     *
+     * This method is not used internally but is exposed
+     * as a convenience method for consumers writing custom
+     * handlers.
+     */
+    test(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<boolean>;
+    protected extendResolverArgs(_args: {
+        request: Request;
+        parsedResult: ParsedResult;
+    }): ResolverExtras;
+    private cloneRequestOrGetFromCache;
+    /**
+     * Execute this request handler and produce a mocked response
+     * using the given resolver function.
+     */
+    run(args: {
+        request: StrictRequest<any>;
+        requestId: string;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<RequestHandlerExecutionResult<ParsedResult> | null>;
+    private wrapResolver;
+    private createExecutionResult;
+}
+
+interface HttpResponseInit extends ResponseInit {
+    type?: ResponseType;
+}
+declare const bodyType: unique symbol;
+type DefaultUnsafeFetchResponse = Response & {
+    [bodyType]?: never;
+};
+interface StrictRequest<BodyType extends JsonBodyType> extends Request {
+    json(): Promise<BodyType>;
+    clone(): StrictRequest<BodyType>;
+}
+/**
+ * Opaque `Response` type that supports strict body type.
+ *
+ * @deprecated Please use {@link HttpResponse} instead.
+ */
+type StrictResponse<BodyType extends DefaultBodyType> = HttpResponse<BodyType>;
+declare const kDefaultContentType: unique symbol;
+/**
+ * A drop-in replacement for the standard `Response` class
+ * to allow additional features, like mocking the response `Set-Cookie` header.
+ *
+ * @example
+ * new HttpResponse('Hello world', { status: 201 })
+ * HttpResponse.json({ name: 'John' })
+ * HttpResponse.formData(form)
+ *
+ * @see {@link https://mswjs.io/docs/api/http-response `HttpResponse` API reference}
+ */
+declare class HttpResponse<BodyType extends DefaultBodyType> extends FetchResponse {
+    readonly [bodyType]: BodyType;
+    constructor(body?: NoInfer<BodyType> | null, init?: HttpResponseInit);
+    static error(): HttpResponse<any>;
+    /**
+     * Create a `Response` with a `Content-Type: "text/plain"` body.
+     * @example
+     * HttpResponse.text('hello world')
+     * HttpResponse.text('Error', { status: 500 })
+     */
+    static text<BodyType extends string>(body?: NoInfer<BodyType> | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/json"` body.
+     * @example
+     * HttpResponse.json({ firstName: 'John' })
+     * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+     */
+    static json<BodyType extends JsonBodyType>(body?: NoInfer<BodyType> | null | undefined, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "application/xml"` body.
+     * @example
+     * HttpResponse.xml(`<user name="John" />`)
+     * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+     */
+    static xml<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `Content-Type: "text/html"` body.
+     * @example
+     * HttpResponse.html(`<p class="author">Jane Doe</p>`)
+     * HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+     */
+    static html<BodyType extends string>(body?: BodyType | null, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with an `ArrayBuffer` body.
+     * @example
+     * const buffer = new ArrayBuffer(3)
+     * const view = new Uint8Array(buffer)
+     * view.set([1, 2, 3])
+     *
+     * HttpResponse.arrayBuffer(buffer)
+     */
+    static arrayBuffer<BodyType extends ArrayBuffer | SharedArrayBuffer>(body?: BodyType, init?: HttpResponseInit): HttpResponse<BodyType>;
+    /**
+     * Create a `Response` with a `FormData` body.
+     * @example
+     * const data = new FormData()
+     * data.set('name', 'Alice')
+     *
+     * HttpResponse.formData(data)
+     */
+    static formData(body?: FormData, init?: HttpResponseInit): HttpResponse<FormData>;
+}
+
+export { type AsyncResponseResolverReturnType as A, type GraphQLHandlerNameSelector as B, type GraphQLHandlerInfo as C, type DefaultBodyType as D, type GraphQLRequestParsedResult as E, type GraphQLCustomPredicateResult as F, GraphQLHandler as G, HttpResponse as H, isDocumentNode as I, type JsonBodyType as J, type RequestHandlerInternalInfo as K, type RequestHandlerArgs as L, type MaybeAsyncResponseResolverReturnType as M, type RequestHandlerExecutionResult as N, bodyType as O, type ParsedGraphQLRequest as P, type DefaultUnsafeFetchResponse as Q, RequestHandler as R, type StrictRequest as S, kDefaultContentType as T, type ResponseResolver as a, type ResponseResolverReturnType as b, type RequestHandlerOptions as c, type DefaultRequestMultipartBody as d, type ResponseResolverInfo as e, type GraphQLQuery as f, type GraphQLVariables as g, type GraphQLRequestBody as h, type GraphQLResponseBody as i, type GraphQLJsonRequestBody as j, type GraphQLOperationType as k, type GraphQLCustomPredicate as l, type ResponseResolutionContext as m, type HttpResponseInit as n, type StrictResponse as o, type GraphQLPredicate as p, type GraphQLResolverExtras as q, type RequestHandlerDefaultInfo as r, type HandlersExecutionResult as s, executeHandlers as t, type ParsedGraphQLQuery as u, parseDocumentNode as v, type GraphQLParsedOperationsMap as w, type GraphQLMultipartRequestBody as x, parseGraphQLRequest as y, type DocumentTypeDecoration as z };

node_modules/msw/lib/core/HttpResponse.d.mts

@@ -0,0 +1,6 @@
+import '@mswjs/interceptors';
+export { Q as DefaultUnsafeFetchResponse, H as HttpResponse, n as HttpResponseInit, S as StrictRequest, o as StrictResponse, O as bodyType, T as kDefaultContentType } from './HttpResponse-Be4eT3x6.mjs';
+import './typeUtils.mjs';
+import './utils/internal/isIterable.mjs';
+import 'graphql';
+import './utils/matching/matchRequestUrl.mjs';

node_modules/msw/lib/core/HttpResponse.d.ts

@@ -0,0 +1,6 @@
+import '@mswjs/interceptors';
+export { Q as DefaultUnsafeFetchResponse, H as HttpResponse, n as HttpResponseInit, S as StrictRequest, o as StrictResponse, O as bodyType, T as kDefaultContentType } from './HttpResponse-Dj6ibgFJ.js';
+import './typeUtils.js';
+import './utils/internal/isIterable.js';
+import 'graphql';
+import './utils/matching/matchRequestUrl.js';

node_modules/msw/lib/core/HttpResponse.js

@@ -0,0 +1,176 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var HttpResponse_exports = {};
+__export(HttpResponse_exports, {
+  HttpResponse: () => HttpResponse,
+  bodyType: () => bodyType,
+  kDefaultContentType: () => kDefaultContentType
+});
+module.exports = __toCommonJS(HttpResponse_exports);
+var import_interceptors = require("@mswjs/interceptors");
+var import_decorators = require("./utils/HttpResponse/decorators");
+const bodyType = Symbol("bodyType");
+const kDefaultContentType = Symbol.for("kDefaultContentType");
+class HttpResponse extends import_interceptors.FetchResponse {
+  [bodyType] = null;
+  constructor(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    super(body, responseInit);
+    (0, import_decorators.decorateResponse)(this, responseInit);
+  }
+  static error() {
+    return super.error();
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/plain"` body.
+   * @example
+   * HttpResponse.text('hello world')
+   * HttpResponse.text('Error', { status: 500 })
+   */
+  static text(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/plain");
+    }
+    if (!responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set(
+        "Content-Length",
+        body ? new Blob([body]).size.toString() : "0"
+      );
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/json"` body.
+   * @example
+   * HttpResponse.json({ firstName: 'John' })
+   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+   */
+  static json(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "application/json");
+    }
+    const responseText = JSON.stringify(body);
+    if (!responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set(
+        "Content-Length",
+        responseText ? new Blob([responseText]).size.toString() : "0"
+      );
+    }
+    const response = new HttpResponse(responseText, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/xml"` body.
+   * @example
+   * HttpResponse.xml(`<user name="John" />`)
+   * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+   */
+  static xml(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/xml");
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/html"` body.
+   * @example
+   * HttpResponse.html(`<p class="author">Jane Doe</p>`)
+   * HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+   */
+  static html(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/html");
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with an `ArrayBuffer` body.
+   * @example
+   * const buffer = new ArrayBuffer(3)
+   * const view = new Uint8Array(buffer)
+   * view.set([1, 2, 3])
+   *
+   * HttpResponse.arrayBuffer(buffer)
+   */
+  static arrayBuffer(body, init) {
+    const responseInit = (0, import_decorators.normalizeResponseInit)(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "application/octet-stream");
+    }
+    if (body && !responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set("Content-Length", body.byteLength.toString());
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `FormData` body.
+   * @example
+   * const data = new FormData()
+   * data.set('name', 'Alice')
+   *
+   * HttpResponse.formData(data)
+   */
+  static formData(body, init) {
+    return new HttpResponse(body, (0, import_decorators.normalizeResponseInit)(init));
+  }
+}
+//# sourceMappingURL=HttpResponse.js.map

node_modules/msw/lib/core/HttpResponse.mjs

@@ -0,0 +1,159 @@
+import { FetchResponse } from "@mswjs/interceptors";
+import {
+  decorateResponse,
+  normalizeResponseInit
+} from './utils/HttpResponse/decorators.mjs';
+const bodyType = Symbol("bodyType");
+const kDefaultContentType = Symbol.for("kDefaultContentType");
+class HttpResponse extends FetchResponse {
+  [bodyType] = null;
+  constructor(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    super(body, responseInit);
+    decorateResponse(this, responseInit);
+  }
+  static error() {
+    return super.error();
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/plain"` body.
+   * @example
+   * HttpResponse.text('hello world')
+   * HttpResponse.text('Error', { status: 500 })
+   */
+  static text(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/plain");
+    }
+    if (!responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set(
+        "Content-Length",
+        body ? new Blob([body]).size.toString() : "0"
+      );
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/json"` body.
+   * @example
+   * HttpResponse.json({ firstName: 'John' })
+   * HttpResponse.json({ error: 'Not Authorized' }, { status: 401 })
+   */
+  static json(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "application/json");
+    }
+    const responseText = JSON.stringify(body);
+    if (!responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set(
+        "Content-Length",
+        responseText ? new Blob([responseText]).size.toString() : "0"
+      );
+    }
+    const response = new HttpResponse(responseText, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "application/xml"` body.
+   * @example
+   * HttpResponse.xml(`<user name="John" />`)
+   * HttpResponse.xml(`<article id="abc-123" />`, { status: 201 })
+   */
+  static xml(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/xml");
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `Content-Type: "text/html"` body.
+   * @example
+   * HttpResponse.html(`<p class="author">Jane Doe</p>`)
+   * HttpResponse.html(`<main id="abc-123">Main text</main>`, { status: 201 })
+   */
+  static html(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "text/html");
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with an `ArrayBuffer` body.
+   * @example
+   * const buffer = new ArrayBuffer(3)
+   * const view = new Uint8Array(buffer)
+   * view.set([1, 2, 3])
+   *
+   * HttpResponse.arrayBuffer(buffer)
+   */
+  static arrayBuffer(body, init) {
+    const responseInit = normalizeResponseInit(init);
+    const hasExplicitContentType = responseInit.headers.has("Content-Type");
+    if (!hasExplicitContentType) {
+      responseInit.headers.set("Content-Type", "application/octet-stream");
+    }
+    if (body && !responseInit.headers.has("Content-Length")) {
+      responseInit.headers.set("Content-Length", body.byteLength.toString());
+    }
+    const response = new HttpResponse(body, responseInit);
+    if (!hasExplicitContentType) {
+      Object.defineProperty(response, kDefaultContentType, {
+        value: true,
+        enumerable: false
+      });
+    }
+    return response;
+  }
+  /**
+   * Create a `Response` with a `FormData` body.
+   * @example
+   * const data = new FormData()
+   * data.set('name', 'Alice')
+   *
+   * HttpResponse.formData(data)
+   */
+  static formData(body, init) {
+    return new HttpResponse(body, normalizeResponseInit(init));
+  }
+}
+export {
+  HttpResponse,
+  bodyType,
+  kDefaultContentType
+};
+//# sourceMappingURL=HttpResponse.mjs.map

node_modules/msw/lib/core/SetupApi.d.mts

@@ -0,0 +1,44 @@
+import { EventMap, Emitter } from 'strict-event-emitter';
+import { R as RequestHandler } from './HttpResponse-Be4eT3x6.mjs';
+import { LifeCycleEventEmitter } from './sharedOptions.mjs';
+import { Disposable } from './utils/internal/Disposable.mjs';
+import { WebSocketHandler } from './handlers/WebSocketHandler.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+import './utils/matching/matchRequestUrl.mjs';
+import './utils/request/onUnhandledRequest.mjs';
+import '@mswjs/interceptors/WebSocket';
+
+declare abstract class HandlersController {
+    abstract prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void;
+    abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>;
+}
+declare class InMemoryHandlersController implements HandlersController {
+    private initialHandlers;
+    private handlers;
+    constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>);
+    prepend(runtimeHandles: Array<RequestHandler | WebSocketHandler>): void;
+    reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    currentHandlers(): Array<RequestHandler | WebSocketHandler>;
+}
+/**
+ * Generic class for the mock API setup.
+ */
+declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
+    protected handlersController: HandlersController;
+    protected readonly emitter: Emitter<EventsMap>;
+    protected readonly publicEmitter: Emitter<EventsMap>;
+    readonly events: LifeCycleEventEmitter<EventsMap>;
+    constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>);
+    private validateHandlers;
+    use(...runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
+    private createLifeCycleEvents;
+}
+
+export { HandlersController, InMemoryHandlersController, SetupApi };

node_modules/msw/lib/core/SetupApi.d.ts

@@ -0,0 +1,44 @@
+import { EventMap, Emitter } from 'strict-event-emitter';
+import { R as RequestHandler } from './HttpResponse-Dj6ibgFJ.js';
+import { LifeCycleEventEmitter } from './sharedOptions.js';
+import { Disposable } from './utils/internal/Disposable.js';
+import { WebSocketHandler } from './handlers/WebSocketHandler.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+import './utils/matching/matchRequestUrl.js';
+import './utils/request/onUnhandledRequest.js';
+import '@mswjs/interceptors/WebSocket';
+
+declare abstract class HandlersController {
+    abstract prepend(runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void;
+    abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>;
+}
+declare class InMemoryHandlersController implements HandlersController {
+    private initialHandlers;
+    private handlers;
+    constructor(initialHandlers: Array<RequestHandler | WebSocketHandler>);
+    prepend(runtimeHandles: Array<RequestHandler | WebSocketHandler>): void;
+    reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    currentHandlers(): Array<RequestHandler | WebSocketHandler>;
+}
+/**
+ * Generic class for the mock API setup.
+ */
+declare abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
+    protected handlersController: HandlersController;
+    protected readonly emitter: Emitter<EventsMap>;
+    protected readonly publicEmitter: Emitter<EventsMap>;
+    readonly events: LifeCycleEventEmitter<EventsMap>;
+    constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>);
+    private validateHandlers;
+    use(...runtimeHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    restoreHandlers(): void;
+    resetHandlers(...nextHandlers: Array<RequestHandler | WebSocketHandler>): void;
+    listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>;
+    private createLifeCycleEvents;
+}
+
+export { HandlersController, InMemoryHandlersController, SetupApi };

node_modules/msw/lib/core/SetupApi.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SetupApi_exports = {};
+__export(SetupApi_exports, {
+  HandlersController: () => HandlersController,
+  InMemoryHandlersController: () => InMemoryHandlersController,
+  SetupApi: () => SetupApi
+});
+module.exports = __toCommonJS(SetupApi_exports);
+var import_outvariant = require("outvariant");
+var import_strict_event_emitter = require("strict-event-emitter");
+var import_devUtils = require("./utils/internal/devUtils");
+var import_pipeEvents = require("./utils/internal/pipeEvents");
+var import_toReadonlyArray = require("./utils/internal/toReadonlyArray");
+var import_Disposable = require("./utils/internal/Disposable");
+class HandlersController {
+}
+class InMemoryHandlersController {
+  constructor(initialHandlers) {
+    this.initialHandlers = initialHandlers;
+    this.handlers = [...initialHandlers];
+  }
+  handlers;
+  prepend(runtimeHandles) {
+    this.handlers.unshift(...runtimeHandles);
+  }
+  reset(nextHandlers) {
+    this.handlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
+  }
+  currentHandlers() {
+    return this.handlers;
+  }
+}
+class SetupApi extends import_Disposable.Disposable {
+  handlersController;
+  emitter;
+  publicEmitter;
+  events;
+  constructor(...initialHandlers) {
+    super();
+    (0, import_outvariant.invariant)(
+      this.validateHandlers(initialHandlers),
+      import_devUtils.devUtils.formatMessage(
+        `Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`
+      )
+    );
+    this.handlersController = new InMemoryHandlersController(initialHandlers);
+    this.emitter = new import_strict_event_emitter.Emitter();
+    this.publicEmitter = new import_strict_event_emitter.Emitter();
+    (0, import_pipeEvents.pipeEvents)(this.emitter, this.publicEmitter);
+    this.events = this.createLifeCycleEvents();
+    this.subscriptions.push(() => {
+      this.emitter.removeAllListeners();
+      this.publicEmitter.removeAllListeners();
+    });
+  }
+  validateHandlers(handlers) {
+    return handlers.every((handler) => !Array.isArray(handler));
+  }
+  use(...runtimeHandlers) {
+    (0, import_outvariant.invariant)(
+      this.validateHandlers(runtimeHandlers),
+      import_devUtils.devUtils.formatMessage(
+        `Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`
+      )
+    );
+    this.handlersController.prepend(runtimeHandlers);
+  }
+  restoreHandlers() {
+    this.handlersController.currentHandlers().forEach((handler) => {
+      if ("isUsed" in handler) {
+        handler.isUsed = false;
+      }
+    });
+  }
+  resetHandlers(...nextHandlers) {
+    this.handlersController.reset(nextHandlers);
+  }
+  listHandlers() {
+    return (0, import_toReadonlyArray.toReadonlyArray)(this.handlersController.currentHandlers());
+  }
+  createLifeCycleEvents() {
+    return {
+      on: (...args) => {
+        return this.publicEmitter.on(...args);
+      },
+      removeListener: (...args) => {
+        return this.publicEmitter.removeListener(...args);
+      },
+      removeAllListeners: (...args) => {
+        return this.publicEmitter.removeAllListeners(...args);
+      }
+    };
+  }
+}
+//# sourceMappingURL=SetupApi.js.map

node_modules/msw/lib/core/SetupApi.mjs

@@ -0,0 +1,92 @@
+import { invariant } from "outvariant";
+import { Emitter } from "strict-event-emitter";
+import { devUtils } from './utils/internal/devUtils.mjs';
+import { pipeEvents } from './utils/internal/pipeEvents.mjs';
+import { toReadonlyArray } from './utils/internal/toReadonlyArray.mjs';
+import { Disposable } from './utils/internal/Disposable.mjs';
+class HandlersController {
+}
+class InMemoryHandlersController {
+  constructor(initialHandlers) {
+    this.initialHandlers = initialHandlers;
+    this.handlers = [...initialHandlers];
+  }
+  handlers;
+  prepend(runtimeHandles) {
+    this.handlers.unshift(...runtimeHandles);
+  }
+  reset(nextHandlers) {
+    this.handlers = nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers];
+  }
+  currentHandlers() {
+    return this.handlers;
+  }
+}
+class SetupApi extends Disposable {
+  handlersController;
+  emitter;
+  publicEmitter;
+  events;
+  constructor(...initialHandlers) {
+    super();
+    invariant(
+      this.validateHandlers(initialHandlers),
+      devUtils.formatMessage(
+        `Failed to apply given request handlers: invalid input. Did you forget to spread the request handlers Array?`
+      )
+    );
+    this.handlersController = new InMemoryHandlersController(initialHandlers);
+    this.emitter = new Emitter();
+    this.publicEmitter = new Emitter();
+    pipeEvents(this.emitter, this.publicEmitter);
+    this.events = this.createLifeCycleEvents();
+    this.subscriptions.push(() => {
+      this.emitter.removeAllListeners();
+      this.publicEmitter.removeAllListeners();
+    });
+  }
+  validateHandlers(handlers) {
+    return handlers.every((handler) => !Array.isArray(handler));
+  }
+  use(...runtimeHandlers) {
+    invariant(
+      this.validateHandlers(runtimeHandlers),
+      devUtils.formatMessage(
+        `Failed to call "use()" with the given request handlers: invalid input. Did you forget to spread the array of request handlers?`
+      )
+    );
+    this.handlersController.prepend(runtimeHandlers);
+  }
+  restoreHandlers() {
+    this.handlersController.currentHandlers().forEach((handler) => {
+      if ("isUsed" in handler) {
+        handler.isUsed = false;
+      }
+    });
+  }
+  resetHandlers(...nextHandlers) {
+    this.handlersController.reset(nextHandlers);
+  }
+  listHandlers() {
+    return toReadonlyArray(this.handlersController.currentHandlers());
+  }
+  createLifeCycleEvents() {
+    return {
+      on: (...args) => {
+        return this.publicEmitter.on(...args);
+      },
+      removeListener: (...args) => {
+        return this.publicEmitter.removeListener(...args);
+      },
+      removeAllListeners: (...args) => {
+        return this.publicEmitter.removeAllListeners(...args);
+      }
+    };
+  }
+}
+export {
+  HandlersController,
+  InMemoryHandlersController,
+  SetupApi
+};
+//# sourceMappingURL=SetupApi.mjs.map

node_modules/msw/lib/core/bypass.d.mts

@@ -0,0 +1,16 @@
+type BypassRequestInput = string | URL | Request;
+/**
+ * Creates a `Request` instance that will always be ignored by MSW.
+ *
+ * @example
+ * import { bypass } from 'msw'
+ *
+ * fetch(bypass('/resource'))
+ * fetch(bypass(new URL('/resource', 'https://example.com)))
+ * fetch(bypass(new Request('https://example.com/resource')))
+ *
+ * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
+ */
+declare function bypass(input: BypassRequestInput, init?: RequestInit): Request;
+
+export { type BypassRequestInput, bypass };

node_modules/msw/lib/core/bypass.d.ts

@@ -0,0 +1,16 @@
+type BypassRequestInput = string | URL | Request;
+/**
+ * Creates a `Request` instance that will always be ignored by MSW.
+ *
+ * @example
+ * import { bypass } from 'msw'
+ *
+ * fetch(bypass('/resource'))
+ * fetch(bypass(new URL('/resource', 'https://example.com)))
+ * fetch(bypass(new Request('https://example.com/resource')))
+ *
+ * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}
+ */
+declare function bypass(input: BypassRequestInput, init?: RequestInit): Request;
+
+export { type BypassRequestInput, bypass };

node_modules/msw/lib/core/bypass.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bypass_exports = {};
+__export(bypass_exports, {
+  bypass: () => bypass
+});
+module.exports = __toCommonJS(bypass_exports);
+var import_outvariant = require("outvariant");
+function bypass(input, init) {
+  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
+  );
+  (0, import_outvariant.invariant)(
+    !request.bodyUsed,
+    'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+    request.method,
+    request.url
+  );
+  const requestClone = request.clone();
+  requestClone.headers.append("accept", "msw/passthrough");
+  return requestClone;
+}
+//# sourceMappingURL=bypass.js.map

node_modules/msw/lib/core/bypass.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/bypass.ts"],"sourcesContent":["import { invariant } from 'outvariant'\n\nexport type BypassRequestInput = string | URL | Request\n\n/**\n * Creates a `Request` instance that will always be ignored by MSW.\n *\n * @example\n * import { bypass } from 'msw'\n *\n * fetch(bypass('/resource'))\n * fetch(bypass(new URL('/resource', 'https://example.com)))\n * fetch(bypass(new Request('https://example.com/resource')))\n *\n * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}\n */\nexport function bypass(input: BypassRequestInput, init?: RequestInit): Request {\n  // Always create a new Request instance.\n  // This way, the \"init\" modifications will propagate\n  // to the bypass request instance automatically.\n  const request = new Request(\n    // If given a Request instance, clone it not to exhaust\n    // the original request's body.\n    input instanceof Request ? input.clone() : input,\n    init,\n  )\n\n  invariant(\n    !request.bodyUsed,\n    'Failed to create a bypassed request to \"%s %s\": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',\n    request.method,\n    request.url,\n  )\n\n  const requestClone = request.clone()\n\n  /**\n   * Send the internal request header that would instruct MSW\n   * to perform this request as-is, ignoring any matching handlers.\n   * @note Use the `accept` header to support scenarios when the\n   * request cannot have headers (e.g. `sendBeacon` requests).\n   */\n  requestClone.headers.append('accept', 'msw/passthrough')\n\n  return requestClone\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA0B;AAgBnB,SAAS,OAAO,OAA2B,MAA6B;AAI7E,QAAM,UAAU,IAAI;AAAA;AAAA;AAAA,IAGlB,iBAAiB,UAAU,MAAM,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF;AAEA;AAAA,IACE,CAAC,QAAQ;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAEA,QAAM,eAAe,QAAQ,MAAM;AAQnC,eAAa,QAAQ,OAAO,UAAU,iBAAiB;AAEvD,SAAO;AACT;","names":[]}

node_modules/msw/lib/core/bypass.mjs

@@ -0,0 +1,22 @@
+import { invariant } from "outvariant";
+function bypass(input, init) {
+  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,
+    'Failed to create a bypassed request to "%s %s": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',
+    request.method,
+    request.url
+  );
+  const requestClone = request.clone();
+  requestClone.headers.append("accept", "msw/passthrough");
+  return requestClone;
+}
+export {
+  bypass
+};
+//# sourceMappingURL=bypass.mjs.map

node_modules/msw/lib/core/bypass.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/bypass.ts"],"sourcesContent":["import { invariant } from 'outvariant'\n\nexport type BypassRequestInput = string | URL | Request\n\n/**\n * Creates a `Request` instance that will always be ignored by MSW.\n *\n * @example\n * import { bypass } from 'msw'\n *\n * fetch(bypass('/resource'))\n * fetch(bypass(new URL('/resource', 'https://example.com)))\n * fetch(bypass(new Request('https://example.com/resource')))\n *\n * @see {@link https://mswjs.io/docs/api/bypass `bypass()` API reference}\n */\nexport function bypass(input: BypassRequestInput, init?: RequestInit): Request {\n  // Always create a new Request instance.\n  // This way, the \"init\" modifications will propagate\n  // to the bypass request instance automatically.\n  const request = new Request(\n    // If given a Request instance, clone it not to exhaust\n    // the original request's body.\n    input instanceof Request ? input.clone() : input,\n    init,\n  )\n\n  invariant(\n    !request.bodyUsed,\n    'Failed to create a bypassed request to \"%s %s\": given request instance already has its body read. Make sure to clone the intercepted request if you wish to read its body before bypassing it.',\n    request.method,\n    request.url,\n  )\n\n  const requestClone = request.clone()\n\n  /**\n   * Send the internal request header that would instruct MSW\n   * to perform this request as-is, ignoring any matching handlers.\n   * @note Use the `accept` header to support scenarios when the\n   * request cannot have headers (e.g. `sendBeacon` requests).\n   */\n  requestClone.headers.append('accept', 'msw/passthrough')\n\n  return requestClone\n}\n"],"mappings":"AAAA,SAAS,iBAAiB;AAgBnB,SAAS,OAAO,OAA2B,MAA6B;AAI7E,QAAM,UAAU,IAAI;AAAA;AAAA;AAAA,IAGlB,iBAAiB,UAAU,MAAM,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF;AAEA;AAAA,IACE,CAAC,QAAQ;AAAA,IACT;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAEA,QAAM,eAAe,QAAQ,MAAM;AAQnC,eAAa,QAAQ,OAAO,UAAU,iBAAiB;AAEvD,SAAO;AACT;","names":[]}

node_modules/msw/lib/core/delay.d.mts

@@ -0,0 +1,18 @@
+declare const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+declare const MIN_SERVER_RESPONSE_TIME = 100;
+declare const MAX_SERVER_RESPONSE_TIME = 400;
+declare const NODE_SERVER_RESPONSE_TIME = 5;
+type DelayMode = 'real' | 'infinite';
+/**
+ * Delays the response by the given duration (ms).
+ *
+ * @example
+ * await delay() // emulate realistic server response time
+ * await delay(1200) // delay response by 1200ms
+ * await delay('infinite') // delay response infinitely
+ *
+ * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}
+ */
+declare function delay(durationOrMode?: DelayMode | number): Promise<void>;
+
+export { type DelayMode, MAX_SERVER_RESPONSE_TIME, MIN_SERVER_RESPONSE_TIME, NODE_SERVER_RESPONSE_TIME, SET_TIMEOUT_MAX_ALLOWED_INT, delay };

node_modules/msw/lib/core/delay.d.ts

@@ -0,0 +1,18 @@
+declare const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+declare const MIN_SERVER_RESPONSE_TIME = 100;
+declare const MAX_SERVER_RESPONSE_TIME = 400;
+declare const NODE_SERVER_RESPONSE_TIME = 5;
+type DelayMode = 'real' | 'infinite';
+/**
+ * Delays the response by the given duration (ms).
+ *
+ * @example
+ * await delay() // emulate realistic server response time
+ * await delay(1200) // delay response by 1200ms
+ * await delay('infinite') // delay response infinitely
+ *
+ * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}
+ */
+declare function delay(durationOrMode?: DelayMode | number): Promise<void>;
+
+export { type DelayMode, MAX_SERVER_RESPONSE_TIME, MIN_SERVER_RESPONSE_TIME, NODE_SERVER_RESPONSE_TIME, SET_TIMEOUT_MAX_ALLOWED_INT, delay };

node_modules/msw/lib/core/delay.js

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var delay_exports = {};
+__export(delay_exports, {
+  MAX_SERVER_RESPONSE_TIME: () => MAX_SERVER_RESPONSE_TIME,
+  MIN_SERVER_RESPONSE_TIME: () => MIN_SERVER_RESPONSE_TIME,
+  NODE_SERVER_RESPONSE_TIME: () => NODE_SERVER_RESPONSE_TIME,
+  SET_TIMEOUT_MAX_ALLOWED_INT: () => SET_TIMEOUT_MAX_ALLOWED_INT,
+  delay: () => delay
+});
+module.exports = __toCommonJS(delay_exports);
+var import_is_node_process = require("is-node-process");
+var import_hasRefCounted = require("./utils/internal/hasRefCounted");
+const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+const MIN_SERVER_RESPONSE_TIME = 100;
+const MAX_SERVER_RESPONSE_TIME = 400;
+const NODE_SERVER_RESPONSE_TIME = 5;
+function getRealisticResponseTime() {
+  if ((0, import_is_node_process.isNodeProcess)()) {
+    return NODE_SERVER_RESPONSE_TIME;
+  }
+  return Math.floor(
+    Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
+  );
+}
+async function delay(durationOrMode) {
+  let delayTime;
+  if (typeof durationOrMode === "string") {
+    switch (durationOrMode) {
+      case "infinite": {
+        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+        break;
+      }
+      case "real": {
+        delayTime = getRealisticResponseTime();
+        break;
+      }
+      default: {
+        throw new Error(
+          `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
+        );
+      }
+    }
+  } else if (typeof durationOrMode === "undefined") {
+    delayTime = getRealisticResponseTime();
+  } else {
+    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+      throw new Error(
+        `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
+      );
+    }
+    delayTime = durationOrMode;
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(resolve, delayTime);
+    if (delayTime === SET_TIMEOUT_MAX_ALLOWED_INT && (0, import_is_node_process.isNodeProcess)() && (0, import_hasRefCounted.hasRefCounted)(timeoutId)) {
+      timeoutId.unref();
+    }
+  });
+}
+//# sourceMappingURL=delay.js.map

node_modules/msw/lib/core/delay.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/delay.ts"],"sourcesContent":["import { isNodeProcess } from 'is-node-process'\nimport { hasRefCounted } from './utils/internal/hasRefCounted'\n\nexport const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647\nexport const MIN_SERVER_RESPONSE_TIME = 100\nexport const MAX_SERVER_RESPONSE_TIME = 400\nexport const NODE_SERVER_RESPONSE_TIME = 5\n\nfunction getRealisticResponseTime(): number {\n  if (isNodeProcess()) {\n    return NODE_SERVER_RESPONSE_TIME\n  }\n\n  return Math.floor(\n    Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +\n      MIN_SERVER_RESPONSE_TIME,\n  )\n}\n\nexport type DelayMode = 'real' | 'infinite'\n\n/**\n * Delays the response by the given duration (ms).\n *\n * @example\n * await delay() // emulate realistic server response time\n * await delay(1200) // delay response by 1200ms\n * await delay('infinite') // delay response infinitely\n *\n * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}\n */\nexport async function delay(\n  durationOrMode?: DelayMode | number,\n): Promise<void> {\n  let delayTime: number\n\n  if (typeof durationOrMode === 'string') {\n    switch (durationOrMode) {\n      case 'infinite': {\n        // Using `Infinity` as a delay value executes the response timeout immediately.\n        // Instead, use the maximum allowed integer for `setTimeout`.\n        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT\n        break\n      }\n      case 'real': {\n        delayTime = getRealisticResponseTime()\n        break\n      }\n      default: {\n        throw new Error(\n          `Failed to delay a response: unknown delay mode \"${durationOrMode}\". Please make sure you provide one of the supported modes (\"real\", \"infinite\") or a number.`,\n        )\n      }\n    }\n  } else if (typeof durationOrMode === 'undefined') {\n    // Use random realistic server response time when no explicit delay duration was provided.\n    delayTime = getRealisticResponseTime()\n  } else {\n    // Guard against passing values like `Infinity` or `Number.MAX_VALUE`\n    // as the response delay duration. They don't produce the result you may expect.\n    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {\n      throw new Error(\n        `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for \"setTimeout\" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the \"infinite\" delay mode to delay the response indefinitely.`,\n      )\n    }\n\n    delayTime = durationOrMode\n  }\n\n  return new Promise((resolve) => {\n    const timeoutId = setTimeout(resolve, delayTime)\n\n    if (\n      delayTime === SET_TIMEOUT_MAX_ALLOWED_INT &&\n      isNodeProcess() &&\n      hasRefCounted(timeoutId)\n    ) {\n      // Prevent the process from hanging if this is the only active ref.\n      timeoutId.unref()\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAA8B;AAC9B,2BAA8B;AAEvB,MAAM,8BAA8B;AACpC,MAAM,2BAA2B;AACjC,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAEzC,SAAS,2BAAmC;AAC1C,UAAI,sCAAc,GAAG;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,KAAK;AAAA,IACV,KAAK,OAAO,KAAK,2BAA2B,4BAC1C;AAAA,EACJ;AACF;AAcA,eAAsB,MACpB,gBACe;AACf,MAAI;AAEJ,MAAI,OAAO,mBAAmB,UAAU;AACtC,YAAQ,gBAAgB;AAAA,MACtB,KAAK,YAAY;AAGf,oBAAY;AACZ;AAAA,MACF;AAAA,MACA,KAAK,QAAQ;AACX,oBAAY,yBAAyB;AACrC;AAAA,MACF;AAAA,MACA,SAAS;AACP,cAAM,IAAI;AAAA,UACR,mDAAmD,cAAc;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF,WAAW,OAAO,mBAAmB,aAAa;AAEhD,gBAAY,yBAAyB;AAAA,EACvC,OAAO;AAGL,QAAI,iBAAiB,6BAA6B;AAChD,YAAM,IAAI;AAAA,QACR,wDAAwD,cAAc,4DAA4D,2BAA2B;AAAA,MAC/J;AAAA,IACF;AAEA,gBAAY;AAAA,EACd;AAEA,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,YAAY,WAAW,SAAS,SAAS;AAE/C,QACE,cAAc,mCACd,sCAAc,SACd,oCAAc,SAAS,GACvB;AAEA,gBAAU,MAAM;AAAA,IAClB;AAAA,EACF,CAAC;AACH;","names":[]}

node_modules/msw/lib/core/delay.mjs

@@ -0,0 +1,57 @@
+import { isNodeProcess } from "is-node-process";
+import { hasRefCounted } from './utils/internal/hasRefCounted.mjs';
+const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
+const MIN_SERVER_RESPONSE_TIME = 100;
+const MAX_SERVER_RESPONSE_TIME = 400;
+const NODE_SERVER_RESPONSE_TIME = 5;
+function getRealisticResponseTime() {
+  if (isNodeProcess()) {
+    return NODE_SERVER_RESPONSE_TIME;
+  }
+  return Math.floor(
+    Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME
+  );
+}
+async function delay(durationOrMode) {
+  let delayTime;
+  if (typeof durationOrMode === "string") {
+    switch (durationOrMode) {
+      case "infinite": {
+        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
+        break;
+      }
+      case "real": {
+        delayTime = getRealisticResponseTime();
+        break;
+      }
+      default: {
+        throw new Error(
+          `Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`
+        );
+      }
+    }
+  } else if (typeof durationOrMode === "undefined") {
+    delayTime = getRealisticResponseTime();
+  } else {
+    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
+      throw new Error(
+        `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`
+      );
+    }
+    delayTime = durationOrMode;
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(resolve, delayTime);
+    if (delayTime === SET_TIMEOUT_MAX_ALLOWED_INT && isNodeProcess() && hasRefCounted(timeoutId)) {
+      timeoutId.unref();
+    }
+  });
+}
+export {
+  MAX_SERVER_RESPONSE_TIME,
+  MIN_SERVER_RESPONSE_TIME,
+  NODE_SERVER_RESPONSE_TIME,
+  SET_TIMEOUT_MAX_ALLOWED_INT,
+  delay
+};
+//# sourceMappingURL=delay.mjs.map

node_modules/msw/lib/core/delay.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/delay.ts"],"sourcesContent":["import { isNodeProcess } from 'is-node-process'\nimport { hasRefCounted } from './utils/internal/hasRefCounted'\n\nexport const SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647\nexport const MIN_SERVER_RESPONSE_TIME = 100\nexport const MAX_SERVER_RESPONSE_TIME = 400\nexport const NODE_SERVER_RESPONSE_TIME = 5\n\nfunction getRealisticResponseTime(): number {\n  if (isNodeProcess()) {\n    return NODE_SERVER_RESPONSE_TIME\n  }\n\n  return Math.floor(\n    Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) +\n      MIN_SERVER_RESPONSE_TIME,\n  )\n}\n\nexport type DelayMode = 'real' | 'infinite'\n\n/**\n * Delays the response by the given duration (ms).\n *\n * @example\n * await delay() // emulate realistic server response time\n * await delay(1200) // delay response by 1200ms\n * await delay('infinite') // delay response infinitely\n *\n * @see {@link https://mswjs.io/docs/api/delay `delay()` API reference}\n */\nexport async function delay(\n  durationOrMode?: DelayMode | number,\n): Promise<void> {\n  let delayTime: number\n\n  if (typeof durationOrMode === 'string') {\n    switch (durationOrMode) {\n      case 'infinite': {\n        // Using `Infinity` as a delay value executes the response timeout immediately.\n        // Instead, use the maximum allowed integer for `setTimeout`.\n        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT\n        break\n      }\n      case 'real': {\n        delayTime = getRealisticResponseTime()\n        break\n      }\n      default: {\n        throw new Error(\n          `Failed to delay a response: unknown delay mode \"${durationOrMode}\". Please make sure you provide one of the supported modes (\"real\", \"infinite\") or a number.`,\n        )\n      }\n    }\n  } else if (typeof durationOrMode === 'undefined') {\n    // Use random realistic server response time when no explicit delay duration was provided.\n    delayTime = getRealisticResponseTime()\n  } else {\n    // Guard against passing values like `Infinity` or `Number.MAX_VALUE`\n    // as the response delay duration. They don't produce the result you may expect.\n    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {\n      throw new Error(\n        `Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for \"setTimeout\" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the \"infinite\" delay mode to delay the response indefinitely.`,\n      )\n    }\n\n    delayTime = durationOrMode\n  }\n\n  return new Promise((resolve) => {\n    const timeoutId = setTimeout(resolve, delayTime)\n\n    if (\n      delayTime === SET_TIMEOUT_MAX_ALLOWED_INT &&\n      isNodeProcess() &&\n      hasRefCounted(timeoutId)\n    ) {\n      // Prevent the process from hanging if this is the only active ref.\n      timeoutId.unref()\n    }\n  })\n}\n"],"mappings":"AAAA,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAEvB,MAAM,8BAA8B;AACpC,MAAM,2BAA2B;AACjC,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAEzC,SAAS,2BAAmC;AAC1C,MAAI,cAAc,GAAG;AACnB,WAAO;AAAA,EACT;AAEA,SAAO,KAAK;AAAA,IACV,KAAK,OAAO,KAAK,2BAA2B,4BAC1C;AAAA,EACJ;AACF;AAcA,eAAsB,MACpB,gBACe;AACf,MAAI;AAEJ,MAAI,OAAO,mBAAmB,UAAU;AACtC,YAAQ,gBAAgB;AAAA,MACtB,KAAK,YAAY;AAGf,oBAAY;AACZ;AAAA,MACF;AAAA,MACA,KAAK,QAAQ;AACX,oBAAY,yBAAyB;AACrC;AAAA,MACF;AAAA,MACA,SAAS;AACP,cAAM,IAAI;AAAA,UACR,mDAAmD,cAAc;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF,WAAW,OAAO,mBAAmB,aAAa;AAEhD,gBAAY,yBAAyB;AAAA,EACvC,OAAO;AAGL,QAAI,iBAAiB,6BAA6B;AAChD,YAAM,IAAI;AAAA,QACR,wDAAwD,cAAc,4DAA4D,2BAA2B;AAAA,MAC/J;AAAA,IACF;AAEA,gBAAY;AAAA,EACd;AAEA,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,UAAM,YAAY,WAAW,SAAS,SAAS;AAE/C,QACE,cAAc,+BACd,cAAc,KACd,cAAc,SAAS,GACvB;AAEA,gBAAU,MAAM;AAAA,IAClB;AAAA,EACF,CAAC;AACH;","names":[]}

node_modules/msw/lib/core/getResponse.d.mts

@@ -0,0 +1,18 @@
+import { R as RequestHandler, m as ResponseResolutionContext } from './HttpResponse-Be4eT3x6.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+import './utils/matching/matchRequestUrl.mjs';
+
+/**
+ * Finds a response for the given request instance
+ * in the array of request handlers.
+ * @param handlers The array of request handlers.
+ * @param request The `Request` instance.
+ * @param resolutionContext Request resolution options.
+ * @returns {Response} A mocked response, if any.
+ */
+declare const getResponse: (handlers: Array<RequestHandler>, request: Request, resolutionContext?: ResponseResolutionContext) => Promise<Response | undefined>;
+
+export { getResponse };

node_modules/msw/lib/core/getResponse.d.ts

@@ -0,0 +1,18 @@
+import { R as RequestHandler, m as ResponseResolutionContext } from './HttpResponse-Dj6ibgFJ.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+import './utils/matching/matchRequestUrl.js';
+
+/**
+ * Finds a response for the given request instance
+ * in the array of request handlers.
+ * @param handlers The array of request handlers.
+ * @param request The `Request` instance.
+ * @param resolutionContext Request resolution options.
+ * @returns {Response} A mocked response, if any.
+ */
+declare const getResponse: (handlers: Array<RequestHandler>, request: Request, resolutionContext?: ResponseResolutionContext) => Promise<Response | undefined>;
+
+export { getResponse };

node_modules/msw/lib/core/getResponse.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getResponse_exports = {};
+__export(getResponse_exports, {
+  getResponse: () => getResponse
+});
+module.exports = __toCommonJS(getResponse_exports);
+var import_interceptors = require("@mswjs/interceptors");
+var import_executeHandlers = require("./utils/executeHandlers");
+const getResponse = async (handlers, request, resolutionContext) => {
+  const result = await (0, import_executeHandlers.executeHandlers)({
+    request,
+    requestId: (0, import_interceptors.createRequestId)(),
+    handlers,
+    resolutionContext
+  });
+  return result?.response;
+};
+//# sourceMappingURL=getResponse.js.map

node_modules/msw/lib/core/getResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/getResponse.ts"],"sourcesContent":["import { createRequestId } from '@mswjs/interceptors'\nimport type { RequestHandler } from './handlers/RequestHandler'\nimport {\n  executeHandlers,\n  type ResponseResolutionContext,\n} from './utils/executeHandlers'\n\n/**\n * Finds a response for the given request instance\n * in the array of request handlers.\n * @param handlers The array of request handlers.\n * @param request The `Request` instance.\n * @param resolutionContext Request resolution options.\n * @returns {Response} A mocked response, if any.\n */\nexport const getResponse = async (\n  handlers: Array<RequestHandler>,\n  request: Request,\n  resolutionContext?: ResponseResolutionContext,\n): Promise<Response | undefined> => {\n  const result = await executeHandlers({\n    request,\n    requestId: createRequestId(),\n    handlers,\n    resolutionContext,\n  })\n\n  return result?.response\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAAgC;AAEhC,6BAGO;AAUA,MAAM,cAAc,OACzB,UACA,SACA,sBACkC;AAClC,QAAM,SAAS,UAAM,wCAAgB;AAAA,IACnC;AAAA,IACA,eAAW,qCAAgB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;","names":[]}

node_modules/msw/lib/core/getResponse.mjs

@@ -0,0 +1,17 @@
+import { createRequestId } from "@mswjs/interceptors";
+import {
+  executeHandlers
+} from './utils/executeHandlers.mjs';
+const getResponse = async (handlers, request, resolutionContext) => {
+  const result = await executeHandlers({
+    request,
+    requestId: createRequestId(),
+    handlers,
+    resolutionContext
+  });
+  return result?.response;
+};
+export {
+  getResponse
+};
+//# sourceMappingURL=getResponse.mjs.map

node_modules/msw/lib/core/getResponse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/getResponse.ts"],"sourcesContent":["import { createRequestId } from '@mswjs/interceptors'\nimport type { RequestHandler } from './handlers/RequestHandler'\nimport {\n  executeHandlers,\n  type ResponseResolutionContext,\n} from './utils/executeHandlers'\n\n/**\n * Finds a response for the given request instance\n * in the array of request handlers.\n * @param handlers The array of request handlers.\n * @param request The `Request` instance.\n * @param resolutionContext Request resolution options.\n * @returns {Response} A mocked response, if any.\n */\nexport const getResponse = async (\n  handlers: Array<RequestHandler>,\n  request: Request,\n  resolutionContext?: ResponseResolutionContext,\n): Promise<Response | undefined> => {\n  const result = await executeHandlers({\n    request,\n    requestId: createRequestId(),\n    handlers,\n    resolutionContext,\n  })\n\n  return result?.response\n}\n"],"mappings":"AAAA,SAAS,uBAAuB;AAEhC;AAAA,EACE;AAAA,OAEK;AAUA,MAAM,cAAc,OACzB,UACA,SACA,sBACkC;AAClC,QAAM,SAAS,MAAM,gBAAgB;AAAA,IACnC;AAAA,IACA,WAAW,gBAAgB;AAAA,IAC3B;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO,QAAQ;AACjB;","names":[]}

node_modules/msw/lib/core/graphql.d.mts

@@ -0,0 +1,76 @@
+import { f as GraphQLQuery, g as GraphQLVariables, p as GraphQLPredicate, a as ResponseResolver, q as GraphQLResolverExtras, i as GraphQLResponseBody, c as RequestHandlerOptions, G as GraphQLHandler } from './HttpResponse-Be4eT3x6.mjs';
+import { Path } from './utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+
+type GraphQLRequestHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(predicate: GraphQLPredicate<Query, Variables>, resolver: GraphQLResponseResolver<[
+    Query
+] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
+type GraphQLOperationHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(resolver: GraphQLResponseResolver<[
+    Query
+] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
+type GraphQLResponseResolver<Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables> = ResponseResolver<GraphQLResolverExtras<Variables>, null, GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>>;
+interface GraphQLLinkHandlers {
+    query: GraphQLRequestHandler;
+    mutation: GraphQLRequestHandler;
+    operation: GraphQLOperationHandler;
+}
+/**
+ * A namespace to intercept and mock GraphQL operations
+ *
+ * @example
+ * graphql.query('GetUser', resolver)
+ * graphql.mutation('DeletePost', resolver)
+ *
+ * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
+ */
+declare const graphql: {
+    /**
+     * Intercepts a GraphQL query by a given name.
+     *
+     * @example
+     * graphql.query('GetUser', () => {
+     *   return HttpResponse.json({ data: { user: { name: 'John' } } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
+     */
+    query: GraphQLRequestHandler;
+    /**
+     * Intercepts a GraphQL mutation by its name.
+     *
+     * @example
+     * graphql.mutation('SavePost', () => {
+     *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
+     *
+     */
+    mutation: GraphQLRequestHandler;
+    /**
+     * Intercepts any GraphQL operation, regardless of its type or name.
+     *
+     * @example
+     * graphql.operation(() => {
+     *   return HttpResponse.json({ data: { name: 'John' } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
+     */
+    operation: GraphQLOperationHandler;
+    /**
+     * Intercepts GraphQL operations scoped by the given URL.
+     *
+     * @example
+     * const github = graphql.link('https://api.github.com/graphql')
+     * github.query('GetRepo', resolver)
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+     */
+    link(url: Path): GraphQLLinkHandlers;
+};
+
+export { type GraphQLLinkHandlers, type GraphQLOperationHandler, type GraphQLRequestHandler, type GraphQLResponseResolver, graphql };

node_modules/msw/lib/core/graphql.d.ts

@@ -0,0 +1,76 @@
+import { f as GraphQLQuery, g as GraphQLVariables, p as GraphQLPredicate, a as ResponseResolver, q as GraphQLResolverExtras, i as GraphQLResponseBody, c as RequestHandlerOptions, G as GraphQLHandler } from './HttpResponse-Dj6ibgFJ.js';
+import { Path } from './utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+
+type GraphQLRequestHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(predicate: GraphQLPredicate<Query, Variables>, resolver: GraphQLResponseResolver<[
+    Query
+] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
+type GraphQLOperationHandler = <Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables>(resolver: GraphQLResponseResolver<[
+    Query
+] extends [never] ? GraphQLQuery : Query, Variables>, options?: RequestHandlerOptions) => GraphQLHandler;
+type GraphQLResponseResolver<Query extends GraphQLQuery = GraphQLQuery, Variables extends GraphQLVariables = GraphQLVariables> = ResponseResolver<GraphQLResolverExtras<Variables>, null, GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>>;
+interface GraphQLLinkHandlers {
+    query: GraphQLRequestHandler;
+    mutation: GraphQLRequestHandler;
+    operation: GraphQLOperationHandler;
+}
+/**
+ * A namespace to intercept and mock GraphQL operations
+ *
+ * @example
+ * graphql.query('GetUser', resolver)
+ * graphql.mutation('DeletePost', resolver)
+ *
+ * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}
+ */
+declare const graphql: {
+    /**
+     * Intercepts a GraphQL query by a given name.
+     *
+     * @example
+     * graphql.query('GetUser', () => {
+     *   return HttpResponse.json({ data: { user: { name: 'John' } } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
+     */
+    query: GraphQLRequestHandler;
+    /**
+     * Intercepts a GraphQL mutation by its name.
+     *
+     * @example
+     * graphql.mutation('SavePost', () => {
+     *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
+     *
+     */
+    mutation: GraphQLRequestHandler;
+    /**
+     * Intercepts any GraphQL operation, regardless of its type or name.
+     *
+     * @example
+     * graphql.operation(() => {
+     *   return HttpResponse.json({ data: { name: 'John' } })
+     * })
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
+     */
+    operation: GraphQLOperationHandler;
+    /**
+     * Intercepts GraphQL operations scoped by the given URL.
+     *
+     * @example
+     * const github = graphql.link('https://api.github.com/graphql')
+     * github.query('GetRepo', resolver)
+     *
+     * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+     */
+    link(url: Path): GraphQLLinkHandlers;
+};
+
+export { type GraphQLLinkHandlers, type GraphQLOperationHandler, type GraphQLRequestHandler, type GraphQLResponseResolver, graphql };

node_modules/msw/lib/core/graphql.js

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphql_exports = {};
+__export(graphql_exports, {
+  graphql: () => graphql
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_GraphQLHandler = require("./handlers/GraphQLHandler");
+function createScopedGraphQLHandler(operationType, url) {
+  return (predicate, resolver, options = {}) => {
+    return new import_GraphQLHandler.GraphQLHandler(operationType, predicate, url, resolver, options);
+  };
+}
+function createGraphQLOperationHandler(url) {
+  return (resolver, options) => {
+    return new import_GraphQLHandler.GraphQLHandler("all", new RegExp(".*"), url, resolver, options);
+  };
+}
+const graphql = {
+  /**
+   * Intercepts a GraphQL query by a given name.
+   *
+   * @example
+   * graphql.query('GetUser', () => {
+   *   return HttpResponse.json({ data: { user: { name: 'John' } } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
+   */
+  query: createScopedGraphQLHandler("query", "*"),
+  /**
+   * Intercepts a GraphQL mutation by its name.
+   *
+   * @example
+   * graphql.mutation('SavePost', () => {
+   *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
+   *
+   */
+  mutation: createScopedGraphQLHandler("mutation", "*"),
+  /**
+   * Intercepts any GraphQL operation, regardless of its type or name.
+   *
+   * @example
+   * graphql.operation(() => {
+   *   return HttpResponse.json({ data: { name: 'John' } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
+   */
+  operation: createGraphQLOperationHandler("*"),
+  /**
+   * Intercepts GraphQL operations scoped by the given URL.
+   *
+   * @example
+   * const github = graphql.link('https://api.github.com/graphql')
+   * github.query('GetRepo', resolver)
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+   */
+  link(url) {
+    return {
+      operation: createGraphQLOperationHandler(url),
+      query: createScopedGraphQLHandler("query", url),
+      mutation: createScopedGraphQLHandler(
+        "mutation",
+        url
+      )
+    };
+  }
+};
+//# sourceMappingURL=graphql.js.map

node_modules/msw/lib/core/graphql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/graphql.ts"],"sourcesContent":["import type { OperationTypeNode } from 'graphql'\nimport {\n  ResponseResolver,\n  RequestHandlerOptions,\n} from './handlers/RequestHandler'\nimport {\n  GraphQLHandler,\n  GraphQLVariables,\n  GraphQLOperationType,\n  GraphQLResolverExtras,\n  GraphQLResponseBody,\n  GraphQLQuery,\n  GraphQLPredicate,\n} from './handlers/GraphQLHandler'\nimport type { Path } from './utils/matching/matchRequestUrl'\n\nexport type GraphQLRequestHandler = <\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n>(\n  predicate: GraphQLPredicate<Query, Variables>,\n  resolver: GraphQLResponseResolver<\n    [Query] extends [never] ? GraphQLQuery : Query,\n    Variables\n  >,\n  options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLOperationHandler = <\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n>(\n  resolver: GraphQLResponseResolver<\n    [Query] extends [never] ? GraphQLQuery : Query,\n    Variables\n  >,\n  options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLResponseResolver<\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n> = ResponseResolver<\n  GraphQLResolverExtras<Variables>,\n  null,\n  GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>\n>\n\nfunction createScopedGraphQLHandler(\n  operationType: GraphQLOperationType,\n  url: Path,\n): GraphQLRequestHandler {\n  return (predicate, resolver, options = {}) => {\n    return new GraphQLHandler(operationType, predicate, url, resolver, options)\n  }\n}\n\nfunction createGraphQLOperationHandler(url: Path): GraphQLOperationHandler {\n  return (resolver, options) => {\n    return new GraphQLHandler('all', new RegExp('.*'), url, resolver, options)\n  }\n}\n\nexport interface GraphQLLinkHandlers {\n  query: GraphQLRequestHandler\n  mutation: GraphQLRequestHandler\n  operation: GraphQLOperationHandler\n}\n\n/**\n * A namespace to intercept and mock GraphQL operations\n *\n * @example\n * graphql.query('GetUser', resolver)\n * graphql.mutation('DeletePost', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}\n */\nexport const graphql = {\n  /**\n   * Intercepts a GraphQL query by a given name.\n   *\n   * @example\n   * graphql.query('GetUser', () => {\n   *   return HttpResponse.json({ data: { user: { name: 'John' } } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}\n   */\n  query: createScopedGraphQLHandler('query' as OperationTypeNode, '*'),\n\n  /**\n   * Intercepts a GraphQL mutation by its name.\n   *\n   * @example\n   * graphql.mutation('SavePost', () => {\n   *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}\n   *\n   */\n  mutation: createScopedGraphQLHandler('mutation' as OperationTypeNode, '*'),\n\n  /**\n   * Intercepts any GraphQL operation, regardless of its type or name.\n   *\n   * @example\n   * graphql.operation(() => {\n   *   return HttpResponse.json({ data: { name: 'John' } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}\n   */\n  operation: createGraphQLOperationHandler('*'),\n\n  /**\n   * Intercepts GraphQL operations scoped by the given URL.\n   *\n   * @example\n   * const github = graphql.link('https://api.github.com/graphql')\n   * github.query('GetRepo', resolver)\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}\n   */\n  link(url: Path): GraphQLLinkHandlers {\n    return {\n      operation: createGraphQLOperationHandler(url),\n      query: createScopedGraphQLHandler('query' as OperationTypeNode, url),\n      mutation: createScopedGraphQLHandler(\n        'mutation' as OperationTypeNode,\n        url,\n      ),\n    }\n  },\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,4BAQO;AAmCP,SAAS,2BACP,eACA,KACuB;AACvB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,qCAAe,eAAe,WAAW,KAAK,UAAU,OAAO;AAAA,EAC5E;AACF;AAEA,SAAS,8BAA8B,KAAoC;AACzE,SAAO,CAAC,UAAU,YAAY;AAC5B,WAAO,IAAI,qCAAe,OAAO,IAAI,OAAO,IAAI,GAAG,KAAK,UAAU,OAAO;AAAA,EAC3E;AACF;AAiBO,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,OAAO,2BAA2B,SAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanE,UAAU,2BAA2B,YAAiC,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYzE,WAAW,8BAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,KAAK,KAAgC;AACnC,WAAO;AAAA,MACL,WAAW,8BAA8B,GAAG;AAAA,MAC5C,OAAO,2BAA2B,SAA8B,GAAG;AAAA,MACnE,UAAU;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

node_modules/msw/lib/core/graphql.mjs

@@ -0,0 +1,72 @@
+import {
+  GraphQLHandler
+} from './handlers/GraphQLHandler.mjs';
+function createScopedGraphQLHandler(operationType, url) {
+  return (predicate, resolver, options = {}) => {
+    return new GraphQLHandler(operationType, predicate, url, resolver, options);
+  };
+}
+function createGraphQLOperationHandler(url) {
+  return (resolver, options) => {
+    return new GraphQLHandler("all", new RegExp(".*"), url, resolver, options);
+  };
+}
+const graphql = {
+  /**
+   * Intercepts a GraphQL query by a given name.
+   *
+   * @example
+   * graphql.query('GetUser', () => {
+   *   return HttpResponse.json({ data: { user: { name: 'John' } } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}
+   */
+  query: createScopedGraphQLHandler("query", "*"),
+  /**
+   * Intercepts a GraphQL mutation by its name.
+   *
+   * @example
+   * graphql.mutation('SavePost', () => {
+   *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}
+   *
+   */
+  mutation: createScopedGraphQLHandler("mutation", "*"),
+  /**
+   * Intercepts any GraphQL operation, regardless of its type or name.
+   *
+   * @example
+   * graphql.operation(() => {
+   *   return HttpResponse.json({ data: { name: 'John' } })
+   * })
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}
+   */
+  operation: createGraphQLOperationHandler("*"),
+  /**
+   * Intercepts GraphQL operations scoped by the given URL.
+   *
+   * @example
+   * const github = graphql.link('https://api.github.com/graphql')
+   * github.query('GetRepo', resolver)
+   *
+   * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}
+   */
+  link(url) {
+    return {
+      operation: createGraphQLOperationHandler(url),
+      query: createScopedGraphQLHandler("query", url),
+      mutation: createScopedGraphQLHandler(
+        "mutation",
+        url
+      )
+    };
+  }
+};
+export {
+  graphql
+};
+//# sourceMappingURL=graphql.mjs.map

node_modules/msw/lib/core/graphql.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/graphql.ts"],"sourcesContent":["import type { OperationTypeNode } from 'graphql'\nimport {\n  ResponseResolver,\n  RequestHandlerOptions,\n} from './handlers/RequestHandler'\nimport {\n  GraphQLHandler,\n  GraphQLVariables,\n  GraphQLOperationType,\n  GraphQLResolverExtras,\n  GraphQLResponseBody,\n  GraphQLQuery,\n  GraphQLPredicate,\n} from './handlers/GraphQLHandler'\nimport type { Path } from './utils/matching/matchRequestUrl'\n\nexport type GraphQLRequestHandler = <\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n>(\n  predicate: GraphQLPredicate<Query, Variables>,\n  resolver: GraphQLResponseResolver<\n    [Query] extends [never] ? GraphQLQuery : Query,\n    Variables\n  >,\n  options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLOperationHandler = <\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n>(\n  resolver: GraphQLResponseResolver<\n    [Query] extends [never] ? GraphQLQuery : Query,\n    Variables\n  >,\n  options?: RequestHandlerOptions,\n) => GraphQLHandler\n\nexport type GraphQLResponseResolver<\n  Query extends GraphQLQuery = GraphQLQuery,\n  Variables extends GraphQLVariables = GraphQLVariables,\n> = ResponseResolver<\n  GraphQLResolverExtras<Variables>,\n  null,\n  GraphQLResponseBody<[Query] extends [never] ? GraphQLQuery : Query>\n>\n\nfunction createScopedGraphQLHandler(\n  operationType: GraphQLOperationType,\n  url: Path,\n): GraphQLRequestHandler {\n  return (predicate, resolver, options = {}) => {\n    return new GraphQLHandler(operationType, predicate, url, resolver, options)\n  }\n}\n\nfunction createGraphQLOperationHandler(url: Path): GraphQLOperationHandler {\n  return (resolver, options) => {\n    return new GraphQLHandler('all', new RegExp('.*'), url, resolver, options)\n  }\n}\n\nexport interface GraphQLLinkHandlers {\n  query: GraphQLRequestHandler\n  mutation: GraphQLRequestHandler\n  operation: GraphQLOperationHandler\n}\n\n/**\n * A namespace to intercept and mock GraphQL operations\n *\n * @example\n * graphql.query('GetUser', resolver)\n * graphql.mutation('DeletePost', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/graphql `graphql` API reference}\n */\nexport const graphql = {\n  /**\n   * Intercepts a GraphQL query by a given name.\n   *\n   * @example\n   * graphql.query('GetUser', () => {\n   *   return HttpResponse.json({ data: { user: { name: 'John' } } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqlqueryqueryname-resolver `graphql.query()` API reference}\n   */\n  query: createScopedGraphQLHandler('query' as OperationTypeNode, '*'),\n\n  /**\n   * Intercepts a GraphQL mutation by its name.\n   *\n   * @example\n   * graphql.mutation('SavePost', () => {\n   *   return HttpResponse.json({ data: { post: { id: 'abc-123 } } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqlmutationmutationname-resolver `graphql.query()` API reference}\n   *\n   */\n  mutation: createScopedGraphQLHandler('mutation' as OperationTypeNode, '*'),\n\n  /**\n   * Intercepts any GraphQL operation, regardless of its type or name.\n   *\n   * @example\n   * graphql.operation(() => {\n   *   return HttpResponse.json({ data: { name: 'John' } })\n   * })\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqloperationresolver `graphql.operation()` API reference}\n   */\n  operation: createGraphQLOperationHandler('*'),\n\n  /**\n   * Intercepts GraphQL operations scoped by the given URL.\n   *\n   * @example\n   * const github = graphql.link('https://api.github.com/graphql')\n   * github.query('GetRepo', resolver)\n   *\n   * @see {@link https://mswjs.io/docs/api/graphql#graphqllinkurl `graphql.link()` API reference}\n   */\n  link(url: Path): GraphQLLinkHandlers {\n    return {\n      operation: createGraphQLOperationHandler(url),\n      query: createScopedGraphQLHandler('query' as OperationTypeNode, url),\n      mutation: createScopedGraphQLHandler(\n        'mutation' as OperationTypeNode,\n        url,\n      ),\n    }\n  },\n}\n"],"mappings":"AAKA;AAAA,EACE;AAAA,OAOK;AAmCP,SAAS,2BACP,eACA,KACuB;AACvB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,eAAe,eAAe,WAAW,KAAK,UAAU,OAAO;AAAA,EAC5E;AACF;AAEA,SAAS,8BAA8B,KAAoC;AACzE,SAAO,CAAC,UAAU,YAAY;AAC5B,WAAO,IAAI,eAAe,OAAO,IAAI,OAAO,IAAI,GAAG,KAAK,UAAU,OAAO;AAAA,EAC3E;AACF;AAiBO,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWrB,OAAO,2BAA2B,SAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAanE,UAAU,2BAA2B,YAAiC,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYzE,WAAW,8BAA8B,GAAG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5C,KAAK,KAAgC;AACnC,WAAO;AAAA,MACL,WAAW,8BAA8B,GAAG;AAAA,MAC5C,OAAO,2BAA2B,SAA8B,GAAG;AAAA,MACnE,UAAU;AAAA,QACR;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

node_modules/msw/lib/core/handlers/GraphQLHandler.d.mts

@@ -0,0 +1,6 @@
+import 'graphql';
+export { z as DocumentTypeDecoration, l as GraphQLCustomPredicate, F as GraphQLCustomPredicateResult, G as GraphQLHandler, C as GraphQLHandlerInfo, B as GraphQLHandlerNameSelector, j as GraphQLJsonRequestBody, k as GraphQLOperationType, p as GraphQLPredicate, f as GraphQLQuery, h as GraphQLRequestBody, E as GraphQLRequestParsedResult, q as GraphQLResolverExtras, i as GraphQLResponseBody, g as GraphQLVariables, I as isDocumentNode } from '../HttpResponse-Be4eT3x6.mjs';
+import '../utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.mjs';
+import '../typeUtils.mjs';

node_modules/msw/lib/core/handlers/GraphQLHandler.d.ts

@@ -0,0 +1,6 @@
+import 'graphql';
+export { z as DocumentTypeDecoration, l as GraphQLCustomPredicate, F as GraphQLCustomPredicateResult, G as GraphQLHandler, C as GraphQLHandlerInfo, B as GraphQLHandlerNameSelector, j as GraphQLJsonRequestBody, k as GraphQLOperationType, p as GraphQLPredicate, f as GraphQLQuery, h as GraphQLRequestBody, E as GraphQLRequestParsedResult, q as GraphQLResolverExtras, i as GraphQLResponseBody, g as GraphQLVariables, I as isDocumentNode } from '../HttpResponse-Dj6ibgFJ.js';
+import '../utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.js';
+import '../typeUtils.js';

node_modules/msw/lib/core/handlers/GraphQLHandler.js

@@ -0,0 +1,231 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var GraphQLHandler_exports = {};
+__export(GraphQLHandler_exports, {
+  GraphQLHandler: () => GraphQLHandler,
+  isDocumentNode: () => isDocumentNode
+});
+module.exports = __toCommonJS(GraphQLHandler_exports);
+var import_outvariant = require("outvariant");
+var import_graphql = require("graphql");
+var import_RequestHandler = require("./RequestHandler");
+var import_getTimestamp = require("../utils/logging/getTimestamp");
+var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor");
+var import_serializeRequest = require("../utils/logging/serializeRequest");
+var import_serializeResponse = require("../utils/logging/serializeResponse");
+var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
+var import_parseGraphQLRequest = require("../utils/internal/parseGraphQLRequest");
+var import_toPublicUrl = require("../utils/request/toPublicUrl");
+var import_devUtils = require("../utils/internal/devUtils");
+var import_getRequestCookies = require("../utils/request/getRequestCookies");
+var import_HttpResponse = require("../HttpResponse");
+var import_getAllAcceptedMimeTypes = require("../utils/request/getAllAcceptedMimeTypes");
+function isDocumentNode(value) {
+  if (value == null) {
+    return false;
+  }
+  return typeof value === "object" && "kind" in value && "definitions" in value;
+}
+function isDocumentTypeDecoration(value) {
+  return value instanceof String;
+}
+class GraphQLHandler extends import_RequestHandler.RequestHandler {
+  endpoint;
+  static parsedRequestCache = /* @__PURE__ */ new WeakMap();
+  static #parseOperationName(predicate, operationType) {
+    const getOperationName = (node) => {
+      (0, import_outvariant.invariant)(
+        node.operationType === operationType,
+        'Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "%s" but got "%s").',
+        operationType,
+        node.operationType
+      );
+      (0, import_outvariant.invariant)(
+        node.operationName,
+        "Failed to create a GraphQL handler: provided a DocumentNode without operation name"
+      );
+      return node.operationName;
+    };
+    if (isDocumentNode(predicate)) {
+      return getOperationName((0, import_parseGraphQLRequest.parseDocumentNode)(predicate));
+    }
+    if (isDocumentTypeDecoration(predicate)) {
+      const documentNode = (0, import_graphql.parse)(predicate.toString());
+      (0, import_outvariant.invariant)(
+        isDocumentNode(documentNode),
+        "Failed to create a GraphQL handler: given TypedDocumentString (%s) does not produce a valid DocumentNode",
+        predicate
+      );
+      return getOperationName((0, import_parseGraphQLRequest.parseDocumentNode)(documentNode));
+    }
+    return predicate;
+  }
+  constructor(operationType, predicate, endpoint, resolver, options) {
+    const operationName = GraphQLHandler.#parseOperationName(
+      predicate,
+      operationType
+    );
+    const displayOperationName = typeof operationName === "function" ? "[custom predicate]" : operationName;
+    const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType}${displayOperationName ? ` ${displayOperationName}` : ""} (origin: ${endpoint.toString()})`;
+    super({
+      info: {
+        header,
+        operationType,
+        operationName: GraphQLHandler.#parseOperationName(
+          predicate,
+          operationType
+        )
+      },
+      resolver,
+      options
+    });
+    this.endpoint = endpoint;
+  }
+  /**
+   * Parses the request body, once per request, cached across all
+   * GraphQL handlers. This is done to avoid multiple parsing of the
+   * request body, which each requires a clone of the request.
+   */
+  async parseGraphQLRequestOrGetFromCache(request) {
+    if (!GraphQLHandler.parsedRequestCache.has(request)) {
+      GraphQLHandler.parsedRequestCache.set(
+        request,
+        await (0, import_parseGraphQLRequest.parseGraphQLRequest)(request).catch((error) => {
+          console.error(error);
+          return void 0;
+        })
+      );
+    }
+    return GraphQLHandler.parsedRequestCache.get(request);
+  }
+  async parse(args) {
+    const match = (0, import_matchRequestUrl.matchRequestUrl)(new URL(args.request.url), this.endpoint);
+    const cookies = (0, import_getRequestCookies.getAllRequestCookies)(args.request);
+    if (!match.matches) {
+      return {
+        match,
+        cookies
+      };
+    }
+    const parsedResult = await this.parseGraphQLRequestOrGetFromCache(
+      args.request
+    );
+    if (typeof parsedResult === "undefined") {
+      return {
+        match,
+        cookies
+      };
+    }
+    return {
+      match,
+      cookies,
+      query: parsedResult.query,
+      operationType: parsedResult.operationType,
+      operationName: parsedResult.operationName,
+      variables: parsedResult.variables
+    };
+  }
+  async predicate(args) {
+    if (args.parsedResult.operationType === void 0) {
+      return false;
+    }
+    if (!args.parsedResult.operationName && this.info.operationType !== "all") {
+      const publicUrl = (0, import_toPublicUrl.toPublicUrl)(args.request.url);
+      import_devUtils.devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
+
+Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`);
+      return false;
+    }
+    const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
+    const hasMatchingOperationName = await this.matchOperationName({
+      request: args.request,
+      parsedResult: args.parsedResult
+    });
+    return args.parsedResult.match.matches && hasMatchingOperationType && hasMatchingOperationName;
+  }
+  async run(args) {
+    const result = await super.run(args);
+    if (result?.response == null) {
+      return result;
+    }
+    if (!(import_HttpResponse.kDefaultContentType in result.response)) {
+      return result;
+    }
+    const acceptedMimeTypes = (0, import_getAllAcceptedMimeTypes.getAllAcceptedMimeTypes)(
+      args.request.headers.get("accept")
+    );
+    if (acceptedMimeTypes.length === 0) {
+      return result;
+    }
+    const graphqlResponseIndex = acceptedMimeTypes.indexOf(
+      "application/graphql-response+json"
+    );
+    const jsonIndex = acceptedMimeTypes.indexOf("application/json");
+    if (graphqlResponseIndex !== -1 && (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)) {
+      result.response.headers.set(
+        "content-type",
+        "application/graphql-response+json"
+      );
+    }
+    return result;
+  }
+  async matchOperationName(args) {
+    if (typeof this.info.operationName === "function") {
+      const customPredicateResult = await this.info.operationName({
+        request: args.request,
+        ...this.extendResolverArgs({
+          request: args.request,
+          parsedResult: args.parsedResult
+        })
+      });
+      return typeof customPredicateResult === "boolean" ? customPredicateResult : customPredicateResult.matches;
+    }
+    if (this.info.operationName instanceof RegExp) {
+      return this.info.operationName.test(args.parsedResult.operationName || "");
+    }
+    return args.parsedResult.operationName === this.info.operationName;
+  }
+  extendResolverArgs(args) {
+    return {
+      query: args.parsedResult.query || "",
+      operationType: args.parsedResult.operationType,
+      operationName: args.parsedResult.operationName || "",
+      variables: args.parsedResult.variables || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  async log(args) {
+    const loggedRequest = await (0, import_serializeRequest.serializeRequest)(args.request);
+    const loggedResponse = await (0, import_serializeResponse.serializeResponse)(args.response);
+    const statusColor = (0, import_getStatusCodeColor.getStatusCodeColor)(loggedResponse.status);
+    const requestInfo = args.parsedResult.operationName ? `${args.parsedResult.operationType} ${args.parsedResult.operationName}` : `anonymous ${args.parsedResult.operationType}`;
+    console.groupCollapsed(
+      import_devUtils.devUtils.formatMessage(
+        `${(0, import_getTimestamp.getTimestamp)()} ${requestInfo} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
+      ),
+      `color:${statusColor}`,
+      "color:inherit"
+    );
+    console.log("Request:", loggedRequest);
+    console.log("Handler:", this);
+    console.log("Response:", loggedResponse);
+    console.groupEnd();
+  }
+}
+//# sourceMappingURL=GraphQLHandler.js.map

node_modules/msw/lib/core/handlers/GraphQLHandler.mjs

@@ -0,0 +1,218 @@
+import { invariant } from "outvariant";
+import {
+  parse
+} from "graphql";
+import {
+  RequestHandler
+} from './RequestHandler.mjs';
+import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
+import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
+import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
+import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
+import { matchRequestUrl } from '../utils/matching/matchRequestUrl.mjs';
+import {
+  parseGraphQLRequest,
+  parseDocumentNode
+} from '../utils/internal/parseGraphQLRequest.mjs';
+import { toPublicUrl } from '../utils/request/toPublicUrl.mjs';
+import { devUtils } from '../utils/internal/devUtils.mjs';
+import { getAllRequestCookies } from '../utils/request/getRequestCookies.mjs';
+import { kDefaultContentType } from '../HttpResponse.mjs';
+import { getAllAcceptedMimeTypes } from '../utils/request/getAllAcceptedMimeTypes.mjs';
+function isDocumentNode(value) {
+  if (value == null) {
+    return false;
+  }
+  return typeof value === "object" && "kind" in value && "definitions" in value;
+}
+function isDocumentTypeDecoration(value) {
+  return value instanceof String;
+}
+class GraphQLHandler extends RequestHandler {
+  endpoint;
+  static parsedRequestCache = /* @__PURE__ */ new WeakMap();
+  static #parseOperationName(predicate, operationType) {
+    const getOperationName = (node) => {
+      invariant(
+        node.operationType === operationType,
+        'Failed to create a GraphQL handler: provided a DocumentNode with a mismatched operation type (expected "%s" but got "%s").',
+        operationType,
+        node.operationType
+      );
+      invariant(
+        node.operationName,
+        "Failed to create a GraphQL handler: provided a DocumentNode without operation name"
+      );
+      return node.operationName;
+    };
+    if (isDocumentNode(predicate)) {
+      return getOperationName(parseDocumentNode(predicate));
+    }
+    if (isDocumentTypeDecoration(predicate)) {
+      const documentNode = parse(predicate.toString());
+      invariant(
+        isDocumentNode(documentNode),
+        "Failed to create a GraphQL handler: given TypedDocumentString (%s) does not produce a valid DocumentNode",
+        predicate
+      );
+      return getOperationName(parseDocumentNode(documentNode));
+    }
+    return predicate;
+  }
+  constructor(operationType, predicate, endpoint, resolver, options) {
+    const operationName = GraphQLHandler.#parseOperationName(
+      predicate,
+      operationType
+    );
+    const displayOperationName = typeof operationName === "function" ? "[custom predicate]" : operationName;
+    const header = operationType === "all" ? `${operationType} (origin: ${endpoint.toString()})` : `${operationType}${displayOperationName ? ` ${displayOperationName}` : ""} (origin: ${endpoint.toString()})`;
+    super({
+      info: {
+        header,
+        operationType,
+        operationName: GraphQLHandler.#parseOperationName(
+          predicate,
+          operationType
+        )
+      },
+      resolver,
+      options
+    });
+    this.endpoint = endpoint;
+  }
+  /**
+   * Parses the request body, once per request, cached across all
+   * GraphQL handlers. This is done to avoid multiple parsing of the
+   * request body, which each requires a clone of the request.
+   */
+  async parseGraphQLRequestOrGetFromCache(request) {
+    if (!GraphQLHandler.parsedRequestCache.has(request)) {
+      GraphQLHandler.parsedRequestCache.set(
+        request,
+        await parseGraphQLRequest(request).catch((error) => {
+          console.error(error);
+          return void 0;
+        })
+      );
+    }
+    return GraphQLHandler.parsedRequestCache.get(request);
+  }
+  async parse(args) {
+    const match = matchRequestUrl(new URL(args.request.url), this.endpoint);
+    const cookies = getAllRequestCookies(args.request);
+    if (!match.matches) {
+      return {
+        match,
+        cookies
+      };
+    }
+    const parsedResult = await this.parseGraphQLRequestOrGetFromCache(
+      args.request
+    );
+    if (typeof parsedResult === "undefined") {
+      return {
+        match,
+        cookies
+      };
+    }
+    return {
+      match,
+      cookies,
+      query: parsedResult.query,
+      operationType: parsedResult.operationType,
+      operationName: parsedResult.operationName,
+      variables: parsedResult.variables
+    };
+  }
+  async predicate(args) {
+    if (args.parsedResult.operationType === void 0) {
+      return false;
+    }
+    if (!args.parsedResult.operationName && this.info.operationType !== "all") {
+      const publicUrl = toPublicUrl(args.request.url);
+      devUtils.warn(`Failed to intercept a GraphQL request at "${args.request.method} ${publicUrl}": anonymous GraphQL operations are not supported.
+
+Consider naming this operation or using "graphql.operation()" request handler to intercept GraphQL requests regardless of their operation name/type. Read more: https://mswjs.io/docs/api/graphql/#graphqloperationresolver`);
+      return false;
+    }
+    const hasMatchingOperationType = this.info.operationType === "all" || args.parsedResult.operationType === this.info.operationType;
+    const hasMatchingOperationName = await this.matchOperationName({
+      request: args.request,
+      parsedResult: args.parsedResult
+    });
+    return args.parsedResult.match.matches && hasMatchingOperationType && hasMatchingOperationName;
+  }
+  async run(args) {
+    const result = await super.run(args);
+    if (result?.response == null) {
+      return result;
+    }
+    if (!(kDefaultContentType in result.response)) {
+      return result;
+    }
+    const acceptedMimeTypes = getAllAcceptedMimeTypes(
+      args.request.headers.get("accept")
+    );
+    if (acceptedMimeTypes.length === 0) {
+      return result;
+    }
+    const graphqlResponseIndex = acceptedMimeTypes.indexOf(
+      "application/graphql-response+json"
+    );
+    const jsonIndex = acceptedMimeTypes.indexOf("application/json");
+    if (graphqlResponseIndex !== -1 && (jsonIndex === -1 || graphqlResponseIndex <= jsonIndex)) {
+      result.response.headers.set(
+        "content-type",
+        "application/graphql-response+json"
+      );
+    }
+    return result;
+  }
+  async matchOperationName(args) {
+    if (typeof this.info.operationName === "function") {
+      const customPredicateResult = await this.info.operationName({
+        request: args.request,
+        ...this.extendResolverArgs({
+          request: args.request,
+          parsedResult: args.parsedResult
+        })
+      });
+      return typeof customPredicateResult === "boolean" ? customPredicateResult : customPredicateResult.matches;
+    }
+    if (this.info.operationName instanceof RegExp) {
+      return this.info.operationName.test(args.parsedResult.operationName || "");
+    }
+    return args.parsedResult.operationName === this.info.operationName;
+  }
+  extendResolverArgs(args) {
+    return {
+      query: args.parsedResult.query || "",
+      operationType: args.parsedResult.operationType,
+      operationName: args.parsedResult.operationName || "",
+      variables: args.parsedResult.variables || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  async log(args) {
+    const loggedRequest = await serializeRequest(args.request);
+    const loggedResponse = await serializeResponse(args.response);
+    const statusColor = getStatusCodeColor(loggedResponse.status);
+    const requestInfo = args.parsedResult.operationName ? `${args.parsedResult.operationType} ${args.parsedResult.operationName}` : `anonymous ${args.parsedResult.operationType}`;
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp()} ${requestInfo} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
+      ),
+      `color:${statusColor}`,
+      "color:inherit"
+    );
+    console.log("Request:", loggedRequest);
+    console.log("Handler:", this);
+    console.log("Response:", loggedResponse);
+    console.groupEnd();
+  }
+}
+export {
+  GraphQLHandler,
+  isDocumentNode
+};
+//# sourceMappingURL=GraphQLHandler.mjs.map

node_modules/msw/lib/core/handlers/HttpHandler.d.mts

@@ -0,0 +1,75 @@
+import { R as RequestHandler, r as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions, m as ResponseResolutionContext } from '../HttpResponse-Be4eT3x6.mjs';
+import { PathParams, Path, Match } from '../utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.mjs';
+import '../typeUtils.mjs';
+import 'graphql';
+
+type HttpHandlerMethod = string | RegExp;
+interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
+    method: HttpHandlerMethod;
+    path: HttpRequestPredicate<PathParams>;
+}
+declare enum HttpMethods {
+    HEAD = "HEAD",
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    DELETE = "DELETE"
+}
+type RequestQuery = {
+    [queryName: string]: string;
+};
+type HttpRequestParsedResult = {
+    match: Match;
+    cookies: Record<string, string>;
+};
+type HttpRequestResolverExtras<Params extends PathParams> = {
+    params: Params;
+    cookies: Record<string, string>;
+};
+type HttpCustomPredicate<Params extends PathParams> = (args: {
+    request: Request;
+    cookies: Record<string, string>;
+}) => HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>;
+type HttpCustomPredicateResult<Params extends PathParams> = boolean | {
+    matches: boolean;
+    params: Params;
+};
+type HttpRequestPredicate<Params extends PathParams> = Path | HttpCustomPredicate<Params>;
+/**
+ * Request handler for HTTP requests.
+ * Provides request matching based on method and URL.
+ */
+declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
+    constructor(method: HttpHandlerMethod, predicate: HttpRequestPredicate<PathParams>, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    private checkRedundantQueryParameters;
+    parse(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<{
+        match: Match;
+        cookies: Record<string, string>;
+    }>;
+    predicate(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<boolean>;
+    private matchMethod;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+    }): {
+        params: PathParams<string>;
+        cookies: Record<string, string>;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+    }): Promise<void>;
+}
+
+export { type HttpCustomPredicate, type HttpCustomPredicateResult, HttpHandler, type HttpHandlerInfo, type HttpHandlerMethod, HttpMethods, type HttpRequestParsedResult, type HttpRequestPredicate, type HttpRequestResolverExtras, type RequestQuery };

node_modules/msw/lib/core/handlers/HttpHandler.d.ts

@@ -0,0 +1,75 @@
+import { R as RequestHandler, r as RequestHandlerDefaultInfo, a as ResponseResolver, c as RequestHandlerOptions, m as ResponseResolutionContext } from '../HttpResponse-Dj6ibgFJ.js';
+import { PathParams, Path, Match } from '../utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import '../utils/internal/isIterable.js';
+import '../typeUtils.js';
+import 'graphql';
+
+type HttpHandlerMethod = string | RegExp;
+interface HttpHandlerInfo extends RequestHandlerDefaultInfo {
+    method: HttpHandlerMethod;
+    path: HttpRequestPredicate<PathParams>;
+}
+declare enum HttpMethods {
+    HEAD = "HEAD",
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    DELETE = "DELETE"
+}
+type RequestQuery = {
+    [queryName: string]: string;
+};
+type HttpRequestParsedResult = {
+    match: Match;
+    cookies: Record<string, string>;
+};
+type HttpRequestResolverExtras<Params extends PathParams> = {
+    params: Params;
+    cookies: Record<string, string>;
+};
+type HttpCustomPredicate<Params extends PathParams> = (args: {
+    request: Request;
+    cookies: Record<string, string>;
+}) => HttpCustomPredicateResult<Params> | Promise<HttpCustomPredicateResult<Params>>;
+type HttpCustomPredicateResult<Params extends PathParams> = boolean | {
+    matches: boolean;
+    params: Params;
+};
+type HttpRequestPredicate<Params extends PathParams> = Path | HttpCustomPredicate<Params>;
+/**
+ * Request handler for HTTP requests.
+ * Provides request matching based on method and URL.
+ */
+declare class HttpHandler extends RequestHandler<HttpHandlerInfo, HttpRequestParsedResult, HttpRequestResolverExtras<any>> {
+    constructor(method: HttpHandlerMethod, predicate: HttpRequestPredicate<PathParams>, resolver: ResponseResolver<HttpRequestResolverExtras<any>, any, any>, options?: RequestHandlerOptions);
+    private checkRedundantQueryParameters;
+    parse(args: {
+        request: Request;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<{
+        match: Match;
+        cookies: Record<string, string>;
+    }>;
+    predicate(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+        resolutionContext?: ResponseResolutionContext;
+    }): Promise<boolean>;
+    private matchMethod;
+    protected extendResolverArgs(args: {
+        request: Request;
+        parsedResult: HttpRequestParsedResult;
+    }): {
+        params: PathParams<string>;
+        cookies: Record<string, string>;
+    };
+    log(args: {
+        request: Request;
+        response: Response;
+    }): Promise<void>;
+}
+
+export { type HttpCustomPredicate, type HttpCustomPredicateResult, HttpHandler, type HttpHandlerInfo, type HttpHandlerMethod, HttpMethods, type HttpRequestParsedResult, type HttpRequestPredicate, type HttpRequestResolverExtras, type RequestQuery };

node_modules/msw/lib/core/handlers/HttpHandler.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var HttpHandler_exports = {};
+__export(HttpHandler_exports, {
+  HttpHandler: () => HttpHandler,
+  HttpMethods: () => HttpMethods
+});
+module.exports = __toCommonJS(HttpHandler_exports);
+var import_devUtils = require("../utils/internal/devUtils");
+var import_isStringEqual = require("../utils/internal/isStringEqual");
+var import_getStatusCodeColor = require("../utils/logging/getStatusCodeColor");
+var import_getTimestamp = require("../utils/logging/getTimestamp");
+var import_serializeRequest = require("../utils/logging/serializeRequest");
+var import_serializeResponse = require("../utils/logging/serializeResponse");
+var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
+var import_toPublicUrl = require("../utils/request/toPublicUrl");
+var import_getRequestCookies = require("../utils/request/getRequestCookies");
+var import_cleanUrl = require("../utils/url/cleanUrl");
+var import_RequestHandler = require("./RequestHandler");
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends import_RequestHandler.RequestHandler {
+  constructor(method, predicate, resolver, options) {
+    const displayPath = typeof predicate === "function" ? "[custom predicate]" : predicate;
+    super({
+      info: {
+        header: `${method}${displayPath ? ` ${displayPath}` : ""}`,
+        path: predicate,
+        method
+      },
+      resolver,
+      options
+    });
+    this.checkRedundantQueryParameters();
+  }
+  checkRedundantQueryParameters() {
+    const { method, path } = this.info;
+    if (!path || path instanceof RegExp || typeof path === "function") {
+      return;
+    }
+    const url = (0, import_cleanUrl.cleanUrl)(path);
+    if (url === path) {
+      return;
+    }
+    import_devUtils.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 using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`
+    );
+  }
+  async parse(args) {
+    const url = new URL(args.request.url);
+    const cookies = (0, import_getRequestCookies.getAllRequestCookies)(args.request);
+    if (typeof this.info.path === "function") {
+      const customPredicateResult = await this.info.path({
+        request: args.request,
+        cookies
+      });
+      const match2 = typeof customPredicateResult === "boolean" ? {
+        matches: customPredicateResult,
+        params: {}
+      } : customPredicateResult;
+      return {
+        match: match2,
+        cookies
+      };
+    }
+    const match = this.info.path ? (0, import_matchRequestUrl.matchRequestUrl)(url, this.info.path, args.resolutionContext?.baseUrl) : { matches: false, params: {} };
+    return {
+      match,
+      cookies
+    };
+  }
+  async predicate(args) {
+    const hasMatchingMethod = this.matchMethod(args.request.method);
+    const hasMatchingUrl = args.parsedResult.match.matches;
+    return hasMatchingMethod && hasMatchingUrl;
+  }
+  matchMethod(actualMethod) {
+    return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : (0, import_isStringEqual.isStringEqual)(this.info.method, actualMethod);
+  }
+  extendResolverArgs(args) {
+    return {
+      params: args.parsedResult.match?.params || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  async log(args) {
+    const publicUrl = (0, import_toPublicUrl.toPublicUrl)(args.request.url);
+    const loggedRequest = await (0, import_serializeRequest.serializeRequest)(args.request);
+    const loggedResponse = await (0, import_serializeResponse.serializeResponse)(args.response);
+    const statusColor = (0, import_getStatusCodeColor.getStatusCodeColor)(loggedResponse.status);
+    console.groupCollapsed(
+      import_devUtils.devUtils.formatMessage(
+        `${(0, import_getTimestamp.getTimestamp)()} ${args.request.method} ${publicUrl} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
+      ),
+      `color:${statusColor}`,
+      "color:inherit"
+    );
+    console.log("Request", loggedRequest);
+    console.log("Handler:", this);
+    console.log("Response", loggedResponse);
+    console.groupEnd();
+  }
+}
+//# sourceMappingURL=HttpHandler.js.map

node_modules/msw/lib/core/handlers/HttpHandler.mjs

@@ -0,0 +1,112 @@
+import { devUtils } from '../utils/internal/devUtils.mjs';
+import { isStringEqual } from '../utils/internal/isStringEqual.mjs';
+import { getStatusCodeColor } from '../utils/logging/getStatusCodeColor.mjs';
+import { getTimestamp } from '../utils/logging/getTimestamp.mjs';
+import { serializeRequest } from '../utils/logging/serializeRequest.mjs';
+import { serializeResponse } from '../utils/logging/serializeResponse.mjs';
+import {
+  matchRequestUrl
+} from '../utils/matching/matchRequestUrl.mjs';
+import { toPublicUrl } from '../utils/request/toPublicUrl.mjs';
+import { getAllRequestCookies } from '../utils/request/getRequestCookies.mjs';
+import { cleanUrl } from '../utils/url/cleanUrl.mjs';
+import {
+  RequestHandler
+} from './RequestHandler.mjs';
+var HttpMethods = /* @__PURE__ */ ((HttpMethods2) => {
+  HttpMethods2["HEAD"] = "HEAD";
+  HttpMethods2["GET"] = "GET";
+  HttpMethods2["POST"] = "POST";
+  HttpMethods2["PUT"] = "PUT";
+  HttpMethods2["PATCH"] = "PATCH";
+  HttpMethods2["OPTIONS"] = "OPTIONS";
+  HttpMethods2["DELETE"] = "DELETE";
+  return HttpMethods2;
+})(HttpMethods || {});
+class HttpHandler extends RequestHandler {
+  constructor(method, predicate, resolver, options) {
+    const displayPath = typeof predicate === "function" ? "[custom predicate]" : predicate;
+    super({
+      info: {
+        header: `${method}${displayPath ? ` ${displayPath}` : ""}`,
+        path: predicate,
+        method
+      },
+      resolver,
+      options
+    });
+    this.checkRedundantQueryParameters();
+  }
+  checkRedundantQueryParameters() {
+    const { method, path } = this.info;
+    if (!path || path instanceof RegExp || typeof path === "function") {
+      return;
+    }
+    const url = cleanUrl(path);
+    if (url === path) {
+      return;
+    }
+    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 using "new URL(request.url).searchParams" instead. Learn more: https://mswjs.io/docs/http/intercepting-requests#querysearch-parameters`
+    );
+  }
+  async parse(args) {
+    const url = new URL(args.request.url);
+    const cookies = getAllRequestCookies(args.request);
+    if (typeof this.info.path === "function") {
+      const customPredicateResult = await this.info.path({
+        request: args.request,
+        cookies
+      });
+      const match2 = typeof customPredicateResult === "boolean" ? {
+        matches: customPredicateResult,
+        params: {}
+      } : customPredicateResult;
+      return {
+        match: match2,
+        cookies
+      };
+    }
+    const match = this.info.path ? matchRequestUrl(url, this.info.path, args.resolutionContext?.baseUrl) : { matches: false, params: {} };
+    return {
+      match,
+      cookies
+    };
+  }
+  async predicate(args) {
+    const hasMatchingMethod = this.matchMethod(args.request.method);
+    const hasMatchingUrl = args.parsedResult.match.matches;
+    return hasMatchingMethod && hasMatchingUrl;
+  }
+  matchMethod(actualMethod) {
+    return this.info.method instanceof RegExp ? this.info.method.test(actualMethod) : isStringEqual(this.info.method, actualMethod);
+  }
+  extendResolverArgs(args) {
+    return {
+      params: args.parsedResult.match?.params || {},
+      cookies: args.parsedResult.cookies
+    };
+  }
+  async log(args) {
+    const publicUrl = toPublicUrl(args.request.url);
+    const loggedRequest = await serializeRequest(args.request);
+    const loggedResponse = await serializeResponse(args.response);
+    const statusColor = getStatusCodeColor(loggedResponse.status);
+    console.groupCollapsed(
+      devUtils.formatMessage(
+        `${getTimestamp()} ${args.request.method} ${publicUrl} (%c${loggedResponse.status} ${loggedResponse.statusText}%c)`
+      ),
+      `color:${statusColor}`,
+      "color:inherit"
+    );
+    console.log("Request", loggedRequest);
+    console.log("Handler:", this);
+    console.log("Response", loggedResponse);
+    console.groupEnd();
+  }
+}
+export {
+  HttpHandler,
+  HttpMethods
+};
+//# sourceMappingURL=HttpHandler.mjs.map

node_modules/msw/lib/core/handlers/RequestHandler.d.mts

@@ -0,0 +1,6 @@
+import '../utils/internal/isIterable.mjs';
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, J as JsonBodyType, M as MaybeAsyncResponseResolverReturnType, R as RequestHandler, L as RequestHandlerArgs, r as RequestHandlerDefaultInfo, N as RequestHandlerExecutionResult, K as RequestHandlerInternalInfo, c as RequestHandlerOptions, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType } from '../HttpResponse-Be4eT3x6.mjs';
+import '../typeUtils.mjs';
+import '@mswjs/interceptors';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.mjs';

node_modules/msw/lib/core/handlers/RequestHandler.d.ts

@@ -0,0 +1,6 @@
+import '../utils/internal/isIterable.js';
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, J as JsonBodyType, M as MaybeAsyncResponseResolverReturnType, R as RequestHandler, L as RequestHandlerArgs, r as RequestHandlerDefaultInfo, N as RequestHandlerExecutionResult, K as RequestHandlerInternalInfo, c as RequestHandlerOptions, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType } from '../HttpResponse-Dj6ibgFJ.js';
+import '../typeUtils.js';
+import '@mswjs/interceptors';
+import 'graphql';
+import '../utils/matching/matchRequestUrl.js';

node_modules/msw/lib/core/handlers/RequestHandler.js

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RequestHandler_exports = {};
+__export(RequestHandler_exports, {
+  RequestHandler: () => RequestHandler
+});
+module.exports = __toCommonJS(RequestHandler_exports);
+var import_getCallFrame = require("../utils/internal/getCallFrame");
+var import_isIterable = require("../utils/internal/isIterable");
+class RequestHandler {
+  static cache = /* @__PURE__ */ new WeakMap();
+  __kind;
+  info;
+  /**
+   * Indicates whether this request handler has been used
+   * (its resolver has successfully executed).
+   */
+  isUsed;
+  resolver;
+  resolverIterator;
+  resolverIteratorResult;
+  options;
+  constructor(args) {
+    this.resolver = args.resolver;
+    this.options = args.options;
+    const callFrame = (0, import_getCallFrame.getCallFrame)(new Error());
+    this.info = {
+      ...args.info,
+      callFrame
+    };
+    this.isUsed = false;
+    this.__kind = "RequestHandler";
+  }
+  /**
+   * Parse the intercepted request to extract additional information from it.
+   * Parsed result is then exposed to other methods of this request handler.
+   */
+  async parse(_args) {
+    return {};
+  }
+  /**
+   * Test if this handler matches the given request.
+   *
+   * This method is not used internally but is exposed
+   * as a convenience method for consumers writing custom
+   * handlers.
+   */
+  async test(args) {
+    const parsedResult = await this.parse({
+      request: args.request,
+      resolutionContext: args.resolutionContext
+    });
+    return this.predicate({
+      request: args.request,
+      parsedResult,
+      resolutionContext: args.resolutionContext
+    });
+  }
+  extendResolverArgs(_args) {
+    return {};
+  }
+  // Clone the request instance before it's passed to the handler phases
+  // and the response resolver so we can always read it for logging.
+  // We only clone it once per request to avoid unnecessary overhead.
+  cloneRequestOrGetFromCache(request) {
+    const existingClone = RequestHandler.cache.get(request);
+    if (typeof existingClone !== "undefined") {
+      return existingClone;
+    }
+    const clonedRequest = request.clone();
+    RequestHandler.cache.set(request, clonedRequest);
+    return clonedRequest;
+  }
+  /**
+   * Execute this request handler and produce a mocked response
+   * using the given resolver function.
+   */
+  async run(args) {
+    if (this.isUsed && this.options?.once) {
+      return null;
+    }
+    const requestClone = this.cloneRequestOrGetFromCache(args.request);
+    const parsedResult = await this.parse({
+      request: args.request,
+      resolutionContext: args.resolutionContext
+    });
+    const shouldInterceptRequest = await this.predicate({
+      request: args.request,
+      parsedResult,
+      resolutionContext: args.resolutionContext
+    });
+    if (!shouldInterceptRequest) {
+      return null;
+    }
+    if (this.isUsed && this.options?.once) {
+      return null;
+    }
+    this.isUsed = true;
+    const executeResolver = this.wrapResolver(this.resolver);
+    const resolverExtras = this.extendResolverArgs({
+      request: args.request,
+      parsedResult
+    });
+    const mockedResponsePromise = executeResolver({
+      ...resolverExtras,
+      requestId: args.requestId,
+      request: args.request
+    }).catch((errorOrResponse) => {
+      if (errorOrResponse instanceof Response) {
+        return errorOrResponse;
+      }
+      throw errorOrResponse;
+    });
+    const mockedResponse = await mockedResponsePromise;
+    const executionResult = this.createExecutionResult({
+      // Pass the cloned request to the result so that logging
+      // and other consumers could read its body once more.
+      request: requestClone,
+      requestId: args.requestId,
+      response: mockedResponse,
+      parsedResult
+    });
+    return executionResult;
+  }
+  wrapResolver(resolver) {
+    return async (info) => {
+      if (!this.resolverIterator) {
+        const result = await resolver(info);
+        if (!(0, import_isIterable.isIterable)(result)) {
+          return result;
+        }
+        this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
+      }
+      this.isUsed = false;
+      const { done, value } = await this.resolverIterator.next();
+      const nextResponse = await value;
+      if (nextResponse) {
+        this.resolverIteratorResult = nextResponse.clone();
+      }
+      if (done) {
+        this.isUsed = true;
+        return this.resolverIteratorResult?.clone();
+      }
+      return nextResponse;
+    };
+  }
+  createExecutionResult(args) {
+    return {
+      handler: this,
+      request: args.request,
+      requestId: args.requestId,
+      response: args.response,
+      parsedResult: args.parsedResult
+    };
+  }
+}
+//# sourceMappingURL=RequestHandler.js.map

node_modules/msw/lib/core/handlers/RequestHandler.mjs

@@ -0,0 +1,155 @@
+import { getCallFrame } from '../utils/internal/getCallFrame.mjs';
+import {
+  isIterable
+} from '../utils/internal/isIterable.mjs';
+class RequestHandler {
+  static cache = /* @__PURE__ */ new WeakMap();
+  __kind;
+  info;
+  /**
+   * Indicates whether this request handler has been used
+   * (its resolver has successfully executed).
+   */
+  isUsed;
+  resolver;
+  resolverIterator;
+  resolverIteratorResult;
+  options;
+  constructor(args) {
+    this.resolver = args.resolver;
+    this.options = args.options;
+    const callFrame = getCallFrame(new Error());
+    this.info = {
+      ...args.info,
+      callFrame
+    };
+    this.isUsed = false;
+    this.__kind = "RequestHandler";
+  }
+  /**
+   * Parse the intercepted request to extract additional information from it.
+   * Parsed result is then exposed to other methods of this request handler.
+   */
+  async parse(_args) {
+    return {};
+  }
+  /**
+   * Test if this handler matches the given request.
+   *
+   * This method is not used internally but is exposed
+   * as a convenience method for consumers writing custom
+   * handlers.
+   */
+  async test(args) {
+    const parsedResult = await this.parse({
+      request: args.request,
+      resolutionContext: args.resolutionContext
+    });
+    return this.predicate({
+      request: args.request,
+      parsedResult,
+      resolutionContext: args.resolutionContext
+    });
+  }
+  extendResolverArgs(_args) {
+    return {};
+  }
+  // Clone the request instance before it's passed to the handler phases
+  // and the response resolver so we can always read it for logging.
+  // We only clone it once per request to avoid unnecessary overhead.
+  cloneRequestOrGetFromCache(request) {
+    const existingClone = RequestHandler.cache.get(request);
+    if (typeof existingClone !== "undefined") {
+      return existingClone;
+    }
+    const clonedRequest = request.clone();
+    RequestHandler.cache.set(request, clonedRequest);
+    return clonedRequest;
+  }
+  /**
+   * Execute this request handler and produce a mocked response
+   * using the given resolver function.
+   */
+  async run(args) {
+    if (this.isUsed && this.options?.once) {
+      return null;
+    }
+    const requestClone = this.cloneRequestOrGetFromCache(args.request);
+    const parsedResult = await this.parse({
+      request: args.request,
+      resolutionContext: args.resolutionContext
+    });
+    const shouldInterceptRequest = await this.predicate({
+      request: args.request,
+      parsedResult,
+      resolutionContext: args.resolutionContext
+    });
+    if (!shouldInterceptRequest) {
+      return null;
+    }
+    if (this.isUsed && this.options?.once) {
+      return null;
+    }
+    this.isUsed = true;
+    const executeResolver = this.wrapResolver(this.resolver);
+    const resolverExtras = this.extendResolverArgs({
+      request: args.request,
+      parsedResult
+    });
+    const mockedResponsePromise = executeResolver({
+      ...resolverExtras,
+      requestId: args.requestId,
+      request: args.request
+    }).catch((errorOrResponse) => {
+      if (errorOrResponse instanceof Response) {
+        return errorOrResponse;
+      }
+      throw errorOrResponse;
+    });
+    const mockedResponse = await mockedResponsePromise;
+    const executionResult = this.createExecutionResult({
+      // Pass the cloned request to the result so that logging
+      // and other consumers could read its body once more.
+      request: requestClone,
+      requestId: args.requestId,
+      response: mockedResponse,
+      parsedResult
+    });
+    return executionResult;
+  }
+  wrapResolver(resolver) {
+    return async (info) => {
+      if (!this.resolverIterator) {
+        const result = await resolver(info);
+        if (!isIterable(result)) {
+          return result;
+        }
+        this.resolverIterator = Symbol.iterator in result ? result[Symbol.iterator]() : result[Symbol.asyncIterator]();
+      }
+      this.isUsed = false;
+      const { done, value } = await this.resolverIterator.next();
+      const nextResponse = await value;
+      if (nextResponse) {
+        this.resolverIteratorResult = nextResponse.clone();
+      }
+      if (done) {
+        this.isUsed = true;
+        return this.resolverIteratorResult?.clone();
+      }
+      return nextResponse;
+    };
+  }
+  createExecutionResult(args) {
+    return {
+      handler: this,
+      request: args.request,
+      requestId: args.requestId,
+      response: args.response,
+      parsedResult: args.parsedResult
+    };
+  }
+}
+export {
+  RequestHandler
+};
+//# sourceMappingURL=RequestHandler.mjs.map

node_modules/msw/lib/core/handlers/WebSocketHandler.d.mts

@@ -0,0 +1,42 @@
+import { Emitter } from 'strict-event-emitter';
+import { WebSocketClientConnectionProtocol, WebSocketServerConnectionProtocol, WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
+import { Path, PathParams, Match } from '../utils/matching/matchRequestUrl.mjs';
+
+type WebSocketHandlerParsedResult = {
+    match: Match;
+};
+type WebSocketHandlerEventMap = {
+    connection: [args: WebSocketHandlerConnection];
+};
+interface WebSocketHandlerConnection {
+    client: WebSocketClientConnectionProtocol;
+    server: WebSocketServerConnectionProtocol;
+    info: WebSocketConnectionData['info'];
+    params: PathParams;
+}
+interface WebSocketResolutionContext {
+    baseUrl?: string;
+}
+declare const kEmitter: unique symbol;
+declare const kSender: unique symbol;
+declare class WebSocketHandler {
+    #private;
+    protected readonly url: Path;
+    private readonly __kind;
+    id: string;
+    callFrame?: string;
+    protected [kEmitter]: Emitter<WebSocketHandlerEventMap>;
+    constructor(url: Path);
+    parse(args: {
+        url: URL;
+        resolutionContext?: WebSocketResolutionContext;
+    }): WebSocketHandlerParsedResult;
+    predicate(args: {
+        url: URL;
+        parsedResult: WebSocketHandlerParsedResult;
+    }): boolean;
+    run(connection: Omit<WebSocketHandlerConnection, 'params'>, resolutionContext?: WebSocketResolutionContext): Promise<boolean>;
+    protected connect(connection: WebSocketHandlerConnection): boolean;
+}
+
+export { WebSocketHandler, type WebSocketHandlerConnection, type WebSocketHandlerEventMap, type WebSocketResolutionContext, kEmitter, kSender };

node_modules/msw/lib/core/handlers/WebSocketHandler.d.ts

@@ -0,0 +1,42 @@
+import { Emitter } from 'strict-event-emitter';
+import { WebSocketClientConnectionProtocol, WebSocketServerConnectionProtocol, WebSocketConnectionData } from '@mswjs/interceptors/WebSocket';
+import { Path, PathParams, Match } from '../utils/matching/matchRequestUrl.js';
+
+type WebSocketHandlerParsedResult = {
+    match: Match;
+};
+type WebSocketHandlerEventMap = {
+    connection: [args: WebSocketHandlerConnection];
+};
+interface WebSocketHandlerConnection {
+    client: WebSocketClientConnectionProtocol;
+    server: WebSocketServerConnectionProtocol;
+    info: WebSocketConnectionData['info'];
+    params: PathParams;
+}
+interface WebSocketResolutionContext {
+    baseUrl?: string;
+}
+declare const kEmitter: unique symbol;
+declare const kSender: unique symbol;
+declare class WebSocketHandler {
+    #private;
+    protected readonly url: Path;
+    private readonly __kind;
+    id: string;
+    callFrame?: string;
+    protected [kEmitter]: Emitter<WebSocketHandlerEventMap>;
+    constructor(url: Path);
+    parse(args: {
+        url: URL;
+        resolutionContext?: WebSocketResolutionContext;
+    }): WebSocketHandlerParsedResult;
+    predicate(args: {
+        url: URL;
+        parsedResult: WebSocketHandlerParsedResult;
+    }): boolean;
+    run(connection: Omit<WebSocketHandlerConnection, 'params'>, resolutionContext?: WebSocketResolutionContext): Promise<boolean>;
+    protected connect(connection: WebSocketHandlerConnection): boolean;
+}
+
+export { WebSocketHandler, type WebSocketHandlerConnection, type WebSocketHandlerEventMap, type WebSocketResolutionContext, kEmitter, kSender };

node_modules/msw/lib/core/handlers/WebSocketHandler.js

@@ -0,0 +1,147 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WebSocketHandler_exports = {};
+__export(WebSocketHandler_exports, {
+  WebSocketHandler: () => WebSocketHandler,
+  kEmitter: () => kEmitter,
+  kSender: () => kSender
+});
+module.exports = __toCommonJS(WebSocketHandler_exports);
+var import_strict_event_emitter = require("strict-event-emitter");
+var import_interceptors = require("@mswjs/interceptors");
+var import_matchRequestUrl = require("../utils/matching/matchRequestUrl");
+var import_getCallFrame = require("../utils/internal/getCallFrame");
+const kEmitter = Symbol("kEmitter");
+const kSender = Symbol("kSender");
+const kStopPropagationPatched = Symbol("kStopPropagationPatched");
+const KOnStopPropagation = Symbol("KOnStopPropagation");
+class WebSocketHandler {
+  constructor(url) {
+    this.url = url;
+    this.id = (0, import_interceptors.createRequestId)();
+    this[kEmitter] = new import_strict_event_emitter.Emitter();
+    this.callFrame = (0, import_getCallFrame.getCallFrame)(new Error());
+    this.__kind = "EventHandler";
+  }
+  __kind;
+  id;
+  callFrame;
+  [kEmitter];
+  parse(args) {
+    const clientUrl = new URL(args.url);
+    const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
+    clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
+    const match = (0, import_matchRequestUrl.matchRequestUrl)(
+      clientUrl,
+      resolvedHandlerUrl,
+      args.resolutionContext?.baseUrl
+    );
+    return {
+      match
+    };
+  }
+  predicate(args) {
+    return args.parsedResult.match.matches;
+  }
+  async run(connection, resolutionContext) {
+    const parsedResult = this.parse({
+      url: connection.client.url,
+      resolutionContext
+    });
+    if (!this.predicate({ url: connection.client.url, parsedResult })) {
+      return false;
+    }
+    const resolvedConnection = {
+      ...connection,
+      params: parsedResult.match.params || {}
+    };
+    return this.connect(resolvedConnection);
+  }
+  connect(connection) {
+    connection.client.addEventListener(
+      "message",
+      createStopPropagationListener(this)
+    );
+    connection.client.addEventListener(
+      "close",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "open",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "message",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "error",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "close",
+      createStopPropagationListener(this)
+    );
+    return this[kEmitter].emit("connection", connection);
+  }
+  #resolveWebSocketUrl(url, baseUrl) {
+    const resolvedUrl = (0, import_interceptors.resolveWebSocketUrl)(
+      baseUrl ? (
+        /**
+         * @note Resolve against the base URL preemtively because `resolveWebSocketUrl` only
+         * resolves against `location.href`, which is missing in Node.js. Base URL allows
+         * the handler to accept a relative URL in Node.js.
+         */
+        new URL(url, baseUrl)
+      ) : url
+    );
+    return resolvedUrl.replace(/\/$/, "");
+  }
+}
+function createStopPropagationListener(handler) {
+  return function stopPropagationListener(event) {
+    const propagationStoppedAt = Reflect.get(event, "kPropagationStoppedAt");
+    if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
+      event.stopImmediatePropagation();
+      return;
+    }
+    Object.defineProperty(event, KOnStopPropagation, {
+      value() {
+        Object.defineProperty(event, "kPropagationStoppedAt", {
+          value: handler.id
+        });
+      },
+      configurable: true
+    });
+    if (!Reflect.get(event, kStopPropagationPatched)) {
+      event.stopPropagation = new Proxy(event.stopPropagation, {
+        apply: (target, thisArg, args) => {
+          Reflect.get(event, KOnStopPropagation)?.call(handler);
+          return Reflect.apply(target, thisArg, args);
+        }
+      });
+      Object.defineProperty(event, kStopPropagationPatched, {
+        value: true,
+        // If something else attempts to redefine this, throw.
+        configurable: false
+      });
+    }
+  };
+}
+//# sourceMappingURL=WebSocketHandler.js.map

node_modules/msw/lib/core/handlers/WebSocketHandler.mjs

@@ -0,0 +1,129 @@
+import { Emitter } from "strict-event-emitter";
+import { createRequestId, resolveWebSocketUrl } from "@mswjs/interceptors";
+import {
+  matchRequestUrl
+} from '../utils/matching/matchRequestUrl.mjs';
+import { getCallFrame } from '../utils/internal/getCallFrame.mjs';
+const kEmitter = Symbol("kEmitter");
+const kSender = Symbol("kSender");
+const kStopPropagationPatched = Symbol("kStopPropagationPatched");
+const KOnStopPropagation = Symbol("KOnStopPropagation");
+class WebSocketHandler {
+  constructor(url) {
+    this.url = url;
+    this.id = createRequestId();
+    this[kEmitter] = new Emitter();
+    this.callFrame = getCallFrame(new Error());
+    this.__kind = "EventHandler";
+  }
+  __kind;
+  id;
+  callFrame;
+  [kEmitter];
+  parse(args) {
+    const clientUrl = new URL(args.url);
+    const resolvedHandlerUrl = this.url instanceof RegExp || this.url.startsWith("*") ? this.url : this.#resolveWebSocketUrl(this.url, args.resolutionContext?.baseUrl);
+    clientUrl.pathname = clientUrl.pathname.replace(/^\/socket.io\//, "/");
+    const match = matchRequestUrl(
+      clientUrl,
+      resolvedHandlerUrl,
+      args.resolutionContext?.baseUrl
+    );
+    return {
+      match
+    };
+  }
+  predicate(args) {
+    return args.parsedResult.match.matches;
+  }
+  async run(connection, resolutionContext) {
+    const parsedResult = this.parse({
+      url: connection.client.url,
+      resolutionContext
+    });
+    if (!this.predicate({ url: connection.client.url, parsedResult })) {
+      return false;
+    }
+    const resolvedConnection = {
+      ...connection,
+      params: parsedResult.match.params || {}
+    };
+    return this.connect(resolvedConnection);
+  }
+  connect(connection) {
+    connection.client.addEventListener(
+      "message",
+      createStopPropagationListener(this)
+    );
+    connection.client.addEventListener(
+      "close",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "open",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "message",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "error",
+      createStopPropagationListener(this)
+    );
+    connection.server.addEventListener(
+      "close",
+      createStopPropagationListener(this)
+    );
+    return this[kEmitter].emit("connection", connection);
+  }
+  #resolveWebSocketUrl(url, baseUrl) {
+    const resolvedUrl = resolveWebSocketUrl(
+      baseUrl ? (
+        /**
+         * @note Resolve against the base URL preemtively because `resolveWebSocketUrl` only
+         * resolves against `location.href`, which is missing in Node.js. Base URL allows
+         * the handler to accept a relative URL in Node.js.
+         */
+        new URL(url, baseUrl)
+      ) : url
+    );
+    return resolvedUrl.replace(/\/$/, "");
+  }
+}
+function createStopPropagationListener(handler) {
+  return function stopPropagationListener(event) {
+    const propagationStoppedAt = Reflect.get(event, "kPropagationStoppedAt");
+    if (propagationStoppedAt && handler.id !== propagationStoppedAt) {
+      event.stopImmediatePropagation();
+      return;
+    }
+    Object.defineProperty(event, KOnStopPropagation, {
+      value() {
+        Object.defineProperty(event, "kPropagationStoppedAt", {
+          value: handler.id
+        });
+      },
+      configurable: true
+    });
+    if (!Reflect.get(event, kStopPropagationPatched)) {
+      event.stopPropagation = new Proxy(event.stopPropagation, {
+        apply: (target, thisArg, args) => {
+          Reflect.get(event, KOnStopPropagation)?.call(handler);
+          return Reflect.apply(target, thisArg, args);
+        }
+      });
+      Object.defineProperty(event, kStopPropagationPatched, {
+        value: true,
+        // If something else attempts to redefine this, throw.
+        configurable: false
+      });
+    }
+  };
+}
+export {
+  WebSocketHandler,
+  kEmitter,
+  kSender
+};
+//# sourceMappingURL=WebSocketHandler.mjs.map

node_modules/msw/lib/core/handlers/common.d.mts

@@ -0,0 +1,3 @@
+type HandlerKind = 'RequestHandler' | 'EventHandler';
+
+export type { HandlerKind };

node_modules/msw/lib/core/handlers/common.d.ts

@@ -0,0 +1,3 @@
+type HandlerKind = 'RequestHandler' | 'EventHandler';
+
+export type { HandlerKind };

node_modules/msw/lib/core/handlers/common.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+module.exports = __toCommonJS(common_exports);
+//# sourceMappingURL=common.js.map

node_modules/msw/lib/core/handlers/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/handlers/common.ts"],"sourcesContent":["export type HandlerKind = 'RequestHandler' | 'EventHandler'\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

node_modules/msw/lib/core/handlers/common.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=common.mjs.map

node_modules/msw/lib/core/handlers/common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

node_modules/msw/lib/core/http.d.mts

@@ -0,0 +1,31 @@
+import { D as DefaultBodyType, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-Be4eT3x6.mjs';
+import { HttpRequestPredicate, HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.mjs';
+import { PathParams } from './utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+
+type HttpRequestHandler = <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(predicate: HttpRequestPredicate<Params>, resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
+type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = DefaultBodyType> = ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>;
+/**
+ * A namespace to intercept and mock HTTP requests.
+ *
+ * @example
+ * http.get('/user', resolver)
+ * http.post('/post/:id', resolver)
+ *
+ * @see {@link https://mswjs.io/docs/api/http `http` API reference}
+ */
+declare const http: {
+    all: HttpRequestHandler;
+    head: HttpRequestHandler;
+    get: HttpRequestHandler;
+    post: HttpRequestHandler;
+    put: HttpRequestHandler;
+    delete: HttpRequestHandler;
+    patch: HttpRequestHandler;
+    options: HttpRequestHandler;
+};
+
+export { type HttpRequestHandler, type HttpResponseResolver, http };

node_modules/msw/lib/core/http.d.ts

@@ -0,0 +1,31 @@
+import { D as DefaultBodyType, a as ResponseResolver, c as RequestHandlerOptions } from './HttpResponse-Dj6ibgFJ.js';
+import { HttpRequestPredicate, HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
+import { PathParams } from './utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+
+type HttpRequestHandler = <Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = undefined>(predicate: HttpRequestPredicate<Params>, resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>, options?: RequestHandlerOptions) => HttpHandler;
+type HttpResponseResolver<Params extends PathParams<keyof Params> = PathParams, RequestBodyType extends DefaultBodyType = DefaultBodyType, ResponseBodyType extends DefaultBodyType = DefaultBodyType> = ResponseResolver<HttpRequestResolverExtras<Params>, RequestBodyType, ResponseBodyType>;
+/**
+ * A namespace to intercept and mock HTTP requests.
+ *
+ * @example
+ * http.get('/user', resolver)
+ * http.post('/post/:id', resolver)
+ *
+ * @see {@link https://mswjs.io/docs/api/http `http` API reference}
+ */
+declare const http: {
+    all: HttpRequestHandler;
+    head: HttpRequestHandler;
+    get: HttpRequestHandler;
+    post: HttpRequestHandler;
+    put: HttpRequestHandler;
+    delete: HttpRequestHandler;
+    patch: HttpRequestHandler;
+    options: HttpRequestHandler;
+};
+
+export { type HttpRequestHandler, type HttpResponseResolver, http };

node_modules/msw/lib/core/http.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var http_exports = {};
+__export(http_exports, {
+  http: () => http
+});
+module.exports = __toCommonJS(http_exports);
+var import_HttpHandler = require("./handlers/HttpHandler");
+function createHttpHandler(method) {
+  return (predicate, resolver, options = {}) => {
+    return new import_HttpHandler.HttpHandler(method, predicate, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(import_HttpHandler.HttpMethods.HEAD),
+  get: createHttpHandler(import_HttpHandler.HttpMethods.GET),
+  post: createHttpHandler(import_HttpHandler.HttpMethods.POST),
+  put: createHttpHandler(import_HttpHandler.HttpMethods.PUT),
+  delete: createHttpHandler(import_HttpHandler.HttpMethods.DELETE),
+  patch: createHttpHandler(import_HttpHandler.HttpMethods.PATCH),
+  options: createHttpHandler(import_HttpHandler.HttpMethods.OPTIONS)
+};
+//# sourceMappingURL=http.js.map

node_modules/msw/lib/core/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/http.ts"],"sourcesContent":["import {\n  DefaultBodyType,\n  RequestHandlerOptions,\n  ResponseResolver,\n} from './handlers/RequestHandler'\nimport {\n  HttpMethods,\n  HttpHandler,\n  HttpRequestResolverExtras,\n  HttpRequestPredicate,\n} from './handlers/HttpHandler'\nimport type { PathParams } from './utils/matching/matchRequestUrl'\n\nexport type HttpRequestHandler = <\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  // Response body type MUST be undefined by default.\n  // This is how we can distinguish between a handler that\n  // returns plain \"Response\" and the one returning \"HttpResponse\"\n  // to enforce a stricter response body type.\n  ResponseBodyType extends DefaultBodyType = undefined,\n>(\n  predicate: HttpRequestPredicate<Params>,\n  resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,\n  options?: RequestHandlerOptions,\n) => HttpHandler\n\nexport type HttpResponseResolver<\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  ResponseBodyType extends DefaultBodyType = DefaultBodyType,\n> = ResponseResolver<\n  HttpRequestResolverExtras<Params>,\n  RequestBodyType,\n  ResponseBodyType\n>\n\nfunction createHttpHandler<Method extends HttpMethods | RegExp>(\n  method: Method,\n): HttpRequestHandler {\n  return (predicate, resolver, options = {}) => {\n    return new HttpHandler(method, predicate, resolver, options)\n  }\n}\n\n/**\n * A namespace to intercept and mock HTTP requests.\n *\n * @example\n * http.get('/user', resolver)\n * http.post('/post/:id', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/http `http` API reference}\n */\nexport const http = {\n  all: createHttpHandler(/.+/),\n  head: createHttpHandler(HttpMethods.HEAD),\n  get: createHttpHandler(HttpMethods.GET),\n  post: createHttpHandler(HttpMethods.POST),\n  put: createHttpHandler(HttpMethods.PUT),\n  delete: createHttpHandler(HttpMethods.DELETE),\n  patch: createHttpHandler(HttpMethods.PATCH),\n  options: createHttpHandler(HttpMethods.OPTIONS),\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAKO;AA2BP,SAAS,kBACP,QACoB;AACpB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,+BAAY,QAAQ,WAAW,UAAU,OAAO;AAAA,EAC7D;AACF;AAWO,MAAM,OAAO;AAAA,EAClB,KAAK,kBAAkB,IAAI;AAAA,EAC3B,MAAM,kBAAkB,+BAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,+BAAY,GAAG;AAAA,EACtC,MAAM,kBAAkB,+BAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,+BAAY,GAAG;AAAA,EACtC,QAAQ,kBAAkB,+BAAY,MAAM;AAAA,EAC5C,OAAO,kBAAkB,+BAAY,KAAK;AAAA,EAC1C,SAAS,kBAAkB,+BAAY,OAAO;AAChD;","names":[]}

node_modules/msw/lib/core/http.mjs

@@ -0,0 +1,23 @@
+import {
+  HttpMethods,
+  HttpHandler
+} from './handlers/HttpHandler.mjs';
+function createHttpHandler(method) {
+  return (predicate, resolver, options = {}) => {
+    return new HttpHandler(method, predicate, resolver, options);
+  };
+}
+const http = {
+  all: createHttpHandler(/.+/),
+  head: createHttpHandler(HttpMethods.HEAD),
+  get: createHttpHandler(HttpMethods.GET),
+  post: createHttpHandler(HttpMethods.POST),
+  put: createHttpHandler(HttpMethods.PUT),
+  delete: createHttpHandler(HttpMethods.DELETE),
+  patch: createHttpHandler(HttpMethods.PATCH),
+  options: createHttpHandler(HttpMethods.OPTIONS)
+};
+export {
+  http
+};
+//# sourceMappingURL=http.mjs.map

node_modules/msw/lib/core/http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/http.ts"],"sourcesContent":["import {\n  DefaultBodyType,\n  RequestHandlerOptions,\n  ResponseResolver,\n} from './handlers/RequestHandler'\nimport {\n  HttpMethods,\n  HttpHandler,\n  HttpRequestResolverExtras,\n  HttpRequestPredicate,\n} from './handlers/HttpHandler'\nimport type { PathParams } from './utils/matching/matchRequestUrl'\n\nexport type HttpRequestHandler = <\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  // Response body type MUST be undefined by default.\n  // This is how we can distinguish between a handler that\n  // returns plain \"Response\" and the one returning \"HttpResponse\"\n  // to enforce a stricter response body type.\n  ResponseBodyType extends DefaultBodyType = undefined,\n>(\n  predicate: HttpRequestPredicate<Params>,\n  resolver: HttpResponseResolver<Params, RequestBodyType, ResponseBodyType>,\n  options?: RequestHandlerOptions,\n) => HttpHandler\n\nexport type HttpResponseResolver<\n  Params extends PathParams<keyof Params> = PathParams,\n  RequestBodyType extends DefaultBodyType = DefaultBodyType,\n  ResponseBodyType extends DefaultBodyType = DefaultBodyType,\n> = ResponseResolver<\n  HttpRequestResolverExtras<Params>,\n  RequestBodyType,\n  ResponseBodyType\n>\n\nfunction createHttpHandler<Method extends HttpMethods | RegExp>(\n  method: Method,\n): HttpRequestHandler {\n  return (predicate, resolver, options = {}) => {\n    return new HttpHandler(method, predicate, resolver, options)\n  }\n}\n\n/**\n * A namespace to intercept and mock HTTP requests.\n *\n * @example\n * http.get('/user', resolver)\n * http.post('/post/:id', resolver)\n *\n * @see {@link https://mswjs.io/docs/api/http `http` API reference}\n */\nexport const http = {\n  all: createHttpHandler(/.+/),\n  head: createHttpHandler(HttpMethods.HEAD),\n  get: createHttpHandler(HttpMethods.GET),\n  post: createHttpHandler(HttpMethods.POST),\n  put: createHttpHandler(HttpMethods.PUT),\n  delete: createHttpHandler(HttpMethods.DELETE),\n  patch: createHttpHandler(HttpMethods.PATCH),\n  options: createHttpHandler(HttpMethods.OPTIONS),\n}\n"],"mappings":"AAKA;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AA2BP,SAAS,kBACP,QACoB;AACpB,SAAO,CAAC,WAAW,UAAU,UAAU,CAAC,MAAM;AAC5C,WAAO,IAAI,YAAY,QAAQ,WAAW,UAAU,OAAO;AAAA,EAC7D;AACF;AAWO,MAAM,OAAO;AAAA,EAClB,KAAK,kBAAkB,IAAI;AAAA,EAC3B,MAAM,kBAAkB,YAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,YAAY,GAAG;AAAA,EACtC,MAAM,kBAAkB,YAAY,IAAI;AAAA,EACxC,KAAK,kBAAkB,YAAY,GAAG;AAAA,EACtC,QAAQ,kBAAkB,YAAY,MAAM;AAAA,EAC5C,OAAO,kBAAkB,YAAY,KAAK;AAAA,EAC1C,SAAS,kBAAkB,YAAY,OAAO;AAChD;","names":[]}

node_modules/msw/lib/core/index.d.mts

@@ -0,0 +1,32 @@
+export { SetupApi } from './SetupApi.mjs';
+import { G as GraphQLHandler } from './HttpResponse-Be4eT3x6.mjs';
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, l as GraphQLCustomPredicate, j as GraphQLJsonRequestBody, k as GraphQLOperationType, f as GraphQLQuery, h as GraphQLRequestBody, i as GraphQLResponseBody, g as GraphQLVariables, H as HttpResponse, n as HttpResponseInit, J as JsonBodyType, P as ParsedGraphQLRequest, R as RequestHandler, c as RequestHandlerOptions, m as ResponseResolutionContext, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType, S as StrictRequest, o as StrictResponse } from './HttpResponse-Be4eT3x6.mjs';
+export { HttpRequestHandler, HttpResponseResolver, http } from './http.mjs';
+import { HttpHandler } from './handlers/HttpHandler.mjs';
+export { HttpCustomPredicate, HttpHandlerInfo, HttpHandlerMethod, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery } from './handlers/HttpHandler.mjs';
+export { GraphQLLinkHandlers, GraphQLOperationHandler, GraphQLRequestHandler, GraphQLResponseResolver, graphql } from './graphql.mjs';
+export { WebSocketEventListener, WebSocketLink, ws } from './ws.mjs';
+import { WebSocketHandler } from './handlers/WebSocketHandler.mjs';
+export { WebSocketHandlerConnection, WebSocketHandlerEventMap } from './handlers/WebSocketHandler.mjs';
+export { ServerSentEventMessage, ServerSentEventRequestHandler, ServerSentEventResolver, ServerSentEventResolverExtras, sse } from './sse.mjs';
+export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
+export { HandleRequestOptions, handleRequest } from './utils/handleRequest.mjs';
+export { UnhandledRequestCallback, UnhandledRequestStrategy, onUnhandledRequest } from './utils/request/onUnhandledRequest.mjs';
+export { getResponse } from './getResponse.mjs';
+export { cleanUrl } from './utils/url/cleanUrl.mjs';
+export { LifeCycleEventsMap, SharedOptions } from './sharedOptions.mjs';
+export { DelayMode, delay } from './delay.mjs';
+export { bypass } from './bypass.mjs';
+export { passthrough } from './passthrough.mjs';
+export { isCommonAssetRequest } from './isCommonAssetRequest.mjs';
+export { WebSocketData } from '@mswjs/interceptors/WebSocket';
+import 'strict-event-emitter';
+import './utils/internal/Disposable.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+
+type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler;
+
+export { type AnyHandler, GraphQLHandler, HttpHandler, WebSocketHandler };

node_modules/msw/lib/core/index.d.ts

@@ -0,0 +1,32 @@
+export { SetupApi } from './SetupApi.js';
+import { G as GraphQLHandler } from './HttpResponse-Dj6ibgFJ.js';
+export { A as AsyncResponseResolverReturnType, D as DefaultBodyType, d as DefaultRequestMultipartBody, l as GraphQLCustomPredicate, j as GraphQLJsonRequestBody, k as GraphQLOperationType, f as GraphQLQuery, h as GraphQLRequestBody, i as GraphQLResponseBody, g as GraphQLVariables, H as HttpResponse, n as HttpResponseInit, J as JsonBodyType, P as ParsedGraphQLRequest, R as RequestHandler, c as RequestHandlerOptions, m as ResponseResolutionContext, a as ResponseResolver, e as ResponseResolverInfo, b as ResponseResolverReturnType, S as StrictRequest, o as StrictResponse } from './HttpResponse-Dj6ibgFJ.js';
+export { HttpRequestHandler, HttpResponseResolver, http } from './http.js';
+import { HttpHandler } from './handlers/HttpHandler.js';
+export { HttpCustomPredicate, HttpHandlerInfo, HttpHandlerMethod, HttpMethods, HttpRequestParsedResult, HttpRequestResolverExtras, RequestQuery } from './handlers/HttpHandler.js';
+export { GraphQLLinkHandlers, GraphQLOperationHandler, GraphQLRequestHandler, GraphQLResponseResolver, graphql } from './graphql.js';
+export { WebSocketEventListener, WebSocketLink, ws } from './ws.js';
+import { WebSocketHandler } from './handlers/WebSocketHandler.js';
+export { WebSocketHandlerConnection, WebSocketHandlerEventMap } from './handlers/WebSocketHandler.js';
+export { ServerSentEventMessage, ServerSentEventRequestHandler, ServerSentEventResolver, ServerSentEventResolverExtras, sse } from './sse.js';
+export { Match, Path, PathParams, matchRequestUrl } from './utils/matching/matchRequestUrl.js';
+export { HandleRequestOptions, handleRequest } from './utils/handleRequest.js';
+export { UnhandledRequestCallback, UnhandledRequestStrategy, onUnhandledRequest } from './utils/request/onUnhandledRequest.js';
+export { getResponse } from './getResponse.js';
+export { cleanUrl } from './utils/url/cleanUrl.js';
+export { LifeCycleEventsMap, SharedOptions } from './sharedOptions.js';
+export { DelayMode, delay } from './delay.js';
+export { bypass } from './bypass.js';
+export { passthrough } from './passthrough.js';
+export { isCommonAssetRequest } from './isCommonAssetRequest.js';
+export { WebSocketData } from '@mswjs/interceptors/WebSocket';
+import 'strict-event-emitter';
+import './utils/internal/Disposable.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+
+type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler;
+
+export { type AnyHandler, GraphQLHandler, HttpHandler, WebSocketHandler };

node_modules/msw/lib/core/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  GraphQLHandler: () => import_GraphQLHandler.GraphQLHandler,
+  HttpHandler: () => import_HttpHandler.HttpHandler,
+  HttpMethods: () => import_HttpHandler.HttpMethods,
+  HttpResponse: () => import_HttpResponse.HttpResponse,
+  RequestHandler: () => import_RequestHandler.RequestHandler,
+  SetupApi: () => import_SetupApi.SetupApi,
+  WebSocketHandler: () => import_WebSocketHandler.WebSocketHandler,
+  bypass: () => import_bypass.bypass,
+  cleanUrl: () => import_cleanUrl.cleanUrl,
+  delay: () => import_delay.delay,
+  getResponse: () => import_getResponse.getResponse,
+  graphql: () => import_graphql.graphql,
+  handleRequest: () => import_handleRequest.handleRequest,
+  http: () => import_http.http,
+  isCommonAssetRequest: () => import_isCommonAssetRequest.isCommonAssetRequest,
+  matchRequestUrl: () => import_matchRequestUrl.matchRequestUrl,
+  onUnhandledRequest: () => import_onUnhandledRequest.onUnhandledRequest,
+  passthrough: () => import_passthrough.passthrough,
+  sse: () => import_sse.sse,
+  ws: () => import_ws.ws
+});
+module.exports = __toCommonJS(index_exports);
+var import_checkGlobals = require("./utils/internal/checkGlobals");
+var import_SetupApi = require("./SetupApi");
+var import_RequestHandler = require("./handlers/RequestHandler");
+var import_http = require("./http");
+var import_HttpHandler = require("./handlers/HttpHandler");
+var import_graphql = require("./graphql");
+var import_GraphQLHandler = require("./handlers/GraphQLHandler");
+var import_ws = require("./ws");
+var import_WebSocketHandler = require("./handlers/WebSocketHandler");
+var import_sse = require("./sse");
+var import_matchRequestUrl = require("./utils/matching/matchRequestUrl");
+var import_handleRequest = require("./utils/handleRequest");
+var import_onUnhandledRequest = require("./utils/request/onUnhandledRequest");
+var import_getResponse = require("./getResponse");
+var import_cleanUrl = require("./utils/url/cleanUrl");
+var import_HttpResponse = require("./HttpResponse");
+var import_delay = require("./delay");
+var import_bypass = require("./bypass");
+var import_passthrough = require("./passthrough");
+var import_isCommonAssetRequest = require("./isCommonAssetRequest");
+(0, import_checkGlobals.checkGlobals)();
+//# sourceMappingURL=index.js.map

node_modules/msw/lib/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["import { checkGlobals } from './utils/internal/checkGlobals'\n\nexport { SetupApi } from './SetupApi'\n\n/* HTTP handlers */\nexport { RequestHandler } from './handlers/RequestHandler'\nexport { http } from './http'\nexport { HttpHandler, HttpMethods } from './handlers/HttpHandler'\nexport { graphql } from './graphql'\nexport { GraphQLHandler } from './handlers/GraphQLHandler'\n\n/* WebSocket handler */\nexport { ws, type WebSocketLink } from './ws'\nexport {\n  WebSocketHandler,\n  type WebSocketHandlerEventMap,\n  type WebSocketHandlerConnection,\n} from './handlers/WebSocketHandler'\n\n/* Server-Sent Events */\nexport {\n  sse,\n  type ServerSentEventRequestHandler,\n  type ServerSentEventResolver,\n  type ServerSentEventResolverExtras,\n  type ServerSentEventMessage,\n} from './sse'\n\nimport type { HttpHandler } from './handlers/HttpHandler'\nimport type { GraphQLHandler } from './handlers/GraphQLHandler'\nimport type { WebSocketHandler } from './handlers/WebSocketHandler'\n\nexport type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler\n\n/* Utils */\nexport { matchRequestUrl } from './utils/matching/matchRequestUrl'\nexport { handleRequest, type HandleRequestOptions } from './utils/handleRequest'\nexport {\n  onUnhandledRequest,\n  type UnhandledRequestStrategy,\n  type UnhandledRequestCallback,\n} from './utils/request/onUnhandledRequest'\nexport { getResponse } from './getResponse'\nexport { cleanUrl } from './utils/url/cleanUrl'\n\n/**\n * Type definitions.\n */\n\nexport type { SharedOptions, LifeCycleEventsMap } from './sharedOptions'\n\nexport type {\n  ResponseResolver,\n  ResponseResolverReturnType,\n  AsyncResponseResolverReturnType,\n  RequestHandlerOptions,\n  DefaultBodyType,\n  DefaultRequestMultipartBody,\n  JsonBodyType,\n  ResponseResolverInfo,\n} from './handlers/RequestHandler'\n\nexport type {\n  RequestQuery,\n  HttpRequestParsedResult,\n  HttpHandlerInfo,\n  HttpRequestResolverExtras,\n  HttpHandlerMethod,\n  HttpCustomPredicate,\n} from './handlers/HttpHandler'\nexport type { HttpRequestHandler, HttpResponseResolver } from './http'\n\nexport type {\n  GraphQLQuery,\n  GraphQLVariables,\n  GraphQLRequestBody,\n  GraphQLResponseBody,\n  GraphQLJsonRequestBody,\n  GraphQLOperationType,\n  GraphQLCustomPredicate,\n} from './handlers/GraphQLHandler'\nexport type {\n  GraphQLRequestHandler,\n  GraphQLOperationHandler,\n  GraphQLResponseResolver,\n  GraphQLLinkHandlers,\n} from './graphql'\n\nexport type { WebSocketData, WebSocketEventListener } from './ws'\n\nexport type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'\nexport type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'\nexport type { ResponseResolutionContext } from './utils/executeHandlers'\n\nexport {\n  HttpResponse,\n  type HttpResponseInit,\n  type StrictRequest,\n  type StrictResponse,\n} from './HttpResponse'\nexport { delay, type DelayMode } from './delay'\nexport { bypass } from './bypass'\nexport { passthrough } from './passthrough'\nexport { isCommonAssetRequest } from './isCommonAssetRequest'\n\n// Validate environmental globals before executing any code.\n// This ensures that the library gives user-friendly errors\n// when ran in the environments that require additional polyfills\n// from the end user.\ncheckGlobals()\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,0BAA6B;AAE7B,sBAAyB;AAGzB,4BAA+B;AAC/B,kBAAqB;AACrB,yBAAyC;AACzC,qBAAwB;AACxB,4BAA+B;AAG/B,gBAAuC;AACvC,8BAIO;AAGP,iBAMO;AASP,6BAAgC;AAChC,2BAAyD;AACzD,gCAIO;AACP,yBAA4B;AAC5B,sBAAyB;AAmDzB,0BAKO;AACP,mBAAsC;AACtC,oBAAuB;AACvB,yBAA4B;AAC5B,kCAAqC;AAAA,IAMrC,kCAAa;","names":[]}

node_modules/msw/lib/core/index.mjs

@@ -0,0 +1,52 @@
+import { checkGlobals } from './utils/internal/checkGlobals.mjs';
+import { SetupApi } from './SetupApi.mjs';
+import { RequestHandler } from './handlers/RequestHandler.mjs';
+import { http } from './http.mjs';
+import { HttpHandler, HttpMethods } from './handlers/HttpHandler.mjs';
+import { graphql } from './graphql.mjs';
+import { GraphQLHandler } from './handlers/GraphQLHandler.mjs';
+import { ws } from './ws.mjs';
+import {
+  WebSocketHandler
+} from './handlers/WebSocketHandler.mjs';
+import {
+  sse
+} from './sse.mjs';
+import { matchRequestUrl } from './utils/matching/matchRequestUrl.mjs';
+import { handleRequest } from './utils/handleRequest.mjs';
+import {
+  onUnhandledRequest
+} from './utils/request/onUnhandledRequest.mjs';
+import { getResponse } from './getResponse.mjs';
+import { cleanUrl } from './utils/url/cleanUrl.mjs';
+import {
+  HttpResponse
+} from './HttpResponse.mjs';
+import { delay } from './delay.mjs';
+import { bypass } from './bypass.mjs';
+import { passthrough } from './passthrough.mjs';
+import { isCommonAssetRequest } from './isCommonAssetRequest.mjs';
+checkGlobals();
+export {
+  GraphQLHandler,
+  HttpHandler,
+  HttpMethods,
+  HttpResponse,
+  RequestHandler,
+  SetupApi,
+  WebSocketHandler,
+  bypass,
+  cleanUrl,
+  delay,
+  getResponse,
+  graphql,
+  handleRequest,
+  http,
+  isCommonAssetRequest,
+  matchRequestUrl,
+  onUnhandledRequest,
+  passthrough,
+  sse,
+  ws
+};
+//# sourceMappingURL=index.mjs.map

node_modules/msw/lib/core/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["import { checkGlobals } from './utils/internal/checkGlobals'\n\nexport { SetupApi } from './SetupApi'\n\n/* HTTP handlers */\nexport { RequestHandler } from './handlers/RequestHandler'\nexport { http } from './http'\nexport { HttpHandler, HttpMethods } from './handlers/HttpHandler'\nexport { graphql } from './graphql'\nexport { GraphQLHandler } from './handlers/GraphQLHandler'\n\n/* WebSocket handler */\nexport { ws, type WebSocketLink } from './ws'\nexport {\n  WebSocketHandler,\n  type WebSocketHandlerEventMap,\n  type WebSocketHandlerConnection,\n} from './handlers/WebSocketHandler'\n\n/* Server-Sent Events */\nexport {\n  sse,\n  type ServerSentEventRequestHandler,\n  type ServerSentEventResolver,\n  type ServerSentEventResolverExtras,\n  type ServerSentEventMessage,\n} from './sse'\n\nimport type { HttpHandler } from './handlers/HttpHandler'\nimport type { GraphQLHandler } from './handlers/GraphQLHandler'\nimport type { WebSocketHandler } from './handlers/WebSocketHandler'\n\nexport type AnyHandler = HttpHandler | GraphQLHandler | WebSocketHandler\n\n/* Utils */\nexport { matchRequestUrl } from './utils/matching/matchRequestUrl'\nexport { handleRequest, type HandleRequestOptions } from './utils/handleRequest'\nexport {\n  onUnhandledRequest,\n  type UnhandledRequestStrategy,\n  type UnhandledRequestCallback,\n} from './utils/request/onUnhandledRequest'\nexport { getResponse } from './getResponse'\nexport { cleanUrl } from './utils/url/cleanUrl'\n\n/**\n * Type definitions.\n */\n\nexport type { SharedOptions, LifeCycleEventsMap } from './sharedOptions'\n\nexport type {\n  ResponseResolver,\n  ResponseResolverReturnType,\n  AsyncResponseResolverReturnType,\n  RequestHandlerOptions,\n  DefaultBodyType,\n  DefaultRequestMultipartBody,\n  JsonBodyType,\n  ResponseResolverInfo,\n} from './handlers/RequestHandler'\n\nexport type {\n  RequestQuery,\n  HttpRequestParsedResult,\n  HttpHandlerInfo,\n  HttpRequestResolverExtras,\n  HttpHandlerMethod,\n  HttpCustomPredicate,\n} from './handlers/HttpHandler'\nexport type { HttpRequestHandler, HttpResponseResolver } from './http'\n\nexport type {\n  GraphQLQuery,\n  GraphQLVariables,\n  GraphQLRequestBody,\n  GraphQLResponseBody,\n  GraphQLJsonRequestBody,\n  GraphQLOperationType,\n  GraphQLCustomPredicate,\n} from './handlers/GraphQLHandler'\nexport type {\n  GraphQLRequestHandler,\n  GraphQLOperationHandler,\n  GraphQLResponseResolver,\n  GraphQLLinkHandlers,\n} from './graphql'\n\nexport type { WebSocketData, WebSocketEventListener } from './ws'\n\nexport type { Path, PathParams, Match } from './utils/matching/matchRequestUrl'\nexport type { ParsedGraphQLRequest } from './utils/internal/parseGraphQLRequest'\nexport type { ResponseResolutionContext } from './utils/executeHandlers'\n\nexport {\n  HttpResponse,\n  type HttpResponseInit,\n  type StrictRequest,\n  type StrictResponse,\n} from './HttpResponse'\nexport { delay, type DelayMode } from './delay'\nexport { bypass } from './bypass'\nexport { passthrough } from './passthrough'\nexport { isCommonAssetRequest } from './isCommonAssetRequest'\n\n// Validate environmental globals before executing any code.\n// This ensures that the library gives user-friendly errors\n// when ran in the environments that require additional polyfills\n// from the end user.\ncheckGlobals()\n"],"mappings":"AAAA,SAAS,oBAAoB;AAE7B,SAAS,gBAAgB;AAGzB,SAAS,sBAAsB;AAC/B,SAAS,YAAY;AACrB,SAAS,aAAa,mBAAmB;AACzC,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAG/B,SAAS,UAA8B;AACvC;AAAA,EACE;AAAA,OAGK;AAGP;AAAA,EACE;AAAA,OAKK;AASP,SAAS,uBAAuB;AAChC,SAAS,qBAAgD;AACzD;AAAA,EACE;AAAA,OAGK;AACP,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB;AAmDzB;AAAA,EACE;AAAA,OAIK;AACP,SAAS,aAA6B;AACtC,SAAS,cAAc;AACvB,SAAS,mBAAmB;AAC5B,SAAS,4BAA4B;AAMrC,aAAa;","names":[]}

node_modules/msw/lib/core/isCommonAssetRequest.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Determines if the given request is a static asset request.
+ * Useful when deciding which unhandled requests to ignore.
+ * @note Despite being ignored, you can still intercept and mock
+ * static assets by creating request handlers for them.
+ *
+ * @example
+ * import { isCommonAssetRequest } from 'msw'
+ *
+ * await worker.start({
+ *   onUnhandledRequest(request, print) {
+ *     if (!isCommonAssetRequest(request)) {
+ *       print.warning()
+ *     }
+ *   }
+ * })
+ */
+declare function isCommonAssetRequest(request: Request): boolean;
+
+export { isCommonAssetRequest };

node_modules/msw/lib/core/isCommonAssetRequest.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Determines if the given request is a static asset request.
+ * Useful when deciding which unhandled requests to ignore.
+ * @note Despite being ignored, you can still intercept and mock
+ * static assets by creating request handlers for them.
+ *
+ * @example
+ * import { isCommonAssetRequest } from 'msw'
+ *
+ * await worker.start({
+ *   onUnhandledRequest(request, print) {
+ *     if (!isCommonAssetRequest(request)) {
+ *       print.warning()
+ *     }
+ *   }
+ * })
+ */
+declare function isCommonAssetRequest(request: Request): boolean;
+
+export { isCommonAssetRequest };

node_modules/msw/lib/core/isCommonAssetRequest.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isCommonAssetRequest_exports = {};
+__export(isCommonAssetRequest_exports, {
+  isCommonAssetRequest: () => isCommonAssetRequest
+});
+module.exports = __toCommonJS(isCommonAssetRequest_exports);
+function isCommonAssetRequest(request) {
+  const url = new URL(request.url);
+  if (url.protocol === "file:") {
+    return true;
+  }
+  if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
+    return true;
+  }
+  if (/node_modules/.test(url.pathname)) {
+    return true;
+  }
+  if (url.pathname.includes("@vite")) {
+    return true;
+  }
+  return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
+    url.pathname
+  );
+}
+//# sourceMappingURL=isCommonAssetRequest.js.map

node_modules/msw/lib/core/isCommonAssetRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/isCommonAssetRequest.ts"],"sourcesContent":["/**\n * Determines if the given request is a static asset request.\n * Useful when deciding which unhandled requests to ignore.\n * @note Despite being ignored, you can still intercept and mock\n * static assets by creating request handlers for them.\n *\n * @example\n * import { isCommonAssetRequest } from 'msw'\n *\n * await worker.start({\n *   onUnhandledRequest(request, print) {\n *     if (!isCommonAssetRequest(request)) {\n *       print.warning()\n *     }\n *   }\n * })\n */\nexport function isCommonAssetRequest(request: Request): boolean {\n  const url = new URL(request.url)\n\n  // Ignore certain protocols.\n  if (url.protocol === 'file:') {\n    return true\n  }\n\n  // Ignore static assets hosts.\n  if (/(fonts\\.googleapis\\.com)/.test(url.hostname)) {\n    return true\n  }\n\n  // Ignore node modules served over HTTP.\n  if (/node_modules/.test(url.pathname)) {\n    return true\n  }\n\n  // Ignore internal Vite requests, like \"/@vite/client\".\n  if (url.pathname.includes('@vite')) {\n    return true\n  }\n\n  // Ignore common static assets.\n  return /\\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(\n    url.pathname,\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,qBAAqB,SAA2B;AAC9D,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,MAAI,IAAI,aAAa,SAAS;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,2BAA2B,KAAK,IAAI,QAAQ,GAAG;AACjD,WAAO;AAAA,EACT;AAGA,MAAI,eAAe,KAAK,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,IAAI,SAAS,SAAS,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AAGA,SAAO,yKAAyK;AAAA,IAC9K,IAAI;AAAA,EACN;AACF;","names":[]}

node_modules/msw/lib/core/isCommonAssetRequest.mjs

@@ -0,0 +1,22 @@
+function isCommonAssetRequest(request) {
+  const url = new URL(request.url);
+  if (url.protocol === "file:") {
+    return true;
+  }
+  if (/(fonts\.googleapis\.com)/.test(url.hostname)) {
+    return true;
+  }
+  if (/node_modules/.test(url.pathname)) {
+    return true;
+  }
+  if (url.pathname.includes("@vite")) {
+    return true;
+  }
+  return /\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(
+    url.pathname
+  );
+}
+export {
+  isCommonAssetRequest
+};
+//# sourceMappingURL=isCommonAssetRequest.mjs.map

node_modules/msw/lib/core/isCommonAssetRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/isCommonAssetRequest.ts"],"sourcesContent":["/**\n * Determines if the given request is a static asset request.\n * Useful when deciding which unhandled requests to ignore.\n * @note Despite being ignored, you can still intercept and mock\n * static assets by creating request handlers for them.\n *\n * @example\n * import { isCommonAssetRequest } from 'msw'\n *\n * await worker.start({\n *   onUnhandledRequest(request, print) {\n *     if (!isCommonAssetRequest(request)) {\n *       print.warning()\n *     }\n *   }\n * })\n */\nexport function isCommonAssetRequest(request: Request): boolean {\n  const url = new URL(request.url)\n\n  // Ignore certain protocols.\n  if (url.protocol === 'file:') {\n    return true\n  }\n\n  // Ignore static assets hosts.\n  if (/(fonts\\.googleapis\\.com)/.test(url.hostname)) {\n    return true\n  }\n\n  // Ignore node modules served over HTTP.\n  if (/node_modules/.test(url.pathname)) {\n    return true\n  }\n\n  // Ignore internal Vite requests, like \"/@vite/client\".\n  if (url.pathname.includes('@vite')) {\n    return true\n  }\n\n  // Ignore common static assets.\n  return /\\.(s?css|less|m?jsx?|m?tsx?|html|ttf|otf|woff|woff2|eot|gif|jpe?g|png|avif|webp|svg|mp4|webm|ogg|mov|mp3|wav|ogg|flac|aac|pdf|txt|csv|json|xml|md|zip|tar|gz|rar|7z)$/i.test(\n    url.pathname,\n  )\n}\n"],"mappings":"AAiBO,SAAS,qBAAqB,SAA2B;AAC9D,QAAM,MAAM,IAAI,IAAI,QAAQ,GAAG;AAG/B,MAAI,IAAI,aAAa,SAAS;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,2BAA2B,KAAK,IAAI,QAAQ,GAAG;AACjD,WAAO;AAAA,EACT;AAGA,MAAI,eAAe,KAAK,IAAI,QAAQ,GAAG;AACrC,WAAO;AAAA,EACT;AAGA,MAAI,IAAI,SAAS,SAAS,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AAGA,SAAO,yKAAyK;AAAA,IAC9K,IAAI;AAAA,EACN;AACF;","names":[]}

node_modules/msw/lib/core/passthrough.d.mts

@@ -0,0 +1,24 @@
+import { H as HttpResponse } from './HttpResponse-Be4eT3x6.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+import './utils/matching/matchRequestUrl.mjs';
+
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+declare function passthrough(): HttpResponse<any>;
+
+export { passthrough };

node_modules/msw/lib/core/passthrough.d.ts

@@ -0,0 +1,24 @@
+import { H as HttpResponse } from './HttpResponse-Dj6ibgFJ.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+import './utils/matching/matchRequestUrl.js';
+
+/**
+ * Performs the intercepted request as-is.
+ *
+ * This stops request handler lookup so no other handlers
+ * can affect this request past this point.
+ * Unlike `bypass()`, this will not trigger an additional request.
+ *
+ * @example
+ * http.get('/resource', () => {
+ *   return passthrough()
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}
+ */
+declare function passthrough(): HttpResponse<any>;
+
+export { passthrough };

node_modules/msw/lib/core/passthrough.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var passthrough_exports = {};
+__export(passthrough_exports, {
+  passthrough: () => passthrough
+});
+module.exports = __toCommonJS(passthrough_exports);
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+//# sourceMappingURL=passthrough.js.map

node_modules/msw/lib/core/passthrough.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/passthrough.ts"],"sourcesContent":["import type { HttpResponse } from './HttpResponse'\n\n/**\n * Performs the intercepted request as-is.\n *\n * This stops request handler lookup so no other handlers\n * can affect this request past this point.\n * Unlike `bypass()`, this will not trigger an additional request.\n *\n * @example\n * http.get('/resource', () => {\n *   return passthrough()\n * })\n *\n * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}\n */\nexport function passthrough(): HttpResponse<any> {\n  return new Response(null, {\n    status: 302,\n    statusText: 'Passthrough',\n    headers: {\n      'x-msw-intention': 'passthrough',\n    },\n  }) as HttpResponse<any>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,cAAiC;AAC/C,SAAO,IAAI,SAAS,MAAM;AAAA,IACxB,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,SAAS;AAAA,MACP,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AACH;","names":[]}

node_modules/msw/lib/core/passthrough.mjs

@@ -0,0 +1,13 @@
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: {
+      "x-msw-intention": "passthrough"
+    }
+  });
+}
+export {
+  passthrough
+};
+//# sourceMappingURL=passthrough.mjs.map

node_modules/msw/lib/core/passthrough.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/passthrough.ts"],"sourcesContent":["import type { HttpResponse } from './HttpResponse'\n\n/**\n * Performs the intercepted request as-is.\n *\n * This stops request handler lookup so no other handlers\n * can affect this request past this point.\n * Unlike `bypass()`, this will not trigger an additional request.\n *\n * @example\n * http.get('/resource', () => {\n *   return passthrough()\n * })\n *\n * @see {@link https://mswjs.io/docs/api/passthrough `passthrough()` API reference}\n */\nexport function passthrough(): HttpResponse<any> {\n  return new Response(null, {\n    status: 302,\n    statusText: 'Passthrough',\n    headers: {\n      'x-msw-intention': 'passthrough',\n    },\n  }) as HttpResponse<any>\n}\n"],"mappings":"AAgBO,SAAS,cAAiC;AAC/C,SAAO,IAAI,SAAS,MAAM;AAAA,IACxB,QAAQ;AAAA,IACR,YAAY;AAAA,IACZ,SAAS;AAAA,MACP,mBAAmB;AAAA,IACrB;AAAA,EACF,CAAC;AACH;","names":[]}

node_modules/msw/lib/core/sharedOptions.d.mts

@@ -0,0 +1,64 @@
+import { Emitter } from 'strict-event-emitter';
+import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest.mjs';
+
+interface SharedOptions {
+    /**
+     * Specifies how to react to a request that has no corresponding
+     * request handler. Warns on unhandled requests by default.
+     *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
+     * @example worker.start({ onUnhandledRequest: 'warn' })
+     * @example server.listen({ onUnhandledRequest: 'error' })
+     */
+    onUnhandledRequest?: UnhandledRequestStrategy;
+}
+type LifeCycleEventsMap = {
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+
+export type { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions };

node_modules/msw/lib/core/sharedOptions.d.ts

@@ -0,0 +1,64 @@
+import { Emitter } from 'strict-event-emitter';
+import { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest.js';
+
+interface SharedOptions {
+    /**
+     * Specifies how to react to a request that has no corresponding
+     * request handler. Warns on unhandled requests by default.
+     *
+     * @example worker.start({ onUnhandledRequest: 'bypass' })
+     * @example worker.start({ onUnhandledRequest: 'warn' })
+     * @example server.listen({ onUnhandledRequest: 'error' })
+     */
+    onUnhandledRequest?: UnhandledRequestStrategy;
+}
+type LifeCycleEventsMap = {
+    'request:start': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:match': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:unhandled': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'request:end': [
+        args: {
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:mocked': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    'response:bypass': [
+        args: {
+            response: Response;
+            request: Request;
+            requestId: string;
+        }
+    ];
+    unhandledException: [
+        args: {
+            error: Error;
+            request: Request;
+            requestId: string;
+        }
+    ];
+};
+type LifeCycleEventEmitter<EventsMap extends Record<string | symbol, any>> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>;
+
+export type { LifeCycleEventEmitter, LifeCycleEventsMap, SharedOptions };

node_modules/msw/lib/core/sharedOptions.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sharedOptions_exports = {};
+module.exports = __toCommonJS(sharedOptions_exports);
+//# sourceMappingURL=sharedOptions.js.map

node_modules/msw/lib/core/sharedOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/sharedOptions.ts"],"sourcesContent":["import type { Emitter } from 'strict-event-emitter'\nimport type { UnhandledRequestStrategy } from './utils/request/onUnhandledRequest'\n\nexport interface SharedOptions {\n  /**\n   * Specifies how to react to a request that has no corresponding\n   * request handler. Warns on unhandled requests by default.\n   *\n   * @example worker.start({ onUnhandledRequest: 'bypass' })\n   * @example worker.start({ onUnhandledRequest: 'warn' })\n   * @example server.listen({ onUnhandledRequest: 'error' })\n   */\n  onUnhandledRequest?: UnhandledRequestStrategy\n}\n\nexport type LifeCycleEventsMap = {\n  'request:start': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:match': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:unhandled': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'request:end': [\n    args: {\n      request: Request\n      requestId: string\n    },\n  ]\n  'response:mocked': [\n    args: {\n      response: Response\n      request: Request\n      requestId: string\n    },\n  ]\n  'response:bypass': [\n    args: {\n      response: Response\n      request: Request\n      requestId: string\n    },\n  ]\n  unhandledException: [\n    args: {\n      error: Error\n      request: Request\n      requestId: string\n    },\n  ]\n}\n\nexport type LifeCycleEventEmitter<\n  EventsMap extends Record<string | symbol, any>,\n> = Pick<Emitter<EventsMap>, 'on' | 'removeListener' | 'removeAllListeners'>\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

node_modules/msw/lib/core/sharedOptions.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=sharedOptions.mjs.map

node_modules/msw/lib/core/sharedOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

node_modules/msw/lib/core/sse.d.mts

@@ -0,0 +1,116 @@
+import { Emitter } from 'strict-event-emitter';
+import { a as ResponseResolver } from './HttpResponse-Be4eT3x6.mjs';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.mjs';
+import { PathParams, Path } from './utils/matching/matchRequestUrl.mjs';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.mjs';
+import './typeUtils.mjs';
+import 'graphql';
+
+type EventMapConstraint = {
+    message?: unknown;
+    [key: string]: unknown;
+    [key: symbol | number]: never;
+};
+type ServerSentEventResolverExtras<EventMap extends EventMapConstraint, Params extends PathParams> = HttpRequestResolverExtras<Params> & {
+    client: ServerSentEventClient<EventMap>;
+    server: ServerSentEventServer;
+};
+type ServerSentEventResolver<EventMap extends EventMapConstraint, Params extends PathParams> = ResponseResolver<ServerSentEventResolverExtras<EventMap, Params>, any, any>;
+type ServerSentEventRequestHandler = <EventMap extends EventMapConstraint = {
+    message: unknown;
+}, Params extends PathParams<keyof Params> = PathParams, RequestPath extends Path = Path>(path: RequestPath, resolver: ServerSentEventResolver<EventMap, Params>) => HttpHandler;
+type ServerSentEventMessage<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> = ToEventDiscriminatedUnion<EventMap & {
+    message: unknown;
+}> | {
+    id?: never;
+    event?: never;
+    data?: never;
+    retry: number;
+};
+/**
+ * Intercept Server-Sent Events (SSE).
+ *
+ * @example
+ * sse('http://localhost:4321', ({ client }) => {
+ *   client.send({ data: 'hello world' })
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/sse/ Mocking Server-Sent Events}
+ * @see {@link https://mswjs.io/docs/api/sse `sse()` API reference}
+ */
+declare const sse: ServerSentEventRequestHandler;
+type Values<T> = T[keyof T];
+type Identity<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+type ToEventDiscriminatedUnion<T> = Values<{
+    [K in keyof T]: Identity<(K extends 'message' ? {
+        id?: string;
+        event?: K;
+        data?: T[K];
+        retry?: never;
+    } : {
+        id?: string;
+        event: K;
+        data?: T[K];
+        retry?: never;
+    }) & (undefined extends T[K] ? unknown : {
+        data: unknown;
+    })>;
+}>;
+type ServerSentEventClientEventMap = {
+    message: [
+        payload: {
+            id?: string;
+            event: string;
+            data?: unknown;
+            frames: Array<string>;
+        }
+    ];
+    error: [];
+    close: [];
+};
+declare class ServerSentEventClient<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> {
+    #private;
+    constructor(args: {
+        controller: ReadableStreamDefaultController;
+        emitter: Emitter<ServerSentEventClientEventMap>;
+    });
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload: ServerSentEventMessage<EventMap>): void;
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event: Event): void;
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error(): void;
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close(): void;
+}
+declare class ServerSentEventServer {
+    #private;
+    constructor(args: {
+        request: Request;
+        client: ServerSentEventClient<any>;
+    });
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect(): EventSource;
+}
+
+export { type ServerSentEventMessage, type ServerSentEventRequestHandler, type ServerSentEventResolver, type ServerSentEventResolverExtras, sse };

node_modules/msw/lib/core/sse.d.ts

@@ -0,0 +1,116 @@
+import { Emitter } from 'strict-event-emitter';
+import { a as ResponseResolver } from './HttpResponse-Dj6ibgFJ.js';
+import { HttpRequestResolverExtras, HttpHandler } from './handlers/HttpHandler.js';
+import { PathParams, Path } from './utils/matching/matchRequestUrl.js';
+import '@mswjs/interceptors';
+import './utils/internal/isIterable.js';
+import './typeUtils.js';
+import 'graphql';
+
+type EventMapConstraint = {
+    message?: unknown;
+    [key: string]: unknown;
+    [key: symbol | number]: never;
+};
+type ServerSentEventResolverExtras<EventMap extends EventMapConstraint, Params extends PathParams> = HttpRequestResolverExtras<Params> & {
+    client: ServerSentEventClient<EventMap>;
+    server: ServerSentEventServer;
+};
+type ServerSentEventResolver<EventMap extends EventMapConstraint, Params extends PathParams> = ResponseResolver<ServerSentEventResolverExtras<EventMap, Params>, any, any>;
+type ServerSentEventRequestHandler = <EventMap extends EventMapConstraint = {
+    message: unknown;
+}, Params extends PathParams<keyof Params> = PathParams, RequestPath extends Path = Path>(path: RequestPath, resolver: ServerSentEventResolver<EventMap, Params>) => HttpHandler;
+type ServerSentEventMessage<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> = ToEventDiscriminatedUnion<EventMap & {
+    message: unknown;
+}> | {
+    id?: never;
+    event?: never;
+    data?: never;
+    retry: number;
+};
+/**
+ * Intercept Server-Sent Events (SSE).
+ *
+ * @example
+ * sse('http://localhost:4321', ({ client }) => {
+ *   client.send({ data: 'hello world' })
+ * })
+ *
+ * @see {@link https://mswjs.io/docs/sse/ Mocking Server-Sent Events}
+ * @see {@link https://mswjs.io/docs/api/sse `sse()` API reference}
+ */
+declare const sse: ServerSentEventRequestHandler;
+type Values<T> = T[keyof T];
+type Identity<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+type ToEventDiscriminatedUnion<T> = Values<{
+    [K in keyof T]: Identity<(K extends 'message' ? {
+        id?: string;
+        event?: K;
+        data?: T[K];
+        retry?: never;
+    } : {
+        id?: string;
+        event: K;
+        data?: T[K];
+        retry?: never;
+    }) & (undefined extends T[K] ? unknown : {
+        data: unknown;
+    })>;
+}>;
+type ServerSentEventClientEventMap = {
+    message: [
+        payload: {
+            id?: string;
+            event: string;
+            data?: unknown;
+            frames: Array<string>;
+        }
+    ];
+    error: [];
+    close: [];
+};
+declare class ServerSentEventClient<EventMap extends EventMapConstraint = {
+    message: unknown;
+}> {
+    #private;
+    constructor(args: {
+        controller: ReadableStreamDefaultController;
+        emitter: Emitter<ServerSentEventClientEventMap>;
+    });
+    /**
+     * Sends the given payload to the intercepted `EventSource`.
+     */
+    send(payload: ServerSentEventMessage<EventMap>): void;
+    /**
+     * Dispatches the given event on the intercepted `EventSource`.
+     */
+    dispatchEvent(event: Event): void;
+    /**
+     * Errors the underlying `EventSource`, closing the connection with an error.
+     * This is equivalent to aborting the connection and will produce a `TypeError: Failed to fetch`
+     * error.
+     */
+    error(): void;
+    /**
+     * Closes the underlying `EventSource`, closing the connection.
+     */
+    close(): void;
+}
+declare class ServerSentEventServer {
+    #private;
+    constructor(args: {
+        request: Request;
+        client: ServerSentEventClient<any>;
+    });
+    /**
+     * Establishes the actual connection for this SSE request
+     * and returns the `EventSource` instance.
+     */
+    connect(): EventSource;
+}
+
+export { type ServerSentEventMessage, type ServerSentEventRequestHandler, type ServerSentEventResolver, type ServerSentEventResolverExtras, sse };