@willwade/aac-processors 0.1.19 → 0.1.21

package/dist/browser/utilities/analytics/reference/index.js

@@ -4,57 +4,63 @@
  * Loads reference vocabulary lists, core lists, and sentences
  * for AAC metrics analysis.
  */
-import { getFs, getPath } from '../../../utils/io';
+import { defaultFileAdapter } from '../../../utils/io';
 export class ReferenceLoader {
-    constructor(dataDir, locale = 'en') {
+    constructor(dataDir, locale = 'en', fileAdapter = defaultFileAdapter) {
         this.locale = locale;
+        this.fileAdapter = fileAdapter;
         if (dataDir) {
             this.dataDir = dataDir;
         }
         else {
             // Resolve the data directory relative to this file's location
             // Use __dirname which works correctly after compilation
-            this.dataDir = getPath().join(__dirname, 'data');
+            this.dataDir = this.fileAdapter.join(__dirname, 'data');
         }
     }
     /**
      * Load core vocabulary lists
      */
     loadCoreLists() {
-        const filePath = getPath().join(this.dataDir, `core_lists.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput } = this.fileAdapter;
+        const filePath = this.fileAdapter.join(this.dataDir, `core_lists.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load common words with baseline effort scores
      */
     loadCommonWords() {
-        const filePath = getPath().join(this.dataDir, `common_words.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `common_words.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load synonym mappings
      */
     loadSynonyms() {
-        const filePath = getPath().join(this.dataDir, `synonyms.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `synonyms.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load test sentences
      */
     loadSentences() {
-        const filePath = getPath().join(this.dataDir, `sentences.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `sentences.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
      * Load fringe vocabulary
      */
     loadFringe() {
-        const filePath = getPath().join(this.dataDir, `fringe.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `fringe.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         const data = JSON.parse(String(content));
         // Flatten nested category words if needed
         if (Array.isArray(data) && data.length > 0 && data[0].categories) {
@@ -72,8 +78,9 @@ export class ReferenceLoader {
      * Load base words hash map
      */
     loadBaseWords() {
-        const filePath = getPath().join(this.dataDir, `base_words.${this.locale}.json`);
-        const content = getFs().readFileSync(filePath, 'utf-8');
+        const { readTextFromInput, join } = this.fileAdapter;
+        const filePath = join(this.dataDir, `base_words.${this.locale}.json`);
+        const content = readTextFromInput(filePath);
         return JSON.parse(String(content));
     }
     /**
@@ -110,13 +117,14 @@ export class ReferenceLoader {
 /**
  * Get the default reference data path
  */
-export function getReferenceDataPath() {
-    return String(getPath().join(__dirname, 'data'));
+export function getReferenceDataPath(fileAdapter = defaultFileAdapter) {
+    return String(fileAdapter.join(__dirname, 'data'));
 }
 /**
  * Check if reference data files exist
  */
-export function hasReferenceData() {
+export function hasReferenceData(fileAdapter = defaultFileAdapter) {
+    const { pathExists, join } = fileAdapter;
     const dataPath = getReferenceDataPath();
     const requiredFiles = [
         'core_lists.en.json',
@@ -125,5 +133,5 @@ export function hasReferenceData() {
         'synonyms.en.json',
         'fringe.en.json',
     ];
-    return requiredFiles.every((file) => getFs().existsSync(getPath().join(dataPath, file)));
+    return requiredFiles.every((file) => pathExists(join(dataPath, file)));
 }

package/dist/browser/utils/io.js

@@ -20,7 +20,7 @@ export function getNodeRequire() {
     }
     return cachedRequire;
 }
-export function getFs() {
+function getFs() {
     if (!cachedFs) {
         try {
             const nodeRequire = getNodeRequire();
@@ -36,7 +36,7 @@ export function getFs() {
     }
     return cachedFs;
 }
-export function getPath() {
+function getPath() {
     if (!cachedPath) {
         try {
             const nodeRequire = getNodeRequire();
@@ -114,10 +114,16 @@ export function encodeText(text) {
     }
     return new TextEncoder().encode(text);
 }
-export function readBinaryFromInput(input) {
+// extname algorithm from node:path
+const splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/; //eslint-disable-line
+const splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/; //eslint-disable-line
+export function extname(path) {
+    const tail = splitDeviceRe.exec(path)?.at(3) ?? '';
+    return splitTailRe.exec(tail)?.at(3) ?? '';
+}
+function readBinaryFromInput(input) {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input);
+        return getFs().readFileSync(input);
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
         return input;
@@ -127,10 +133,9 @@ export function readBinaryFromInput(input) {
     }
     return input;
 }
-export function readTextFromInput(input, encoding = 'utf8') {
+function readTextFromInput(input, encoding = 'utf8') {
     if (typeof input === 'string') {
-        const fs = getFs();
-        return fs.readFileSync(input, encoding);
+        return getFs().readFileSync(input, encoding);
     }
     if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) {
         return input.toString(encoding);
@@ -140,11 +145,59 @@ export function readTextFromInput(input, encoding = 'utf8') {
     }
     return decodeText(input);
 }
-export function writeBinaryToPath(outputPath, data) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, data);
+function writeBinaryToPath(outputPath, data) {
+    getFs().writeFileSync(outputPath, data);
+}
+function writeTextToPath(outputPath, text) {
+    getFs().writeFileSync(outputPath, text, 'utf8');
+}
+function pathExists(path) {
+    return getFs().existsSync(path);
+}
+function isDirectory(path) {
+    return getFs().statSync(path).isDirectory();
+}
+function getFileSize(path) {
+    return getFs().statSync(path).size;
+}
+function mkDir(path, options) {
+    getFs().mkdirSync(path, options);
+}
+function listDir(path) {
+    return getFs().readdirSync(path);
+}
+function removePath(path, options) {
+    getFs().rmSync(path, options);
+}
+function mkTempDir(prefix) {
+    const path = join(getOs().tmpdir(), prefix);
+    return getFs().mkdtempSync(path);
+}
+function join(...pathParts) {
+    return getPath().join(...pathParts);
+}
+export function joinWin32(...pathParts) {
+    return getPath().win32.join(...pathParts);
+}
+function dirname(path) {
+    return getPath().dirname(path);
 }
-export function writeTextToPath(outputPath, text) {
-    const fs = getFs();
-    fs.writeFileSync(outputPath, text, 'utf8');
+function basename(path, suffix) {
+    return getPath().basename(path, suffix);
 }
+export const defaultFileAdapter = {
+    readBinaryFromInput,
+    readTextFromInput,
+    writeBinaryToPath,
+    writeTextToPath,
+    pathExists,
+    isDirectory,
+    getFileSize,
+    mkDir,
+    listDir,
+    removePath,
+    mkTempDir,
+    join,
+    dirname,
+    basename,
+};

package/dist/browser/utils/sqlite.js

@@ -1,4 +1,4 @@
-import { getFs, getNodeRequire, getOs, getPath, isNodeRuntime, readBinaryFromInput } from './io';
+import { defaultFileAdapter, getNodeRequire, isNodeRuntime } from './io';
 let sqlJsConfig = null;
 let sqlJsPromise = null;
 export function configureSqlJs(config) {
@@ -70,6 +70,7 @@ export function requireBetterSqlite3() {
     return getBetterSqlite3();
 }
 export async function openSqliteDatabase(input, options = {}) {
+    const { readBinaryFromInput, mkTempDir, writeBinaryToPath, removePath, join } = options.fileAdapter ?? defaultFileAdapter;
     if (typeof input === 'string') {
         if (!isNodeRuntime()) {
             throw new Error('SQLite file paths are not supported in browser environments.');
@@ -84,12 +85,9 @@ export async function openSqliteDatabase(input, options = {}) {
         const db = new SQL.Database(data);
         return { db: createSqlJsAdapter(db) };
     }
-    const fs = getFs();
-    const path = getPath();
-    const os = getOs();
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aac-sqlite-'));
-    const dbPath = path.join(tempDir, 'input.sqlite');
-    fs.writeFileSync(dbPath, data);
+    const tempDir = mkTempDir('aac-sqlite-');
+    const dbPath = join(tempDir, 'input.sqlite');
+    writeBinaryToPath(dbPath, data);
     const Database = getBetterSqlite3();
     const db = new Database(dbPath, { readonly: options.readonly ?? true });
     const cleanup = () => {
@@ -98,7 +96,7 @@ export async function openSqliteDatabase(input, options = {}) {
         }
         finally {
             try {
-                fs.rmSync(tempDir, { recursive: true, force: true });
+                removePath(tempDir, { recursive: true, force: true });
             }
             catch (error) {
                 console.warn('Failed to clean up temporary SQLite files:', error);

package/dist/browser/utils/zip.js

@@ -1,54 +1,56 @@
-import { isNodeRuntime, readBinaryFromInput, getNodeRequire } from './io';
-export async function openZipFromInput(input) {
-    if (typeof input === 'string') {
-        if (!isNodeRuntime()) {
-            throw new Error('Zip file paths are not supported in browser environments.');
-        }
-        const AdmZip = getNodeRequire()('adm-zip');
-        const admZip = new AdmZip(input);
-        return {
-            zip: {
-                listFiles: () => admZip.getEntries().map((entry) => entry.entryName),
-                readFile: (name) => {
-                    const entry = admZip.getEntry(name);
-                    if (!entry) {
-                        throw new Error(`Zip entry not found: ${name}`);
-                    }
-                    return Promise.resolve(entry.getData());
-                },
-            },
-        };
-    }
-    const data = readBinaryFromInput(input);
+import { isNodeRuntime, getNodeRequire, defaultFileAdapter, } from './io';
+export async function getZipAdapter(input, fileAdapter) {
+    const adapter = fileAdapter ?? defaultFileAdapter;
     if (isNodeRuntime()) {
         const AdmZip = getNodeRequire()('adm-zip');
-        const admZip = new AdmZip(Buffer.from(data));
+        const zip = input === undefined
+            ? new AdmZip(input)
+            : typeof input === 'string'
+                ? new AdmZip(input)
+                : new AdmZip(Buffer.from(adapter.readBinaryFromInput(input)));
         return {
-            zip: {
-                listFiles: () => admZip.getEntries().map((entry) => entry.entryName),
-                readFile: (name) => {
-                    const entry = admZip.getEntry(name);
-                    if (!entry) {
-                        throw new Error(`Zip entry not found: ${name}`);
-                    }
-                    return Promise.resolve(entry.getData());
-                },
+            listFiles: () => {
+                return zip
+                    .getEntries()
+                    .filter((entry) => !entry.isDirectory)
+                    .map((entry) => entry.entryName);
+            },
+            readFile: (name) => {
+                const entry = zip.getEntry(name);
+                if (!entry)
+                    throw new Error(`Zip entry not found: ${name}`);
+                return Promise.resolve(entry.getData());
+            },
+            writeFiles: (files) => {
+                files.forEach((file) => {
+                    zip.addFile(file.name, Buffer.from(file.data));
+                });
+                return Promise.resolve(zip.toBuffer());
             },
         };
     }
     const module = await import('jszip');
-    const init = module.default || module;
-    const zip = await init.loadAsync(data);
+    const JSZip = module.default || module;
+    if (input !== undefined && typeof input === 'string')
+        throw new Error('Zip file paths are not supported in browser environments.');
+    const zip = input ? await JSZip.loadAsync(adapter.readBinaryFromInput(input)) : new JSZip();
     return {
-        zip: {
-            listFiles: () => Object.keys(zip.files),
-            readFile: async (name) => {
-                const file = zip.file(name);
-                if (!file) {
-                    throw new Error(`Zip entry not found: ${name}`);
-                }
-                return file.async('uint8array');
-            },
+        listFiles: () => {
+            return Object.entries(zip.files)
+                .filter(([_, entry]) => !entry.dir)
+                .map(([name, _]) => name);
+        },
+        readFile: async (name) => {
+            const file = zip.file(name);
+            if (!file)
+                throw new Error(`Zip entry not found: ${name}`);
+            return file.async('uint8array');
+        },
+        writeFiles: async (files) => {
+            files.forEach((file) => {
+                zip.file(file.name, file.data);
+            });
+            return await zip.generateAsync({ type: 'uint8array' });
         },
     };
 }

package/dist/browser/validation/baseValidator.js

@@ -1,3 +1,5 @@
+import { defaultFileAdapter } from '../utils/io';
+import { getZipAdapter } from '../utils/zip';
 import { ValidationError, } from './validationTypes';
 /**
  * Base class for all format validators
@@ -14,6 +16,9 @@ export class BaseValidator {
             includeWarnings: options.includeWarnings ?? true,
             stopOnBlocker: options.stopOnBlocker ?? true,
             customRules: options.customRules || [],
+            fileAdapter: defaultFileAdapter,
+            zipAdapter: getZipAdapter,
+            ...options,
         };
         this.reset();
     }

package/dist/browser/validation/gridsetValidator.js

@@ -1,10 +1,9 @@
 /* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import JSZip from 'jszip';
 import * as xml2js from 'xml2js';
 import { BaseValidator } from './baseValidator';
-import { decodeText, getBasename, getFs, toUint8Array } from '../utils/io';
+import { decodeText, defaultFileAdapter, getBasename, toUint8Array, } from '../utils/io';
 /**
  * Validator for Grid3/Smartbox Gridset files (.gridset, .gridsetx)
  */
@@ -15,12 +14,12 @@ export class GridsetValidator extends BaseValidator {
     /**
      * Validate a Gridset file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new GridsetValidator();
-        const fs = getFs();
-        const content = fs.readFileSync(filePath);
-        const stats = fs.statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const content = readBinaryFromInput(filePath);
+        const size = getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is Gridset format
@@ -109,24 +108,17 @@ export class GridsetValidator extends BaseValidator {
      * Validate a ZIP archive (.gridset)
      */
     async validateZipArchive(content, filename, _filesize) {
-        let zip;
-        try {
-            zip = await JSZip.loadAsync(toUint8Array(content));
-        }
-        catch (e) {
-            this.err(`Failed to open ZIP archive: ${e.message}`, true);
-            return;
-        }
-        const entries = Object.values(zip.files).filter((entry) => !entry.dir);
+        const zip = await this._options.zipAdapter(content);
+        const entries = zip.listFiles();
         // Check for gridset.xml (required)
         await this.add_check('gridset_xml_presence', 'gridset.xml presence', async () => {
-            const gridsetEntry = entries.find((e) => e.name.toLowerCase() === 'gridset.xml');
+            const gridsetEntry = entries.find((e) => e.toLowerCase() === 'gridset.xml');
             if (!gridsetEntry) {
                 this.err('Missing gridset.xml in archive', true);
             }
             else {
                 try {
-                    const gridsetXml = await gridsetEntry.async('string');
+                    const gridsetXml = await zip.readFile(gridsetEntry);
                     const parser = new xml2js.Parser();
                     const xmlObj = await parser.parseStringPromise(gridsetXml);
                     const gridset = xmlObj.gridset || xmlObj.Gridset;
@@ -144,13 +136,13 @@ export class GridsetValidator extends BaseValidator {
         });
         // Check for settings.xml (highly recommended/required for metadata)
         await this.add_check('settings_xml_presence', 'settings.xml presence', async () => {
-            const settingsEntry = entries.find((e) => e.name.toLowerCase() === 'settings.xml');
+            const settingsEntry = entries.find((e) => e.toLowerCase() === 'settings.xml');
             if (!settingsEntry) {
                 this.warn('Missing settings.xml in archive (required for full metadata)');
             }
             else {
                 try {
-                    const settingsXml = await settingsEntry.async('string');
+                    const settingsXml = await zip.readFile(settingsEntry);
                     const parser = new xml2js.Parser();
                     const xmlObj = await parser.parseStringPromise(settingsXml);
                     const settings = xmlObj.GridSetSettings || xmlObj.gridSetSettings || xmlObj.GridsetSettings;

package/dist/browser/validation/obfValidator.js

@@ -5,7 +5,7 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 import JSZip from 'jszip';
 import { BaseValidator } from './baseValidator';
-import { decodeText, getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
+import { decodeText, defaultFileAdapter, getBasename, toUint8Array, } from '../utils/io';
 const OBF_FORMAT = 'open-board-0.1';
 const OBF_FORMAT_CURRENT_VERSION = 0.1;
 /**
@@ -18,11 +18,12 @@ export class ObfValidator extends BaseValidator {
     /**
      * Validate an OBF file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new ObfValidator();
         const content = readBinaryFromInput(filePath);
-        const stats = getFs().statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const size = getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is OBF format

package/dist/browser/validation/snapValidator.js

@@ -3,7 +3,7 @@
 import * as xml2js from 'xml2js';
 import JSZip from 'jszip';
 import { BaseValidator } from './baseValidator';
-import { getBasename, getFs, readBinaryFromInput, toUint8Array } from '../utils/io';
+import { defaultFileAdapter, getBasename, toUint8Array } from '../utils/io';
 import { openSqliteDatabase } from '../utils/sqlite';
 /**
  * Validator for Snap files (.spb, .sps)
@@ -16,11 +16,12 @@ export class SnapValidator extends BaseValidator {
     /**
      * Validate a Snap file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new SnapValidator();
         const content = readBinaryFromInput(filePath);
-        const stats = getFs().statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const size = getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is Snap format
@@ -158,7 +159,10 @@ export class SnapValidator extends BaseValidator {
         await this.add_check('sqlite', 'valid SQLite database', async () => {
             let cleanup;
             try {
-                const result = await openSqliteDatabase(content, { readonly: true });
+                const result = await openSqliteDatabase(content, {
+                    readonly: true,
+                    fileAdapter: this._options.fileAdapter,
+                });
                 const db = result.db;
                 cleanup = result.cleanup;
                 const tableRows = db

package/dist/browser/validation/touchChatValidator.js

@@ -3,9 +3,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 import * as xml2js from 'xml2js';
 import { BaseValidator } from './baseValidator';
-import { decodeText, getBasename, getFs, readBinaryFromInput, toUint8Array, } from '../utils/io';
-import { openZipFromInput } from '../utils/zip';
+import { decodeText, defaultFileAdapter, getBasename, toUint8Array, } from '../utils/io';
 import { openSqliteDatabase } from '../utils/sqlite';
+import { getZipAdapter } from '../utils/zip';
 /**
  * Validator for TouchChat files (.ce)
  * TouchChat files are ZIP archives that contain a .c4v SQLite database.
@@ -18,23 +18,26 @@ export class TouchChatValidator extends BaseValidator {
     /**
      * Validate a TouchChat file from disk
      */
-    static async validateFile(filePath) {
+    static async validateFile(filePath, fileAdapter) {
+        const { readBinaryFromInput, getFileSize } = fileAdapter ?? defaultFileAdapter;
         const validator = new TouchChatValidator();
         const content = readBinaryFromInput(filePath);
-        const stats = getFs().statSync(filePath);
-        return validator.validate(content, getBasename(filePath), stats.size);
+        const size = getFileSize(filePath);
+        return validator.validate(content, getBasename(filePath), size);
     }
     /**
      * Check if content is TouchChat format
      */
-    static async identifyFormat(content, filename, zipAdapter) {
+    static async identifyFormat(content, filename, fileAdapter = defaultFileAdapter, zipAdapter) {
         const name = filename.toLowerCase();
         if (name.endsWith('.ce')) {
             return true;
         }
         // Try to parse as ZIP and check for .c4v database
         try {
-            const { zip } = zipAdapter ? await zipAdapter(content) : await openZipFromInput(content);
+            const zip = zipAdapter
+                ? await zipAdapter(content)
+                : await getZipAdapter(content, fileAdapter);
             const entries = zip.listFiles();
             if (entries.some((entry) => entry.toLowerCase().endsWith('.c4v'))) {
                 return true;
@@ -66,7 +69,9 @@ export class TouchChatValidator extends BaseValidator {
             }
         });
         const looksLikeXml = this.isXmlBuffer(content);
-        const zipped = looksLikeXml ? false : await this.tryValidateZipSqlite(content);
+        const zipped = looksLikeXml
+            ? false
+            : await this.tryValidateZipSqlite(content, this._options.fileAdapter, this._options.zipAdapter);
         if (!zipped) {
             let xmlObj = null;
             await this.add_check('xml_parse', 'valid XML', async () => {
@@ -246,11 +251,13 @@ export class TouchChatValidator extends BaseValidator {
         }
         return bytes[start] === 0x3c; // '<'
     }
-    async tryValidateZipSqlite(content) {
+    async tryValidateZipSqlite(content, fileAdapter = defaultFileAdapter, zipAdapter) {
         let usedZip = false;
         await this.add_check('zip', 'TouchChat ZIP package', async () => {
             try {
-                const { zip } = await openZipFromInput(content);
+                const zip = zipAdapter
+                    ? await zipAdapter(content)
+                    : await getZipAdapter(content, fileAdapter);
                 const entries = zip.listFiles();
                 const vocabEntry = entries.find((name) => name.toLowerCase().endsWith('.c4v'));
                 if (!vocabEntry) {
@@ -275,7 +282,10 @@ export class TouchChatValidator extends BaseValidator {
         await this.add_check('sqlite', 'valid TouchChat SQLite database', async () => {
             let cleanup;
             try {
-                const result = await openSqliteDatabase(content, { readonly: true });
+                const result = await openSqliteDatabase(content, {
+                    readonly: true,
+                    fileAdapter: this._options.fileAdapter,
+                });
                 const db = result.db;
                 cleanup = result.cleanup;
                 const tableRows = db