aidex-mcp 1.4.1

package/build/db/database.d.ts

@@ -0,0 +1,69 @@
+/**
+ * SQLite Database wrapper for AiDex
+ */
+import Database from 'better-sqlite3';
+export interface DatabaseConfig {
+    dbPath: string;
+    readonly?: boolean;
+}
+export declare class AiDexDatabase {
+    private db;
+    private dbPath;
+    constructor(config: DatabaseConfig);
+    /**
+     * Initialize database with schema
+     */
+    initSchema(): void;
+    /**
+     * Set metadata value
+     */
+    setMetadata(key: string, value: string | null): void;
+    /**
+     * Get metadata value
+     */
+    getMetadata(key: string): string | null;
+    /**
+     * Delete metadata entry
+     */
+    deleteMetadata(key: string): void;
+    /**
+     * Run a function in a transaction
+     */
+    transaction<T>(fn: () => T): T;
+    /**
+     * Get the underlying better-sqlite3 database instance
+     */
+    getDb(): Database.Database;
+    /**
+     * Get database file path
+     */
+    getPath(): string;
+    /**
+     * Get database statistics
+     */
+    getStats(): {
+        files: number;
+        lines: number;
+        items: number;
+        occurrences: number;
+        methods: number;
+        types: number;
+        dependencies: number;
+        sizeBytes: number;
+    };
+    /**
+     * Close database connection
+     */
+    close(): void;
+}
+/**
+ * Open or create an AiDex database
+ */
+export declare function openDatabase(dbPath: string, readonly?: boolean): AiDexDatabase;
+/**
+ * Create and initialize a new AiDex database
+ * If incremental=true, keeps existing data for incremental updates
+ * If incremental=false (default), clears all data for fresh re-index
+ */
+export declare function createDatabase(dbPath: string, projectName?: string, projectRoot?: string, incremental?: boolean): AiDexDatabase;
+//# sourceMappingURL=database.d.ts.map

package/build/db/database.js

