@aigne/afs-index 1.12.0-beta.5

package/dist/backend/memory-backend.cjs

@@ -0,0 +1,304 @@
+const require_registry = require('../keys/registry.cjs');
+
+//#region src/backend/memory-backend.ts
+/**
+* MemoryIndexBackend — zero-dependency in-memory backend for the Index Provider.
+*
+* Uses plain Maps for storage and simple word matching for FTS.
+* Suitable for testing and small data sets.
+*/
+var MemoryIndexBackend = class {
+	entries = /* @__PURE__ */ new Map();
+	anchorData = /* @__PURE__ */ new Map();
+	anchorKeys = /* @__PURE__ */ new Map();
+	summaries = /* @__PURE__ */ new Map();
+	embeddings = /* @__PURE__ */ new Map();
+	keyRegistry;
+	constructor(keyRegistry) {
+		this.keyRegistry = keyRegistry ?? new require_registry.KeyGeneratorRegistry();
+	}
+	/** See `IndexBackend.setKeyRegistry` — wires an injected backend to the provider's shared registry. */
+	setKeyRegistry(registry) {
+		this.keyRegistry = registry;
+	}
+	async initialize() {}
+	async close() {
+		this.entries.clear();
+		this.anchorData.clear();
+		this.anchorKeys.clear();
+		this.summaries.clear();
+		this.embeddings.clear();
+	}
+	async writeEntry(entry) {
+		this.entries.set(entry.entryPath, { ...entry });
+	}
+	async getEntry(path) {
+		return this.entries.get(path) ?? null;
+	}
+	async removeEntry(path) {
+		this.entries.delete(path);
+	}
+	async listEntries(filter) {
+		return Array.from(this.entries.values()).filter((e) => {
+			if (filter.domain && e.domain !== filter.domain) return false;
+			if (filter.state && e.state !== filter.state) return false;
+			if (filter.extractorId && e.extractorId !== filter.extractorId) return false;
+			if (filter.scope && !e.entryPath.startsWith(filter.scope)) return false;
+			if (filter.boundDomains && filter.boundDomains.length > 0) {
+				if (!filter.boundDomains.includes(e.domain)) return false;
+			}
+			return true;
+		});
+	}
+	async markStale(filter) {
+		let count = 0;
+		for (const entry of this.entries.values()) {
+			if (entry.state !== "active") continue;
+			if (filter.domain && entry.domain !== filter.domain) continue;
+			if (filter.extractorId && entry.extractorId !== filter.extractorId) continue;
+			if (filter.scope && !entry.entryPath.startsWith(filter.scope)) continue;
+			if (filter.boundDomains && filter.boundDomains.length > 0 && !filter.boundDomains.includes(entry.domain)) continue;
+			if (filter.anchorType) {
+				if (!(this.anchorData.get(entry.entryPath) ?? []).some((a) => a.type === filter.anchorType)) continue;
+			}
+			entry.state = "stale";
+			count++;
+		}
+		return count;
+	}
+	async countEntries(filter) {
+		return (await this.listEntries(filter)).length;
+	}
+	async writeAnchors(path, anchors) {
+		this.anchorData.set(path, anchors.map((a) => ({ ...a })));
+		for (const [key, entries] of this.anchorKeys) {
+			entries.delete(path);
+			if (entries.size === 0) this.anchorKeys.delete(key);
+		}
+		for (const anchor of anchors) {
+			const keys = this.keyRegistry.generateKeys(anchor);
+			for (const key of keys) {
+				if (!this.anchorKeys.has(key)) this.anchorKeys.set(key, /* @__PURE__ */ new Map());
+				this.anchorKeys.get(key).set(path, anchor.confidence);
+			}
+		}
+	}
+	async queryAnchors(query) {
+		if (query.keys.length === 0) return [];
+		const domainsSet = query.domains && query.domains.length > 0 ? new Set(query.domains) : null;
+		const groups = query.keys.map((kg) => {
+			const matches = /* @__PURE__ */ new Map();
+			for (const rawValue of kg.values) {
+				const candidates = new Set([rawValue]);
+				const synthetic = {
+					type: kg.type ?? "exact",
+					values: [rawValue],
+					confidence: 1
+				};
+				for (const k of this.keyRegistry.generateKeys(synthetic)) candidates.add(k);
+				for (const key of candidates) {
+					const entries = this.anchorKeys.get(key);
+					if (!entries) continue;
+					for (const [path, conf] of entries) {
+						if (query.scope && !path.startsWith(query.scope)) continue;
+						if (query.pathPrefix && !path.startsWith(query.pathPrefix)) continue;
+						if (domainsSet) {
+							const entry = this.entries.get(path);
+							if (!entry || !domainsSet.has(entry.domain)) continue;
+						}
+						if (query.minConfidence != null && conf < query.minConfidence) continue;
+						const current = matches.get(path);
+						matches.set(path, current != null ? Math.min(current, conf) : conf);
+					}
+				}
+			}
+			return matches;
+		});
+		if (groups.length === 0) return [];
+		let result = new Map(groups[0]);
+		for (let i = 1; i < groups.length; i++) {
+			const next = /* @__PURE__ */ new Map();
+			for (const [path, score] of result) {
+				const otherScore = groups[i].get(path);
+				if (otherScore != null) next.set(path, Math.min(score, otherScore));
+			}
+			result = next;
+		}
+		let results = Array.from(result).map(([entryPath, score]) => ({
+			entryPath,
+			score
+		}));
+		if (query.metaFilter && Object.keys(query.metaFilter).length > 0) results = results.filter((r) => {
+			return matchesMeta(this.entries.get(r.entryPath)?.meta, query.metaFilter);
+		});
+		results.sort((a, b) => b.score - a.score);
+		if (query.limit) results = results.slice(0, query.limit);
+		return results;
+	}
+	async removeAnchors(path) {
+		this.anchorData.delete(path);
+		for (const [key, entries] of this.anchorKeys) {
+			entries.delete(path);
+			if (entries.size === 0) this.anchorKeys.delete(key);
+		}
+	}
+	async getAnchorData(path) {
+		return (this.anchorData.get(path) ?? []).map((a) => ({
+			entryPath: path,
+			anchorType: a.type,
+			confidence: a.confidence,
+			rawAnchor: JSON.stringify(a)
+		}));
+	}
+	async writeSummary(path, summary) {
+		this.summaries.set(path, summary);
+	}
+	async getSummary(path) {
+		return this.summaries.get(path) ?? null;
+	}
+	async queryFTS(text, limit, metaFilter, opts) {
+		const isOr = /\bOR\b/.test(text);
+		const terms = text.toLowerCase().split(/\s+/).filter((t) => t.length > 0 && t !== "or");
+		if (terms.length === 0) return [];
+		const results = [];
+		for (const [path, summary] of this.summaries) {
+			const entry = this.entries.get(path);
+			if (opts?.domain && entry?.domain !== opts.domain) continue;
+			if (opts?.domains && opts.domains.length > 0 && (!entry || !opts.domains.includes(entry.domain))) continue;
+			if (opts?.scope && !path.startsWith(opts.scope)) continue;
+			if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;
+			const lowerSummary = summary.toLowerCase();
+			const matchCount = terms.filter((t) => lowerSummary.includes(t)).length;
+			if (isOr ? matchCount > 0 : matchCount === terms.length) {
+				if (metaFilter && Object.keys(metaFilter).length > 0) {
+					if (!matchesMeta(entry?.meta, metaFilter)) continue;
+				}
+				results.push({
+					entryPath: path,
+					rank: matchCount / terms.length
+				});
+			}
+		}
+		results.sort((a, b) => b.rank - a.rank);
+		if (limit != null) return results.slice(0, limit);
+		return results;
+	}
+	async removeSummary(path) {
+		this.summaries.delete(path);
+	}
+	async writeEmbedding(path, embedding) {
+		this.embeddings.set(path, [...embedding]);
+	}
+	async queryVector(embedding, limit, opts) {
+		const results = [];
+		for (const [path, stored] of this.embeddings) {
+			const entry = this.entries.get(path);
+			if (!entry) continue;
+			if (opts?.domain && entry.domain !== opts.domain) continue;
+			if (opts?.domains && opts.domains.length > 0 && !opts.domains.includes(entry.domain)) continue;
+			if (opts?.scope && !path.startsWith(opts.scope)) continue;
+			if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;
+			const similarity = cosineSimilarity(embedding, stored);
+			results.push({
+				entryPath: path,
+				similarity
+			});
+		}
+		results.sort((a, b) => b.similarity - a.similarity);
+		if (limit != null) return results.slice(0, limit);
+		return results;
+	}
+	async removeEmbedding(path) {
+		this.embeddings.delete(path);
+	}
+	embeddingCapability() {
+		return {
+			supported: true,
+			dimension: 0
+		};
+	}
+	async writeEntriesBatch(entries) {
+		for (const entry of entries) await this.writeEntry(entry);
+	}
+	async writeAnchorsBatch(items) {
+		for (const item of items) await this.writeAnchors(item.path, item.anchors);
+	}
+	async writeSummariesBatch(items) {
+		for (const item of items) await this.writeSummary(item.path, item.summary);
+	}
+	async purgeEntries(paths, opts) {
+		const skipVector = opts?.skipVector === true;
+		let count = 0;
+		for (const path of paths) if (this.entries.has(path)) {
+			await this.removeAnchors(path);
+			this.summaries.delete(path);
+			if (!skipVector) this.embeddings.delete(path);
+			this.entries.delete(path);
+			count++;
+		}
+		return count;
+	}
+	async queryCombined(keys, text, opts) {
+		const anchorResults = keys.length > 0 ? await this.queryAnchors({
+			keys,
+			scope: opts?.scope,
+			minConfidence: opts?.minConfidence,
+			limit: opts?.limit
+		}) : [];
+		const anchorPaths = new Set(anchorResults.map((r) => r.entryPath));
+		const ftsResults = text ? await this.queryFTS(text, opts?.limit) : [];
+		const results = anchorResults.map((r) => {
+			const fts = ftsResults.find((f) => f.entryPath === r.entryPath);
+			return {
+				entryPath: r.entryPath,
+				anchorScore: r.score,
+				ftsRank: fts?.rank,
+				score: r.score + (fts?.rank ?? 0)
+			};
+		});
+		for (const f of ftsResults) if (!anchorPaths.has(f.entryPath)) results.push({
+			entryPath: f.entryPath,
+			ftsRank: f.rank,
+			score: f.rank
+		});
+		results.sort((a, b) => b.score - a.score);
+		if (opts?.limit != null) return results.slice(0, opts.limit);
+		return results;
+	}
+};
+/**
+* Check if an entry's meta matches the given filter.
+* Each field in metaFilter is AND-ed. Array values are OR-ed within a field.
+*
+* NOTE: Uses strict equality (===) for value comparison. This works correctly
+* for primitive values (string, number, boolean, null). Nested objects or arrays
+* as meta values would need deep comparison to match correctly.
+*/
+function matchesMeta(meta, filter) {
+	if (!meta) return false;
+	for (const [key, expected] of Object.entries(filter)) {
+		const actual = meta[key];
+		if (Array.isArray(expected)) {
+			if (expected.length === 0) return false;
+			if (!expected.includes(actual)) return false;
+		} else if (actual !== expected) return false;
+	}
+	return true;
+}
+/** Cosine similarity between two vectors. Returns 0 for zero-length vectors. */
+function cosineSimilarity(a, b) {
+	const len = Math.min(a.length, b.length);
+	let dot = 0;
+	let magA = 0;
+	let magB = 0;
+	for (let i = 0; i < len; i++) {
+		dot += a[i] * b[i];
+		magA += a[i] * a[i];
+		magB += b[i] * b[i];
+	}
+	const denom = Math.sqrt(magA) * Math.sqrt(magB);
+	return denom === 0 ? 0 : dot / denom;
+}
+
+//#endregion
+exports.MemoryIndexBackend = MemoryIndexBackend;

