@effect-app/infra 2.73.4 → 2.74.0

package/src/api/routing/dynamic-middleware.ts

@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Array, Context, Effect, type Layer, Option, type S } from "effect-app"
+import { type GetEffectContext, type RPCContextMap } from "effect-app/client"
+import { type Tag } from "effect-app/Context"
+import { typedValuesOf } from "effect-app/utils"
+import { InfraLogger } from "../../logger.js"
+import { sort } from "./tsort.js"
+
+export type ContextWithLayer<
+  Config,
+  Id,
+  Service,
+  E,
+  R,
+  MakeE,
+  MakeR,
+  Tag extends string,
+  Args extends [config: Config, headers: Record<string, string>],
+  Dependencies extends any[]
+> =
+  & Context.Tag<
+    Id,
+    { handle: (...args: Args) => Effect<Option<Context<Service>>, E, R>; _tag: Tag }
+  >
+  & {
+    Default: Layer.Layer<Id, MakeE, MakeR>
+    dependsOn?: Dependencies
+  }
+
+export type AnyContextWithLayer<Config, Service, Error> =
+  | ContextWithLayer<
+    Config,
+    any,
+    Service,
+    Error,
+    any,
+    any,
+    any,
+    string,
+    any,
+    any
+  >
+  | ContextWithLayer<
+    Config,
+    any,
+    Service,
+    Error,
+    never,
+    any,
+    never,
+    any,
+    any,
+    any
+  >
+  | ContextWithLayer<
+    Config,
+    any,
+    Service,
+    Error,
+    any,
+    any,
+    never,
+    any,
+    any,
+    any
+  >
+  | ContextWithLayer<
+    Config,
+    any,
+    Service,
+    Error,
+    never,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+
+export const mergeContexts = Effect.fnUntraced(
+  function*<T extends readonly { maker: any; handle: Effect<Context<any>> }[]>(makers: T) {
+    let context = Context.empty()
+    for (const mw of makers) {
+      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
+      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
+      yield* InfraLogger.logDebug(
+        "Built context for middleware",
+        mw.maker.key ?? mw.maker,
+        (moreContext as any).toJSON().services
+      )
+      context = Context.merge(context, moreContext)
+    }
+    return context as Context.Context<Effect.Success<T[number]["handle"]>>
+  }
+)
+
+export const mergeOptionContexts = Effect.fnUntraced(
+  function*<T extends readonly { maker: any; handle: Effect<Option<Context<any>>> }[]>(makers: T) {
+    let context = Context.empty()
+    for (const mw of makers) {
+      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
+      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
+      yield* InfraLogger.logDebug(
+        "Built context for middleware",
+        mw.maker.key ?? mw.maker,
+        Option.map(moreContext, (c) => (c as any).toJSON().services)
+      )
+      if (moreContext.value) {
+        context = Context.merge(context, moreContext.value)
+      }
+    }
+    return context
+  }
+)
+
+export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>() =>
+<
+  TI extends {
+    [K in keyof T]: AnyContextWithLayer<
+      { [K in keyof T]?: T[K]["contextActivation"] },
+      T[K]["service"],
+      S.Schema.Type<T[K]["error"]>
+    >
+  }
+>(implementations: TI) => ({
+  dependencies: typedValuesOf(implementations).map((_) => _.Default) as {
+    [K in keyof TI]: TI[K]["Default"]
+  }[keyof TI][],
+  effect: Effect.gen(function*() {
+    const sorted = sort(typedValuesOf(implementations))
+
+    const makers = yield* Effect.all(sorted)
+    return Effect.fnUntraced(
+      function*(config: { [K in keyof T]?: T[K]["contextActivation"] }, headers: Record<string, string>) {
+        const ctx = yield* mergeOptionContexts(
+          Array.map(
+            makers,
+            (_, i) => ({ maker: sorted[i], handle: (_ as any).handle(config, headers) as any }) as any
+          )
+        )
+        return ctx as Context.Context<
+          GetEffectContext<T, typeof config>
+        >
+      }
+    ) as (
+      config: { [K in keyof T]?: T[K]["contextActivation"] },
+      headers: Record<string, string>
+    ) => Effect.Effect<
+      Context.Context<GetEffectContext<T, typeof config>>,
+      Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>,
+      Effect.Context<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>
+    >
+  })
+})

