@dexto/core 1.5.8 → 1.6.0

package/dist/storage/blob/factory.js

@@ -1,15 +0,0 @@
-import "../../chunk-PTJYTZNU.js";
-import { blobStoreRegistry } from "./registry.js";
-function createBlobStore(config, logger) {
-  const validatedConfig = blobStoreRegistry.validateConfig(config);
-  const provider = blobStoreRegistry.get(validatedConfig.type);
-  if (!provider) {
-    throw new Error(`Provider '${validatedConfig.type}' not found in registry`);
-  }
-  const providerName = provider.metadata?.displayName || validatedConfig.type;
-  logger.info(`Using ${providerName} blob store`);
-  return provider.create(validatedConfig, logger);
-}
-export {
-  createBlobStore
-};

package/dist/storage/blob/local-blob-store.cjs

@@ -1,496 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var local_blob_store_exports = {};
-__export(local_blob_store_exports, {
-  LocalBlobStore: () => LocalBlobStore
-});
-module.exports = __toCommonJS(local_blob_store_exports);
-var import_fs = require("fs");
-var import_path = __toESM(require("path"), 1);
-var import_crypto = require("crypto");
-var import_url = require("url");
-var import_types = require("../../logger/v2/types.js");
-var import_errors = require("../errors.js");
-class LocalBlobStore {
-  config;
-  storePath;
-  connected = false;
-  statsCache = null;
-  statsCachePromise = null;
-  lastStatsRefresh = 0;
-  logger;
-  static STATS_REFRESH_INTERVAL_MS = 6e4;
-  // 1 minute
-  constructor(config, logger) {
-    this.config = config;
-    this.storePath = config.storePath;
-    this.logger = logger.createChild(import_types.DextoLogComponent.STORAGE);
-  }
-  async connect() {
-    if (this.connected) return;
-    try {
-      await import_fs.promises.mkdir(this.storePath, { recursive: true });
-      await this.refreshStatsCache();
-      this.lastStatsRefresh = Date.now();
-      this.connected = true;
-      this.logger.debug(`LocalBlobStore connected at: ${this.storePath}`);
-    } catch (error) {
-      throw import_errors.StorageError.blobOperationFailed("connect", "local", error);
-    }
-  }
-  async disconnect() {
-    this.connected = false;
-    this.logger.debug("LocalBlobStore disconnected");
-  }
-  /**
-   * Normalize metadata after JSON parsing to ensure createdAt is a Date object
-   */
-  normalizeMetadata(parsed) {
-    return {
-      ...parsed,
-      createdAt: parsed.createdAt instanceof Date ? parsed.createdAt : new Date(parsed.createdAt)
-    };
-  }
-  isConnected() {
-    return this.connected;
-  }
-  getStoreType() {
-    return "local";
-  }
-  async store(input, metadata = {}) {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const buffer = await this.inputToBuffer(input);
-    if (buffer.length > this.config.maxBlobSize) {
-      throw import_errors.StorageError.blobSizeExceeded(buffer.length, this.config.maxBlobSize);
-    }
-    const hash = (0, import_crypto.createHash)("sha256").update(buffer).digest("hex").substring(0, 16);
-    const id = hash;
-    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
-    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
-    try {
-      const existingMeta = await import_fs.promises.readFile(metaPath, "utf-8");
-      const parsed = JSON.parse(existingMeta);
-      const existingMetadata = this.normalizeMetadata(parsed);
-      this.logger.debug(
-        `Blob ${id} already exists, returning existing reference (deduplication)`
-      );
-      return {
-        id,
-        uri: `blob:${id}`,
-        metadata: existingMetadata
-      };
-    } catch {
-    }
-    const maxTotalSize = this.config.maxTotalSize;
-    if (maxTotalSize) {
-      const stats = await this.ensureStatsCache();
-      if (stats.totalSize + buffer.length > maxTotalSize) {
-        throw import_errors.StorageError.blobTotalSizeExceeded(
-          stats.totalSize + buffer.length,
-          maxTotalSize
-        );
-      }
-    }
-    const storedMetadata = {
-      id,
-      mimeType: metadata.mimeType || this.detectMimeType(buffer, metadata.originalName),
-      originalName: metadata.originalName,
-      createdAt: metadata.createdAt || /* @__PURE__ */ new Date(),
-      source: metadata.source || "system",
-      size: buffer.length,
-      hash
-    };
-    try {
-      await Promise.all([
-        import_fs.promises.writeFile(blobPath, buffer),
-        import_fs.promises.writeFile(metaPath, JSON.stringify(storedMetadata, null, 2))
-      ]);
-      this.logger.debug(
-        `Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`
-      );
-      this.updateStatsCacheAfterStore(buffer.length);
-      return {
-        id,
-        uri: `blob:${id}`,
-        metadata: storedMetadata
-      };
-    } catch (error) {
-      await Promise.allSettled([
-        import_fs.promises.unlink(blobPath).catch(() => {
-        }),
-        import_fs.promises.unlink(metaPath).catch(() => {
-        })
-      ]);
-      throw import_errors.StorageError.blobOperationFailed("store", "local", error);
-    }
-  }
-  async retrieve(reference, format = "buffer") {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const id = this.parseReference(reference);
-    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
-    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
-    try {
-      const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
-      const parsed = JSON.parse(metaContent);
-      const metadata = this.normalizeMetadata(parsed);
-      switch (format) {
-        case "base64": {
-          const buffer = await import_fs.promises.readFile(blobPath);
-          return { format: "base64", data: buffer.toString("base64"), metadata };
-        }
-        case "buffer": {
-          const buffer = await import_fs.promises.readFile(blobPath);
-          return { format: "buffer", data: buffer, metadata };
-        }
-        case "path": {
-          await import_fs.promises.access(blobPath);
-          return { format: "path", data: blobPath, metadata };
-        }
-        case "stream": {
-          const stream = (0, import_fs.createReadStream)(blobPath);
-          return { format: "stream", data: stream, metadata };
-        }
-        case "url": {
-          const absolutePath = import_path.default.resolve(blobPath);
-          return {
-            format: "url",
-            data: (0, import_url.pathToFileURL)(absolutePath).toString(),
-            metadata
-          };
-        }
-        default:
-          throw import_errors.StorageError.blobInvalidInput(format, `Unsupported format: ${format}`);
-      }
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-        throw import_errors.StorageError.blobNotFound(reference);
-      }
-      throw import_errors.StorageError.blobOperationFailed("retrieve", "local", error);
-    }
-  }
-  async exists(reference) {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const id = this.parseReference(reference);
-    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
-    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
-    try {
-      await Promise.all([import_fs.promises.access(blobPath), import_fs.promises.access(metaPath)]);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async delete(reference) {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const id = this.parseReference(reference);
-    const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
-    const metaPath = import_path.default.join(this.storePath, `${id}.meta.json`);
-    try {
-      const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
-      const parsed = JSON.parse(metaContent);
-      const metadata = this.normalizeMetadata(parsed);
-      await Promise.all([import_fs.promises.unlink(blobPath), import_fs.promises.unlink(metaPath)]);
-      this.logger.debug(`Deleted blob: ${id}`);
-      this.updateStatsCacheAfterDelete(metadata.size);
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-        throw import_errors.StorageError.blobNotFound(reference);
-      }
-      throw import_errors.StorageError.blobOperationFailed("delete", "local", error);
-    }
-  }
-  async cleanup(olderThan) {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const cleanupDays = this.config.cleanupAfterDays;
-    const cutoffDate = olderThan || new Date(Date.now() - cleanupDays * 24 * 60 * 60 * 1e3);
-    let deletedCount = 0;
-    try {
-      const files = await import_fs.promises.readdir(this.storePath);
-      const metaFiles = files.filter((f) => f.endsWith(".meta.json"));
-      for (const metaFile of metaFiles) {
-        const metaPath = import_path.default.join(this.storePath, metaFile);
-        const id = metaFile.replace(".meta.json", "");
-        const blobPath = import_path.default.join(this.storePath, `${id}.dat`);
-        try {
-          const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
-          const parsed = JSON.parse(metaContent);
-          const metadata = this.normalizeMetadata(parsed);
-          if (metadata.createdAt < cutoffDate) {
-            await Promise.all([
-              import_fs.promises.unlink(blobPath).catch(() => {
-              }),
-              import_fs.promises.unlink(metaPath).catch(() => {
-              })
-            ]);
-            deletedCount++;
-            this.updateStatsCacheAfterDelete(metadata.size);
-            this.logger.debug(`Cleaned up old blob: ${id}`);
-          }
-        } catch (error) {
-          this.logger.warn(
-            `Failed to process blob metadata ${metaFile}: ${String(error)}`
-          );
-        }
-      }
-      if (deletedCount > 0) {
-        this.logger.info(`Blob cleanup: removed ${deletedCount} old blobs`);
-      }
-      return deletedCount;
-    } catch (error) {
-      throw import_errors.StorageError.blobCleanupFailed("local", error);
-    }
-  }
-  async getStats() {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    const stats = await this.ensureStatsCache();
-    return {
-      count: stats.count,
-      totalSize: stats.totalSize,
-      backendType: "local",
-      storePath: this.storePath
-    };
-  }
-  getStoragePath() {
-    return this.storePath;
-  }
-  async listBlobs() {
-    if (!this.connected) {
-      throw import_errors.StorageError.blobBackendNotConnected("local");
-    }
-    try {
-      const files = await import_fs.promises.readdir(this.storePath);
-      const metaFiles = files.filter((f) => f.endsWith(".meta.json"));
-      const blobs = [];
-      for (const metaFile of metaFiles) {
-        try {
-          const metaPath = import_path.default.join(this.storePath, metaFile);
-          const metaContent = await import_fs.promises.readFile(metaPath, "utf-8");
-          const parsed = JSON.parse(metaContent);
-          const metadata = this.normalizeMetadata(parsed);
-          const blobId = metaFile.replace(".meta.json", "");
-          blobs.push({
-            id: blobId,
-            uri: `blob:${blobId}`,
-            metadata
-          });
-        } catch (error) {
-          this.logger.warn(
-            `Failed to process blob metadata ${metaFile}: ${String(error)}`
-          );
-        }
-      }
-      return blobs;
-    } catch (error) {
-      this.logger.warn(`Failed to list blobs: ${String(error)}`);
-      return [];
-    }
-  }
-  async ensureStatsCache() {
-    const now = Date.now();
-    const cacheAge = now - this.lastStatsRefresh;
-    const isStale = cacheAge > LocalBlobStore.STATS_REFRESH_INTERVAL_MS;
-    if (!this.statsCache || isStale) {
-      if (!this.statsCachePromise) {
-        this.statsCachePromise = this.refreshStatsCache();
-      }
-      try {
-        await this.statsCachePromise;
-        this.lastStatsRefresh = now;
-      } finally {
-        this.statsCachePromise = null;
-      }
-    }
-    return this.statsCache ?? { count: 0, totalSize: 0 };
-  }
-  async refreshStatsCache() {
-    const stats = { count: 0, totalSize: 0 };
-    try {
-      const files = await import_fs.promises.readdir(this.storePath);
-      const datFiles = files.filter((f) => f.endsWith(".dat"));
-      stats.count = datFiles.length;
-      for (const datFile of datFiles) {
-        try {
-          const stat = await import_fs.promises.stat(import_path.default.join(this.storePath, datFile));
-          stats.totalSize += stat.size;
-        } catch (error) {
-          this.logger.debug(
-            `Skipping size calculation for ${datFile}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    } catch (error) {
-      this.logger.warn(`Failed to refresh blob stats cache: ${String(error)}`);
-    }
-    this.statsCache = stats;
-  }
-  updateStatsCacheAfterStore(size) {
-    if (!this.statsCache) {
-      this.statsCache = { count: 1, totalSize: size };
-      return;
-    }
-    this.statsCache.count += 1;
-    this.statsCache.totalSize += size;
-  }
-  updateStatsCacheAfterDelete(size) {
-    if (!this.statsCache) {
-      this.statsCache = { count: 0, totalSize: 0 };
-      return;
-    }
-    this.statsCache.count = Math.max(0, this.statsCache.count - 1);
-    this.statsCache.totalSize = Math.max(0, this.statsCache.totalSize - size);
-  }
-  /**
-   * Convert various input types to Buffer
-   */
-  async inputToBuffer(input) {
-    if (Buffer.isBuffer(input)) {
-      return input;
-    }
-    if (input instanceof Uint8Array) {
-      return Buffer.from(input);
-    }
-    if (input instanceof ArrayBuffer) {
-      return Buffer.from(new Uint8Array(input));
-    }
-    if (typeof input === "string") {
-      if (input.startsWith("data:")) {
-        const commaIndex = input.indexOf(",");
-        if (commaIndex !== -1 && input.includes(";base64,")) {
-          const base64Data = input.substring(commaIndex + 1);
-          return Buffer.from(base64Data, "base64");
-        }
-        throw import_errors.StorageError.blobEncodingError(
-          "inputToBuffer",
-          "Unsupported data URI format"
-        );
-      }
-      if ((input.includes("/") || input.includes("\\")) && input.length > 1) {
-        try {
-          await import_fs.promises.access(input);
-          return await import_fs.promises.readFile(input);
-        } catch {
-        }
-      }
-      try {
-        return Buffer.from(input, "base64");
-      } catch {
-        throw import_errors.StorageError.blobEncodingError("inputToBuffer", "Invalid base64 string");
-      }
-    }
-    throw import_errors.StorageError.blobInvalidInput(input, `Unsupported input type: ${typeof input}`);
-  }
-  /**
-   * Parse blob reference to extract ID
-   */
-  parseReference(reference) {
-    if (!reference) {
-      throw import_errors.StorageError.blobInvalidReference(reference, "Empty reference");
-    }
-    if (reference.startsWith("blob:")) {
-      const id = reference.substring(5);
-      if (!id) {
-        throw import_errors.StorageError.blobInvalidReference(reference, "Empty blob ID after prefix");
-      }
-      return id;
-    }
-    return reference;
-  }
-  /**
-   * Detect MIME type from buffer content and/or filename
-   */
-  detectMimeType(buffer, filename) {
-    const header = buffer.subarray(0, 16);
-    if (header.length >= 3) {
-      const jpegSignature = header.subarray(0, 3);
-      if (jpegSignature.equals(Buffer.from([255, 216, 255]))) {
-        return "image/jpeg";
-      }
-    }
-    if (header.length >= 4) {
-      const signature = header.subarray(0, 4);
-      if (signature.equals(Buffer.from([137, 80, 78, 71]))) return "image/png";
-      if (signature.equals(Buffer.from([71, 73, 70, 56]))) return "image/gif";
-      if (signature.equals(Buffer.from([37, 80, 68, 70]))) return "application/pdf";
-    }
-    if (filename) {
-      const ext = import_path.default.extname(filename).toLowerCase();
-      const mimeTypes = {
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".png": "image/png",
-        ".gif": "image/gif",
-        ".pdf": "application/pdf",
-        ".txt": "text/plain",
-        ".json": "application/json",
-        ".xml": "text/xml",
-        ".html": "text/html",
-        ".css": "text/css",
-        ".js": "text/javascript",
-        ".mp3": "audio/mpeg",
-        ".mp4": "video/mp4",
-        ".wav": "audio/wav"
-      };
-      if (mimeTypes[ext]) return mimeTypes[ext];
-    }
-    if (this.isTextBuffer(buffer)) {
-      return "text/plain";
-    }
-    return "application/octet-stream";
-  }
-  /**
-   * Check if buffer contains text content
-   */
-  isTextBuffer(buffer) {
-    let printableCount = 0;
-    const sampleSize = Math.min(512, buffer.length);
-    for (let i = 0; i < sampleSize; i++) {
-      const byte = buffer[i];
-      if (byte !== void 0 && (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13)) {
-        printableCount++;
-      }
-    }
-    return printableCount / sampleSize > 0.7;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LocalBlobStore
-});

package/dist/storage/blob/local-blob-store.d.ts

@@ -1,58 +0,0 @@
-import type { IDextoLogger } from '../../logger/v2/types.js';
-import type { BlobStore, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats } from './types.js';
-import type { LocalBlobStoreConfig } from './schemas.js';
-/**
- * Local filesystem blob store implementation.
- *
- * Stores blobs on the local filesystem with content-based deduplication
- * and metadata tracking. This is the default store for development
- * and single-machine deployments.
- */
-export declare class LocalBlobStore implements BlobStore {
-    private config;
-    private storePath;
-    private connected;
-    private statsCache;
-    private statsCachePromise;
-    private lastStatsRefresh;
-    private logger;
-    private static readonly STATS_REFRESH_INTERVAL_MS;
-    constructor(config: LocalBlobStoreConfig, logger: IDextoLogger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    /**
-     * Normalize metadata after JSON parsing to ensure createdAt is a Date object
-     */
-    private normalizeMetadata;
-    isConnected(): boolean;
-    getStoreType(): string;
-    store(input: BlobInput, metadata?: BlobMetadata): Promise<BlobReference>;
-    retrieve(reference: string, format?: 'base64' | 'buffer' | 'path' | 'stream' | 'url'): Promise<BlobData>;
-    exists(reference: string): Promise<boolean>;
-    delete(reference: string): Promise<void>;
-    cleanup(olderThan?: Date): Promise<number>;
-    getStats(): Promise<BlobStats>;
-    getStoragePath(): string | undefined;
-    listBlobs(): Promise<BlobReference[]>;
-    private ensureStatsCache;
-    private refreshStatsCache;
-    private updateStatsCacheAfterStore;
-    private updateStatsCacheAfterDelete;
-    /**
-     * Convert various input types to Buffer
-     */
-    private inputToBuffer;
-    /**
-     * Parse blob reference to extract ID
-     */
-    private parseReference;
-    /**
-     * Detect MIME type from buffer content and/or filename
-     */
-    private detectMimeType;
-    /**
-     * Check if buffer contains text content
-     */
-    private isTextBuffer;
-}
-//# sourceMappingURL=local-blob-store.d.ts.map

package/dist/storage/blob/local-blob-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"local-blob-store.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/local-blob-store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,KAAK,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,SAAS,EAEZ,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC5C,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,UAAU,CAAqD;IACvE,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,MAAM,CAAe;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAS;gBAE9C,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,YAAY;IAOxD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAQzB,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAIhB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,GAAE,YAAiB,GAAG,OAAO,CAAC,aAAa,CAAC;IAyF5E,QAAQ,CACV,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAgB,GACnE,OAAO,CAAC,QAAQ,CAAC;IAsDd,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB3C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBxC,OAAO,CAAC,SAAS,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAiD1C,QAAQ,IAAI,OAAO,CAAC,SAAS,CAAC;IAepC,cAAc,IAAI,MAAM,GAAG,SAAS;IAI9B,SAAS,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YAqC7B,gBAAgB;YAsBhB,iBAAiB;IAwB/B,OAAO,CAAC,0BAA0B;IASlC,OAAO,CAAC,2BAA2B;IASnC;;OAEG;YACW,aAAa;IAgD3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAiDtB;;OAEG;IACH,OAAO,CAAC,YAAY;CAiBvB"}