@effect-uai/core 0.12.1 → 0.14.0

package/src/image-generator/ImageGenerator.ts

@@ -0,0 +1,165 @@
+import { Context, Data, Effect, Stream } from "effect"
+import type * as AiError from "../domain/AiError.js"
+import type {
+  AspectRatio,
+  GeneratedImage,
+  ImageResolution,
+  ImageSource,
+  ProviderData,
+} from "../domain/Image.js"
+
+export type { AspectRatio, GeneratedImage, ImageResolution, ProviderData } from "../domain/Image.js"
+
+/**
+ * Cross-provider text-to-image request. Shape and resolution are given
+ * as a ratio plus a tier rather than exact pixels: every provider takes
+ * one or derives the other. Exact dimensions, quality tiers, output
+ * encodings, and moderation knobs are vendor-specific and live on each
+ * provider's typed request.
+ */
+export type CommonImageGenerateRequest = {
+  readonly prompt: string
+  /** Each provider narrows this to its typed literal union. */
+  readonly model: string
+  readonly aspectRatio?: AspectRatio
+  readonly resolution?: ImageResolution
+  /** Default 1. Implementors without multi-image output fail `Unsupported` for more. */
+  readonly n?: number
+}
+
+/**
+ * Edit request: the same prompt-driven generation, conditioned on
+ * reference images. Separate from `generate` because the reference set
+ * is required here and absent there, and providers expose the two as
+ * distinct wire shapes. Per-provider caps on the array length apply.
+ */
+export type CommonImageEditRequest = CommonImageGenerateRequest & {
+  readonly images: ReadonlyArray<ImageSource>
+}
+
+/** Gated by {@link ImageStreaming}; `partialImages` is the preview-frame count. */
+export type CommonStreamImageRequest = CommonImageGenerateRequest & {
+  readonly partialImages: 1 | 2 | 3
+}
+
+/** The same previews, for an edit. Gated by {@link ImageStreaming}. */
+export type CommonStreamImageEditRequest = CommonImageEditRequest & {
+  readonly partialImages: 1 | 2 | 3
+}
+
+/** Optional throughout: not every provider bills or reports per token. */
+export type ImageUsage = {
+  readonly inputTokens?: number
+  readonly outputTokens?: number
+  readonly totalTokens?: number
+}
+
+export type ImageResponse = {
+  readonly images: ReadonlyArray<GeneratedImage>
+  readonly usage: ImageUsage
+  /**
+   * Response-level extras, keyed by provider name: the seed a request
+   * resolved to, timings, safety flags. Per-image extras live on each
+   * {@link GeneratedImage} instead. See `Image.ProviderData`.
+   */
+  readonly providerData?: ProviderData
+}
+
+/**
+ * Zero or more `PartialImage` previews, then exactly one `Complete`.
+ * `Complete` carries the `ImageResponse` fields flat, so it is
+ * assignable to `ImageResponse` and needs no unwrapping.
+ */
+export type ImageStreamEvent = Data.TaggedEnum<{
+  PartialImage: {
+    readonly image: ImageSource
+    /** Counts from 0 in emission order. */
+    readonly index: number
+  }
+  Complete: {
+    readonly images: ReadonlyArray<GeneratedImage>
+    readonly usage: ImageUsage
+  }
+}>
+
+/**
+ * Namespace of constructors, type guards, and matchers for
+ * `ImageStreamEvent`, provided by `Data.taggedEnum`.
+ */
+export const ImageStreamEvent = Data.taggedEnum<ImageStreamEvent>()
+
+export const isPartialImage = ImageStreamEvent.$is("PartialImage")
+export const isComplete = ImageStreamEvent.$is("Complete")
+
+export type ImageGeneratorService = {
+  /** Prompt in, images out. Universally supported. */
+  readonly generate: (
+    request: CommonImageGenerateRequest,
+  ) => Effect.Effect<ImageResponse, AiError.AiError>
+  /** Prompt plus reference images in, images out. Universally supported. */
+  readonly edit: (request: CommonImageEditRequest) => Effect.Effect<ImageResponse, AiError.AiError>
+  /**
+   * Preview frames as the image resolves, then the final response.
+   * Implementors without a partial-image wire return `Unsupported` and
+   * do NOT register {@link ImageStreaming}, so the top-level helper is
+   * a compile-time error against their Layer.
+   */
+  readonly streamGeneration: (
+    request: CommonStreamImageRequest,
+  ) => Stream.Stream<ImageStreamEvent, AiError.AiError>
+  /** {@link streamGeneration} conditioned on reference images. */
+  readonly streamEdit: (
+    request: CommonStreamImageEditRequest,
+  ) => Stream.Stream<ImageStreamEvent, AiError.AiError>
+}
+
+export class ImageGenerator extends Context.Service<ImageGenerator, ImageGeneratorService>()(
+  "@betalyra/effect-uai/ImageGenerator",
+) {}
+
+/**
+ * Capability marker for partial-image streaming. Phantom: the value is
+ * `void`, providers register with
+ * `Layer.succeed(ImageStreaming, undefined)`. Calling
+ * {@link streamGeneration} while only a non-streaming Layer is in scope
+ * fails at `Effect.provide` with a type error.
+ */
+export class ImageStreaming extends Context.Service<ImageStreaming, void>()(
+  "@betalyra/effect-uai/capability/ImageStreaming",
+) {}
+
+/** Text to image. */
+export const generate = (
+  request: CommonImageGenerateRequest,
+): Effect.Effect<ImageResponse, AiError.AiError, ImageGenerator> =>
+  Effect.flatMap(ImageGenerator, (g) => g.generate(request))
+
+/** Text plus reference images to image. */
+export const edit = (
+  request: CommonImageEditRequest,
+): Effect.Effect<ImageResponse, AiError.AiError, ImageGenerator> =>
+  Effect.flatMap(ImageGenerator, (g) => g.edit(request))
+
+/** Preview frames then the final response. Requires {@link ImageStreaming} in R. */
+export const streamGeneration = (
+  request: CommonStreamImageRequest,
+): Stream.Stream<ImageStreamEvent, AiError.AiError, ImageGenerator | ImageStreaming> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const g = yield* ImageGenerator
+      yield* ImageStreaming
+      return g.streamGeneration(request)
+    }),
+  )
+
+/** The same, conditioned on reference images. Requires {@link ImageStreaming} in R. */
+export const streamEdit = (
+  request: CommonStreamImageEditRequest,
+): Stream.Stream<ImageStreamEvent, AiError.AiError, ImageGenerator | ImageStreaming> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const g = yield* ImageGenerator
+      yield* ImageStreaming
+      return g.streamEdit(request)
+    }),
+  )