package/src/api/routing/tsort.ts

@@ -0,0 +1,56 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+export function tsort(edges) {
+  const nodes = new Map(), sorted = [], visited = new Map()
+
+  const Node = function(id) {
+    this.id = id
+    this.afters = []
+  }
+
+  edges.forEach((v) => {
+    const from = v[0], to = v[1]
+    if (!nodes.get(from)) nodes.set(from, new Node(from))
+    if (!nodes.get(to)) nodes.set(to, new Node(to))
+    nodes.get(from).afters.push(to)
+  })
+  ;[...nodes.keys()].forEach(function visit(idstr, ancestors) {
+    const node = nodes.get(idstr), id = node.id
+
+    if (visited.get(idstr)) return
+    if (!Array.isArray(ancestors)) ancestors = []
+
+    ancestors.push(id)
+    visited.set(idstr, true)
+    node.afters.forEach(function(afterID) {
+      if (ancestors.indexOf(afterID) >= 0) {
+        throw new Error("closed chain : " + afterID + " is in " + id)
+      }
+      visit(
+        afterID,
+        ancestors.map(function(v) {
+          return v
+        })
+      )
+    })
+    sorted.unshift(id)
+  })
+
+  return sorted
+}
+
+export const createEdges = <T extends { dependsOn?: any[] }>(dep: readonly T[]) => {
+  const result = []
+  dep.forEach((key) => {
+    key.dependsOn?.forEach((n) => {
+      result.push([n, key])
+    })
+  })
+  return result
+}
+
+export const sort = <T>(dep: readonly (T & { dependsOn?: any[] })[]): readonly T[] => {
+  const edges = createEdges(dep)
+  const result = tsort(edges)
+  return result.concat(dep.filter((v) => !result.includes(v)))
+}

package/src/api/routing.ts

@@ -3,16 +3,14 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
-import { logError, reportError } from "@effect-app/infra/errorReporter"
-import { InfraLogger } from "@effect-app/infra/logger"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { Array, Cause, Duration, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray, ParseResult, Predicate, Request, S, Schedule, Schema } from "effect-app"
+import { type Array, Duration, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
-import { pretty, typedKeysOf, typedValuesOf } from "effect-app/utils"
+import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import type { Contravariant } from "effect/Types"
 import { type YieldWrap } from "effect/Utils"
-import { type Middleware } from "./routing/DynamicMiddleware.js"
+import { DevMode, type Middleware } from "./routing/DynamicMiddleware.js"
 
 export * from "./routing/DynamicMiddleware.js"
 
@@ -36,9 +34,6 @@ export namespace LayersUtils {
     : never
 }
 
-const logRequestError = logError("Request")
-const reportRequestError = reportError("Request")
-
 // retry just once on optimistic concurrency exceptions
 const optimisticConcurrencySchedule = Schedule.once.pipe(
   Schedule.intersect(Schedule.recurWhile<any>((a) => a?._tag === "OptimisticConcurrencyException"))
@@ -423,64 +418,17 @@ export const makeRouter = <
                   }
                 } as any
                 : resource,