package/dist/backend/memory-backend.d.cts

@@ -0,0 +1,66 @@
+import { IndexBackend, RemoveIndexOptions } from "./types.cjs";
+import { Anchor, AnchorData, AnchorQuery, AnchorResult, CombinedResult, EntryFilter, FTSResult, IndexedEntry, QueryOpts, StaleFilter, VectorResult } from "../types.cjs";
+import { KeyGeneratorRegistry } from "../keys/registry.cjs";
+
+//#region src/backend/memory-backend.d.ts
+declare class MemoryIndexBackend implements IndexBackend {
+  private entries;
+  private anchorData;
+  private anchorKeys;
+  private summaries;
+  private embeddings;
+  private keyRegistry;
+  constructor(keyRegistry?: KeyGeneratorRegistry);
+  /** See `IndexBackend.setKeyRegistry` — wires an injected backend to the provider's shared registry. */
+  setKeyRegistry(registry: KeyGeneratorRegistry): void;
+  initialize(): Promise<void>;
+  close(): Promise<void>;
+  writeEntry(entry: IndexedEntry): Promise<void>;
+  getEntry(path: string): Promise<IndexedEntry | null>;
+  removeEntry(path: string): Promise<void>;
+  listEntries(filter: EntryFilter): Promise<IndexedEntry[]>;
+  markStale(filter: StaleFilter): Promise<number>;
+  countEntries(filter: EntryFilter): Promise<number>;
+  writeAnchors(path: string, anchors: Anchor[]): Promise<void>;
+  queryAnchors(query: AnchorQuery): Promise<AnchorResult[]>;
+  removeAnchors(path: string): Promise<void>;
+  getAnchorData(path: string): Promise<AnchorData[]>;
+  writeSummary(path: string, summary: string): Promise<void>;
+  getSummary(path: string): Promise<string | null>;
+  queryFTS(text: string, limit?: number, metaFilter?: Record<string, unknown>, opts?: {
+    domain?: string;
+    domains?: string[];
+    scope?: string;
+    pathPrefix?: string;
+  }): Promise<FTSResult[]>;
+  removeSummary(path: string): Promise<void>;
+  writeEmbedding(path: string, embedding: number[]): Promise<void>;
+  queryVector(embedding: number[], limit?: number, opts?: {
+    domain?: string;
+    domains?: string[];
+    scope?: string;
+    pathPrefix?: string;
+  }): Promise<VectorResult[]>;
+  removeEmbedding(path: string): Promise<void>;
+  embeddingCapability(): {
+    supported: boolean;
+    dimension: number;
+  };
+  writeEntriesBatch(entries: IndexedEntry[]): Promise<void>;
+  writeAnchorsBatch(items: {
+    path: string;
+    anchors: Anchor[];
+  }[]): Promise<void>;
+  writeSummariesBatch(items: {
+    path: string;
+    summary: string;
+  }[]): Promise<void>;
+  purgeEntries(paths: string[], opts?: RemoveIndexOptions): Promise<number>;
+  queryCombined(keys: {
+    type: string;
+    values: string[];
+  }[], text?: string, opts?: QueryOpts): Promise<CombinedResult[]>;
+}
+//#endregion
+export { MemoryIndexBackend };
+//# sourceMappingURL=memory-backend.d.cts.map

