@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/language-detector.js

@@ -0,0 +1,16 @@
+import { franc } from "franc-min";
+import { iso6393, iso6393To1 } from "iso-639-3";
+export function detectLanguage(text) {
+    if (!text || text.trim().length === 0) {
+        return "en";
+    }
+    const detected = franc(text, { minLength: 10 });
+    if (detected === "und") {
+        return "en";
+    }
+    return iso6393To1[detected] || "en";
+}
+export function getLanguageName(code) {
+    const lang = iso6393.find((l) => l.iso6391 === code);
+    return lang?.name || "English";
+}

package/dist/services/logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(message: string, data?: unknown): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/services/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/services/logger.ts"],"names":[],"mappings":"AAqDA,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,QAQlD"}

package/dist/services/logger.js

@@ -0,0 +1,51 @@
+import { appendFileSync, writeFileSync, existsSync, mkdirSync, statSync, renameSync, unlinkSync, } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getLogFilePath() {
+    return process.env.OPENCODE_MEM_LOG_FILE || join(homedir(), ".opencode-mem", "opencode-mem.log");
+}
+function getLogDirPath() {
+    const logFile = getLogFilePath();
+    const lastSlash = Math.max(logFile.lastIndexOf("/"), logFile.lastIndexOf("\\"));
+    return lastSlash === -1 ? "." : logFile.slice(0, lastSlash);
+}
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+const GLOBAL_LOGGER_KEY = Symbol.for("opencode-mem.logger.initialized");
+function rotateLog() {
+    const logFile = getLogFilePath();
+    try {
+        if (!existsSync(logFile))
+            return;
+        const stats = statSync(logFile);
+        if (stats.size < MAX_LOG_SIZE)
+            return;
+        const oldLog = logFile + ".old";
+        if (existsSync(oldLog))
+            unlinkSync(oldLog);
+        renameSync(logFile, oldLog);
+    }
+    catch { }
+}
+function ensureLoggerInitialized() {
+    if (globalThis[GLOBAL_LOGGER_KEY])
+        return;
+    const logDir = getLogDirPath();
+    const logFile = getLogFilePath();
+    if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+    }
+    rotateLog();
+    writeFileSync(logFile, `\n--- Session started: ${new Date().toISOString()} ---\n`, {
+        flag: "a",
+    });
+    globalThis[GLOBAL_LOGGER_KEY] = true;
+}
+export function log(message, data) {
+    ensureLoggerInitialized();
+    const logFile = getLogFilePath();
+    const timestamp = new Date().toISOString();
+    const line = data
+        ? `[${timestamp}] ${message}: ${JSON.stringify(data)}\n`
+        : `[${timestamp}] ${message}\n`;
+    appendFileSync(logFile, line);
+}

package/dist/services/migration-service.d.ts

@@ -0,0 +1,42 @@
+export interface DimensionMismatch {
+    needsMigration: boolean;
+    configDimensions: number;
+    configModel: string;
+    shardMismatches: Array<{
+        shardId: number;
+        dbPath: string;
+        storedDimensions: number;
+        storedModel: string;
+        vectorCount: number;
+    }>;
+}
+export interface MigrationProgress {
+    phase: "preparing" | "re-embedding" | "cleanup" | "complete";
+    processed: number;
+    total: number;
+    currentShard?: string;
+}
+export interface MigrationResult {
+    success: boolean;
+    strategy: "fresh-start" | "re-embed";
+    deletedShards: number;
+    reEmbeddedMemories: number;
+    duration: number;
+    error?: string;
+}
+export declare class MigrationService {
+    private isRunning;
+    private progressCallback?;
+    detectDimensionMismatch(): Promise<DimensionMismatch>;
+    migrateToNewModel(strategy: "fresh-start" | "re-embed", progressCallback?: (progress: MigrationProgress) => void): Promise<MigrationResult>;
+    private freshStartMigration;
+    private reEmbedMigration;
+    private reportProgress;
+    getStatus(): {
+        isRunning: boolean;
+        configModel: string;
+        configDimensions: number;
+    };
+}
+export declare const migrationService: MigrationService;
+//# sourceMappingURL=migration-service.d.ts.map