package/src/index.ts

@@ -4,6 +4,7 @@ export * as Browser from "./browser/Browser.js"
 export * as BrowserError from "./browser/BrowserError.js"
 export * as BrowserTool from "./browser/BrowserTool.js"
 export * as Capabilities from "./capabilities/Capabilities.js"
+export * as Chunker from "./chunker/Chunker.js"
 export * as Citation from "./domain/Citation.js"
 export * as DeepResearch from "./research/DeepResearch.js"
 export * as Image from "./domain/Image.js"
@@ -16,8 +17,10 @@ export * as Transcript from "./domain/Transcript.js"
 export * as Turn from "./domain/Turn.js"
 export * as Embedding from "./embedding-model/Embedding.js"
 export * as EmbeddingModel from "./embedding-model/EmbeddingModel.js"
+export * as ImageGenerator from "./image-generator/ImageGenerator.js"
 export * as LanguageModel from "./language-model/LanguageModel.js"
 export * as MusicGenerator from "./music-generator/MusicGenerator.js"
+export * as Reranker from "./reranker/Reranker.js"
 export * as Memory from "./sandbox/Memory.js"
 export * as Sandbox from "./sandbox/Sandbox.js"
 export * as SandboxError from "./sandbox/SandboxError.js"
@@ -30,6 +33,7 @@ export * as WebReadTool from "./web-read/WebReadTool.js"
 export * as WebSearch from "./web-search/WebSearch.js"
 export * as WebSearchTool from "./web-search/WebSearchTool.js"
 export * as Vector from "./math/Vector.js"
