@khoralabs/chat 0.1.0

package/dist/index.js

@@ -0,0 +1,453 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/errors.ts
+class ChatError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChatError";
+    this.code = code;
+  }
+}
+
+class ChatNotFoundError extends ChatError {
+  resource;
+  resourceId;
+  constructor(resource, resourceId) {
+    super("not_found", `${resource} not found: ${resourceId}`);
+    this.name = "ChatNotFoundError";
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+}
+
+class ChatConflictError extends ChatError {
+  reason;
+  constructor(reason, message) {
+    super("conflict", message);
+    this.name = "ChatConflictError";
+    this.reason = reason;
+  }
+}
+
+class ChatValidationError extends ChatError {
+  constructor(message) {
+    super("validation", message);
+    this.name = "ChatValidationError";
+  }
+}
+
+class ChatPermissionError extends ChatError {
+  constructor(message) {
+    super("permission_denied", message);
+    this.name = "ChatPermissionError";
+  }
+}
+// src/hash.ts
+function sha256Hex(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function stableStringify(value) {
+  if (value === undefined) {
+    return "null";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function canonicalPostVersionPayload(input) {
+  return stableStringify({
+    postId: input.postId,
+    versionId: input.versionId,
+    threadId: input.threadId,
+    author: input.author,
+    role: input.role,
+    parts: input.parts,
+    metadata: input.metadata ?? null,
+    mentions: input.mentions ?? null,
+    model: input.model ?? null,
+    usage: input.usage ?? null,
+    parentVersionId: input.parentVersionId ?? null,
+    previousPostVersionId: input.previousPostVersionId ?? null
+  });
+}
+function computeContentHash(payload) {
+  return sha256Hex(canonicalPostVersionPayload(payload));
+}
+function computeLineageHash(input) {
+  return sha256Hex(stableStringify({
+    previousLineageHash: input.previousLineageHash,
+    contentHash: input.contentHash,
+    postId: input.postId,
+    versionId: input.versionId
+  }));
+}
+function canonicalAclEventPayload(input) {
+  return stableStringify({
+    type: input.type,
+    targetType: input.targetType,
+    targetId: input.targetId,
+    scope: input.scope ?? null,
+    role: input.role ?? null,
+    actor: input.actor,
+    previousAclEventId: input.previousAclEventId ?? null
+  });
+}
+function computeAclEventContentHash(payload) {
+  return sha256Hex(canonicalAclEventPayload(payload));
+}
+function signedPayloadBytes(payload) {
+  return new TextEncoder().encode(payload);
+}
+function canonicalSignedPostVersionPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    lineageHash: input.lineageHash,
+    payload: JSON.parse(canonicalPostVersionPayload(input))
+  });
+}
+function canonicalSignedAclEventPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    payload: JSON.parse(canonicalAclEventPayload(input.payload))
+  });
+}
+async function maybeSignPayload(payload, signer, sign) {
+  return sign(signedPayloadBytes(payload), signer);
+}
+// src/ids.ts
+function createId() {
+  return crypto.randomUUID();
+}
+function scopeKey(scope) {
+  return `${scope.type}:${scope.id}`;
+}
+function scopeRefFromKey(key) {
+  const separatorIndex = key.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid scope key: ${key}`);
+  }
+  return {
+    type: key.slice(0, separatorIndex),
+    id: key.slice(separatorIndex + 1)
+  };
+}
+// src/lineage.ts
+function walkLineageFromHead(headVersionId, versionsById) {
+  const lineage = [];
+  let currentId = headVersionId;
+  const seenPostIds = new Set;
+  while (currentId) {
+    const version = versionsById.get(currentId);
+    if (!version)
+      break;
+    if (!seenPostIds.has(version.postId)) {
+      lineage.push(version);
+      seenPostIds.add(version.postId);
+    }
+    currentId = version.previousPostVersionId;
+  }
+  return lineage.reverse();
+}
+function lineageBetween(headVersionId, ancestorVersionId, versionsById) {
+  const lineage = walkLineageFromHead(headVersionId, versionsById);
+  const startIndex = lineage.findIndex((version) => version.id === ancestorVersionId);
+  if (startIndex === -1)
+    return null;
+  return lineage.slice(startIndex);
+}
+function postFromVersion(version, index, deletedAtMs) {
+  return {
+    ...version,
+    id: version.postId,
+    status: "complete",
+    versionId: version.id,
+    previousVersionId: version.parentVersionId ?? null,
+    index,
+    updatedAtMs: version.parentVersionId ? version.createdAtMs : null,
+    deletedAtMs: deletedAtMs ?? null
+  };
+}
+// src/stream.ts
+function rebuildStreamCacheFromEvents(events) {
+  const sorted = [...events].sort((a, b) => a.revision - b.revision);
+  let message = null;
+  let mentions;
+  let model;
+  let usage;
+  let revision = 0;
+  for (const event of sorted) {
+    if (event.eventType === "stream.started") {
+      if (!event.message) {
+        throw new Error(`stream.started event ${event.id} missing message`);
+      }
+      message = event.message;
+      mentions = event.mentions;
+      model = event.model;
+      usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.delta") {
+      if (!event.message) {
+        throw new Error(`stream.delta event ${event.id} missing message`);
+      }
+      message = event.message;
+      if (event.mentions !== undefined)
+        mentions = event.mentions;
+      if (event.model !== undefined)
+        model = event.model;
+      if (event.usage !== undefined)
+        usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.completed" || event.eventType === "stream.aborted") {
+      revision = event.revision;
+    }
+  }
+  if (!message) {
+    throw new Error("stream events did not produce a message");
+  }
+  return { message, mentions, model, usage, revision };
+}
+function streamingPostFromCache(input) {
+  return {
+    ...input.message,
+    id: input.postId,
+    status: "streaming",
+    threadId: input.threadId,
+    author: input.author,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    index: input.index,
+    streamRevision: input.streamRevision,
+    createdAtMs: input.createdAtMs,
+    updatedAtMs: input.updatedAtMs ?? null,
+    deletedAtMs: input.deletedAtMs ?? null
+  };
+}
+function mergeThreadPostsForList(lineagePosts, activePosts) {
+  const byIndex = new Map;
+  for (const item of lineagePosts) {
+    byIndex.set(item.index, item.post);
+  }
+  for (const post of activePosts) {
+    if (post.status === "streaming" || post.status === "aborted") {
+      byIndex.set(post.index, post);
+    }
+  }
+  return [...byIndex.entries()].sort(([a], [b]) => a - b).map(([, post]) => post);
+}
+// src/validation.ts
+function assertThreadRoot(root) {
+  if (root.type === "channel") {
+    if (!root.channelId.trim()) {
+      throw new ChatValidationError("channel root requires channelId");
+    }
+    return;
+  }
+  if (!root.postId.trim()) {
+    throw new ChatValidationError("post root requires postId");
+  }
+}
+function assertNonEmptyString(value, label) {
+  if (!value.trim()) {
+    throw new ChatValidationError(`${label} is required`);
+  }
+}
+// src/service.ts
+function createChatService(persistence, options = {}) {
+  const emit = (event) => {
+    options.onEvent?.(event);
+  };
+  async function requireChannel(id) {
+    const channel = await persistence.getChannel(id);
+    if (!channel)
+      throw new ChatNotFoundError("channel", id);
+    return channel;
+  }
+  async function requireThread(id) {
+    const thread = await persistence.getThread(id);
+    if (!thread)
+      throw new ChatNotFoundError("thread", id);
+    return thread;
+  }
+  async function requirePost(id) {
+    const post = await persistence.getPost(id);
+    if (!post)
+      throw new ChatNotFoundError("post", id);
+    return post;
+  }
+  return {
+    async createChannel(input) {
+      const channel = await persistence.createChannel({
+        ...input,
+        id: input.id ?? options.generateId?.() ?? createId()
+      });
+      emit({ type: "channel.created", channel });
+      return channel;
+    },
+    async createThread(input) {
+      const thread = await persistence.createThread({
+        ...input,
+        id: input.id ?? options.generateId?.() ?? createId()
+      });
+      emit({ type: "thread.created", thread });
+      return thread;
+    },
+    getChannel: requireChannel,
+    getThread: requireThread,
+    getPost: requirePost,
+    listThreads: (input) => persistence.listThreads(input),
+    listPosts: (input) => persistence.listPosts(input),
+    getThreadTip: (threadId) => persistence.getThreadTip(threadId),
+    async appendPost(input) {
+      const result = await persistence.appendPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict: expected ${input.expectedHeadPostVersionId ?? "null"}, current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.appended",
+        threadId: input.threadId,
+        post: result.post
+      });
+      return { post: result.post, head: result.head };
+    },
+    async editPost(input) {
+      const result = await persistence.editPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict during edit: current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.updated",
+        threadId: result.post.threadId,
+        post: result.post
+      });
+      return { post: result.post, head: result.head };
+    },
+    async deletePost(input) {
+      const post = await persistence.deletePost(input);
+      emit({
+        type: "post.deleted",
+        threadId: post.threadId,
+        postId: post.id,
+        deletedAtMs: post.deletedAtMs ?? Date.now()
+      });
+      return post;
+    },
+    addChannelMember: (input) => persistence.addChannelMember(input),
+    removeChannelMember: (input) => persistence.removeChannelMember(input),
+    async addThreadParticipant(input) {
+      const event = await persistence.addThreadParticipant(input);
+      emit({
+        type: "participant.added",
+        threadId: input.threadId,
+        scope: input.scope,
+        role: input.role
+      });
+      return event;
+    },
+    removeThreadParticipant: (input) => persistence.removeThreadParticipant(input),
+    createThreadHead: (input) => persistence.createThreadHead(input),
+    listChannelMembers: (channelId) => persistence.listChannelMembers(channelId),
+    listThreadParticipants: (threadId) => persistence.listThreadParticipants(threadId),
+    async startStreamedPost(input) {
+      const result = await persistence.startStreamedPost(input);
+      emit({
+        type: "post.stream.started",
+        threadId: input.threadId,
+        post: result.post,
+        revision: result.revision
+      });
+      return result;
+    },
+    async applyPostDelta(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const result = await persistence.applyPostDelta(input);
+      emit({
+        type: "post.stream.delta",
+        threadId: record.threadId,
+        post: result.post,
+        revision: result.revision
+      });
+      return result;
+    },
+    async completeStreamedPost(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const streamRevision = record.status === "streaming" ? record.streamRevision : input.expectedRevision;
+      const result = await persistence.completeStreamedPost(input);
+      if (!result.ok) {
+        throw new ChatConflictError("head_conflict", `head conflict during stream completion: current ${result.currentHead.headPostVersionId}`);
+      }
+      emit({
+        type: "post.stream.completed",
+        threadId: record.threadId,
+        post: result.post,
+        head: result.head,
+        revision: typeof streamRevision === "number" ? streamRevision + 1 : 0
+      });
+      return { post: result.post, head: result.head };
+    },
+    async abortStreamedPost(input) {
+      const record = await persistence.getPost(input.postId);
+      if (!record)
+        throw new ChatNotFoundError("post", input.postId);
+      const result = await persistence.abortStreamedPost(input);
+      emit({
+        type: "post.stream.aborted",
+        threadId: record.threadId,
+        postId: input.postId,
+        revision: result.post.streamRevision,
+        deletedAtMs: result.post.deletedAtMs ?? Date.now()
+      });
+      return result.post;
+    },
+    setPostVersionSignature(versionId, signature) {
+      return persistence.setPostVersionSignature(versionId, signature);
+    }
+  };
+}
+export {
+  walkLineageFromHead,
+  streamingPostFromCache,
+  signedPayloadBytes,
+  sha256Hex,
+  scopeRefFromKey,
+  scopeKey,
+  rebuildStreamCacheFromEvents,
+  postFromVersion,
+  mergeThreadPostsForList,
+  maybeSignPayload,
+  lineageBetween,
+  createId,
+  createChatService,
+  computeLineageHash,
+  computeContentHash,
+  computeAclEventContentHash,
+  canonicalSignedPostVersionPayload,
+  canonicalSignedAclEventPayload,
+  canonicalPostVersionPayload,
+  canonicalAclEventPayload,
+  assertThreadRoot,
+  assertNonEmptyString,
+  ChatValidationError,
+  ChatPermissionError,
+  ChatNotFoundError,
+  ChatError,
+  ChatConflictError
+};

package/dist/lineage.d.ts

@@ -0,0 +1,5 @@
+import type { CommittedPost, PostVersion } from "./types.js";
+export declare function walkLineageFromHead<T extends Pick<PostVersion, "id" | "postId" | "previousPostVersionId">>(headVersionId: string, versionsById: Map<string, T>): T[];
+export declare function lineageBetween(headVersionId: string, ancestorVersionId: string, versionsById: Map<string, Pick<PostVersion, "id" | "postId" | "previousPostVersionId">>): Pick<PostVersion, "id" | "postId" | "previousPostVersionId">[] | null;
+export declare function postFromVersion(version: PostVersion, index: number, deletedAtMs?: number | null): CommittedPost;
+//# sourceMappingURL=lineage.d.ts.map

package/dist/lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineage.d.ts","sourceRoot":"","sources":["../src/lineage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D,wBAAgB,mBAAmB,CACjC,CAAC,SAAS,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,QAAQ,GAAG,uBAAuB,CAAC,EACtE,aAAa,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAgB1D;AAED,wBAAgB,cAAc,CAC5B,aAAa,EAAE,MAAM,EACrB,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,QAAQ,GAAG,uBAAuB,CAAC,CAAC,GACtF,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,QAAQ,GAAG,uBAAuB,CAAC,EAAE,GAAG,IAAI,CAKvE;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAC1B,aAAa,CAWf"}

package/dist/persistence/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./persistence/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/persistence/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/persistence/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/persistence/core/persistence/base-persistence.d.ts

@@ -0,0 +1,12 @@
+import type { CreateThreadInput, ThreadRoot } from "../../../domain.js";
+export declare abstract class BaseChatPersistence {
+    protected assertThreadRootExists(root: ThreadRoot): void;
+    protected requireChannel(id: string): Promise<import("../../../types.js").Channel>;
+    protected requireThread(id: string): Promise<import("../../../types.js").Thread>;
+    protected requirePost(id: string): Promise<import("../../../types.js").Post>;
+    protected validateCreateThreadInput(input: CreateThreadInput): void;
+    abstract getChannel(id: string): Promise<import("../../../domain.js").Channel | null>;
+    abstract getThread(id: string): Promise<import("../../../domain.js").Thread | null>;
+    abstract getPost(id: string): Promise<import("../../../domain.js").Post | null>;
+}
+//# sourceMappingURL=base-persistence.d.ts.map

package/dist/persistence/core/persistence/base-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-persistence.d.ts","sourceRoot":"","sources":["../../../../src/persistence/core/persistence/base-persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGxE,8BAAsB,mBAAmB;IACvC,SAAS,CAAC,sBAAsB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;cASxC,cAAc,CAAC,EAAE,EAAE,MAAM;cAMzB,aAAa,CAAC,EAAE,EAAE,MAAM;cAMxB,WAAW,CAAC,EAAE,EAAE,MAAM;IAMtC,SAAS,CAAC,yBAAyB,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAInE,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,GAAG,IAAI,CAAC;IACrF,QAAQ,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnF,QAAQ,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,GAAG,IAAI,CAAC;CAChF"}

package/dist/persistence/core/persistence/helpers.d.ts

@@ -0,0 +1,30 @@
+import type { AppendPostInput, EditPostInput, PreparedAppendPost, PreparedEditPost } from "../../../domain.js";
+export type PrepareAppendOptions = {
+    generateId?: () => string;
+    now?: () => number;
+};
+export declare function prepareAppendPost(input: AppendPostInput & {
+    previousPostVersionId: string | null;
+    previousLineageHash: string | null;
+}, options?: PrepareAppendOptions): PreparedAppendPost;
+export declare function prepareEditPost(input: EditPostInput & {
+    threadId: string;
+    previousPostVersionId: string | null;
+    previousLineageHash: string | null;
+}, options?: PrepareAppendOptions): PreparedEditPost;
+export declare function buildAclEventContentHash(input: {
+    type: string;
+    targetType: "channel" | "thread";
+    targetId: string;
+    scope?: {
+        type: string;
+        id: string;
+    };
+    role?: string;
+    actor: {
+        type: string;
+        id: string;
+    };
+    previousAclEventId?: string | null;
+}): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/persistence/core/persistence/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../src/persistence/core/persistence/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAQ5B,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,eAAe,GAAG;IACvB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC,EACD,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CA8CpB;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC,EACD,OAAO,GAAE,oBAAyB,GACjC,gBAAgB,CA8ClB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,SAAS,GAAG,QAAQ,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC,GAAG,MAAM,CAET"}

package/dist/persistence/core/persistence/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./base-persistence.js";
+export * from "./helpers.js";
+export * from "./memory-persistence.js";
+export { prepareAppendForSigning, type SignedChatPersistenceOptions, signPreparedAppendPost, withSignedChatPersistence, } from "./signed-persistence.js";
+export type { AbortStreamedPostInput, AbortStreamedPostResult, AddChannelMemberInput, AddThreadParticipantInput, AppendPostInput, AppendPostResult, ApplyPostDeltaInput, ApplyPostDeltaResult, ChatPersistence, ChatReadPersistence, ChatWritePersistence, CompleteStreamedPostInput, CompleteStreamedPostResult, CreateChannelInput, CreateThreadInput, DeletePostInput, EditPostInput, EditPostResult, ListPostsInput, ListThreadsInput, PreparedAppendPost, PreparedEditPost, RemoveChannelMemberInput, RemoveThreadParticipantInput, StartStreamedPostInput, StartStreamedPostResult, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/persistence/core/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/persistence/core/persistence/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,OAAO,EACL,uBAAuB,EACvB,KAAK,4BAA4B,EACjC,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,0BAA0B,EAC1B,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,wBAAwB,EACxB,4BAA4B,EAC5B,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,YAAY,CAAC"}