package/dist/services/migration-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-service.d.ts","sourceRoot":"","sources":["../../src/services/migration-service.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,aAAa,GAAG,UAAU,CAAC;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,gBAAgB,CAAC,CAAwC;IAE3D,uBAAuB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAoDrD,iBAAiB,CACrB,QAAQ,EAAE,aAAa,GAAG,UAAU,EACpC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,GACvD,OAAO,CAAC,eAAe,CAAC;YA2Cb,mBAAmB;YA8CnB,gBAAgB;IA+I9B,OAAO,CAAC,cAAc;IAMtB,SAAS;;;;;CAOV;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/services/migration-service.js

@@ -0,0 +1,250 @@
+import { shardManager } from "./sqlite/shard-manager.js";
+import { connectionManager } from "./sqlite/connection-manager.js";
+import { vectorSearch } from "./sqlite/vector-search.js";
+import { embeddingService } from "./embedding.js";
+import { CONFIG } from "../config.js";
+import { log } from "./logger.js";
+export class MigrationService {
+    isRunning = false;
+    progressCallback;
+    async detectDimensionMismatch() {
+        const userShards = shardManager.getAllShards("user", "");
+        const projectShards = shardManager.getAllShards("project", "");
+        const allShards = [...userShards, ...projectShards];
+        const mismatches = [];
+        for (const shard of allShards) {
+            try {
+                const db = connectionManager.getConnection(shard.dbPath);
+                const metadataResult = db
+                    .prepare(`
+          SELECT key, value FROM shard_metadata 
+          WHERE key IN ('embedding_dimensions', 'embedding_model')
+        `)
+                    .all();
+                const metadata = Object.fromEntries(metadataResult.map((row) => [row.key, row.value]));
+                const storedDimensions = parseInt(metadata.embedding_dimensions || "0");
+                const storedModel = metadata.embedding_model || "unknown";
+                if (storedDimensions !== CONFIG.embeddingDimensions) {
+                    const vectorCount = vectorSearch.countAllVectors(db);
+                    mismatches.push({
+                        shardId: shard.id,
+                        dbPath: shard.dbPath,
+                        storedDimensions,
+                        storedModel,
+                        vectorCount,
+                    });
+                }
+            }
+            catch (error) {
+                log("Migration: error checking shard", {
+                    shardId: shard.id,
+                    error: String(error),
+                });
+            }
+        }
+        return {
+            needsMigration: mismatches.length > 0,
+            configDimensions: CONFIG.embeddingDimensions,
+            configModel: CONFIG.embeddingModel,
+            shardMismatches: mismatches,
+        };
+    }
+    async migrateToNewModel(strategy, progressCallback) {
+        if (this.isRunning) {
+            throw new Error("Migration already running");
+        }
+        this.isRunning = true;
+        this.progressCallback = progressCallback;
+        const startTime = Date.now();
+        try {
+            const mismatch = await this.detectDimensionMismatch();
+            if (!mismatch.needsMigration) {
+                return {
+                    success: true,
+                    strategy,
+                    deletedShards: 0,
+                    reEmbeddedMemories: 0,
+                    duration: Date.now() - startTime,
+                };
+            }
+            if (strategy === "fresh-start") {
+                return await this.freshStartMigration(mismatch, startTime);
+            }
+            else {
+                return await this.reEmbedMigration(mismatch, startTime);
+            }
+        }
+        catch (error) {
+            log("Migration: failed", { error: String(error) });
+            return {
+                success: false,
+                strategy,
+                deletedShards: 0,
+                reEmbeddedMemories: 0,
+                duration: Date.now() - startTime,
+                error: String(error),
+            };
+        }
+        finally {
+            this.isRunning = false;
+            this.progressCallback = undefined;
+        }
+    }
+    async freshStartMigration(mismatch, startTime) {
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: mismatch.shardMismatches.length,
+        });
+        let deletedShards = 0;
+        for (const [index, shardInfo] of mismatch.shardMismatches.entries()) {
+            try {
+                this.reportProgress({
+                    phase: "cleanup",
+                    processed: index,
+                    total: mismatch.shardMismatches.length,
+                    currentShard: String(shardInfo.shardId),
+                });
+                await shardManager.deleteShard(shardInfo.shardId);
+                deletedShards++;
+            }
+            catch (error) {
+                log("Migration: error deleting shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: mismatch.shardMismatches.length,
+            total: mismatch.shardMismatches.length,
+        });
+        return {
+            success: true,
+            strategy: "fresh-start",
+            deletedShards,
+            reEmbeddedMemories: 0,
+            duration: Date.now() - startTime,
+        };
+    }
+    async reEmbedMigration(mismatch, startTime) {
+        await embeddingService.warmup();
+        embeddingService.clearCache();
+        const totalMemories = mismatch.shardMismatches.reduce((sum, s) => sum + s.vectorCount, 0);
+        this.reportProgress({
+            phase: "preparing",
+            processed: 0,
+            total: totalMemories,
+        });
+        let reEmbeddedCount = 0;
+        let processedCount = 0;
+        for (const shardInfo of mismatch.shardMismatches) {
+            this.reportProgress({
+                phase: "re-embedding",
+                processed: processedCount,
+                total: totalMemories,
+                currentShard: String(shardInfo.shardId),
+            });
+            try {
+                const db = connectionManager.getConnection(shardInfo.dbPath);
+                const memories = vectorSearch.getAllMemories(db);
+                const tempMemories = [];
+                for (const memory of memories) {
+                    tempMemories.push({
+                        id: memory.id,
+                        content: memory.content,
+                        containerTag: memory.container_tag,
+                        type: memory.type,
+                        createdAt: memory.created_at,
+                        updatedAt: memory.updated_at,
+                        metadata: memory.metadata,
+                        displayName: memory.display_name,
+                        userName: memory.user_name,
+                        userEmail: memory.user_email,
+                        projectPath: memory.project_path,
+                        projectName: memory.project_name,
+                        gitRepoUrl: memory.git_repo_url,
+                        isPinned: memory.is_pinned || 0,
+                    });
+                }
+                await shardManager.deleteShard(shardInfo.shardId);
+                for (const memory of tempMemories) {
+                    try {
+                        const vector = await embeddingService.embedWithTimeout(memory.content);
+                        const scope = memory.containerTag.includes("_user_") ? "user" : "project";
+                        const hash = memory.containerTag.split("_").slice(2).join("_");
+                        const newShard = shardManager.getWriteShard(scope, hash);
+                        const newDb = connectionManager.getConnection(newShard.dbPath);
+                        await vectorSearch.insertVector(newDb, {
+                            id: memory.id,
+                            content: memory.content,
+                            vector,
+                            containerTag: memory.containerTag,
+                            type: memory.type || undefined,
+                            createdAt: memory.createdAt,
+                            updatedAt: memory.updatedAt,
+                            metadata: memory.metadata || undefined,
+                            displayName: memory.displayName || undefined,
+                            userName: memory.userName || undefined,
+                            userEmail: memory.userEmail || undefined,
+                            projectPath: memory.projectPath || undefined,
+                            projectName: memory.projectName || undefined,
+                            gitRepoUrl: memory.gitRepoUrl || undefined,
+                        }, newShard);
+                        if (memory.isPinned === 1) {
+                            vectorSearch.pinMemory(newDb, memory.id);
+                        }
+                        shardManager.incrementVectorCount(newShard.id);
+                        reEmbeddedCount++;
+                        processedCount++;
+                        this.reportProgress({
+                            phase: "re-embedding",
+                            processed: processedCount,
+                            total: totalMemories,
+                            currentShard: String(shardInfo.shardId),
+                        });
+                    }
+                    catch (error) {
+                        log("Migration: error re-embedding memory", {
+                            memoryId: memory.id,
+                            error: String(error),
+                        });
+                        processedCount++;
+                    }
+                }
+            }
+            catch (error) {
+                log("Migration: error processing shard", {
+                    shardId: shardInfo.shardId,
+                    error: String(error),
+                });
+            }
+        }
+        this.reportProgress({
+            phase: "complete",
+            processed: totalMemories,
+            total: totalMemories,
+        });
+        return {
+            success: true,
+            strategy: "re-embed",
+            deletedShards: mismatch.shardMismatches.length,
+            reEmbeddedMemories: reEmbeddedCount,
+            duration: Date.now() - startTime,
+        };
+    }
+    reportProgress(progress) {
+        if (this.progressCallback) {
+            this.progressCallback(progress);
+        }
+    }
+    getStatus() {
+        return {
+            isRunning: this.isRunning,
+            configModel: CONFIG.embeddingModel,
+            configDimensions: CONFIG.embeddingDimensions,
+        };
+    }
+}
+export const migrationService = new MigrationService();