+export * as Tokenizer from "./tokenizer/Tokenizer.js"
 export * as Loop from "./loop/Loop.js"
 export * as Retry from "./retry/Retry.js"
 export * as Tool from "./tool/Tool.js"
@@ -40,6 +44,7 @@ export * as Approval from "./tool/Approval.js"
 export * as HistoryCheck from "./tool/HistoryCheck.js"
 export * as JSONL from "./streaming/JSONL.js"
 export * as Lines from "./streaming/Lines.js"
+export * as Multipart from "./streaming/Multipart.js"
 export * as SSE from "./streaming/SSE.js"
 export * as StructuredFormat from "./structured-format/StructuredFormat.js"
 export * as Metrics from "./observability/Metrics.js"

package/src/reranker/Reranker.ts

@@ -0,0 +1,51 @@
+import { Context, Effect } from "effect"
+import type * as AiError from "../domain/AiError.js"
+
+/**
+ * Cross-provider rerank request. Vendor knobs (multimodal documents,
+ * instruction fields, truncation) live on the provider's typed request.
+ */
+export type CommonRerankRequest = {
+  readonly query: string
+  readonly documents: ReadonlyArray<string>
+  /** Each provider narrows this to its typed literal union. */
+  readonly model: string
+  /** Keep only the top N results. Default: all documents. */
+  readonly topN?: number
+}
+
+export type RerankResult = {
+  /** Position in the request's `documents`. */
+  readonly index: number
+  readonly score: number
+}
+
+/** Optional throughout: some providers bill per search unit, not per token. */
+export type RerankUsage = {
+  readonly totalTokens?: number
+}
+
+/**
+ * Score contract: `results` is sorted descending, higher is better. Scores
+ * order candidates within one call; no range or calibration is promised and
+ * they are not comparable across requests. Implementors must sort descending
+ * if the wire does not.
+ */
+export type RerankResponse = {
+  readonly results: ReadonlyArray<RerankResult>
+  readonly usage: RerankUsage
+}
+
+export type RerankerService = {
+  readonly rerank: (request: CommonRerankRequest) => Effect.Effect<RerankResponse, AiError.AiError>
+}
+
+export class Reranker extends Context.Service<Reranker, RerankerService>()(
+  "@betalyra/effect-uai/Reranker",
+) {}
+
+/** Score a candidate set against a query, best first. */
+export const rerank = (
+  request: CommonRerankRequest,
+): Effect.Effect<RerankResponse, AiError.AiError, Reranker> =>
+  Effect.flatMap(Reranker, (r) => r.rerank(request))

