sonamu 0.8.26 → 0.9.0

package/dist/utils/zod-error.js

@@ -1,19 +1,26 @@
-export function humanizeZodError(error) {
-    return error.issues.map(({ path: originPath, message })=>{
-        const path = originPath.map((item)=>{
-            if (typeof item === "symbol") {
-                return item.description ?? item.toString();
-            }
-            if (typeof item === "number") {
-                return `[${item}]`;
-            }
-            return item;
-        });
-        return {
-            path,
-            message: message
-        };
-    });
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/utils/zod-error.ts
+function humanizeZodError(error) {
+	return error.issues.map(({ path: originPath, message }) => {
+		const path = originPath.map((item) => {
+			if (typeof item === "symbol") {
+				return item.description ?? item.toString();
+			}
+			if (typeof item === "number") {
+				return `[${item}]`;
+			}
+			return item;
+		});
+		return {
+			path,
+			message
+		};
+	});
 }
+var init_zod_error = __esmMin((() => {}));
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy96b2QtZXJyb3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyB6IH0gZnJvbSBcInpvZFwiO1xuXG50eXBlIFZhbGlkYXRpb25FcnJvciA9IHtcbiAgcGF0aDogc3RyaW5nW107XG4gIG1lc3NhZ2U6IHN0cmluZztcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiBodW1hbml6ZVpvZEVycm9yKGVycm9yOiB6LlpvZEVycm9yKTogVmFsaWRhdGlvbkVycm9yW10ge1xuICByZXR1cm4gZXJyb3IuaXNzdWVzLm1hcCgoeyBwYXRoOiBvcmlnaW5QYXRoLCBtZXNzYWdlIH0pID0+IHtcbiAgICBjb25zdCBwYXRoID0gb3JpZ2luUGF0aC5tYXAoKGl0ZW0pID0+IHtcbiAgICAgIGlmICh0eXBlb2YgaXRlbSA9PT0gXCJzeW1ib2xcIikge1xuICAgICAgICByZXR1cm4gaXRlbS5kZXNjcmlwdGlvbiA/PyBpdGVtLnRvU3RyaW5nKCk7XG4gICAgICB9XG5cbiAgICAgIGlmICh0eXBlb2YgaXRlbSA9PT0gXCJudW1iZXJcIikge1xuICAgICAgICByZXR1cm4gYFske2l0ZW19XWA7XG4gICAgICB9XG5cbiAgICAgIHJldHVybiBpdGVtO1xuICAgIH0pO1xuXG4gICAgcmV0dXJuIHsgcGF0aCwgbWVzc2FnZTogbWVzc2FnZSB9O1xuICB9KTtcbn1cbiJdLCJuYW1lcyI6WyJodW1hbml6ZVpvZEVycm9yIiwiZXJyb3IiLCJpc3N1ZXMiLCJtYXAiLCJwYXRoIiwib3JpZ2luUGF0aCIsIm1lc3NhZ2UiLCJpdGVtIiwiZGVzY3JpcHRpb24iLCJ0b1N0cmluZyJdLCJtYXBwaW5ncyI6IkFBT0EsT0FBTyxTQUFTQSxpQkFBaUJDLEtBQWlCO0lBQ2hELE9BQU9BLE1BQU1DLE1BQU0sQ0FBQ0MsR0FBRyxDQUFDLENBQUMsRUFBRUMsTUFBTUMsVUFBVSxFQUFFQyxPQUFPLEVBQUU7UUFDcEQsTUFBTUYsT0FBT0MsV0FBV0YsR0FBRyxDQUFDLENBQUNJO1lBQzNCLElBQUksT0FBT0EsU0FBUyxVQUFVO2dCQUM1QixPQUFPQSxLQUFLQyxXQUFXLElBQUlELEtBQUtFLFFBQVE7WUFDMUM7WUFFQSxJQUFJLE9BQU9GLFNBQVMsVUFBVTtnQkFDNUIsT0FBTyxDQUFDLENBQUMsRUFBRUEsS0FBSyxDQUFDLENBQUM7WUFDcEI7WUFFQSxPQUFPQTtRQUNUO1FBRUEsT0FBTztZQUFFSDtZQUFNRSxTQUFTQTtRQUFRO0lBQ2xDO0FBQ0YifQ==
+//#endregion
+init_zod_error();
+export { humanizeZodError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9kLWVycm9yLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy96b2QtZXJyb3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSB6IH0gZnJvbSBcInpvZFwiO1xuXG50eXBlIFZhbGlkYXRpb25FcnJvciA9IHtcbiAgcGF0aDogc3RyaW5nW107XG4gIG1lc3NhZ2U6IHN0cmluZztcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiBodW1hbml6ZVpvZEVycm9yKGVycm9yOiB6LlpvZEVycm9yKTogVmFsaWRhdGlvbkVycm9yW10ge1xuICByZXR1cm4gZXJyb3IuaXNzdWVzLm1hcCgoeyBwYXRoOiBvcmlnaW5QYXRoLCBtZXNzYWdlIH0pID0+IHtcbiAgICBjb25zdCBwYXRoID0gb3JpZ2luUGF0aC5tYXAoKGl0ZW0pID0+IHtcbiAgICAgIGlmICh0eXBlb2YgaXRlbSA9PT0gXCJzeW1ib2xcIikge1xuICAgICAgICByZXR1cm4gaXRlbS5kZXNjcmlwdGlvbiA/PyBpdGVtLnRvU3RyaW5nKCk7XG4gICAgICB9XG5cbiAgICAgIGlmICh0eXBlb2YgaXRlbSA9PT0gXCJudW1iZXJcIikge1xuICAgICAgICByZXR1cm4gYFske2l0ZW19XWA7XG4gICAgICB9XG5cbiAgICAgIHJldHVybiBpdGVtO1xuICAgIH0pO1xuXG4gICAgcmV0dXJuIHsgcGF0aCwgbWVzc2FnZTogbWVzc2FnZSB9O1xuICB9KTtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7O0FBT0EsU0FBZ0IsaUJBQWlCLE9BQXNDO0FBQ3JFLFFBQU8sTUFBTSxPQUFPLEtBQUssRUFBRSxNQUFNLFlBQVksY0FBYztFQUN6RCxNQUFNLE9BQU8sV0FBVyxLQUFLLFNBQVM7QUFDcEMsT0FBSSxPQUFPLFNBQVMsVUFBVTtBQUM1QixXQUFPLEtBQUssZUFBZSxLQUFLLFVBQVU7O0FBRzVDLE9BQUksT0FBTyxTQUFTLFVBQVU7QUFDNUIsV0FBTyxJQUFJLEtBQUs7O0FBR2xCLFVBQU87SUFDUDtBQUVGLFNBQU87R0FBRTtHQUFlO0dBQVM7R0FDakMifQ==

package/dist/vector/chunking.d.ts

@@ -1,4 +1,4 @@
-import type { Chunk, ChunkingConfig } from "./types";
+import { type Chunk, type ChunkingConfig } from "./types";
 /**
  * 텍스트 청킹
  * - 현재 가이드에서는 400토큰 이하만 저장하므로 기본적으로 사용하지 않음

package/dist/vector/chunking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunking.d.ts","sourceRoot":"","sources":["../../src/vector/chunking.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAErD;;;;GAIG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAiB;gBAEnB,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM;IAIhD;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE;IAmC5B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQxC,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,gBAAgB;CA2BzB"}
+{"version":3,"file":"chunking.d.ts","sourceRoot":"","sources":["../../src/vector/chunking.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1D;;;;GAIG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAiB;gBAEnB,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM;IAIhD;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE;IAmC5B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQxC,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,gBAAgB;CA2BzB"}

package/dist/vector/chunking.js

@@ -1,97 +1,103 @@
 import { DEFAULT_VECTOR_CONFIG } from "./config.js";
+
+//#region src/vector/chunking.ts
 /**
- * 텍스트 청킹
- * - 현재 가이드에서는 400토큰 이하만 저장하므로 기본적으로 사용하지 않음
- * - 추후 긴 문서 처리 시 사용
- */ export class Chunking {
-    config;
-    constructor(config = {}){
-        this.config = {
-            ...DEFAULT_VECTOR_CONFIG.chunking,
-            ...config
-        };
-    }
-    /**
-   * 텍스트를 청크로 분할
-   */ chunk(text) {
-        if (text.length < this.config.skipThreshold) {
-            return [
-                {
-                    index: 0,
-                    text: text.trim(),
-                    startOffset: 0,
-                    endOffset: text.length
-                }
-            ];
-        }
-        const chunks = [];
-        let currentPosition = 0;
-        while(currentPosition < text.length){
-            const remainingText = text.slice(currentPosition);
-            const { chunk, length } = this.extractChunk(remainingText);
-            if (chunk.trim().length >= this.config.minChunkSize) {
-                chunks.push({
-                    index: chunks.length,
-                    text: chunk.trim(),
-                    startOffset: currentPosition,
-                    endOffset: currentPosition + length
-                });
-            }
-            const advance = Math.max(length - this.config.chunkOverlap, this.config.minChunkSize);
-            currentPosition += advance;
-        }
-        return chunks;
-    }
-    /**
-   * 청킹이 필요한지 확인
-   */ needsChunking(text) {
-        return text.length > this.config.chunkSize;
-    }
-    /**
-   * 예상 청크 수 계산
-   */ estimateChunkCount(text) {
-        if (text.length <= this.config.chunkSize) {
-            return 1;
-        }
-        const effectiveChunkSize = this.config.chunkSize - this.config.chunkOverlap;
-        return Math.ceil(text.length / effectiveChunkSize);
-    }
-    extractChunk(text) {
-        if (text.length <= this.config.chunkSize) {
-            return {
-                chunk: text,
-                length: text.length
-            };
-        }
-        for (const separator of this.config.separators){
-            const result = this.splitBySeparator(text, separator);
-            if (result) return result;
-        }
-        return {
-            chunk: text.slice(0, this.config.chunkSize),
-            length: this.config.chunkSize
-        };
-    }
-    splitBySeparator(text, separator) {
-        const searchRange = text.slice(0, this.config.chunkSize + 100);
-        let lastIndex = -1;
-        let index = 0;
-        while(true){
-            index = searchRange.indexOf(separator, index);
-            if (index === -1) break;
-            if (index <= this.config.chunkSize) {
-                lastIndex = index + separator.length;
-            }
-            index++;
-        }
-        if (lastIndex > this.config.minChunkSize) {
-            return {
-                chunk: text.slice(0, lastIndex),
-                length: lastIndex
-            };
-        }
-        return null;
-    }
-}
+* 텍스트 청킹
+* - 현재 가이드에서는 400토큰 이하만 저장하므로 기본적으로 사용하지 않음
+* - 추후 긴 문서 처리 시 사용
+*/
+var Chunking = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_VECTOR_CONFIG.chunking,
+			...config
+		};
+	}
+	/**
+	* 텍스트를 청크로 분할
+	*/
+	chunk(text) {
+		if (text.length < this.config.skipThreshold) {
+			return [{
+				index: 0,
+				text: text.trim(),
+				startOffset: 0,
+				endOffset: text.length
+			}];
+		}
+		const chunks = [];
+		let currentPosition = 0;
+		while (currentPosition < text.length) {
+			const remainingText = text.slice(currentPosition);
+			const { chunk, length } = this.extractChunk(remainingText);
+			if (chunk.trim().length >= this.config.minChunkSize) {
+				chunks.push({
+					index: chunks.length,
+					text: chunk.trim(),
+					startOffset: currentPosition,
+					endOffset: currentPosition + length
+				});
+			}
+			const advance = Math.max(length - this.config.chunkOverlap, this.config.minChunkSize);
+			currentPosition += advance;
+		}
+		return chunks;
+	}
+	/**
+	* 청킹이 필요한지 확인
+	*/
+	needsChunking(text) {
+		return text.length > this.config.chunkSize;
+	}
+	/**
+	* 예상 청크 수 계산
+	*/
+	estimateChunkCount(text) {
+		if (text.length <= this.config.chunkSize) {
+			return 1;
+		}
+		const effectiveChunkSize = this.config.chunkSize - this.config.chunkOverlap;
+		return Math.ceil(text.length / effectiveChunkSize);
+	}
+	extractChunk(text) {
+		if (text.length <= this.config.chunkSize) {
+			return {
+				chunk: text,
+				length: text.length
+			};
+		}
+		for (const separator of this.config.separators) {
+			const result = this.splitBySeparator(text, separator);
+			if (result) return result;
+		}
+		return {
+			chunk: text.slice(0, this.config.chunkSize),
+			length: this.config.chunkSize
+		};
+	}
+	splitBySeparator(text, separator) {
+		const searchRange = text.slice(0, this.config.chunkSize + 100);
+		let lastIndex = -1;
+		let index = 0;
+		while (true) {
+			index = searchRange.indexOf(separator, index);
+			if (index === -1) break;
+			if (index <= this.config.chunkSize) {
+				lastIndex = index + separator.length;
+			}
+			index++;
+		}
+		if (lastIndex > this.config.minChunkSize) {
+			return {
+				chunk: text.slice(0, lastIndex),
+				length: lastIndex
+			};
+		}
+		return null;
+	}
+};
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { Chunking };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/vector/config.d.ts