-              rpc.effect(resource, (input: any, headers: HttpHeaders.Headers) =>
-                // TODO: render more data... similar to console?
-                Effect
-                  .annotateCurrentSpan(
-                    "requestInput",
-                    Object.entries(input).reduce((prev, [key, value]: [string, unknown]) => {
-                      prev[key] = key === "password"
-                        ? "<redacted>"
-                        : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-                        ? typeof value === "string" && value.length > 256
-                          ? (value.substring(0, 253) + "...")
-                          : value
-                        : Array.isArray(value)
-                        ? `Array[${value.length}]`
-                        : value === null || value === undefined
-                        ? `${value}`
-                        : typeof value === "object" && value
-                        ? `Object[${Object.keys(value).length}]`
-                        : typeof value
-                      return prev
-                    }, {} as Record<string, string | number | boolean>)
-                  )
-                  .pipe(
-                    // can't use andThen due to some being a function and effect
-                    Effect.zipRight(handle(input, headers)),
-                    // TODO: support ParseResult if the error channel of the request allows it.. but who would want that?
-                    Effect.catchAll((_) => ParseResult.isParseError(_) ? Effect.die(_) : Effect.fail(_)),
-                    Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
-                    Effect.tapDefect((cause) =>
-                      Effect
-                        .all([
-                          reportRequestError(cause, {
-                            action: `${meta.moduleName}.${resource._tag}`
-                          }),
-                          InfraLogger
-                            .logError("Finished request", cause)
-                            .pipe(Effect.annotateLogs({
-                              action: `${meta.moduleName}.${resource._tag}`,
-                              req: pretty(resource),
-                              headers: pretty(headers)
-                              // resHeaders: pretty(
-                              //   Object
-                              //     .entries(headers)
-                              //     .reduce((prev, [key, value]) => {
-                              //       prev[key] = value && typeof value === "string" ? snipString(value) : value
-                              //       return prev
-                              //     }, {} as Record<string, any>)
-                              // )
-                            }))
-                        ])
-                    ),
-                    // NOTE: this does not catch errors from the middlewares..
-                    // we should re-evalute this in any case..
-                    devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error")),
+              rpc.effect(
+                resource,
+                (req, headers) =>
+                  handle(req, headers).pipe(
                     Effect.withSpan("Request." + meta.moduleName + "." + resource._tag, {
                       captureStackTrace: () => handler.stack
-                    })
-                  ), meta.moduleName),
+                    }),
+                    Effect.provideService(DevMode, devMode)
+                  ),
+                meta.moduleName
+              ),
               meta.moduleName
             ] as const
             return acc

package/test/controller.test.ts

@@ -1,18 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
+import { type MakeContext, type MakeErrors, makeRouter, RequestCacheLayers } from "@effect-app/infra/api/routing"
 import type { RequestContext } from "@effect-app/infra/RequestContext"