package/src/streaming/Multipart.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+
+/**
+ * Multipart body for an `HttpClientRequest`, encoded to bytes.
+ *
+ * Use this over `HttpClientRequest.bodyFormData`: the Undici client
+ * passes the `FormData` object straight to `dispatcher.request`, which
+ * cannot serialise it, so the request is never sent and the effect
+ * hangs with no error. Encoding here produces the same bytes every
+ * other client derives internally, so it works on all of them.
+ *
+ * The failure is whatever `Response.arrayBuffer` rejects with; map it
+ * to your provider's transport error at the call site.
+ */
+export const bodyMultipart = (
+  form: FormData,
+): Effect.Effect<
+  (request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest,
+  unknown
+> =>
+  Effect.gen(function* () {
+    const encoded = new Response(form)
+    const buffer = yield* Effect.tryPromise(() => encoded.arrayBuffer())
+    return HttpClientRequest.bodyUint8Array(
+      new Uint8Array(buffer),
+      encoded.headers.get("content-type") ?? "multipart/form-data",
+    )
+  })

package/src/tokenizer/Tokenizer.ts

@@ -0,0 +1,19 @@
+import { Context } from "effect"
+
+/**
+ * Turning text into tokens, for sizing chunks, budgeting context, and
+ * estimating usage a provider does not report. Count with `encode(text).length`.
+ *
+ * Implementor contract: both methods are synchronous, so counting inside a loop
+ * never awaits; loading a vocabulary is the layer's job. `decode` inverts
+ * `encode`. Implement this only over a real vocabulary, never a heuristic:
+ * a character-count estimate is a plain function, not a service.
+ */
+export type TokenizerService = {
+  readonly encode: (text: string) => ReadonlyArray<number>
+  readonly decode: (tokens: ReadonlyArray<number>) => string
+}
+
+export class Tokenizer extends Context.Service<Tokenizer, TokenizerService>()(
+  "@betalyra/effect-uai/Tokenizer",
+) {}

package/dist/Image-BK8-4H6s.d.mts

@@ -1,59 +0,0 @@
-import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
-import { Schema } from "effect";
-declare namespace Image_d_exports {
-  export { ImageBase64Source, ImageBytesSource, ImageMimeType, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl };
-}
-/**
- * Image MIME types AI providers typically accept. The first four are the
- * universal subset (Cohere v4, Voyage multimodal, Jina v4, Google
- * `gemini-embedding-2`); HEIC / HEIF are Google-specific. The
- * `(string & {})` tail keeps autocomplete on the literals while still
- * accepting any string, so a newly-supported format works without an
- * SDK update.
- */
-type ImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/heic" | "image/heif" | (string & {});
-type ImageUrlSource = MediaUrl<ImageMimeType>;
-type ImageBase64Source = MediaBase64<ImageMimeType>;
-type ImageBytesSource = MediaBytes<ImageMimeType>;
-/**
- * Where an image lives. Provider layers normalize across these:
- * `bytes` becomes a base64 data URI for OpenAI / Anthropic, an
- * `inlineData` part for Gemini, and a separate field for Cohere /
- * Voyage. URL constraints (must be HTTPS, must be public, …) are
- * provider-specific and validated at the layer, not in the type.
- */
-type ImageSource = MediaSource<ImageMimeType>;
-declare const ImageUrlSource: Schema.TaggedStruct<"url", {
-  readonly url: Schema.String;
-  readonly mimeType: Schema.optional<Schema.Schema<ImageMimeType>>;
-}>;
-declare const ImageBase64Source: Schema.TaggedStruct<"base64", {
-  readonly base64: Schema.String;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
-}>;
-declare const ImageBytesSource: Schema.TaggedStruct<"bytes", {
-  readonly bytes: Schema.Uint8Array;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
-}>;
-declare const ImageSource: Schema.Schema<ImageSource>;
-declare const imageUrl: (url: string, mimeType?: ImageMimeType) => ImageUrlSource;
-declare const imageBase64: (base64: string, mimeType: ImageMimeType) => ImageBase64Source;
-declare const imageBytes: (bytes: Uint8Array, mimeType: ImageMimeType) => ImageBytesSource;
-declare const isImageUrl: <I>(input: I) => input is I & {
-  readonly _tag: "url";
-  readonly url: string;
-  readonly mimeType?: ImageMimeType | undefined;
-};
-declare const isImageBase64: <I>(input: I) => input is I & {
-  readonly _tag: "base64";
-  readonly base64: string;
-  readonly mimeType: ImageMimeType;
-};
-declare const isImageBytes: <I>(input: I) => input is I & {
-  readonly _tag: "bytes";
-  readonly bytes: Uint8Array<ArrayBufferLike>;
-  readonly mimeType: ImageMimeType;
-};
-//#endregion
-export { ImageUrlSource as a, imageBytes as c, isImageBytes as d, isImageUrl as f, ImageSource as i, imageUrl as l, ImageBytesSource as n, Image_d_exports as o, ImageMimeType as r, imageBase64 as s, ImageBase64Source as t, isImageBase64 as u };
-//# sourceMappingURL=Image-BK8-4H6s.d.mts.map

package/dist/Image-BK8-4H6s.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Image-BK8-4H6s.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;KAWY;KAYA,iBAAiB,SAAS;KAC1B,oBAAoB,YAAY;KAChC,mBAAmB,WAAW;;;;;;;;KAS9B,cAAc,YAAY;cAEzB,gBAAc,OAAA;;;;cAKd,mBAAiB,OAAA;;;;cAKjB,kBAAgB,OAAA;;;;cAKhB,aAAa,OAAO,OAAO;cAM3B,WAAQ,aAAe,WAAa,kBAAgB;cAGpD,cAAW,gBAAkB,UAAY,kBAAgB;cAMzD,aAAU,OAAW,YAAU,UAAY,kBAAgB;cAM3D,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cACV,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;cACb,eAAY,GAAA,OAAA,MAAA,SAAA"}

package/dist/Items-SfUabNuB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Items-SfUabNuB.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;cAOa,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;;;;;;;;;cAU5B,YAAU,OAAA;;;;KAIX,oBAAoB,WAAW;;;;;;;;;cAgB9B,aAAW,OAAA;;;;;;;;;KASZ,qBAAqB,YAAY;cAEhC,cAAY,OAAA;;;;;KAKb,sBAAsB,aAAa;cAElC,uBAAqB,OAAA;;;;;;;KAOtB,+BAA+B,sBAAsB;cAEpD,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;cAE1B,YAAU,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;KACX,oBAAoB,WAAW;cAE9B,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;;;;;cACb,iBAAc,GAAA,OAAA,MAAA,SAAA;;;;;cACd,0BAAuB,GAAA,OAAA,MAAA,SAAA;;;;;;;cACvB,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cAEV,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKX,oBAAoB,WAAW;;;;;;;cAQ9B,SAAO,OAAA;;;;KAIR,iBAAiB,QAAQ;cAExB,cAAY,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,sBAAsB,aAAa;cAElC,MAAI,OAAA;KACL,cAAc,KAAK;cAqBlB,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMR,iBAAiB,QAAQ;cAExB,UAAQ,OAAA;;;;;;;KAQT,kBAAkB,SAAS;cAE1B,gBAAc,OAAA;;;;;;KAMf,wBAAwB,eAAe;;;;;;;cAQtC,WAAS,OAAA;;;;;;;KAOV,mBAAmB,UAAU;cAE5B,aAAW,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACZ,qBAAqB,YAAY;cAMhC,cAAW,GAAA,OAAA,MAAA,SAAA;;;;cACX,eAAY,GAAA,OAAA,MAAA,SAAA;;;;cACZ,eAAY,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cACZ,YAAS,GAAA,OAAA,MAAA,SAAA;;;;cAET,YAAS,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACT,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;;;cACV,mBAAgB,GAAA,OAAA,MAAA,SAAA;;;;;;cAChB,cAAW,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;cAiBX,oBAAkB,OAAA;;;;KAInB,4BAA4B,mBAAmB;cAE9C,qBAAmB,OAAA;;;KAGpB,6BAA6B,oBAAoB;cAEhD,OAAK,OAAA;;;;;;;;;;;;KAON,eAAe,MAAM;cAEpB,YAAU,OAAA;KAUX,oBAAoB,WAAW;cAM9B,WAAQ,iBAAmB;cAM3B,aAAU,iBAAmB;cAM7B,gBAAa,iBAAmB;cAMhC,iBAAc,iBAAmB,mBAAmB"}

package/dist/Media-DwgpifPD.d.mts

@@ -1,57 +0,0 @@
-declare namespace Media_d_exports {
-  export { MediaBase64, MediaBytes, MediaSource, MediaUrl, isMediaBase64, isMediaBytes, isMediaUrl };
-}
-/**
- * Cross-modality media reference shape.
- *
- * Every "media at rest" reference - image, audio, video, document - is one
- * of three variants:
- *
- *   - `url`    : a remote address (HTTP, GCS, etc.). The model fetches it.
- *               `mimeType` is optional - servers usually set Content-Type.
- *               Some providers (Gemini `fileData`) want it explicit.
- *
- *   - `base64` : an inline base64-encoded payload. Always carries a
- *               `mimeType` so the consumer knows how to decode.
- *
- *   - `bytes`  : raw `Uint8Array`. Provider layers normalize to base64 or
- *               multipart upload at the wire boundary - users don't need
- *               to encode themselves.
- *
- * Per-modality files (`Image.ts`, future `Audio.ts` / `Video.ts` /
- * `Document.ts`) instantiate this shape with their typed MIME union to
- * get autocomplete on common formats while keeping the structural type
- * uniform across modalities.
- *
- * Streaming media (live mic feed, streaming TTS playback) is *not*
- * modeled here. Streams carry effect parameters (`Stream<A, E, R>`) and
- * lifecycle (Scope, cancellation) that don't apply to media at rest. The
- * complementary type lives alongside this one as `*Stream` in each
- * per-modality file when those modalities land.
- *
- * Provider-uploaded asset references (OpenAI Files `file_id`, Gemini
- * Files API URIs, Anthropic file IDs) are also out of scope here -
- * they're a separate union (`FileRef`) added when needed.
- */
-type MediaUrl<M extends string = string> = {
-  readonly _tag: "url";
-  readonly url: string;
-  readonly mimeType?: M;
-};
-type MediaBase64<M extends string = string> = {
-  readonly _tag: "base64";
-  readonly base64: string;
-  readonly mimeType: M;
-};
-type MediaBytes<M extends string = string> = {
-  readonly _tag: "bytes";
-  readonly bytes: Uint8Array;
-  readonly mimeType: M;
-};
-type MediaSource<M extends string = string> = MediaUrl<M> | MediaBase64<M> | MediaBytes<M>;
-declare const isMediaUrl: <M extends string>(s: MediaSource<M>) => s is MediaUrl<M>;
-declare const isMediaBase64: <M extends string>(s: MediaSource<M>) => s is MediaBase64<M>;
-declare const isMediaBytes: <M extends string>(s: MediaSource<M>) => s is MediaBytes<M>;
-//#endregion
-export { Media_d_exports as a, isMediaUrl as c, MediaUrl as i, MediaBytes as n, isMediaBase64 as o, MediaSource as r, isMediaBytes as s, MediaBase64 as t };
-//# sourceMappingURL=Media-DwgpifPD.d.mts.map

package/dist/Media-DwgpifPD.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Media-DwgpifPD.d.mts","names":[],"sources":["../src/domain/Media.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiCY,SAAS;WACV;WACA;WACA,WAAW;;KAGV,YAAY;WACb;WACA;WACA,UAAU;;KAGT,WAAW;WACZ;WACA,OAAO;WACP,UAAU;;KAGT,YAAY,6BAA6B,SAAS,KAAK,YAAY,KAAK,WAAW;cAElF,aAAc,kBAAgB,GAAK,YAAY,OAAK,KAAK,SAAS;cAGlE,gBAAiB,kBAAgB,GAAK,YAAY,OAAK,KAAK,YAAY;cAGxE,eAAgB,kBAAgB,GAAK,YAAY,OAAK,KAAK,WAAW"}