@trpc/server 10.43.0 → 11.0.0-next.91

package/src/core/router.ts

@@ -7,19 +7,8 @@ import { defaultTransformer } from '../transformer';
 import { AnyRootConfig } from './internals/config';
 import { omitPrototype } from './internals/omitPrototype';
 import { ProcedureCallOptions } from './internals/procedureBuilder';
-import {
-  AnyMutationProcedure,
-  AnyProcedure,
-  AnyQueryProcedure,
-  AnySubscriptionProcedure,
-  ProcedureArgs,
-} from './procedure';
-import {
-  inferHandlerInput,
-  inferProcedureOutput,
-  ProcedureType,
-  procedureTypes,
-} from './types';
+import { AnyProcedure, ProcedureArgs } from './procedure';
+import { ProcedureType } from './types';
 
 /** @internal **/
 export type ProcedureRecord = Record<string, AnyProcedure>;
@@ -28,66 +17,19 @@ export interface ProcedureRouterRecord {
   [key: string]: AnyProcedure | AnyRouter;
 }
 
-/**
- * @deprecated
- */
-interface DeprecatedProcedureRouterRecord {
-  queries: Record<string, AnyQueryProcedure>;
-  mutations: Record<string, AnyMutationProcedure>;
-  subscriptions: Record<string, AnySubscriptionProcedure>;
-}
-
 export interface RouterDef<
   TConfig extends AnyRootConfig,
   TRecord extends ProcedureRouterRecord,
-  /**
-   * @deprecated
-   */
-  TOld extends DeprecatedProcedureRouterRecord = {
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    queries: {};
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    mutations: {};
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    subscriptions: {};
-  },
 > {
   _config: TConfig;
   router: true;
+  procedure?: never;
   procedures: TRecord;
   record: TRecord;
-  /**
-   * V9 queries
-   * @deprecated
-   */
-  queries: TOld['queries'];
-  /**
-   * V9 mutations
-   * @deprecated
-   */
-  mutations: TOld['mutations'];
-  /**
-   * V9 subscriptions
-   * @deprecated
-   */
-  subscriptions: TOld['subscriptions'];
 }
 