@@ -0,0 +1,126 @@
+/**
+ * SQLite Database wrapper for AiDex
+ */
+import Database from 'better-sqlite3';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class AiDexDatabase {
+    db;
+    dbPath;
+    constructor(config) {
+        this.dbPath = config.dbPath;
+        this.db = new Database(config.dbPath, {
+            readonly: config.readonly ?? false,
+        });
+        // Enable WAL mode and foreign keys
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+    }
+    /**
+     * Initialize database with schema
+     */
+    initSchema() {
+        const schemaPath = join(__dirname, 'schema.sql');
+        const schema = readFileSync(schemaPath, 'utf-8');
+        this.db.exec(schema);
+        // Set initial metadata if not exists
+        const stmt = this.db.prepare('INSERT OR IGNORE INTO metadata (key, value) VALUES (?, ?)');
+        stmt.run('schema_version', '1.0');
+        stmt.run('created_at', Date.now().toString());
+    }
+    /**
+     * Set metadata value
+     */
+    setMetadata(key, value) {
+        this.db.prepare('INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)').run(key, value);
+    }
+    /**
+     * Get metadata value
+     */
+    getMetadata(key) {
+        const row = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get(key);
+        return row?.value ?? null;
+    }
+    /**
+     * Delete metadata entry
+     */
+    deleteMetadata(key) {
+        this.db.prepare('DELETE FROM metadata WHERE key = ?').run(key);
+    }
+    /**
+     * Run a function in a transaction
+     */
+    transaction(fn) {
+        return this.db.transaction(fn)();
+    }
+    /**
+     * Get the underlying better-sqlite3 database instance
+     */
+    getDb() {
+        return this.db;
+    }
+    /**
+     * Get database file path
+     */
+    getPath() {
+        return this.dbPath;
+    }
+    /**
+     * Get database statistics
+     */
+    getStats() {
+        const counts = {
+            files: this.db.prepare('SELECT COUNT(*) as c FROM files').get().c,
+            lines: this.db.prepare('SELECT COUNT(*) as c FROM lines').get().c,
+            items: this.db.prepare('SELECT COUNT(*) as c FROM items').get().c,
+            occurrences: this.db.prepare('SELECT COUNT(*) as c FROM occurrences').get().c,
+            methods: this.db.prepare('SELECT COUNT(*) as c FROM methods').get().c,
+            types: this.db.prepare('SELECT COUNT(*) as c FROM types').get().c,
+            dependencies: this.db.prepare('SELECT COUNT(*) as c FROM dependencies').get().c,
+        };
+        // Get file size
+        const pragmaResult = this.db.pragma('page_count');
+        const pageSizeResult = this.db.pragma('page_size');
+        const pageCount = pragmaResult[0]?.page_count ?? 0;
+        const pageSize = pageSizeResult[0]?.page_size ?? 4096;
+        const sizeBytes = pageCount * pageSize;
+        return { ...counts, sizeBytes };
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}
+/**
+ * Open or create an AiDex database
+ */
+export function openDatabase(dbPath, readonly = false) {
+    return new AiDexDatabase({ dbPath, readonly });
+}
+/**
+ * Create and initialize a new AiDex database
+ * If incremental=true, keeps existing data for incremental updates
+ * If incremental=false (default), clears all data for fresh re-index
+ */
+export function createDatabase(dbPath, projectName, projectRoot, incremental = false) {
+    const db = new AiDexDatabase({ dbPath });
+    db.initSchema();
+    if (!incremental) {
+        // Clear all data for fresh re-index (ON DELETE CASCADE handles related tables)
+        db.getDb().exec('DELETE FROM files');
+        db.getDb().exec('DELETE FROM items');
+    }
+    if (projectName) {
+        db.setMetadata('project_name', projectName);
+    }
+    if (projectRoot) {
+        db.setMetadata('project_root', projectRoot);
+    }
+    db.setMetadata('last_indexed', Date.now().toString());
+    return db;
+}
+//# sourceMappingURL=database.js.map

package/build/db/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Database module exports
+ */
+export { AiDexDatabase, openDatabase, createDatabase } from './database.js';
+export { Queries, createQueries } from './queries.js';
+export type { FileRow, LineRow, ItemRow, OccurrenceRow, SignatureRow, MethodRow, TypeRow, DependencyRow, } from './queries.js';
+//# sourceMappingURL=index.d.ts.map

package/build/db/index.js

@@ -0,0 +1,6 @@
+/**
+ * Database module exports
+ */
+export { AiDexDatabase, openDatabase, createDatabase } from './database.js';
+export { Queries, createQueries } from './queries.js';
+//# sourceMappingURL=index.js.map

package/build/db/queries.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Prepared statements and query helpers for AiDex
+ */
+import type { AiDexDatabase } from './database.js';
+export interface FileRow {
+    id: number;
+    path: string;
+    hash: string;
+    last_indexed: number;
+}
+export interface LineRow {
+    id: number;
+    file_id: number;
+    line_number: number;
+    line_type: 'code' | 'comment' | 'struct' | 'method' | 'property' | 'string';
+    line_hash: string | null;
+    modified: number | null;
+}
+export interface ItemRow {
+    id: number;
+    term: string;
+}
+export interface OccurrenceRow {
+    item_id: number;
+    file_id: number;
+    line_id: number;
+}
+export interface SignatureRow {
+    file_id: number;
+    header_comments: string | null;
+}
+export interface MethodRow {
+    id: number;
+    file_id: number;
+    name: string;
+    prototype: string;
+    line_number: number;
+    visibility: string | null;
+    is_static: number;
+    is_async: number;
+}
+export interface TypeRow {
+    id: number;
+    file_id: number;
+    name: string;
+    kind: 'class' | 'struct' | 'interface' | 'enum' | 'type';
+    line_number: number;
+}
+export interface DependencyRow {
+    id: number;
+    path: string;
+    name: string | null;
+    last_checked: number | null;
+}
+export interface ProjectFileRow {
+    id: number;
+    path: string;
+    type: 'dir' | 'code' | 'config' | 'doc' | 'asset' | 'test' | 'other';
+    extension: string | null;
+    indexed: number;
+}
+export declare class Queries {
+    private db;
+    private _insertFile?;
+    private _updateFileHash?;
+    private _getFileByPath?;
+    private _getFileById?;
+    private _getAllFiles?;
+    private _deleteFile?;
+    private _insertLine?;
+    private _getLinesByFile?;
+    private _deleteLinesByFile?;
+    private _updateLineNumbers?;
+    private _insertItem?;
+    private _getItemByTerm?;
+    private _getItemById?;
+    private _deleteUnusedItems?;
+    private _insertOccurrence?;
+    private _getOccurrencesByItem?;
+    private _getOccurrencesByFile?;
+    private _deleteOccurrencesByFile?;
+    private _insertSignature?;
+    private _getSignatureByFile?;
+    private _deleteSignatureByFile?;
+    private _insertMethod?;
+    private _getMethodsByFile?;
+    private _deleteMethodsByFile?;
+    private _insertType?;
+    private _getTypesByFile?;
+    private _deleteTypesByFile?;
+    constructor(database: AiDexDatabase);
+    insertFile(path: string, hash: string): number;
+    updateFileHash(id: number, hash: string): void;
+    getFileByPath(path: string): FileRow | undefined;
+    getFileById(id: number): FileRow | undefined;
+    getAllFiles(): FileRow[];
+    deleteFile(id: number): void;
+    insertLine(fileId: number, lineId: number, lineNumber: number, lineType: LineRow['line_type'], lineHash?: string, modified?: number): void;
+    getLinesByFile(fileId: number): LineRow[];
+    deleteLinesByFile(fileId: number): void;
+    updateLineNumbers(fileId: number, fromLine: number, offset: number): void;
+    insertItem(term: string): number;
+    getOrCreateItem(term: string): number;
+    getItemByTerm(term: string): ItemRow | undefined;
+    getItemById(id: number): ItemRow | undefined;
+    deleteUnusedItems(): number;
+    insertOccurrence(itemId: number, fileId: number, lineId: number): void;
+    getOccurrencesByItem(itemId: number): Array<{
+        file_id: number;
+        line_id: number;
+        line_number: number;
+        path: string;
+        line_type: string;
+        modified: number | null;
+    }>;
+    getOccurrencesByFile(fileId: number): OccurrenceRow[];
+    deleteOccurrencesByFile(fileId: number): void;
+    insertSignature(fileId: number, headerComments: string | null): void;
+    getSignatureByFile(fileId: number): SignatureRow | undefined;
+    deleteSignatureByFile(fileId: number): void;
+    insertMethod(fileId: number, name: string, prototype: string, lineNumber: number, visibility?: string | null, isStatic?: boolean, isAsync?: boolean): number;
+    getMethodsByFile(fileId: number): MethodRow[];
+    deleteMethodsByFile(fileId: number): void;
+    insertType(fileId: number, name: string, kind: TypeRow['kind'], lineNumber: number): number;
+    getTypesByFile(fileId: number): TypeRow[];
+    deleteTypesByFile(fileId: number): void;
+    searchItems(term: string, mode?: 'exact' | 'contains' | 'starts_with', limit?: number): ItemRow[];
+    /**
+     * Clear all data for a file (before re-indexing)
+     */
+    clearFileData(fileId: number): void;
+    /**
+     * Bulk insert lines
+     */
+    bulkInsertLines(fileId: number, lines: Array<{
+        lineId: number;
+        lineNumber: number;
+        lineType: LineRow['line_type'];
+        lineHash?: string;
+        modified?: number;
+    }>): void;
+    /**
+     * Bulk insert occurrences
+     */
+    bulkInsertOccurrences(occurrences: Array<{
+        itemId: number;
+        fileId: number;
+        lineId: number;
+    }>): void;
+    private _insertProjectFile?;
+    private _getProjectFiles?;
+    private _getProjectFilesByType?;
+    private _clearProjectFiles?;
+    insertProjectFile(path: string, type: ProjectFileRow['type'], extension: string | null, indexed: boolean): void;
+    getProjectFiles(): ProjectFileRow[];
+    getProjectFilesByType(type: ProjectFileRow['type']): ProjectFileRow[];
+    clearProjectFiles(): void;
+}
+/**
+ * Create a Queries instance for the given database
+ */
+export declare function createQueries(database: AiDexDatabase): Queries;
+//# sourceMappingURL=queries.d.ts.map

package/build/db/queries.js

@@ -0,0 +1,273 @@
+/**
+ * Prepared statements and query helpers for AiDex
+ */
+// ============================================================
+// Query class with prepared statements
+// ============================================================
+export class Queries {
+    db;
+    // Prepared statements (lazily initialized)
+    _insertFile;
+    _updateFileHash;
+    _getFileByPath;
+    _getFileById;
+    _getAllFiles;
+    _deleteFile;
+    _insertLine;
+    _getLinesByFile;
+    _deleteLinesByFile;
+    _updateLineNumbers;
+    _insertItem;
+    _getItemByTerm;
+    _getItemById;
+    _deleteUnusedItems;
+    _insertOccurrence;
+    _getOccurrencesByItem;
+    _getOccurrencesByFile;
+    _deleteOccurrencesByFile;
+    _insertSignature;
+    _getSignatureByFile;
+    _deleteSignatureByFile;
+    _insertMethod;
+    _getMethodsByFile;
+    _deleteMethodsByFile;
+    _insertType;
+    _getTypesByFile;
+    _deleteTypesByFile;
+    constructor(database) {
+        this.db = database.getDb();
+    }
+    // --------------------------------------------------------
+    // Files
+    // --------------------------------------------------------
+    insertFile(path, hash) {
+        this._insertFile ??= this.db.prepare('INSERT INTO files (path, hash, last_indexed) VALUES (?, ?, ?)');
+        const result = this._insertFile.run(path, hash, Date.now());
+        return result.lastInsertRowid;
+    }
+    updateFileHash(id, hash) {
+        this._updateFileHash ??= this.db.prepare('UPDATE files SET hash = ?, last_indexed = ? WHERE id = ?');
+        this._updateFileHash.run(hash, Date.now(), id);
+    }
+    getFileByPath(path) {
+        this._getFileByPath ??= this.db.prepare('SELECT * FROM files WHERE path = ?');
+        return this._getFileByPath.get(path);
+    }
+    getFileById(id) {
+        this._getFileById ??= this.db.prepare('SELECT * FROM files WHERE id = ?');
+        return this._getFileById.get(id);
+    }
+    getAllFiles() {
+        this._getAllFiles ??= this.db.prepare('SELECT * FROM files ORDER BY path');
+        return this._getAllFiles.all();
+    }
+    deleteFile(id) {
+        this._deleteFile ??= this.db.prepare('DELETE FROM files WHERE id = ?');
+        this._deleteFile.run(id);
+    }
+    // --------------------------------------------------------
+    // Lines
+    // --------------------------------------------------------
+    insertLine(fileId, lineId, lineNumber, lineType, lineHash, modified) {
+        this._insertLine ??= this.db.prepare('INSERT INTO lines (file_id, id, line_number, line_type, line_hash, modified) VALUES (?, ?, ?, ?, ?, ?)');
+        this._insertLine.run(fileId, lineId, lineNumber, lineType, lineHash ?? null, modified ?? Date.now());
+    }
+    getLinesByFile(fileId) {
+        this._getLinesByFile ??= this.db.prepare('SELECT * FROM lines WHERE file_id = ? ORDER BY line_number');
+        return this._getLinesByFile.all(fileId);
+    }
+    deleteLinesByFile(fileId) {
+        this._deleteLinesByFile ??= this.db.prepare('DELETE FROM lines WHERE file_id = ?');
+        this._deleteLinesByFile.run(fileId);
+    }
+    updateLineNumbers(fileId, fromLine, offset) {
+        this._updateLineNumbers ??= this.db.prepare('UPDATE lines SET line_number = line_number + ? WHERE file_id = ? AND line_number >= ?');
+        this._updateLineNumbers.run(offset, fileId, fromLine);
+    }
+    // --------------------------------------------------------
+    // Items
+    // --------------------------------------------------------
+    insertItem(term) {
+        this._insertItem ??= this.db.prepare('INSERT INTO items (term) VALUES (?)');
+        const result = this._insertItem.run(term);
+        return result.lastInsertRowid;
+    }
+    getOrCreateItem(term) {
+        const existing = this.getItemByTerm(term);
+        if (existing) {
+            return existing.id;
+        }
+        return this.insertItem(term);
+    }
+    getItemByTerm(term) {
+        this._getItemByTerm ??= this.db.prepare('SELECT * FROM items WHERE term = ? COLLATE NOCASE');
+        return this._getItemByTerm.get(term);
+    }
+    getItemById(id) {
+        this._getItemById ??= this.db.prepare('SELECT * FROM items WHERE id = ?');
+        return this._getItemById.get(id);
+    }
+    deleteUnusedItems() {
+        this._deleteUnusedItems ??= this.db.prepare('DELETE FROM items WHERE id NOT IN (SELECT DISTINCT item_id FROM occurrences)');
+        const result = this._deleteUnusedItems.run();
+        return result.changes;
+    }
+    // --------------------------------------------------------
+    // Occurrences
+    // --------------------------------------------------------
+    insertOccurrence(itemId, fileId, lineId) {
+        this._insertOccurrence ??= this.db.prepare('INSERT OR IGNORE INTO occurrences (item_id, file_id, line_id) VALUES (?, ?, ?)');
+        this._insertOccurrence.run(itemId, fileId, lineId);
+    }
+    getOccurrencesByItem(itemId) {
+        this._getOccurrencesByItem ??= this.db.prepare(`
+            SELECT o.file_id, o.line_id, l.line_number, f.path, l.line_type, l.modified
+            FROM occurrences o
+            JOIN lines l ON o.file_id = l.file_id AND o.line_id = l.id
+            JOIN files f ON o.file_id = f.id
+            WHERE o.item_id = ?
+            ORDER BY f.path, l.line_number
+        `);
+        return this._getOccurrencesByItem.all(itemId);
+    }
+    getOccurrencesByFile(fileId) {
+        this._getOccurrencesByFile ??= this.db.prepare('SELECT * FROM occurrences WHERE file_id = ?');
+        return this._getOccurrencesByFile.all(fileId);
+    }
+    deleteOccurrencesByFile(fileId) {
+        this._deleteOccurrencesByFile ??= this.db.prepare('DELETE FROM occurrences WHERE file_id = ?');
+        this._deleteOccurrencesByFile.run(fileId);
+    }
+    // --------------------------------------------------------
+    // Signatures
+    // --------------------------------------------------------
+    insertSignature(fileId, headerComments) {
+        this._insertSignature ??= this.db.prepare('INSERT OR REPLACE INTO signatures (file_id, header_comments) VALUES (?, ?)');
+        this._insertSignature.run(fileId, headerComments);
+    }
+    getSignatureByFile(fileId) {
+        this._getSignatureByFile ??= this.db.prepare('SELECT * FROM signatures WHERE file_id = ?');
+        return this._getSignatureByFile.get(fileId);
+    }
+    deleteSignatureByFile(fileId) {
+        this._deleteSignatureByFile ??= this.db.prepare('DELETE FROM signatures WHERE file_id = ?');
+        this._deleteSignatureByFile.run(fileId);
+    }
+    // --------------------------------------------------------
+    // Methods
+    // --------------------------------------------------------
+    insertMethod(fileId, name, prototype, lineNumber, visibility = null, isStatic = false, isAsync = false) {
+        this._insertMethod ??= this.db.prepare('INSERT INTO methods (file_id, name, prototype, line_number, visibility, is_static, is_async) VALUES (?, ?, ?, ?, ?, ?, ?)');
+        const result = this._insertMethod.run(fileId, name, prototype, lineNumber, visibility, isStatic ? 1 : 0, isAsync ? 1 : 0);
+        return result.lastInsertRowid;
+    }
+    getMethodsByFile(fileId) {
+        this._getMethodsByFile ??= this.db.prepare('SELECT * FROM methods WHERE file_id = ? ORDER BY line_number');
+        return this._getMethodsByFile.all(fileId);
+    }
+    deleteMethodsByFile(fileId) {
+        this._deleteMethodsByFile ??= this.db.prepare('DELETE FROM methods WHERE file_id = ?');
+        this._deleteMethodsByFile.run(fileId);
+    }
+    // --------------------------------------------------------
+    // Types
+    // --------------------------------------------------------
+    insertType(fileId, name, kind, lineNumber) {
+        this._insertType ??= this.db.prepare('INSERT INTO types (file_id, name, kind, line_number) VALUES (?, ?, ?, ?)');
+        const result = this._insertType.run(fileId, name, kind, lineNumber);
+        return result.lastInsertRowid;
+    }
+    getTypesByFile(fileId) {
+        this._getTypesByFile ??= this.db.prepare('SELECT * FROM types WHERE file_id = ? ORDER BY line_number');
+        return this._getTypesByFile.all(fileId);
+    }
+    deleteTypesByFile(fileId) {
+        this._deleteTypesByFile ??= this.db.prepare('DELETE FROM types WHERE file_id = ?');
+        this._deleteTypesByFile.run(fileId);
+    }
+    // --------------------------------------------------------
+    // Query: Search items
+    // --------------------------------------------------------
+    searchItems(term, mode = 'exact', limit = 100) {
+        let sql;
+        let param;
+        switch (mode) {
+            case 'exact':
+                sql = 'SELECT * FROM items WHERE term = ? COLLATE NOCASE LIMIT ?';
+                param = term;
+                break;
+            case 'contains':
+                sql = 'SELECT * FROM items WHERE term LIKE ? COLLATE NOCASE LIMIT ?';
+                param = `%${term}%`;
+                break;
+            case 'starts_with':
+                sql = 'SELECT * FROM items WHERE term LIKE ? COLLATE NOCASE LIMIT ?';
+                param = `${term}%`;
+                break;
+        }
+        return this.db.prepare(sql).all(param, limit);
+    }
+    // --------------------------------------------------------
+    // Bulk operations
+    // --------------------------------------------------------
+    /**
+     * Clear all data for a file (before re-indexing)
+     */
+    clearFileData(fileId) {
+        // Order matters due to foreign keys
+        this.deleteOccurrencesByFile(fileId);
+        this.deleteMethodsByFile(fileId);
+        this.deleteTypesByFile(fileId);
+        this.deleteSignatureByFile(fileId);
+        this.deleteLinesByFile(fileId);
+    }
+    /**
+     * Bulk insert lines
+     */
+    bulkInsertLines(fileId, lines) {
+        const stmt = this.db.prepare('INSERT INTO lines (file_id, id, line_number, line_type, line_hash, modified) VALUES (?, ?, ?, ?, ?, ?)');
+        const now = Date.now();
+        for (const line of lines) {
+            stmt.run(fileId, line.lineId, line.lineNumber, line.lineType, line.lineHash ?? null, line.modified ?? now);
+        }
+    }
+    /**
+     * Bulk insert occurrences
+     */
+    bulkInsertOccurrences(occurrences) {
+        const stmt = this.db.prepare('INSERT OR IGNORE INTO occurrences (item_id, file_id, line_id) VALUES (?, ?, ?)');
+        for (const occ of occurrences) {
+            stmt.run(occ.itemId, occ.fileId, occ.lineId);
+        }
+    }
+    // --------------------------------------------------------
+    // Project Files (project structure)
+    // --------------------------------------------------------
+    _insertProjectFile;
+    _getProjectFiles;
+    _getProjectFilesByType;
+    _clearProjectFiles;
+    insertProjectFile(path, type, extension, indexed) {
+        this._insertProjectFile ??= this.db.prepare('INSERT OR REPLACE INTO project_files (path, type, extension, indexed) VALUES (?, ?, ?, ?)');
+        this._insertProjectFile.run(path, type, extension, indexed ? 1 : 0);
+    }
+    getProjectFiles() {
+        this._getProjectFiles ??= this.db.prepare('SELECT * FROM project_files ORDER BY path');
+        return this._getProjectFiles.all();
+    }
+    getProjectFilesByType(type) {
+        this._getProjectFilesByType ??= this.db.prepare('SELECT * FROM project_files WHERE type = ? ORDER BY path');
+        return this._getProjectFilesByType.all(type);
+    }
+    clearProjectFiles() {
+        this._clearProjectFiles ??= this.db.prepare('DELETE FROM project_files');
+        this._clearProjectFiles.run();
+    }
+}
+/**
+ * Create a Queries instance for the given database
+ */
+export function createQueries(database) {
+    return new Queries(database);
+}
+//# sourceMappingURL=queries.js.map