mcard-js 2.1.41 → 2.1.43

package/dist/chunk-OFHDMLNM.js

@@ -1,355 +0,0 @@
-import {
-  ContentTypeInterpreter,
-  MCard
-} from "./chunk-5BIDGXA6.js";
-import {
-  __export
-} from "./chunk-MLKGABMK.js";
-
-// src/Loader.ts
-var Loader_exports = {};
-__export(Loader_exports, {
-  loadFileToCollection: () => loadFileToCollection,
-  processAndStoreFile: () => processAndStoreFile
-});
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-
-// src/FileIO.ts
-var FileIO_exports = {};
-__export(FileIO_exports, {
-  isProblematicFile: () => isProblematicFile,
-  listFiles: () => listFiles,
-  processFileContent: () => processFileContent,
-  readFileSafely: () => readFileSafely,
-  streamReadNormalizedText: () => streamReadNormalizedText
-});
-import * as crypto from "crypto";
-import * as fs from "fs/promises";
-import * as path from "path";
-async function streamReadNormalizedText(filePath, options) {
-  const { byteCap, wrapWidth } = options;
-  const sha = crypto.createHash("sha256");
-  let totalSize = 0;
-  let producedText = "";
-  let currentLen = 0;
-  const handle = await fs.open(filePath, "r");
-  try {
-    const buffer = new Uint8Array(8192);
-    let remaining = byteCap;
-    const decoder = new TextDecoder("utf-8", { fatal: false });
-    let position = 0;
-    while (remaining > 0) {
-      const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, remaining), position);
-      if (bytesRead === 0) break;
-      position += bytesRead;
-      const chunk = buffer.subarray(0, bytesRead);
-      sha.update(chunk);
-      totalSize += bytesRead;
-      remaining -= bytesRead;
-      const s2 = decoder.decode(chunk, { stream: true });
-      for (const ch of s2) {
-        if (ch === "\r") continue;
-        producedText += ch;
-        if (ch === "\n") {
-          currentLen = 0;
-        } else {
-          currentLen++;
-          if (wrapWidth > 0 && currentLen >= wrapWidth) {
-            producedText += "\n";
-            currentLen = 0;
-          }
-        }
-      }
-    }
-    const s = decoder.decode();
-    for (const ch of s) {
-      if (ch === "\r") continue;
-      producedText += ch;
-      if (ch === "\n") {
-        currentLen = 0;
-      } else {
-        currentLen++;
-        if (wrapWidth > 0 && currentLen >= wrapWidth) {
-          producedText += "\n";
-          currentLen = 0;
-        }
-      }
-    }
-  } finally {
-    await handle.close();
-  }
-  return {
-    text: producedText,
-    originalSize: totalSize,
-    originalSha256Prefix: sha.digest("hex").substring(0, 16)
-  };
-}
-var MAX_FILE_SIZE = 50 * 1024 * 1024;
-var READ_TIMEOUT_MS = 5e3;
-async function isProblematicFile(filePath) {
-  try {
-    const stats = await fs.stat(filePath);
-    if (stats.size === 0) return false;
-    if (path.basename(filePath).startsWith(".")) return true;
-    if (stats.size > MAX_FILE_SIZE) return true;
-    const ext = path.extname(filePath);
-    const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(ext);
-    if (isKnownType && stats.size > 1024 * 1024) return true;
-    const handle = await fs.open(filePath, "r");
-    try {
-      const buffer = new Uint8Array(32 * 1024);
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-      const sample = buffer.subarray(0, bytesRead);
-      if (ContentTypeInterpreter.isUnstructuredBinary(sample)) return true;
-      if (ContentTypeInterpreter.hasPathologicalLines(sample, isKnownType)) return true;
-    } finally {
-      await handle.close();
-    }
-    return false;
-  } catch {
-    return true;
-  }
-}
-async function readFileSafely(filePath, options = {}) {
-  const stats = await fs.stat(filePath);
-  if (stats.size > MAX_FILE_SIZE) throw new Error(`File too large: ${stats.size}`);
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), READ_TIMEOUT_MS);
-  try {
-    const handle = await fs.open(filePath, "r");
-    try {
-      const buffer = new Uint8Array(stats.size);
-      await handle.read(buffer, 0, stats.size, 0);
-      return buffer;
-    } finally {
-      await handle.close();
-    }
-  } catch (e) {
-    const error = e;
-    if (error.name === "AbortError") throw new Error(`Read timeout for ${filePath}`);
-    throw e;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function listFiles(dirPath, recursive = false) {
-  let files = [];
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-      if (entry.name.startsWith(".")) continue;
-      if (entry.isDirectory()) {
-        if (recursive) {
-          files = files.concat(await listFiles(fullPath, true));
-        }
-      } else if (entry.isFile()) {
-        if (!await isProblematicFile(fullPath)) {
-          files.push(fullPath);
-        }
-      }
-    }
-  } catch (e) {
-    console.warn(`Error listing directory ${dirPath}:`, e);
-  }
-  return files;
-}
-async function processFileContent(filePath, options = {}) {
-  const rawContent = await readFileSafely(filePath, { allowPathological: options.allowPathological, maxBytes: options.maxBytes });
-  const sample = rawContent.subarray(0, 1024 * 1024);
-  const detection = ContentTypeInterpreter.detectContentType(sample, path.extname(filePath));
-  let isBinary = ContentTypeInterpreter.isBinaryContent(sample, detection.mimeType);
-  if (options.forceBinary) isBinary = true;
-  let content = rawContent;
-  if (!isBinary) {
-    try {
-      content = new TextDecoder("utf-8", { fatal: true }).decode(rawContent);
-    } catch {
-      content = new TextDecoder("utf-8", { fatal: false }).decode(rawContent);
-    }
-  }
-  return {
-    content,
-    filename: path.basename(filePath),
-    mimeType: detection.mimeType,
-    extension: detection.extension,
-    isBinary,
-    size: rawContent.length
-  };
-}
-
-// src/Loader.ts
-var DEFAULT_MAX_PROBLEM_BYTES = 2 * 1024 * 1024;
-var WRAP_WIDTH_KNOWN = 1e3;
-var WRAP_WIDTH_DEFAULT = 80;
-async function processAndStoreFile(filePath, collection, options = {}) {
-  const {
-    allowProblematic = false,
-    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
-    metadataOnly = false,
-    rootPath
-  } = options;
-  try {
-    let fileInfo;
-    if (await isProblematicFile(filePath)) {
-      if (!allowProblematic) {
-        console.warn(`Skipping problematic file: ${filePath}`);
-        return null;
-      }
-      const extension = path2.extname(filePath).toLowerCase();
-      const isKnownType = ContentTypeInterpreter.isKnownLongLineExtension(extension);
-      const wrapWidth = isKnownType ? WRAP_WIDTH_KNOWN : WRAP_WIDTH_DEFAULT;
-      console.warn(`Problematic file detected, processing as safe text: ${filePath}`);
-      try {
-        const streamed = await streamReadNormalizedText(filePath, {
-          byteCap: maxBytesOnProblem,
-          wrapWidth
-        });
-        fileInfo = {
-          content: streamed.text,
-          filename: path2.basename(filePath),
-          mimeType: "text/plain",
-          extension,
-          isBinary: false,
-          size: streamed.text.length,
-          originalSize: streamed.originalSize,
-          originalSha256Prefix: streamed.originalSha256Prefix,
-          normalized: true,
-          wrapWidth
-        };
-      } catch (e) {
-        console.warn(`Safe text processing failed, falling back to capped binary: ${filePath}`);
-        fileInfo = await processFileContent(filePath, {
-          forceBinary: true,
-          allowPathological: true,
-          maxBytes: maxBytesOnProblem
-        });
-      }
-    } else {
-      console.log(`Processing file: ${filePath}`);
-      fileInfo = await processFileContent(filePath);
-    }
-    if (!fileInfo) return null;
-    const content = fileInfo.content;
-    if (!content || typeof content === "string" && content.length === 0 || content instanceof Uint8Array && content.length === 0) {
-      if (process.env.DEBUG) {
-        console.log(`Skipping empty file: ${filePath} (empty files cannot be stored as MCards)`);
-      }
-      return {
-        hash: "",
-        contentType: fileInfo.mimeType,
-        isBinary: fileInfo.isBinary,
-        filename: fileInfo.filename,
-        size: 0,
-        filePath
-      };
-    }
-    let mcard = null;
-    const isProblematic = await isProblematicFile(filePath);
-    if (metadataOnly && isProblematic) {
-      mcard = null;
-    } else {
-      mcard = await MCard.create(fileInfo.content);
-      const handle = path2.basename(filePath);
-      try {
-        await collection.addWithHandle(mcard, handle);
-      } catch (e) {
-        let registered = false;
-        if (rootPath) {
-          const relPath = path2.relative(rootPath, filePath);
-          if (relPath !== handle) {
-            try {
-              await collection.addWithHandle(mcard, relPath);
-              registered = true;
-            } catch (e2) {
-              if (process.env.DEBUG) {
-                console.log(
-                  `Handle name '${handle}' already in use (common for files like README.md, LICENSE). MCard stored successfully with hash ${mcard.hash.slice(0, 8)}... (accessible by hash, not by handle)`
-                );
-              }
-            }
-          }
-        }
-        if (!registered) {
-          try {
-            await collection.add(mcard);
-          } catch (e3) {
-          }
-        }
-      }
-    }
-    const result = {
-      hash: mcard ? mcard.hash : "METADATA_ONLY",
-      contentType: fileInfo.mimeType,
-      isBinary: fileInfo.isBinary,
-      filename: fileInfo.filename,
-      size: fileInfo.size,
-      filePath
-    };
-    if (fileInfo.originalSize !== void 0) result.originalSize = fileInfo.originalSize;
-    if (fileInfo.originalSha256Prefix) result.originalSha256Prefix = fileInfo.originalSha256Prefix;
-    if (metadataOnly && isProblematic) result.metadataOnly = true;
-    return result;
-  } catch (e) {
-    console.error(`Error processing ${filePath}:`, e);
-    return null;
-  }
-}
-async function loadFileToCollection(targetPath, collection, options = {}) {
-  const {
-    recursive = false,
-    includeProblematic = false,
-    maxBytesOnProblem = DEFAULT_MAX_PROBLEM_BYTES,
-    metadataOnly = false
-  } = options;
-  const resolvedPath = path2.resolve(targetPath);
-  const stats = await fs2.stat(resolvedPath);
-  const results = [];
-  let files = [];
-  let rootPath = resolvedPath;
-  if (stats.isFile()) {
-    files = [resolvedPath];
-    rootPath = path2.dirname(resolvedPath);
-  } else if (stats.isDirectory()) {
-    files = await listFiles(resolvedPath, recursive);
-    rootPath = resolvedPath;
-  } else {
-    throw new Error(`Path ${targetPath} is not a file or directory`);
-  }
-  const uniqueDirs = /* @__PURE__ */ new Set();
-  let maxDepth = 0;
-  for (const file of files) {
-    const dir = path2.dirname(file);
-    if (dir.startsWith(rootPath)) {
-      uniqueDirs.add(dir);
-      const rel = path2.relative(rootPath, file);
-      const parts = rel.split(path2.sep);
-      const depth = parts.length - 1;
-      if (depth > maxDepth) maxDepth = depth;
-    }
-  }
-  const metrics = {
-    filesCount: files.length,
-    directoriesCount: uniqueDirs.size,
-    directoryLevels: maxDepth
-  };
-  console.log(`About to process ${files.length} files`);
-  for (const file of files) {
-    const result = await processAndStoreFile(file, collection, {
-      allowProblematic: includeProblematic,
-      maxBytesOnProblem,
-      metadataOnly,
-      rootPath
-    });
-    if (result) results.push(result);
-  }
-  return { metrics, results };
-}
-
-export {
-  FileIO_exports,
-  processAndStoreFile,
-  loadFileToCollection,
-  Loader_exports
-};