package/dist/services/privacy.d.ts

@@ -0,0 +1,3 @@
+export declare function stripPrivateContent(content: string): string;
+export declare function isFullyPrivate(content: string): boolean;
+//# sourceMappingURL=privacy.d.ts.map

package/dist/services/privacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy.d.ts","sourceRoot":"","sources":["../../src/services/privacy.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGvD"}

package/dist/services/privacy.js

@@ -0,0 +1,7 @@
+export function stripPrivateContent(content) {
+    return content.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]");
+}
+export function isFullyPrivate(content) {
+    const stripped = stripPrivateContent(content).trim();
+    return stripped === "[REDACTED]" || stripped === "";
+}

package/dist/services/secret-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveSecretValue(value: string | undefined): string | undefined;
+//# sourceMappingURL=secret-resolver.d.ts.map

package/dist/services/secret-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-resolver.d.ts","sourceRoot":"","sources":["../../src/services/secret-resolver.ts"],"names":[],"mappings":"AAiCA,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAkChF"}

package/dist/services/secret-resolver.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+function expandPath(path) {
+    if (path.startsWith("~/")) {
+        return join(homedir(), path.slice(2));
+    }
+    if (path === "~") {
+        return homedir();
+    }
+    return path;
+}
+function checkFilePermissions(filePath) {
+    if (platform() === "win32") {
+        return;
+    }
+    try {
+        const stats = statSync(filePath);
+        const mode = stats.mode & 0o777;
+        if (mode > 0o600) {
+            console.warn(`Warning: Secret file ${filePath} has permissive permissions (${mode.toString(8)}). Recommend chmod 600.`);
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not check file permissions for ${filePath}`);
+    }
+}
+export function resolveSecretValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (value.startsWith("file://")) {
+        const filePath = expandPath(value.slice(7));
+        if (!existsSync(filePath)) {
+            throw new Error(`Secret file not found: ${filePath}`);
+        }
+        try {
+            checkFilePermissions(filePath);
+            const content = readFileSync(filePath, "utf-8");
+            return content.trim();
+        }
+        catch (error) {
+            throw new Error(`Failed to read secret file ${filePath}: ${error}`);
+        }
+    }
+    if (value.startsWith("env://")) {
+        const envVar = value.slice(6);
+        const envValue = process.env[envVar];
+        if (!envValue) {
+            throw new Error(`Environment variable not found: ${envVar}`);
+        }
+        return envValue;
+    }
+    return value;
+}

package/dist/services/sqlite/connection-manager.d.ts

@@ -0,0 +1,13 @@
+declare const Database: typeof import("bun:sqlite").Database;
+export declare class ConnectionManager {
+    private connections;
+    private initDatabase;
+    private migrateSchema;
+    getConnection(dbPath: string): typeof Database.prototype;
+    closeConnection(dbPath: string): void;
+    closeAll(): void;
+    checkpointAll(): void;
+}
+export declare const connectionManager: ConnectionManager;
+export {};
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/services/sqlite/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/connection-manager.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,QAAQ,sCAAgB,CAAC;AAE/B,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAqD;IAExE,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,aAAa;IAarB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,QAAQ,CAAC,SAAS;IAiBxD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASrC,QAAQ,IAAI,IAAI;IAYhB,aAAa,IAAI,IAAI;CAStB;AAED,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/services/sqlite/connection-manager.js

@@ -0,0 +1,74 @@
+import { getDatabase } from "./sqlite-bootstrap.js";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { log } from "../logger.js";
+import { CONFIG } from "../../config.js";
+const Database = getDatabase();
+export class ConnectionManager {
+    connections = new Map();
+    initDatabase(db) {
+        db.run("PRAGMA busy_timeout = 5000");
+        db.run("PRAGMA journal_mode = WAL");
+        db.run("PRAGMA synchronous = NORMAL");
+        db.run("PRAGMA cache_size = -64000");
+        db.run("PRAGMA temp_store = MEMORY");
+        db.run("PRAGMA foreign_keys = ON");
+        this.migrateSchema(db);
+    }
+    migrateSchema(db) {
+        try {
+            const columns = db.prepare("PRAGMA table_info(memories)").all();
+            const hasTags = columns.some((c) => c.name === "tags");
+            if (!hasTags && columns.length > 0) {
+                db.run("ALTER TABLE memories ADD COLUMN tags TEXT");
+            }
+        }
+        catch (error) {
+            log("Schema migration error", { error: String(error) });
+        }
+    }
+    getConnection(dbPath) {
+        if (this.connections.has(dbPath)) {
+            return this.connections.get(dbPath);
+        }
+        const dir = dirname(dbPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const db = new Database(dbPath);
+        this.initDatabase(db);
+        this.connections.set(dbPath, db);
+        return db;
+    }
+    closeConnection(dbPath) {
+        const db = this.connections.get(dbPath);
+        if (db) {
+            db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+            db.close();
+            this.connections.delete(dbPath);
+        }
+    }
+    closeAll() {
+        for (const [path, db] of this.connections) {
+            try {
+                db.run("PRAGMA wal_checkpoint(TRUNCATE)");
+                db.close();
+            }
+            catch (error) {
+                log("Error closing database", { path, error: String(error) });
+            }
+        }
+        this.connections.clear();
+    }
+    checkpointAll() {
+        for (const [path, db] of this.connections) {
+            try {
+                db.run("PRAGMA wal_checkpoint(PASSIVE)");
+            }
+            catch (error) {
+                log("Error checkpointing database", { path, error: String(error) });
+            }
+        }
+    }
+}
+export const connectionManager = new ConnectionManager();

package/dist/services/sqlite/shard-manager.d.ts

@@ -0,0 +1,23 @@
+import type { ShardInfo } from "./types.js";
+export declare class ShardManager {
+    private metadataDb;
+    private metadataPath;
+    constructor();
+    private initMetadataDb;
+    private getShardPath;
+    private resolveStoredPath;
+    getActiveShard(scope: "user" | "project", scopeHash: string): ShardInfo | null;
+    getAllShards(scope: "user" | "project", scopeHash: string): ShardInfo[];
+    createShard(scope: "user" | "project", scopeHash: string, shardIndex: number): ShardInfo;
+    private initShardDb;
+    private isShardValid;
+    private ensureShardTables;
+    getWriteShard(scope: "user" | "project", scopeHash: string): ShardInfo;
+    private markShardReadOnly;
+    incrementVectorCount(shardId: number): void;
+    decrementVectorCount(shardId: number): void;
+    getShardByPath(dbPath: string): ShardInfo | null;
+    deleteShard(shardId: number): Promise<void>;
+}
+export declare const shardManager: ShardManager;
+//# sourceMappingURL=shard-manager.d.ts.map

package/dist/services/sqlite/shard-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shard-manager.d.ts","sourceRoot":"","sources":["../../../src/services/sqlite/shard-manager.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,YAAY,CAAS;;IAQ7B,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,iBAAiB;IAKzB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAsB9E,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE;IAgCvE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS;IA2BxF,OAAO,CAAC,WAAW;IA8CnB,OAAO,CAAC,YAAY;IA4BpB,OAAO,CAAC,iBAAiB;IAYzB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS;IA+BtE,OAAO,CAAC,iBAAiB;IAOzB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO3C,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAkB1C,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAkClD;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC"}