@wataruoguchi/emmett-event-store-kysely 1.0.0

package/dist/index.cjs

@@ -0,0 +1,600 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createKyselyEventStoreConsumer: () => createKyselyEventStoreConsumer,
+  createProjectionRegistry: () => createProjectionRegistry,
+  createProjectionRunner: () => createProjectionRunner,
+  createSnapshotProjection: () => createSnapshotProjection,
+  createSnapshotProjectionRegistry: () => createSnapshotProjectionRegistry,
+  getKyselyEventStore: () => getKyselyEventStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/event-store/consumers.ts
+function createKyselyEventStoreConsumer({
+  db,
+  logger,
+  consumerName = "default-consumer",
+  batchSize = 100,
+  pollingInterval = 1e3
+}) {
+  let isRunning = false;
+  let lastProcessedPosition = 0n;
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const allEventHandlers = [];
+  let pollingTimer = null;
+  const processEvents = async () => {
+    if (!isRunning) return;
+    try {
+      const events = await db.selectFrom("messages").select([
+        "message_type",
+        "message_data",
+        "message_metadata",
+        "stream_position",
+        "global_position",
+        "message_id",
+        "stream_id"
+      ]).where("global_position", ">", lastProcessedPosition).where("is_archived", "=", false).orderBy("global_position").limit(batchSize).execute();
+      if (events.length === 0) {
+        return;
+      }
+      for (const row of events) {
+        const event = {
+          kind: "Event",
+          type: row.message_type,
+          data: row.message_data,
+          metadata: {
+            ...row.message_metadata,
+            messageId: row.message_id,
+            streamName: row.stream_id,
+            streamPosition: BigInt(String(row.stream_position)),
+            globalPosition: BigInt(String(row.global_position))
+          }
+        };
+        const typeHandlers = eventHandlers.get(row.message_type) || [];
+        for (const handler of typeHandlers) {
+          try {
+            await handler(event);
+          } catch (error) {
+            logger.error(
+              { error, event },
+              `Error processing event ${row.message_type}`
+            );
+          }
+        }
+        for (const handler of allEventHandlers) {
+          try {
+            await handler(event);
+          } catch (error) {
+            logger.error(
+              { error, event },
+              "Error processing event in all-event handler"
+            );
+          }
+        }
+        const globalPos = row.global_position;
+        if (globalPos !== null) {
+          lastProcessedPosition = BigInt(String(globalPos));
+        }
+      }
+      await updateSubscriptionPosition();
+    } catch (error) {
+      logger.error({ error }, "Error processing events");
+    }
+  };
+  const updateSubscriptionPosition = async () => {
+    try {
+      await db.insertInto("subscriptions").values({
+        consumer_name: consumerName,
+        last_processed_position: lastProcessedPosition,
+        last_processed_transaction_id: lastProcessedPosition,
+        created_at: /* @__PURE__ */ new Date(),
+        updated_at: /* @__PURE__ */ new Date()
+      }).onConflict(
+        (oc) => oc.column("consumer_name").doUpdateSet({
+          last_processed_position: lastProcessedPosition,
+          last_processed_transaction_id: lastProcessedPosition,
+          updated_at: /* @__PURE__ */ new Date()
+        })
+      ).execute();
+    } catch (error) {
+      logger.error({ error }, "Error updating subscription position");
+    }
+  };
+  const loadLastProcessedPosition = async () => {
+    try {
+      const subscription = await db.selectFrom("subscriptions").select(["last_processed_position"]).where("consumer_name", "=", consumerName).executeTakeFirst();
+      if (subscription) {
+        lastProcessedPosition = BigInt(
+          String(subscription.last_processed_position)
+        );
+      }
+    } catch (error) {
+      logger.error({ error }, "Error loading last processed position");
+    }
+  };
+  return {
+    async start() {
+      if (isRunning) return;
+      isRunning = true;
+      await loadLastProcessedPosition();
+      logger.info({ consumerName }, "Starting event store consumer");
+      pollingTimer = setInterval(processEvents, pollingInterval);
+    },
+    async stop() {
+      if (!isRunning) return;
+      isRunning = false;
+      if (pollingTimer) {
+        clearInterval(pollingTimer);
+        pollingTimer = null;
+      }
+      logger.info({ consumerName }, "Stopped event store consumer");
+    },
+    subscribe(handler, eventType) {
+      if (!eventHandlers.has(eventType)) {
+        eventHandlers.set(eventType, []);
+      }
+      const handlers = eventHandlers.get(eventType);
+      if (handlers) {
+        handlers.push(
+          handler
+        );
+      }
+    },
+    subscribeToAll(handler) {
+      allEventHandlers.push(handler);
+    }
+  };
+}
+
+// src/event-store/kysely-event-store.ts
+var import_emmett = require("@event-driven-io/emmett");
+
+// src/types.ts
+var PostgreSQLEventStoreDefaultStreamVersion = 0n;
+var DEFAULT_PARTITION = "default_partition";
+function createProjectionRegistry(...registries) {
+  const combined = {};
+  for (const reg of registries) {
+    for (const [eventType, handlers] of Object.entries(reg)) {
+      combined[eventType] = [...combined[eventType] ?? [], ...handlers];
+    }
+  }
+  return combined;
+}
+
+// src/event-store/kysely-event-store.ts
+var getKyselyEventStore = (deps) => {
+  const { db, logger, inTransaction = false } = deps;
+  const eventStore = {
+    /**
+     * @description We do not use schema management in this package.
+     */
+    schema: {
+      sql: () => "",
+      print: () => console.log(""),
+      migrate: async () => Promise.resolve()
+    },
+    /**
+     * Provide a session-bound event store using a Kysely transaction.
+     * All operations within the callback will share the same DB transaction.
+     */
+    async withSession(callback) {
+      return await db.transaction().execute(async (trx) => {
+        const sessionEventStore = getKyselyEventStore({
+          db: trx,
+          logger,
+          inTransaction: true
+        });
+        return await callback({
+          eventStore: sessionEventStore,
+          close: () => Promise.resolve()
+        });
+      });
+    },
+    async aggregateStream(streamName, options) {
+      const { evolve, initialState, read } = options;
+      logger.debug?.({ streamName, options }, "aggregateStream");
+      const expectedStreamVersion = read?.expectedStreamVersion;
+      const result = await eventStore.readStream(streamName, read);
+      (0, import_emmett.assertExpectedVersionMatchesCurrent)(
+        result.currentStreamVersion,
+        expectedStreamVersion,
+        PostgreSQLEventStoreDefaultStreamVersion
+      );
+      const state = result.events.reduce(
+        (state2, event) => event ? evolve(state2, event) : state2,
+        initialState()
+      );
+      return {
+        state,
+        currentStreamVersion: result.currentStreamVersion,
+        streamExists: result.streamExists
+      };
+    },
+    async readStream(streamName, options) {
+      const partition = getPartition(options);
+      logger.debug?.({ streamName, options, partition }, "readStream");
+      const { currentStreamVersion, streamExists } = await fetchStreamInfo(
+        db,
+        streamName,
+        partition
+      );
+      const range = parseRangeOptions(options);
+      const rows = await buildEventsQuery(
+        { db, logger },
+        streamName,
+        partition,
+        range
+      ).execute();
+      const events = rows.map(
+        (row) => mapRowToEvent(row, streamName)
+      );
+      return {
+        events,
+        currentStreamVersion,
+        streamExists
+      };
+    },
+    async appendToStream(streamName, events, options) {
+      const streamType = getStreamType(options);
+      const partition = getPartition(options);
+      const expected = options?.expectedStreamVersion;
+      logger.debug?.(
+        { streamName, events, options, partition },
+        "appendToStream"
+      );
+      ensureEventsNotEmpty(events, expected);
+      const executeOn = async (executor) => {
+        const { currentStreamVersion, streamExists } = await fetchStreamInfo(
+          executor,
+          streamName,
+          partition
+        );
+        assertExpectedVersion(expected, currentStreamVersion, streamExists);
+        const basePos = currentStreamVersion;
+        const nextStreamPosition = computeNextStreamPosition(
+          basePos,
+          events.length
+        );
+        await upsertStreamRow(
+          executor,
+          streamName,
+          partition,
+          streamType,
+          basePos,
+          nextStreamPosition,
+          expected,
+          streamExists
+        );
+        const messagesToInsert = buildMessagesToInsert(
+          events,
+          basePos,
+          streamName,
+          partition
+        );
+        const lastEventGlobalPosition = await insertMessagesAndGetLastGlobalPosition(
+          executor,
+          messagesToInsert
+        );
+        return {
+          nextExpectedStreamVersion: nextStreamPosition,
+          lastEventGlobalPosition,
+          createdNewStream: !streamExists
+        };
+      };
+      if (inTransaction) {
+        return executeOn(db);
+      }
+      return db.transaction().execute(async (trx) => executeOn(trx));
+    },
+    close: async () => {
+      await Promise.resolve();
+    }
+  };
+  return eventStore;
+};
+function getStreamType(options) {
+  return options?.streamType ?? "unknown";
+}
+function getPartition(options) {
+  return options?.partition ?? DEFAULT_PARTITION;
+}
+function ensureEventsNotEmpty(events, _expected) {
+  if (events.length === 0) {
+    throw new Error("Cannot append empty events array");
+  }
+}
+function assertExpectedVersion(expected, currentPos, streamExistsNow) {
+  if (expected === "STREAM_EXISTS" && !streamExistsNow) {
+    throw new Error("Stream does not exist but expected to exist");
+  }
+  if (expected === "STREAM_DOES_NOT_EXIST" && streamExistsNow) {
+    throw new Error("Stream exists but expected not to exist");
+  }
+  if (typeof expected === "bigint" && expected !== currentPos) {
+    throw new Error(
+      `Expected version ${expected} but current is ${currentPos}`
+    );
+  }
+}
+function computeNextStreamPosition(basePos, eventCount) {
+  return basePos + BigInt(eventCount);
+}
+async function upsertStreamRow(executor, streamId, partition, streamType, basePos, nextStreamPosition, expected, streamExistsNow) {
+  if (!streamExistsNow) {
+    await executor.insertInto("streams").values({
+      stream_id: streamId,
+      stream_position: nextStreamPosition,
+      partition,
+      stream_type: streamType,
+      stream_metadata: {},
+      is_archived: false
+    }).execute();
+    return;
+  }
+  if (typeof expected === "bigint") {
+    const updatedRow = await executor.updateTable("streams").set({ stream_position: nextStreamPosition }).where("stream_id", "=", streamId).where("partition", "=", partition).where("is_archived", "=", false).where("stream_position", "=", basePos).returning("stream_position").executeTakeFirst();
+    if (!updatedRow) {
+      throw new Error(`Expected version ${expected} but current is ${basePos}`);
+    }
+    return;
+  }
+  await executor.updateTable("streams").set({ stream_position: nextStreamPosition }).where("stream_id", "=", streamId).where("partition", "=", partition).where("is_archived", "=", false).execute();
+}
+function buildMessagesToInsert(events, basePos, streamId, partition) {
+  return events.map((e, index) => {
+    const messageId = crypto.randomUUID();
+    const streamPosition = basePos + BigInt(index + 1);
+    const rawMeta = "metadata" in e ? e.metadata : void 0;
+    const eventMeta = rawMeta && typeof rawMeta === "object" ? rawMeta : {};
+    const messageMetadata = {
+      ...eventMeta
+    };
+    return {
+      stream_id: streamId,
+      stream_position: streamPosition,
+      partition,
+      message_data: e.data,
+      message_metadata: messageMetadata,
+      message_schema_version: index.toString(),
+      message_type: e.type,
+      message_kind: "E",
+      message_id: messageId,
+      is_archived: false,
+      created: /* @__PURE__ */ new Date()
+    };
+  });
+}
+async function insertMessagesAndGetLastGlobalPosition(executor, messagesToInsert) {
+  const inserted = await executor.insertInto("messages").values(messagesToInsert).returning("global_position").execute();
+  if (!inserted || Array.isArray(inserted) && inserted.length === 0) {
+    return 0n;
+  }
+  const globalPositions = inserted.map(
+    (r) => BigInt(String(r.global_position))
+  );
+  return globalPositions[globalPositions.length - 1];
+}
+function parseRangeOptions(options) {
+  const from = options && typeof options === "object" && "from" in options ? options.from : void 0;
+  const to = options && typeof options === "object" && "to" in options ? options.to : void 0;
+  const maxCount = options && typeof options === "object" && "maxCount" in options ? options.maxCount : void 0;
+  return { from, to, maxCount };
+}
+function buildEventsQuery(deps, streamId, partition, range) {
+  const { db } = deps;
+  let q = db.selectFrom("messages").select([
+    "message_type",
+    "message_data",
+    "message_metadata",
+    "stream_position",
+    "global_position",
+    "message_id"
+  ]).where("stream_id", "=", streamId).where("partition", "=", partition).where("is_archived", "=", false).orderBy("stream_position");
+  if (range.from !== void 0) {
+    q = q.where("stream_position", ">=", range.from);
+  }
+  if (range.to !== void 0) {
+    q = q.where("stream_position", "<=", range.to);
+  }
+  if (range.maxCount !== void 0) {
+    q = q.limit(Number(range.maxCount));
+  }
+  return q;
+}
+function mapRowToEvent(row, streamId) {
+  const streamPosition = BigInt(String(row.stream_position));
+  const globalPosition = BigInt(String(row.global_position ?? 0));
+  const baseMetadata = row.message_metadata ?? {};
+  return {
+    kind: "Event",
+    type: row.message_type,
+    data: row.message_data,
+    metadata: {
+      ...baseMetadata,
+      messageId: row.message_id,
+      streamId,
+      streamPosition,
+      globalPosition
+    }
+  };
+}
+async function fetchStreamInfo(executor, streamId, partition) {
+  const streamRow = await executor.selectFrom("streams").select(["stream_position"]).where("stream_id", "=", streamId).where("partition", "=", partition).where("is_archived", "=", false).executeTakeFirst();
+  const currentStreamVersion = streamRow ? BigInt(String(streamRow.stream_position)) : PostgreSQLEventStoreDefaultStreamVersion;
+  return { currentStreamVersion, streamExists: !!streamRow };
+}
+
+// src/projections/runner.ts
+function createProjectionRunner({ db, readStream, registry }) {
+  async function getOrCreateCheckpoint(subscriptionId, partition) {
+    const existing = await db.selectFrom("subscriptions").select([
+      "subscription_id as subscriptionId",
+      "partition",
+      "last_processed_position as lastProcessedPosition"
+    ]).where("subscription_id", "=", subscriptionId).where("partition", "=", partition).executeTakeFirst();
+    if (existing) {
+      const last = BigInt(
+        String(
+          existing.lastProcessedPosition
+        )
+      );
+      return {
+        subscriptionId,
+        partition,
+        lastProcessedPosition: last
+      };
+    }
+    await db.insertInto("subscriptions").values({
+      subscription_id: subscriptionId,
+      partition,
+      version: 1,
+      last_processed_position: 0n
+    }).onConflict(
+      (oc) => oc.columns(["subscription_id", "partition", "version"]).doUpdateSet({
+        last_processed_position: (eb) => eb.ref("excluded.last_processed_position")
+      })
+    ).execute();
+    return {
+      subscriptionId,
+      partition,
+      lastProcessedPosition: 0n
+    };
+  }
+  async function updateCheckpoint(subscriptionId, partition, lastProcessedPosition) {
+    await db.updateTable("subscriptions").set({ last_processed_position: lastProcessedPosition }).where("subscription_id", "=", subscriptionId).where("partition", "=", partition).execute();
+  }
+  async function projectEvents(subscriptionId, streamId, opts) {
+    const partition = opts?.partition ?? "default_partition";
+    const batchSize = BigInt(opts?.batchSize ?? 500);
+    const checkpoint = await getOrCreateCheckpoint(subscriptionId, partition);
+    const { events, currentStreamVersion } = await readStream(streamId, {
+      from: checkpoint.lastProcessedPosition + 1n,
+      to: checkpoint.lastProcessedPosition + batchSize,
+      partition
+    });
+    for (const ev of events) {
+      if (!ev) continue;
+      const handlers = registry[ev.type] ?? [];
+      if (handlers.length === 0) {
+        await updateCheckpoint(
+          subscriptionId,
+          partition,
+          ev.metadata.streamPosition
+        );
+        continue;
+      }
+      const projectionEvent = {
+        type: ev.type,
+        data: ev.data,
+        metadata: {
+          streamId: ev.metadata.streamId,
+          streamPosition: ev.metadata.streamPosition,
+          globalPosition: ev.metadata.globalPosition
+        }
+      };
+      for (const handler of handlers) {
+        await handler({ db, partition }, projectionEvent);
+      }
+      await updateCheckpoint(
+        subscriptionId,
+        partition,
+        projectionEvent.metadata.streamPosition
+      );
+    }
+    return { processed: events.length, currentStreamVersion };
+  }
+  return { projectEvents };
+}
+
+// src/projections/snapshot-projection.ts
+function createSnapshotProjection(config) {
+  const {
+    tableName,
+    primaryKeys,
+    extractKeys,
+    evolve,
+    initialState,
+    mapToColumns
+  } = config;
+  return async ({ db, partition }, event) => {
+    const keys = extractKeys(event, partition);
+    const existing = await db.selectFrom(tableName).select(["last_stream_position", "snapshot"]).where((eb) => {
+      const conditions = Object.entries(keys).map(
+        ([key, value]) => eb(key, "=", value)
+      );
+      return eb.and(conditions);
+    }).executeTakeFirst();
+    const lastPos = existing?.last_stream_position ? BigInt(String(existing.last_stream_position)) : -1n;
+    if (event.metadata.streamPosition <= lastPos) {
+      return;
+    }
+    const currentState = existing?.snapshot ? existing.snapshot : initialState();
+    const newState = evolve(currentState, event);
+    const rowData = {
+      ...keys,
+      snapshot: JSON.stringify(newState),
+      stream_id: event.metadata.streamId,
+      last_stream_position: event.metadata.streamPosition.toString(),
+      last_global_position: event.metadata.globalPosition.toString()
+    };
+    if (mapToColumns) {
+      const columns = mapToColumns(newState);
+      Object.assign(rowData, columns);
+    }
+    const insertQuery = db.insertInto(tableName).values(rowData);
+    const updateSet = {
+      snapshot: (eb) => eb.ref("excluded.snapshot"),
+      stream_id: (eb) => eb.ref("excluded.stream_id"),
+      last_stream_position: (eb) => eb.ref("excluded.last_stream_position"),
+      last_global_position: (eb) => eb.ref("excluded.last_global_position")
+    };
+    if (mapToColumns) {
+      const columns = mapToColumns(newState);
+      for (const columnName of Object.keys(columns)) {
+        updateSet[columnName] = (eb) => eb.ref(`excluded.${columnName}`);
+      }
+    }
+    await insertQuery.onConflict((oc) => {
+      const conflictBuilder = oc.columns(primaryKeys);
+      return conflictBuilder.doUpdateSet(updateSet);
+    }).execute();
+  };
+}
+function createSnapshotProjectionRegistry(eventTypes, config) {
+  const handler = createSnapshotProjection(config);
+  const registry = {};
+  for (const eventType of eventTypes) {
+    registry[eventType] = [handler];
+  }
+  return registry;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createKyselyEventStoreConsumer,
+  createProjectionRegistry,
+  createProjectionRunner,
+  createSnapshotProjection,
+  createSnapshotProjectionRegistry,
+  getKyselyEventStore
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createKyselyEventStoreConsumer } from "./event-store/consumers.js";
+export type { KyselyEventStoreConsumer, KyselyEventStoreConsumerConfig, } from "./event-store/consumers.js";
+export { getKyselyEventStore } from "./event-store/kysely-event-store.js";
+export type { KyselyEventStore, KyselyEventStoreOptions, ProjectionReadStreamOptions, } from "./event-store/kysely-event-store.js";
+export { createProjectionRunner } from "./projections/runner.js";
+export { createSnapshotProjection, createSnapshotProjectionRegistry, } from "./projections/snapshot-projection.js";
+export type { SnapshotProjectionConfig } from "./projections/snapshot-projection.js";
+export { createProjectionRegistry } from "./types.js";
+export type { DatabaseExecutor, Dependencies, ExtendedOptions, ProjectionContext, ProjectionEvent, ProjectionEventMetadata, ProjectionHandler, ProjectionRegistry, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,YAAY,EACV,wBAAwB,EACxB,8BAA8B,GAC/B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,sCAAsC,CAAC;AAC9C,YAAY,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createKyselyEventStoreConsumer } from "./event-store/consumers.js";
+export { getKyselyEventStore } from "./event-store/kysely-event-store.js";
+export { createProjectionRunner } from "./projections/runner.js";
+export { createSnapshotProjection, createSnapshotProjectionRegistry, } from "./projections/snapshot-projection.js";
+export { createProjectionRegistry } from "./types.js";