package/dist/chunk-PDBMNUMB.js

@@ -1,316 +0,0 @@
-import {
-  createPage,
-  initCoreSchemas,
-  validateHandle
-} from "./chunk-WTNVQ5WS.js";
-import {
-  MCard
-} from "./chunk-QPZ2HNSU.js";
-
-// src/storage/SqliteNodeEngine.ts
-import { createRequire } from "module";
-var DEFAULT_PAGE_SIZE = 10;
-var SqliteNodeEngine = class _SqliteNodeEngine {
-  db;
-  dbPath;
-  /**
-   * Convert a database row into an MCard instance.
-   */
-  static rowToCard(row) {
-    const content = row.content instanceof Buffer ? new Uint8Array(row.content) : new Uint8Array(row.content);
-    return MCard.fromData(content, row.hash, row.g_time);
-  }
-  /**
-   * Create a new SqliteNodeEngine
-   * @param dbPath Path to database file, or ':memory:' for in-memory database
-   */
-  constructor(dbPath = ":memory:") {
-    this.dbPath = dbPath;
-    const require2 = createRequire(import.meta.url);
-    const Database = require2("better-sqlite3");
-    this.db = new Database(dbPath);
-    this.setupDatabase();
-  }
-  /**
-   * Initialize database schema
-   */
-  setupDatabase() {
-    initCoreSchemas(this.db);
-  }
-  /**
-   * Close the database connection
-   */
-  close() {
-    this.db.close();
-  }
-  /**
-   * Get the database path
-   */
-  getDbPath() {
-    return this.dbPath;
-  }
-  // =========== Card Operations ===========
-  async add(card) {
-    const stmt = this.db.prepare(
-      "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)"
-    );
-    stmt.run(card.hash, Buffer.from(card.content), card.g_time);
-    return card.hash;
-  }
-  /**
-   * Add a card synchronously (for performance-critical paths)
-   */
-  addSync(card) {
-    const stmt = this.db.prepare(
-      "INSERT OR REPLACE INTO card (hash, content, g_time) VALUES (?, ?, ?)"
-    );
-    stmt.run(card.hash, Buffer.from(card.content), card.g_time);
-    return card.hash;
-  }
-  async get(hash) {
-    return this.getSync(hash);
-  }
-  /**
-   * Get a card synchronously
-   */
-  getSync(hash) {
-    const stmt = this.db.prepare("SELECT hash, content, g_time FROM card WHERE hash = ?");
-    const row = stmt.get(hash);
-    if (!row) return null;
-    return _SqliteNodeEngine.rowToCard(row);
-  }
-  async delete(hash) {
-    this.deleteSync(hash);
-  }
-  /**
-   * Delete a card synchronously
-   */
-  deleteSync(hash) {
-    const stmt = this.db.prepare("DELETE FROM card WHERE hash = ?");
-    const result = stmt.run(hash);
-    return result.changes > 0;
-  }
-  async getPage(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
-    return this.getPageSync(pageNumber, pageSize);
-  }
-  /**
-   * Get a page of cards synchronously
-   */
-  getPageSync(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
-    if (pageNumber < 1) throw new Error("Page number must be >= 1");
-    if (pageSize < 1) throw new Error("Page size must be >= 1");
-    const totalItems = this.countSync();
-    const offset = (pageNumber - 1) * pageSize;
-    const stmt = this.db.prepare(
-      "SELECT hash, content, g_time FROM card ORDER BY g_time DESC LIMIT ? OFFSET ?"
-    );
-    const rows = stmt.all(pageSize, offset);
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  async count() {
-    return this.countSync();
-  }
-  /**
-   * Count cards synchronously
-   */
-  countSync() {
-    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM card");
-    const row = stmt.get();
-    return row.count;
-  }
-  async searchByHash(hashPrefix) {
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card WHERE hash LIKE ?").all(`${hashPrefix}%`);
-    return rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-  }
-  async search(query, pageNumber, pageSize) {
-    const offset = (pageNumber - 1) * pageSize;
-    const searchPattern = `%${query}%`;
-    const countResult = this.db.prepare("SELECT COUNT(*) as count FROM card WHERE CAST(content AS TEXT) LIKE ?").get(searchPattern);
-    const totalItems = countResult.count;
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card WHERE CAST(content AS TEXT) LIKE ? LIMIT ? OFFSET ?").all(searchPattern, pageSize, offset);
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  async getAll() {
-    const rows = this.db.prepare("SELECT hash, content, g_time FROM card").all();
-    return rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-  }
-  async clear() {
-    this.clearSync();
-  }
-  /**
-   * Clear all data synchronously
-   * Delete in FK-safe order: children first, then parents
-   */
-  clearSync() {
-    this.db.exec("DELETE FROM handle_history");
-    this.db.exec("DELETE FROM handle_registry");
-    this.db.exec("DELETE FROM card");
-  }
-  // =========== Search Operations ===========
-  /**
-   * Search cards by string in content, hash, or g_time
-   */
-  searchByString(searchString, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
-    if (pageNumber < 1) throw new Error("Page number must be >= 1");
-    if (pageSize < 1) throw new Error("Page size must be >= 1");
-    const pattern = `%${searchString}%`;
-    const offset = (pageNumber - 1) * pageSize;
-    const countStmt = this.db.prepare(`
-            SELECT COUNT(*) as count FROM card 
-            WHERE hash LIKE ? OR g_time LIKE ? OR CAST(content AS TEXT) LIKE ?
-        `);
-    const countRow = countStmt.get(pattern, pattern, pattern);
-    const totalItems = countRow.count;
-    const stmt = this.db.prepare(`
-            SELECT hash, content, g_time FROM card 
-            WHERE hash LIKE ? OR g_time LIKE ? OR CAST(content AS TEXT) LIKE ?
-            ORDER BY g_time DESC LIMIT ? OFFSET ?
-        `);
-    const rows = stmt.all(pattern, pattern, pattern, pageSize, offset);
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  /**
-   * Search cards by content pattern (binary-safe)
-   */
-  searchByContent(searchPattern, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
-    if (pageNumber < 1) throw new Error("Page number must be >= 1");
-    if (pageSize < 1) throw new Error("Page size must be >= 1");
-    if (!searchPattern || typeof searchPattern === "string" && searchPattern.length === 0) {
-      throw new Error("Search pattern cannot be empty");
-    }
-    const searchBytes = typeof searchPattern === "string" ? Buffer.from(searchPattern, "utf-8") : Buffer.from(searchPattern);
-    const offset = (pageNumber - 1) * pageSize;
-    const countStmt = this.db.prepare("SELECT COUNT(*) as count FROM card WHERE INSTR(content, ?) > 0");
-    const countRow = countStmt.get(searchBytes);
-    const totalItems = countRow.count;
-    const stmt = this.db.prepare(`
-            SELECT hash, content, g_time FROM card 
-            WHERE INSTR(content, ?) > 0
-            ORDER BY g_time DESC LIMIT ? OFFSET ?
-        `);
-    const rows = stmt.all(searchBytes, pageSize, offset);
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, totalItems, pageNumber, pageSize);
-  }
-  /**
-   * Get all cards (single page with all items)
-   */
-  getAllCards() {
-    const stmt = this.db.prepare("SELECT hash, content, g_time FROM card ORDER BY g_time DESC");
-    const rows = stmt.all();
-    const items = rows.map((row) => _SqliteNodeEngine.rowToCard(row));
-    return createPage(items, items.length, 1, items.length || 1);
-  }
-  // =========== Handle Operations ===========
-  async registerHandle(handle, hash) {
-    this.registerHandleSync(handle, hash);
-  }
-  /**
-   * Register a handle synchronously
-   */
-  registerHandleSync(handle, hash) {
-    const normalized = validateHandle(handle);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const checkStmt = this.db.prepare("SELECT handle FROM handle_registry WHERE handle = ?");
-    const existing = checkStmt.get(normalized);
-    if (existing) {
-      throw new Error(`Handle '${handle}' already exists.`);
-    }
-    const stmt = this.db.prepare(
-      "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?)"
-    );
-    stmt.run(normalized, hash, now, now);
-  }
-  async resolveHandle(handle) {
-    return this.resolveHandleSync(handle);
-  }
-  /**
-   * Resolve a handle synchronously
-   */
-  resolveHandleSync(handle) {
-    const normalized = validateHandle(handle);
-    const stmt = this.db.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    const row = stmt.get(normalized);
-    return row?.current_hash || null;
-  }
-  async getByHandle(handle) {
-    return this.getByHandleSync(handle);
-  }
-  /**
-   * Get card by handle synchronously
-   */
-  getByHandleSync(handle) {
-    const hash = this.resolveHandleSync(handle);
-    if (!hash) return null;
-    return this.getSync(hash);
-  }
-  async updateHandle(handle, newHash) {
-    return this.updateHandleSync(handle, newHash);
-  }
-  /**
-   * Update a handle synchronously
-   */
-  updateHandleSync(handle, newHash) {
-    const normalized = validateHandle(handle);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const getStmt = this.db.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?");
-    const row = getStmt.get(normalized);
-    if (!row) {
-      throw new Error(`Handle '${handle}' not found.`);
-    }
-    const previousHash = row.current_hash;
-    const historyStmt = this.db.prepare(
-      "INSERT INTO handle_history (handle, previous_hash, changed_at) VALUES (?, ?, ?)"
-    );
-    historyStmt.run(normalized, previousHash, now);
-    const updateStmt = this.db.prepare(
-      "UPDATE handle_registry SET current_hash = ?, updated_at = ? WHERE handle = ?"
-    );
-    updateStmt.run(newHash, now, normalized);
-    return previousHash;
-  }
-  async getHandleHistory(handle) {
-    return this.getHandleHistorySync(handle);
-  }
-  /**
-   * Get handle history synchronously
-   */
-  getHandleHistorySync(handle) {
-    const normalized = validateHandle(handle);
-    const stmt = this.db.prepare(
-      "SELECT previous_hash, changed_at FROM handle_history WHERE handle = ? ORDER BY id DESC"
-    );
-    const rows = stmt.all(normalized);
-    return rows.map((row) => ({
-      previousHash: row.previous_hash,
-      changedAt: row.changed_at
-    }));
-  }
-  async pruneHandleHistory(handle, options = {}) {
-    return this.pruneHandleHistorySync(handle, options);
-  }
-  /**
-   * Prune handle history synchronously
-   */
-  pruneHandleHistorySync(handle, options = {}) {
-    const normalized = validateHandle(handle);
-    let stmt;
-    if (options.deleteAll) {
-      stmt = this.db.prepare("DELETE FROM handle_history WHERE handle = ?");
-      const result = stmt.run(normalized);
-      return result.changes;
-    } else if (options.olderThan) {
-      stmt = this.db.prepare("DELETE FROM handle_history WHERE handle = ? AND changed_at < ?");
-      const result = stmt.run(normalized, options.olderThan);
-      return result.changes;
-    }
-    return 0;
-  }
-};
-
-export {
-  SqliteNodeEngine
-};