-import { expectTypeOf } from "@effect/vitest"
-import { Context, Effect, Layer, S } from "effect-app"
-import { type GetEffectContext, InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { expect, expectTypeOf, it } from "@effect/vitest"
+import { type Array, Context, Effect, Layer, Option, S } from "effect-app"
+import { InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
 import { HttpServerRequest } from "effect-app/http"
 import { Class, TaggedError } from "effect-app/Schema"
 import { ContextProvider, makeMiddleware, mergeContextProviders, MergedContextProvider } from "../src/api/routing/DynamicMiddleware.js"
+import { sort } from "../src/api/routing/tsort.js"
 import { SomeService } from "./query.test.js"
 
 class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
   Class<UserProfile>("UserProfile")({
-    id: S.String
+    id: S.String,
+    roles: S.Array(S.String)
   })
 ) {
 }
@@ -32,7 +34,7 @@ export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<So
 export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-const contextProvider = ContextProvider({
+export const someContextProvider = ContextProvider({
   effect: Effect.gen(function*() {
     yield* SomeService
     if (Math.random() > 0.5) return yield* new CustomError1()
@@ -59,7 +61,7 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requiremeno you can have are the one provided by HttpRouter.HttpRouter.Provided
       yield* HttpServerRequest.HttpServerRequest
 
       // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
@@ -74,62 +76,118 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
   })
 }) {}
 
+class RequestCacheContext extends Effect.Service<RequestCacheContext>()("RequestCacheContext", {
+  effect: Effect.gen(function*() {
+    return Effect.gen(function*() {
+      const ctx = yield* Layer.build(RequestCacheLayers)
+      return ctx as Context.Context<any> // todo: ugh.
+    })
+  })
+}) {}
+
 const merged = mergeContextProviders(MyContextProvider)
 export const contextProvider2 = ContextProvider(merged)
 export const contextProvider3 = MergedContextProvider(MyContextProvider)
-
-expectTypeOf(contextProvider2).toEqualTypeOf<typeof contextProvider>()
+expectTypeOf(contextProvider2).toEqualTypeOf<typeof someContextProvider>()
 expectTypeOf(contextProvider3).toEqualTypeOf<typeof contextProvider2>()
+const merged2 = mergeContextProviders(MyContextProvider, RequestCacheContext)
+export const contextProvider22 = ContextProvider(merged2)
+export const contextProvider23 = MergedContextProvider(MyContextProvider, RequestCacheContext)
+expectTypeOf(contextProvider23).toEqualTypeOf<typeof contextProvider22>()
 
 export type RequestContextMap = {
-  allowAnonymous: RPCContextMap.Inverted<"userProfile", UserProfile, typeof NotLoggedInError>
-  // TODO: not boolean but `string[]`
-  requireRoles: RPCContextMap.Custom<"", never, typeof UnauthorizedError, Array<string>>
+  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
+  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
+  test: RPCContextMap<never, typeof S.Never>
 }
 
 const Str = Context.GenericTag<"str", "str">("str")
 const Str2 = Context.GenericTag<"str2", "str">("str2")
 
+class AllowAnonymous extends Effect.Service<AllowAnonymous>()("AllowAnonymous", {
+  effect: Effect.gen(function*() {
+    return {
+      handle: Effect.fn(function*(opts: { allowAnonymous?: false }, headers: Record<string, string>) {
+        const isLoggedIn = !!headers["x-user"]
+        if (!isLoggedIn) {
+          if (!opts.allowAnonymous) {
+            return yield* new NotLoggedInError({ message: "Not logged in" })
+          }
+          return Option.none()
+        }
+        return Option.some(Context.make(
+          UserProfile,
+          { id: "whatever", roles: ["user", "manager"] }
+        ))
+      })
+    }
+  })
+}) {}
+
+class RequireRoles extends Effect.Service<RequireRoles>()("RequireRoles", {
+  effect: Effect.gen(function*() {
+    return {
+      handle: Effect.fn(
+        function*(cfg: { requireRoles?: readonly string[] }) {
+          // we don't know if the service will be provided or not, so we use option..
+          const userProfile = yield* Effect.serviceOption(UserProfile)
+          const { requireRoles } = cfg
+          if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+            return yield* new UnauthorizedError({ message: "don't have the right roles" })
+          }
+          return Option.none<Context<never>>()
+        }
+      )
+    }
+  })
+}) {
+  static dependsOn = [AllowAnonymous]
+}
+
+class Test extends Effect.Service<Test>()("Test", {
+  effect: Effect.gen(function*() {
+    return {
+      handle: Effect.fn(function*() {
+        return Option.none<Context<never>>()
+      })
+    }
+  })
+}) {}
+
+// TODO: eventually it might be nice if we have total control over order somehow..
+// [ AddRequestNameToSpanContext, RequestCacheContext, UninterruptibleMiddleware, Dynamic(or individual, AllowAnonymous, RequireRoles, Test - or whichever order) ]
 const middleware = makeMiddleware<RequestContextMap>()({
   dependencies: [Layer.effect(Str2, Str)],
-  contextProvider,
+  // TODO: I guess it makes sense to support just passing array of context providers too, like dynamicMiddlewares?
+  contextProvider: MergedContextProvider(RequestCacheContext, MyContextProvider),
+  // or is the better api to use constructors outside, like how contextProvider is used now?
+  dynamicMiddlewares: {
+    requireRoles: RequireRoles,
+    allowAnonymous: AllowAnonymous,
+    test: Test
+  },
+  // TODO: 0..n of these generic middlewares?
   execute: (maker) =>
     Effect.gen(function*() {
-      return maker((_schema, handler, moduleName) => (req, headers) => {
-        return Effect
-          .gen(function*() {
-            // const headers = yield* Rpc.currentHeaders
-            const ctx = Context.empty().pipe(
-              Context.add(UserProfile, { id: "whatever" })
-            )
-
-            // you can use only HttpRouter.HttpRouter.Provided here as additional context
-            // and what ContextMaker provides too
-            // const someElse = yield* SomeElse
-
-            yield* Some // provided by ContextMaker
-            yield* HttpServerRequest.HttpServerRequest // provided by HttpRouter.HttpRouter.Provided
-
-            return yield* handler(req, headers).pipe(
-              Effect.provide(ctx as Context.Context<GetEffectContext<RequestContextMap, (typeof _schema)["config"]>>)
-              // I do expect the ContextMaker to provide this
-              // Effect.provideService(Some, new Some({ a: 1 }))
-            )
-          })
-          .pipe(
-            Effect.provide(
-              Effect
-                .gen(function*() {
-                  yield* Effect.annotateCurrentSpan("request.name", moduleName ? `${moduleName}.${req._tag}` : req._tag)
-
-                  // const httpReq = yield* HttpServerRequest.HttpServerRequest
-
-                  //
-                })
-                .pipe(Layer.effectDiscard)
-            )
-          )
-      })
+      return maker(
+        (_schema, handler) => (req, headers) =>
+          // contextProvider and dynamicMiddlewares are already provided here.
+          // aka this runs "last"
+          Effect
+            .gen(function*() {
+              // you can use only HttpRouter.HttpRouter.Provided here as additional context
+              // and what ContextMaker provides too
+              // const someElse = yield* SomeElse
+              yield* Some // provided by ContextMaker
+              yield* HttpServerRequest.HttpServerRequest // provided by HttpRouter.HttpRouter.Provided
+
+              return yield* handler(req, headers)
+                .pipe(
+                  // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
+                  Effect.uninterruptible
+                )
+            })
+      )
     })
 })
 
@@ -141,7 +199,8 @@ export type RequestConfig = {
 }
 export const { TaggedRequest: Req } = makeRpcClient<RequestConfig, RequestContextMap>({
   allowAnonymous: NotLoggedInError,
-  requireRoles: UnauthorizedError
+  requireRoles: UnauthorizedError,
+  test: S.Never
 })
 
 export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
@@ -269,6 +328,13 @@ const router = Router(Something)({
   }
 })
 
+it("sorts based on requirements", () => {
+  const input = [RequireRoles, AllowAnonymous, Test]
+  const sorted = sort(input)
+  console.dir({ input, sorted }, { depth: 10 })
+  expect(sorted).toEqual([AllowAnonymous, RequireRoles, Test])
+})
+
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
 expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | "str">()

package/test/dist/controller.legacy2.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.legacy2.test.d.ts","sourceRoot":"","sources":["../controller.legacy2.test.ts"],"names":[],"mappings":"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"}

package/test/dist/controller.legacy3.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.legacy3.test.d.ts","sourceRoot":"","sources":["../controller.legacy3.test.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEjC,OAAO,EAAW,MAAM,EAAY,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAC1E,OAAO,EAAwC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC/G,OAAO,EAAe,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAOhE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,MAAM,MAAM,GAAG;IAGnB,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAmGD,eAAO,MAAQ,QAAQ;;;;;gBA0EgwD,MAAO,KAAK;;;;;;GA1E1wD,QAAQ;;;;;;iDA0Eq0F,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAA2yD,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CA1E1oU,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;yCAxEL,EAAG,MAAM,CAAC,MAAM;iBAgClC,EA/BK,MACb,CA8BQ,GA9BJ,GA8BI,EA9BC,MAEV,CA4BS,MA5BF;iBAAuB,EAAE,MAC9B,CA2BO,GA3BH,GA2BG,EA3BG,MAAK,CAAC,MAAM;;;;;;2CASkB,EAAG,MAAM,CAAC,MAAM;iBAkBjD,EAAA,MAjBA,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAiBtB,EAPO,MAAC,CAAC,MAAM;iBACA,EAAG,MAAM,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAc1C,EAAA,MAAL,CAAK,MAAE;;;;;2CAMqC,EAAG,MAAM,CAAC,MAAM;;;;;CA6BnE,CAAA;;;;;;;;;;AAEF,qBAAa,YAAa,SAAQ,iBAEX;CAAG;;;;;;;;;;AAE1B,qBAAa,gBAAiB,SAAQ,qBAEb;CAAG;;;;;AAI5B,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG"}