-export type AnyRouterDef<
-  TConfig extends AnyRootConfig = AnyRootConfig,
-  TOld extends DeprecatedProcedureRouterRecord = any,
-> = RouterDef<TConfig, any, TOld>;
-
-/**
- * @internal
- */
-type inferHandlerFn<TProcedures extends ProcedureRecord> = <
-  TProcedure extends TProcedures[TPath],
-  TPath extends string & keyof TProcedures,
->(
-  path: TPath,
-  ...args: inferHandlerInput<TProcedure>
-) => Promise<inferProcedureOutput<TProcedure>>;
+export type AnyRouterDef<TConfig extends AnyRootConfig = AnyRootConfig> =
+  RouterDef<TConfig, any>;
 
 type DecorateProcedure<TProcedure extends AnyProcedure> = (
   input: ProcedureArgs<TProcedure['_def']>[0],
@@ -109,20 +51,7 @@ type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
  */
 type RouterCaller<TDef extends AnyRouterDef> = (
   ctx: TDef['_config']['$types']['ctx'],
-) => DecoratedProcedureRecord<TDef['record']> & {
-  /**
-   * @deprecated
-   */
-  query: inferHandlerFn<TDef['queries']>;
-  /**
-   * @deprecated
-   */
-  mutation: inferHandlerFn<TDef['mutations']>;
-  /**
-   * @deprecated
-   */
-  subscription: inferHandlerFn<TDef['subscriptions']>;
-};
+) => DecoratedProcedureRecord<TDef['record']>;
 
 export interface Router<TDef extends AnyRouterDef> {
   _def: TDef;
@@ -179,9 +108,9 @@ export type CreateRouterInner<
   TProcRouterRecord extends ProcedureRouterRecord,
 > = Router<RouterDef<TConfig, TProcRouterRecord>> &
   /**
-   * This should be deleted in v11
-   * @deprecated
-   */ TProcRouterRecord;
+   * This adds ability to call procedures directly but is primarily used for quick access in type inference
+   */
+  TProcRouterRecord;
 
 /**
  * @internal
@@ -229,15 +158,6 @@ export function createRouterFactory<TConfig extends AnyRootConfig>(
       procedures: routerProcedures,
       ...emptyRouter,
       record: procedures,
-      queries: Object.entries(routerProcedures)
-        .filter((pair) => (pair[1] as any)._def.query)
-        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-      mutations: Object.entries(routerProcedures)
-        .filter((pair) => (pair[1] as any)._def.mutation)
-        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
-      subscriptions: Object.entries(routerProcedures)
-        .filter((pair) => (pair[1] as any)._def.subscription)
-        .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {}),
     };
 
     const router: AnyRouter = {
@@ -245,35 +165,14 @@ export function createRouterFactory<TConfig extends AnyRootConfig>(
       _def,
       createCaller(ctx) {
         const proxy = createRecursiveProxy(({ path, args }) => {
-          // interop mode
-          if (
-            path.length === 1 &&
-            procedureTypes.includes(path[0] as ProcedureType)
-          ) {
-            return callProcedure({
-              procedures: _def.procedures,
-              path: args[0] as string,
-              rawInput: args[1],
-              ctx,
-              type: path[0] as ProcedureType,
-            });
-          }
-
           const fullPath = path.join('.');
           const procedure = _def.procedures[fullPath] as AnyProcedure;
 
-          let type: ProcedureType = 'query';
-          if (procedure._def.mutation) {
-            type = 'mutation';
-          } else if (procedure._def.subscription) {
-            type = 'subscription';
-          }
-
           return procedure({
             path: fullPath,
-            rawInput: args[0],
+            getRawInput: async () => args[0],
             ctx,
-            type,
+            type: procedure._def.type,
           });
         });
 
@@ -303,6 +202,11 @@ export function createRouterFactory<TConfig extends AnyRootConfig>(
   };
 }
 
+function isProcedure(
+  procedureOrRouter: AnyProcedure | AnyRouter,
+): procedureOrRouter is AnyProcedure {
+  return !!procedureOrRouter._def.procedure;
+}
 /**
  * @internal
  */
@@ -310,15 +214,13 @@ export function callProcedure(
   opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
 ) {
   const { type, path } = opts;
-
-  if (!(path in opts.procedures) || !opts.procedures[path]?._def[type]) {
+  const proc = opts.procedures[path];
+  if (!proc || !isProcedure(proc) || proc._def.type !== type) {
     throw new TRPCError({
       code: 'NOT_FOUND',
       message: `No "${type}"-procedure on path "${path}"`,
     });
   }
 
-  const procedure = opts.procedures[path] as AnyProcedure;
-
-  return procedure(opts);
+  return proc(opts);
 }

package/src/core/types.ts

@@ -1,5 +1,4 @@
-import { inferObservableValue } from '../observable';
-import { inferTransformedProcedureOutput } from '../shared/jsonify';
+import { inferTransformedProcedureOutput } from '../shared';
 import { AnyProcedure, ProcedureArgs } from './procedure';
 import { AnyRouter, AnyRouterDef, Router } from './router';
 
@@ -11,12 +10,14 @@ export type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
     : never
   : never;
 
+export type inferRouterConfig<TRouter extends AnyRouter> =
+  inferRouterDef<TRouter>['_config'];
 export type inferRouterContext<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_config']['$types']['ctx'];
+  inferRouterConfig<TRouter>['$types']['ctx'];
 export type inferRouterError<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_config']['$types']['errorShape'];
+  inferRouterConfig<TRouter>['$types']['errorShape'];
 export type inferRouterMeta<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_config']['$types']['meta'];
+  inferRouterConfig<TRouter>['$types']['meta'];
 
 export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
 /**
@@ -29,7 +30,7 @@ export type inferHandlerInput<TProcedure extends AnyProcedure> = ProcedureArgs<
 >;
 
 export type inferProcedureInput<TProcedure extends AnyProcedure> =
-  inferHandlerInput<TProcedure>[0];
+  inferProcedureParams<TProcedure>['_input_in'];
 
 export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
   ? TProcedure['_def']
@@ -37,19 +38,6 @@ export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
 export type inferProcedureOutput<TProcedure> =
   inferProcedureParams<TProcedure>['_output_out'];
 
-/**
- * @deprecated will be removed in next major as it's v9 stuff
- */
-export type inferSubscriptionOutput<
-  TRouter extends AnyRouter,
-  TPath extends string & keyof TRouter['_def']['subscriptions'],
-> = inferObservableValue<
-  inferProcedureOutput<TRouter['_def']['subscriptions'][TPath]>
->;
-
-export type inferProcedureClientError<TProcedure extends AnyProcedure> =
-  inferProcedureParams<TProcedure>['_config']['errorShape'];
-
 type GetInferenceHelpers<
   TType extends 'input' | 'output',
   TRouter extends AnyRouter,
@@ -60,7 +48,10 @@ type GetInferenceHelpers<
       : TRouterOrProcedure extends AnyProcedure
       ? TType extends 'input'
         ? inferProcedureInput<TRouterOrProcedure>
-        : inferTransformedProcedureOutput<TRouterOrProcedure>
+        : inferTransformedProcedureOutput<
+            TRouter['_def']['_config'],
+            TRouterOrProcedure
+          >
       : never
     : never;
 };

package/src/http/resolveHTTPResponse.ts

@@ -16,7 +16,12 @@ import {
 } from './contentType';
 import { getHTTPStatusCode } from './getHTTPStatusCode';
 import { HTTPHeaders, HTTPResponse, ResponseChunk } from './internals/types';
-import { HTTPBaseHandlerOptions, HTTPRequest } from './types';
+import {
+  HTTPBaseHandlerOptions,
+  HTTPRequest,
+  ResolveHTTPRequestOptionsContextFn,
+  TRPCRequestInfo,
+} from './types';
 
 const HTTP_METHOD_PROCEDURE_TYPE_MAP: Record<
   string,
@@ -40,7 +45,7 @@ interface ResolveHTTPRequestOptions<
   TRouter extends AnyRouter,
   TRequest extends HTTPRequest,
 > extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-  createContext: () => Promise<inferRouterContext<TRouter>>;
+  createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
   req: TRequest;
   path: string;
   error?: Maybe<TRPCError>;
@@ -145,7 +150,7 @@ async function inputToProcedureCall<
     const data = await callProcedure({
       procedures: opts.router._def.procedures,
       path,
-      rawInput: input,
+      getRawInput: async () => input,
       ctx,
       type,
     });
@@ -287,17 +292,6 @@ export async function resolveHTTPResponse<
     req.headers['trpc-batch-mode'] === 'stream';
 
   try {
-    // we create context first so that (unless `createContext()` throws)
-    // error handler may access context information
-    //
-    // this way even if the client sends malformed input that might cause an exception:
-    //  - `opts.error` has value,
-    //  - batching is not enabled,
-    //  - `type` is unknown,
-    //  - `getInputs` throws because of malformed JSON,
-    // context value is still available to the error handler
-    ctx = await opts.createContext();
-
     if (opts.error) {
       throw opts.error;
     }
@@ -328,6 +322,15 @@ export async function resolveHTTPResponse<
     paths = isBatchCall
       ? decodeURIComponent(opts.path).split(',')
       : [opts.path];
+    const info: TRPCRequestInfo = {
+      isBatchCall,
+      calls: paths.map((path, idx) => ({
+        path,
+        type,
+        input: inputs[idx] ?? undefined,
+      })),
+    };
+    ctx = await opts.createContext({ info });
     const promises = paths.map((path, index) =>
       inputToProcedureCall({ opts, ctx, type, input: inputs[index], path }),
     );

package/src/http/types.ts

@@ -1,4 +1,4 @@
-import { AnyRouter } from '../core';
+import { AnyRouter, inferRouterContext, ProcedureType } from '../core';
 import { BaseHandlerOptions } from '../internals/types';
 import { HTTPHeaders, ResponseMetaFn } from './internals/types';
 
@@ -26,3 +26,26 @@ export interface ResponseMeta {
   status?: number;
   headers?: Record<string, string>;
 }
+
+/** @internal */
+export type ProcedureCall = {
+  type: ProcedureType;
+  input?: unknown;
+  path: string;
+};
+
+/**
+ * Information about the incoming request
+ * @internal
+ */
+export type TRPCRequestInfo = {
+  isBatchCall: boolean;
+  calls: ProcedureCall[];
+};
+
+/**
+ * Inner createContext function for `resolveHTTPResponse` used to forward `TRPCRequestInfo` to `createContext`
+ * @internal
+ */
+export type ResolveHTTPRequestOptionsContextFn<TRouter extends AnyRouter> =
+  (opts: { info: TRPCRequestInfo }) => Promise<inferRouterContext<TRouter>>;

package/src/index.ts

@@ -1,6 +1,20 @@
+// FIXME: this file should only export
+// - `initTRPC`
+// - `TRPCError`
+// - (maybe something else?)
+
 export * from './transformer';
 export * from './error/TRPCError';
 export * from './types';
-export { router } from './deprecated/router';
 export * from './core';
-export * from './internals';
+export { type DefaultErrorShape } from './error/formatter';
+export type { RootConfig, AnyRootConfig } from './core/internals/config';
+
+/**
+ * ⚠️ ⚠️ ⚠️ Danger zone ⚠️ ⚠️ ⚠️
+ * @remark
+ * Do not use things from this export as they are subject to change without notice. They only exists to support `.d.ts`-files
+ * If you need something from here, please open an issue and we'll see if we can expose it in a stable way.
+ * @deprecated
+ */
+export * as unstableExternalsExport from './unstableInternalsExport';

package/src/rpc/envelopes.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-namespace */
-import { ProcedureType } from '../deprecated/router';
+import { ProcedureType } from '../core';
 import { TRPC_ERROR_CODE_NUMBER } from './codes';
 
 /**
@@ -64,11 +64,6 @@ export interface TRPCSuccessResponse<TData>
     }
   > {}
 
-/**
- * @deprecated use `TRPCSuccessResponse` instead
- */
-export type TRPCResultResponse<TData = unknown> = TRPCSuccessResponse<TData>;
-
 export interface TRPCErrorResponse<
   TError extends TRPCErrorShape = TRPCErrorShape,
 > extends JSONRPC2.ErrorResponse<TError> {}

package/src/rpc/index.ts

@@ -1,3 +1,2 @@
 export * from './codes';
 export * from './envelopes';
-export * from './parseTRPCMessage';

package/src/shared/getErrorShape.ts

@@ -1,7 +1,8 @@
 import { ProcedureType } from '../core';
+import { AnyRootConfig } from '../core/internals/config';
+import { DefaultErrorShape } from '../error/formatter';
 import { TRPCError } from '../error/TRPCError';
 import { getHTTPStatusCodeFromError } from '../http/getHTTPStatusCode';
-import { AnyRootConfig, DefaultErrorShape } from '../internals';
 import { TRPC_ERROR_CODES_BY_KEY } from '../rpc';
 
 /**

package/src/shared/index.ts

@@ -6,3 +6,5 @@ export * from './transformTRPCResponse';
 export type { SerializeObject, Serialize } from './internal/serialize';
 
 export { getErrorShape } from './getErrorShape';
+
+export * from './types';

package/src/shared/jsonify.ts

@@ -1,4 +1,5 @@
 import { AnyProcedure } from '../core';
+import { AnyRootConfig } from '../core/internals/config';
 import { inferObservableValue } from '../observable';
 import { DefaultDataTransformer } from '../transformer';
 import type { Serialize } from './internal/serialize';
@@ -6,13 +7,16 @@ import type { Serialize } from './internal/serialize';
 /**
  * @internal
  */
-export type inferTransformedProcedureOutput<TProcedure extends AnyProcedure> =
-  TProcedure['_def']['_config']['transformer'] extends DefaultDataTransformer
-    ? Serialize<TProcedure['_def']['_output_out']>
-    : TProcedure['_def']['_output_out'];
+export type inferTransformedProcedureOutput<
+  TConfig extends AnyRootConfig,
+  TProcedure extends AnyProcedure,
+> = TConfig['transformer'] extends DefaultDataTransformer
+  ? Serialize<TProcedure['_def']['_output_out']>
+  : TProcedure['_def']['_output_out'];
 
 export type inferTransformedSubscriptionOutput<
+  TConfig extends AnyRootConfig,
   TProcedure extends AnyProcedure,
-> = TProcedure['_def']['_config']['transformer'] extends DefaultDataTransformer
+> = TConfig['transformer'] extends DefaultDataTransformer
   ? Serialize<inferObservableValue<TProcedure['_def']['_output_out']>>
   : inferObservableValue<TProcedure['_def']['_output_out']>;

package/src/shared/transformTRPCResponse.ts

@@ -1,4 +1,4 @@
-import { AnyRootConfig } from '../internals';
+import { AnyRootConfig } from '../core/internals/config';
 import { TRPCResponse, TRPCResponseMessage } from '../rpc';
 
 function transformTRPCResponseItem<

package/src/shared/types.ts

@@ -0,0 +1,9 @@
+import { AnyRouter } from '../core';
+import { AnyRootConfig } from '../core/internals/config';
+
+export type TRPCInferrable = AnyRouter | AnyRootConfig;
+export type inferConfig<TInferrable extends TRPCInferrable> =
+  TInferrable extends AnyRouter ? TInferrable['_def']['_config'] : TInferrable;
+
+export type inferErrorShape<TInferrable extends TRPCInferrable> =
+  inferConfig<TInferrable>['$types']['errorShape'];

package/src/types.ts

@@ -115,3 +115,11 @@ export type DeepPartial<TObject> = TObject extends object
       [P in keyof TObject]?: DeepPartial<TObject[P]>;
     }
   : TObject;
+
+/**
+ * Omits the key without removing a potential union
+ * @internal
+ */
+export type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any
+  ? Omit<TObj, TKey>
+  : never;

package/src/unstableInternalsExport.ts

@@ -0,0 +1,10 @@
+/**
+ * These types have to be exported so users can generate their own types definitions files
+ *
+ * @remark Do not `import` anything here as it will be unreliable between minor versions of tRPC
+ */
+export { mergeRouters } from './core/internals/mergeRouters';
+export * from './core/internals/procedureBuilder';
+export * from './core/internals/utils';
+export type { MiddlewareFunction, MiddlewareBuilder } from './core/middleware';
+export * from './core/procedure';

package/unstableInternalsExport/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/unstableInternalsExport';

package/unstableInternalsExport/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/unstableInternalsExport');

package/adapters/zodFileSchema/index.d.ts

@@ -1 +0,0 @@
-export * from '../../dist/adapters/zodFileSchema';

package/adapters/zodFileSchema/index.js

@@ -1 +0,0 @@
-module.exports = require('../../dist/adapters/zodFileSchema');

package/dist/adapters/lambda/index.d.ts

@@ -1,12 +0,0 @@
-import { awsLambdaRequestHandler, CreateAWSLambdaContextOptions } from '../aws-lambda';
-import { APIGatewayEvent } from '../aws-lambda/utils';
-export * from '../aws-lambda';
-/**
- * @deprecated use `aws-lambda` instead
- */
-export type CreateLambdaContextOptions<TEvent extends APIGatewayEvent> = CreateAWSLambdaContextOptions<TEvent>;
-/**
- * @deprecated use `aws-lambda` instead
- */
-export declare const lambdaRequestHandler: typeof awsLambdaRequestHandler;
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/lambda/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/lambda/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,cAAc,eAAe,CAAC;AAE9B;;GAEG;AACH,MAAM,MAAM,0BAA0B,CAAC,MAAM,SAAS,eAAe,IACnE,6BAA6B,CAAC,MAAM,CAAC,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,oBAAoB,gCAA0B,CAAC"}

package/dist/deprecated/internals/middlewares.d.ts

@@ -1,52 +0,0 @@
-import { TRPCError } from '../../error/TRPCError';
-import { ProcedureType } from '../router';
-/**
- * @deprecated
- */
-export declare const middlewareMarker: "middlewareMarker" & {
-    __brand: 'middlewareMarker';
-};
-interface MiddlewareResultBase<TContext> {
-    /**
-     * All middlewares should pass through their `next()`'s output.
-     * Requiring this marker makes sure that can't be forgotten at compile-time.
-     */
-    readonly marker: typeof middlewareMarker;
-    ctx: TContext;
-}
-/**
- * @deprecated
- */
-interface MiddlewareOKResult<TContext> extends MiddlewareResultBase<TContext> {
-    ok: true;
-    data: unknown;
-}
-/**
- * @deprecated
- */
-interface MiddlewareErrorResult<TContext> extends MiddlewareResultBase<TContext> {
-    ok: false;
-    error: TRPCError;
-}
-/**
- * @deprecated
- */
-export type MiddlewareResult<TContext> = MiddlewareErrorResult<TContext> | MiddlewareOKResult<TContext>;
-/**
- * @deprecated
- */
-export type MiddlewareFunction<TInputContext, TContext, TMeta> = (opts: {
-    ctx: TInputContext;
-    type: ProcedureType;
-    path: string;
-    rawInput: unknown;
-    meta?: TMeta;
-    next: {
-        (): Promise<MiddlewareResult<TInputContext>>;
-        <TNewContext>(opts: {
-            ctx: TNewContext;
-        }): Promise<MiddlewareResult<TNewContext>>;
-    };
-}) => Promise<MiddlewareResult<TContext>>;
-export {};
-//# sourceMappingURL=middlewares.d.ts.map

package/dist/deprecated/internals/middlewares.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middlewares.d.ts","sourceRoot":"","sources":["../../../src/deprecated/internals/middlewares.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,gBAAgB;aAClB,kBAAkB;CAC5B,CAAC;AAEF,UAAU,oBAAoB,CAAC,QAAQ;IACrC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,gBAAgB,CAAC;IACzC,GAAG,EAAE,QAAQ,CAAC;CACf;AAED;;GAEG;AACH,UAAU,kBAAkB,CAAC,QAAQ,CAAE,SAAQ,oBAAoB,CAAC,QAAQ,CAAC;IAC3E,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,OAAO,CAAC;CAEf;AAED;;GAEG;AACH,UAAU,qBAAqB,CAAC,QAAQ,CACtC,SAAQ,oBAAoB,CAAC,QAAQ,CAAC;IACtC,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,SAAS,CAAC;CAElB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,IACjC,qBAAqB,CAAC,QAAQ,CAAC,GAC/B,kBAAkB,CAAC,QAAQ,CAAC,CAAC;AAEjC;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,aAAa,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC,IAAI,EAAE;IACtE,GAAG,EAAE,aAAa,CAAC;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,IAAI,EAAE;QACJ,IAAI,OAAO,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;QAC7C,CAAC,WAAW,EAAE,IAAI,EAAE;YAAE,GAAG,EAAE,WAAW,CAAA;SAAE,GAAG,OAAO,CAChD,gBAAgB,CAAC,WAAW,CAAC,CAC9B,CAAC;KACH,CAAC;CACH,KAAK,OAAO,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC"}