package/dist/projections/runner.d.ts

@@ -0,0 +1,22 @@
+import type { KyselyEventStore } from "../event-store/kysely-event-store.js";
+import type { DatabaseExecutor, ProjectionRegistry } from "../types.js";
+export type SubscriptionCheckpoint = {
+    subscriptionId: string;
+    partition: string;
+    lastProcessedPosition: bigint;
+};
+export type ProjectionRunnerDeps<T extends DatabaseExecutor = DatabaseExecutor> = {
+    db: T;
+    readStream: KyselyEventStore["readStream"];
+    registry: ProjectionRegistry<T>;
+};
+export declare function createProjectionRunner<T extends DatabaseExecutor = DatabaseExecutor>({ db, readStream, registry }: ProjectionRunnerDeps<T>): {
+    projectEvents: (subscriptionId: string, streamId: string, opts?: {
+        partition?: string;
+        batchSize?: number;
+    }) => Promise<{
+        processed: number;
+        currentStreamVersion: bigint;
+    }>;
+};
+//# sourceMappingURL=runner.d.ts.map

package/dist/projections/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/projections/runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EACV,gBAAgB,EAEhB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,IAC3C;IACF,EAAE,EAAE,CAAC,CAAC;IACN,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC3C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,EAC7C,EAAE,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,oBAAoB,CAAC,CAAC,CAAC;oCA4EnC,MAAM,YACZ,MAAM,SACT;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;;;;EAiDpD"}