package/dist/backend/memory-backend.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-backend.d.cts","names":[],"sources":["../../src/backend/memory-backend.ts"],"mappings":";;;;;cAsBa,kBAAA,YAA8B,YAAA;EAAA,QACjC,OAAA;EAAA,QACA,UAAA;EAAA,QACA,UAAA;EAAA,QACA,SAAA;EAAA,QACA,UAAA;EAAA,QACA,WAAA;cAEI,WAAA,GAAc,oBAAA;EAmCA;EA9B1B,cAAA,CAAe,QAAA,EAAU,oBAAA;EAInB,UAAA,CAAA,GAAc,OAAA;EAId,KAAA,CAAA,GAAS,OAAA;EAUT,UAAA,CAAW,KAAA,EAAO,YAAA,GAAe,OAAA;EAIjC,QAAA,CAAS,IAAA,WAAe,OAAA,CAAQ,YAAA;EAIhC,WAAA,CAAY,IAAA,WAAe,OAAA;EAI3B,WAAA,CAAY,MAAA,EAAQ,WAAA,GAAc,OAAA,CAAQ,YAAA;EAgB1C,SAAA,CAAU,MAAA,EAAQ,WAAA,GAAc,OAAA;EAuBhC,YAAA,CAAa,MAAA,EAAQ,WAAA,GAAc,OAAA;EAMnC,YAAA,CAAa,IAAA,UAAc,OAAA,EAAS,MAAA,KAAW,OAAA;EAsB/C,YAAA,CAAa,KAAA,EAAO,WAAA,GAAc,OAAA,CAAQ,YAAA;EAqE1C,aAAA,CAAc,IAAA,WAAe,OAAA;EAQ7B,aAAA,CAAc,IAAA,WAAe,OAAA,CAAQ,UAAA;EAYrC,YAAA,CAAa,IAAA,UAAc,OAAA,WAAkB,OAAA;EAI7C,UAAA,CAAW,IAAA,WAAe,OAAA;EAI1B,QAAA,CACJ,IAAA,UACA,KAAA,WACA,UAAA,GAAa,MAAA,mBACb,IAAA;IAAS,MAAA;IAAiB,OAAA;IAAoB,KAAA;IAAgB,UAAA;EAAA,IAC7D,OAAA,CAAQ,SAAA;EA6CL,aAAA,CAAc,IAAA,WAAe,OAAA;EAM7B,cAAA,CAAe,IAAA,UAAc,SAAA,aAAsB,OAAA;EAInD,WAAA,CACJ,SAAA,YACA,KAAA,WACA,IAAA;IAAS,MAAA;IAAiB,OAAA;IAAoB,KAAA;IAAgB,UAAA;EAAA,IAC7D,OAAA,CAAQ,YAAA;EAsBL,eAAA,CAAgB,IAAA,WAAe,OAAA;EAIrC,mBAAA,CAAA;IAAyB,SAAA;IAAoB,SAAA;EAAA;EAMvC,iBAAA,CAAkB,OAAA,EAAS,YAAA,KAAiB,OAAA;EAM5C,iBAAA,CAAkB,KAAA;IAAS,IAAA;IAAc,OAAA,EAAS,MAAA;EAAA,MAAe,OAAA;EAMjE,mBAAA,CAAoB,KAAA;IAAS,IAAA;IAAc,OAAA;EAAA,MAAsB,OAAA;EAMjE,YAAA,CAAa,KAAA,YAAiB,IAAA,GAAO,kBAAA,GAAqB,OAAA;EAkB1D,aAAA,CACJ,IAAA;IAAQ,IAAA;IAAc,MAAA;EAAA,KACtB,IAAA,WACA,IAAA,GAAO,SAAA,GACN,OAAA,CAAQ,cAAA;AAAA"}