@@ -1,4 +1,4 @@
-import type { VectorConfig } from "./types";
+import { type VectorConfig } from "./types";
 /**
  * 벡터 검색 기본 설정
  * 사용자는 이 설정을 override하여 커스터마이즈할 수 있음

package/dist/vector/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/vector/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,YA6CnC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,YAAY,CAQtF"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/vector/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,YA6CnC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,YAAY,CAQtF"}

package/dist/vector/config.js

@@ -1,83 +1,81 @@
+//#region src/vector/config.ts
 /**
- * 벡터 검색 기본 설정
- * 사용자는 이 설정을 override하여 커스터마이즈할 수 있음
- */ export const DEFAULT_VECTOR_CONFIG = {
-    // Voyage AI 설정
-    // apiKey는 Sonamu.secrets에서 로드되므로 여기서는 빈 문자열
-    voyage: {
-        apiKey: "",
-        baseUrl: "https://api.voyageai.com/v1/embeddings",
-        model: "voyage-3",
-        dimensions: 1024,
-        maxTokens: 32000,
-        batchSize: 128
-    },
-    // OpenAI 설정
-    // apiKey는 Sonamu.secrets에서 로드되므로 여기서는 빈 문자열
-    openai: {
-        apiKey: "",
-        baseUrl: "https://api.openai.com/v1/embeddings",
-        model: "text-embedding-3-small",
-        dimensions: 1536,
-        maxTokens: 8191,
-        batchSize: 100
-    },
-    // 청킹 설정 (필요시 사용)
-    chunking: {
-        chunkSize: 500,
-        chunkOverlap: 50,
-        minChunkSize: 50,
-        skipThreshold: 200,
-        separators: [
-            "\n\n",
-            "\n",
-            "。",
-            ". ",
-            "! ",
-            "? ",
-            ", ",
-            " "
-        ]
-    },
-    // 검색 설정
-    search: {
-        defaultLimit: 10,
-        similarityThreshold: 0.5,
-        vectorWeight: 0.7,
-        ftsWeight: 0.3
-    },
-    // pgvector 설정
-    pgvector: {
-        iterativeScan: true,
-        efSearch: 100
-    }
+* 벡터 검색 기본 설정
+* 사용자는 이 설정을 override하여 커스터마이즈할 수 있음
+*/
+const DEFAULT_VECTOR_CONFIG = {
+	voyage: {
+		apiKey: "",
+		baseUrl: "https://api.voyageai.com/v1/embeddings",
+		model: "voyage-3",
+		dimensions: 1024,
+		maxTokens: 32e3,
+		batchSize: 128
+	},
+	openai: {
+		apiKey: "",
+		baseUrl: "https://api.openai.com/v1/embeddings",
+		model: "text-embedding-3-small",
+		dimensions: 1536,
+		maxTokens: 8191,
+		batchSize: 100
+	},
+	chunking: {
+		chunkSize: 500,
+		chunkOverlap: 50,
+		minChunkSize: 50,
+		skipThreshold: 200,
+		separators: [
+			"\n\n",
+			"\n",
+			"。",
+			". ",
+			"! ",
+			"? ",
+			", ",
+			" "
+		]
+	},
+	search: {
+		defaultLimit: 10,
+		similarityThreshold: .5,
+		vectorWeight: .7,
+		ftsWeight: .3
+	},
+	pgvector: {
+		iterativeScan: true,
+		efSearch: 100
+	}
 };
 /**
- * 설정 생성 헬퍼 함수
- * 부분 설정만 제공하면 나머지는 기본값 사용
- */ export function createVectorConfig(overrides = {}) {
-    return {
-        voyage: {
-            ...DEFAULT_VECTOR_CONFIG.voyage,
-            ...overrides.voyage
-        },
-        openai: {
-            ...DEFAULT_VECTOR_CONFIG.openai,
-            ...overrides.openai
-        },
-        chunking: {
-            ...DEFAULT_VECTOR_CONFIG.chunking,
-            ...overrides.chunking
-        },
-        search: {
-            ...DEFAULT_VECTOR_CONFIG.search,
-            ...overrides.search
-        },
-        pgvector: {
-            ...DEFAULT_VECTOR_CONFIG.pgvector,
-            ...overrides.pgvector
-        }
-    };
+* 설정 생성 헬퍼 함수
+* 부분 설정만 제공하면 나머지는 기본값 사용
+*/
+function createVectorConfig(overrides = {}) {
+	return {
+		voyage: {
+			...DEFAULT_VECTOR_CONFIG.voyage,
+			...overrides.voyage
+		},
+		openai: {
+			...DEFAULT_VECTOR_CONFIG.openai,
+			...overrides.openai
+		},
+		chunking: {
+			...DEFAULT_VECTOR_CONFIG.chunking,
+			...overrides.chunking
+		},
+		search: {
+			...DEFAULT_VECTOR_CONFIG.search,
+			...overrides.search
+		},
+		pgvector: {
+			...DEFAULT_VECTOR_CONFIG.pgvector,
+			...overrides.pgvector
+		}
+	};
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//#endregion
+export { DEFAULT_VECTOR_CONFIG, createVectorConfig };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/vector/embedding.d.ts

@@ -1,4 +1,4 @@
-import type { EmbeddingProvider, EmbeddingResult, ProgressCallback, VectorConfig, VectorInputType } from "./types";
+import { type EmbeddingProvider, type EmbeddingResult, type ProgressCallback, type VectorConfig, type VectorInputType } from "./types";
 /**
  * 임베딩 클라이언트
  * Voyage AI와 OpenAI 임베딩을 SDK 방식으로 통합 지원

package/dist/vector/embedding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/vector/embedding.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,eAAe,EAChB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAU9C;;OAEG;YACW,eAAe;IAS7B;;OAEG;YACW,iBAAiB;IAS/B;;;;;;OAMG;IACG,KAAK,CACT,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,EACvC,UAAU,CAAC,EAAE,gBAAgB,GAC5B,OAAO,CAAC,eAAe,EAAE,CAAC;IA0B7B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,GACtC,OAAO,CAAC,eAAe,CAAC;IAK3B;;OAEG;YACW,WAAW;IAuBzB;;OAEG;YACW,WAAW;IAiBzB;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;CAGnD;AACD,eAAO,MAAM,SAAS,gBAAuB,CAAC"}
+{"version":3,"file":"embedding.d.ts","sourceRoot":"","sources":["../../src/vector/embedding.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,eAAe,EACrB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,MAAM,CAAe;gBAEjB,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM;IAU9C;;OAEG;YACW,eAAe;IAS7B;;OAEG;YACW,iBAAiB;IAS/B;;;;;;OAMG;IACG,KAAK,CACT,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,EACvC,UAAU,CAAC,EAAE,gBAAgB,GAC5B,OAAO,CAAC,eAAe,EAAE,CAAC;IA0B7B;;OAEG;IACG,QAAQ,CACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,GAAE,eAA4B,GACtC,OAAO,CAAC,eAAe,CAAC;IAK3B;;OAEG;YACW,WAAW;IAuBzB;;OAEG;YACW,WAAW;IAiBzB;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM;CAGnD;AACD,eAAO,MAAM,SAAS,gBAAuB,CAAC"}