package/dist/backend/memory-backend.d.mts

@@ -0,0 +1,66 @@
+import { IndexBackend, RemoveIndexOptions } from "./types.mjs";
+import { Anchor, AnchorData, AnchorQuery, AnchorResult, CombinedResult, EntryFilter, FTSResult, IndexedEntry, QueryOpts, StaleFilter, VectorResult } from "../types.mjs";
+import { KeyGeneratorRegistry } from "../keys/registry.mjs";
+
+//#region src/backend/memory-backend.d.ts
+declare class MemoryIndexBackend implements IndexBackend {
+  private entries;
+  private anchorData;
+  private anchorKeys;
+  private summaries;
+  private embeddings;
+  private keyRegistry;
+  constructor(keyRegistry?: KeyGeneratorRegistry);
+  /** See `IndexBackend.setKeyRegistry` — wires an injected backend to the provider's shared registry. */
+  setKeyRegistry(registry: KeyGeneratorRegistry): void;
+  initialize(): Promise<void>;
+  close(): Promise<void>;
+  writeEntry(entry: IndexedEntry): Promise<void>;
+  getEntry(path: string): Promise<IndexedEntry | null>;
+  removeEntry(path: string): Promise<void>;
+  listEntries(filter: EntryFilter): Promise<IndexedEntry[]>;
+  markStale(filter: StaleFilter): Promise<number>;
+  countEntries(filter: EntryFilter): Promise<number>;
+  writeAnchors(path: string, anchors: Anchor[]): Promise<void>;
+  queryAnchors(query: AnchorQuery): Promise<AnchorResult[]>;
+  removeAnchors(path: string): Promise<void>;
+  getAnchorData(path: string): Promise<AnchorData[]>;
+  writeSummary(path: string, summary: string): Promise<void>;
+  getSummary(path: string): Promise<string | null>;
+  queryFTS(text: string, limit?: number, metaFilter?: Record<string, unknown>, opts?: {
+    domain?: string;
+    domains?: string[];
+    scope?: string;
+    pathPrefix?: string;
+  }): Promise<FTSResult[]>;
+  removeSummary(path: string): Promise<void>;
+  writeEmbedding(path: string, embedding: number[]): Promise<void>;
+  queryVector(embedding: number[], limit?: number, opts?: {
+    domain?: string;
+    domains?: string[];
+    scope?: string;
+    pathPrefix?: string;
+  }): Promise<VectorResult[]>;
+  removeEmbedding(path: string): Promise<void>;
+  embeddingCapability(): {
+    supported: boolean;
+    dimension: number;
+  };
+  writeEntriesBatch(entries: IndexedEntry[]): Promise<void>;
+  writeAnchorsBatch(items: {
+    path: string;
+    anchors: Anchor[];
+  }[]): Promise<void>;
+  writeSummariesBatch(items: {
+    path: string;
+    summary: string;
+  }[]): Promise<void>;
+  purgeEntries(paths: string[], opts?: RemoveIndexOptions): Promise<number>;
+  queryCombined(keys: {
+    type: string;
+    values: string[];
+  }[], text?: string, opts?: QueryOpts): Promise<CombinedResult[]>;
+}
+//#endregion
+export { MemoryIndexBackend };
+//# sourceMappingURL=memory-backend.d.mts.map

package/dist/backend/memory-backend.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-backend.d.mts","names":[],"sources":["../../src/backend/memory-backend.ts"],"mappings":";;;;;cAsBa,kBAAA,YAA8B,YAAA;EAAA,QACjC,OAAA;EAAA,QACA,UAAA;EAAA,QACA,UAAA;EAAA,QACA,SAAA;EAAA,QACA,UAAA;EAAA,QACA,WAAA;cAEI,WAAA,GAAc,oBAAA;EAmCA;EA9B1B,cAAA,CAAe,QAAA,EAAU,oBAAA;EAInB,UAAA,CAAA,GAAc,OAAA;EAId,KAAA,CAAA,GAAS,OAAA;EAUT,UAAA,CAAW,KAAA,EAAO,YAAA,GAAe,OAAA;EAIjC,QAAA,CAAS,IAAA,WAAe,OAAA,CAAQ,YAAA;EAIhC,WAAA,CAAY,IAAA,WAAe,OAAA;EAI3B,WAAA,CAAY,MAAA,EAAQ,WAAA,GAAc,OAAA,CAAQ,YAAA;EAgB1C,SAAA,CAAU,MAAA,EAAQ,WAAA,GAAc,OAAA;EAuBhC,YAAA,CAAa,MAAA,EAAQ,WAAA,GAAc,OAAA;EAMnC,YAAA,CAAa,IAAA,UAAc,OAAA,EAAS,MAAA,KAAW,OAAA;EAsB/C,YAAA,CAAa,KAAA,EAAO,WAAA,GAAc,OAAA,CAAQ,YAAA;EAqE1C,aAAA,CAAc,IAAA,WAAe,OAAA;EAQ7B,aAAA,CAAc,IAAA,WAAe,OAAA,CAAQ,UAAA;EAYrC,YAAA,CAAa,IAAA,UAAc,OAAA,WAAkB,OAAA;EAI7C,UAAA,CAAW,IAAA,WAAe,OAAA;EAI1B,QAAA,CACJ,IAAA,UACA,KAAA,WACA,UAAA,GAAa,MAAA,mBACb,IAAA;IAAS,MAAA;IAAiB,OAAA;IAAoB,KAAA;IAAgB,UAAA;EAAA,IAC7D,OAAA,CAAQ,SAAA;EA6CL,aAAA,CAAc,IAAA,WAAe,OAAA;EAM7B,cAAA,CAAe,IAAA,UAAc,SAAA,aAAsB,OAAA;EAInD,WAAA,CACJ,SAAA,YACA,KAAA,WACA,IAAA;IAAS,MAAA;IAAiB,OAAA;IAAoB,KAAA;IAAgB,UAAA;EAAA,IAC7D,OAAA,CAAQ,YAAA;EAsBL,eAAA,CAAgB,IAAA,WAAe,OAAA;EAIrC,mBAAA,CAAA;IAAyB,SAAA;IAAoB,SAAA;EAAA;EAMvC,iBAAA,CAAkB,OAAA,EAAS,YAAA,KAAiB,OAAA;EAM5C,iBAAA,CAAkB,KAAA;IAAS,IAAA;IAAc,OAAA,EAAS,MAAA;EAAA,MAAe,OAAA;EAMjE,mBAAA,CAAoB,KAAA;IAAS,IAAA;IAAc,OAAA;EAAA,MAAsB,OAAA;EAMjE,YAAA,CAAa,KAAA,YAAiB,IAAA,GAAO,kBAAA,GAAqB,OAAA;EAkB1D,aAAA,CACJ,IAAA;IAAQ,IAAA;IAAc,MAAA;EAAA,KACtB,IAAA,WACA,IAAA,GAAO,SAAA,GACN,OAAA,CAAQ,cAAA;AAAA"}