yomitan-core 1.6.0 → 1.7.0

package/dist/database/node-sqlite.d.ts

@@ -0,0 +1,51 @@
+import "../dictionary-o42ErAc-.js";
+import { DeleteDictionaryProgressCallback, DictionaryAndQueryRequest, DictionaryCounts, DictionarySet, KanjiEntry, KanjiMeta, MatchType, Media$1 as Media, MediaRequest, ObjectStoreName, Summary, Tag$2 as Tag, TermEntry, TermExactRequest, TermMeta } from "../dictionary-importer-BUhx1hez.js";
+import { DictionaryDatabaseBackend } from "../backend-07mdJJW2.js";
+
+//#region src/database/node-sqlite-dictionary-database.d.ts
+type NodeSqliteDictionaryDBOptions = {
+  path: string;
+};
+declare class NodeSqliteDictionaryDB implements DictionaryDatabaseBackend {
+  private _path;
+  private _db;
+  private _isOpen;
+  constructor(options: NodeSqliteDictionaryDBOptions | string);
+  open(): Promise<void>;
+  close(): void;
+  get isOpen(): boolean;
+  purge(): Promise<boolean>;
+  deleteDictionary(dictionaryName: string, onProgress?: DeleteDictionaryProgressCallback): Promise<void>;
+  findTermsBulk(termList: string[], dictionaries: DictionarySet, matchType: MatchType): Promise<TermEntry[]>;
+  findTermsExactBulk(termList: TermExactRequest[], dictionaries: DictionarySet): Promise<TermEntry[]>;
+  findTermsBySequenceBulk(items: DictionaryAndQueryRequest[]): Promise<TermEntry[]>;
+  findTermMetaBulk(termList: string[], dictionaries: DictionarySet): Promise<TermMeta[]>;
+  findKanjiBulk(kanjiList: string[], dictionaries: DictionarySet): Promise<KanjiEntry[]>;
+  findKanjiMetaBulk(kanjiList: string[], dictionaries: DictionarySet): Promise<KanjiMeta[]>;
+  findTagMetaBulk(items: DictionaryAndQueryRequest[]): Promise<(Tag | undefined)[]>;
+  findTagForTitle(name: string, dictionary: string): Promise<Tag | undefined>;
+  getMedia(items: MediaRequest[]): Promise<Media[]>;
+  getDictionaryInfo(): Promise<Summary[]>;
+  getDictionaryCounts(dictionaryNames: string[], getTotal: boolean): Promise<DictionaryCounts>;
+  dictionaryExists(title: string): Promise<boolean>;
+  bulkAdd(objectStoreName: ObjectStoreName, items: unknown[], start: number, count: number): Promise<void>;
+  addWithResult(objectStoreName: ObjectStoreName, item: unknown): Promise<number>;
+  bulkUpdate(objectStoreName: ObjectStoreName, items: {
+    primaryKey: number;
+    data: unknown;
+  }[], start: number, count: number): Promise<void>;
+  private _getDb;
+  private _createSchema;
+  private _selectTerms;
+  private _selectJsonRows;
+  private _getInsertStatement;
+  private _getUpdateStatement;
+  private _createTerm;
+  private _createTermMeta;
+  private _createKanji;
+}
+declare function createNodeSqliteDictionaryDB(options: NodeSqliteDictionaryDBOptions | string): NodeSqliteDictionaryDB;
+
+//#endregion
+export { NodeSqliteDictionaryDB, createNodeSqliteDictionaryDB };
+//# sourceMappingURL=node-sqlite.d.ts.map

package/dist/database/node-sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-sqlite.d.ts","names":[],"sources":["../../src/database/node-sqlite-dictionary-database.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/database/node-sqlite.js

@@ -0,0 +1,501 @@
+import { stringReverse } from "../utilities-CcvCnZvO.js";
+import { log } from "../log-C6n0pevi.js";
+import Database from "better-sqlite3";
+
+//#region src/database/node-sqlite-dictionary-database.ts
+const DELETE_TARGETS = [
+	"kanji",
+	"kanjiMeta",
+	"terms",
+	"termMeta",
+	"tagMeta",
+	"media"
+];
+var NodeSqliteDictionaryDB = class {
+	_path;
+	_db = null;
+	_isOpen = false;
+	constructor(options) {
+		this._path = typeof options === "string" ? options : options.path;
+	}
+	async open() {
+		if (this._isOpen) return;
+		this._db = new Database(this._path);
+		this._db.pragma("journal_mode = WAL");
+		this._db.pragma("foreign_keys = ON");
+		this._createSchema();
+		this._isOpen = true;
+	}
+	close() {
+		if (this._db !== null) this._db.close();
+		this._db = null;
+		this._isOpen = false;
+	}
+	get isOpen() {
+		return this._isOpen;
+	}
+	async purge() {
+		try {
+			const db = this._getDb();
+			const purge = db.transaction(() => {
+				for (const storeName of ["dictionaries", ...DELETE_TARGETS]) {
+					db.prepare(`DELETE FROM ${storeName}`).run();
+					db.prepare("DELETE FROM sqlite_sequence WHERE name = ?").run(storeName);
+				}
+			});
+			purge();
+			return true;
+		} catch (e) {
+			log.error(e);
+			return false;
+		}
+	}
+	async deleteDictionary(dictionaryName, onProgress) {
+		const db = this._getDb();
+		const progressData = {
+			count: 0,
+			processed: 0,
+			storeCount: DELETE_TARGETS.length + 1,
+			storesProcesed: 0
+		};
+		for (const storeName of DELETE_TARGETS) {
+			const ids = db.prepare(`SELECT id FROM ${storeName} WHERE dictionary = ? ORDER BY id`).all(dictionaryName).map((row) => row.id);
+			progressData.storesProcesed += 1;
+			progressData.count += ids.length;
+			onProgress?.(progressData);
+			const deleteById = db.prepare(`DELETE FROM ${storeName} WHERE id = ?`);
+			const deleteBatch = db.transaction((batch) => {
+				for (const id of batch) deleteById.run(id);
+			});
+			const batchSize = 1e3;
+			for (let i = 0; i < ids.length; i += batchSize) {
+				const batch = ids.slice(i, i + batchSize);
+				deleteBatch(batch);
+				progressData.processed += batch.length;
+				onProgress?.(progressData);
+			}
+		}
+		db.prepare("DELETE FROM dictionaries WHERE title = ?").run(dictionaryName);
+		progressData.storesProcesed += 1;
+		onProgress?.(progressData);
+	}
+	async findTermsBulk(termList, dictionaries, matchType) {
+		if (termList.length === 0) return [];
+		const visited = new Set();
+		const results = [];
+		const indexNames = matchType === "suffix" ? ["expressionReverse", "readingReverse"] : ["expression", "reading"];
+		for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {
+			const item = termList[itemIndex];
+			for (let indexIndex = 0; indexIndex < indexNames.length; indexIndex += 1) {
+				const indexName = indexNames[indexIndex];
+				const queryText = matchType === "suffix" ? stringReverse(item) : item;
+				const rows = matchType === "exact" ? this._selectTerms(`${indexName} = ?`, [queryText]) : this._selectTerms(`${indexName} LIKE ? ESCAPE '\\'`, [`${escapeLike(queryText)}%`]).filter((row) => String(row[indexName] ?? "").startsWith(queryText));
+				for (const row of rows) {
+					if (!dictionaries.has(row.dictionary) || visited.has(row.id)) continue;
+					visited.add(row.id);
+					const matchSourceIsTerm = indexIndex === 0;
+					const matchSource = matchSourceIsTerm ? "term" : "reading";
+					const actualMatchType = (matchSourceIsTerm ? row.expression : row.reading) === item ? "exact" : matchType;
+					results.push(this._createTerm(matchSource, actualMatchType, row, itemIndex));
+				}
+			}
+		}
+		return results;
+	}
+	async findTermsExactBulk(termList, dictionaries) {
+		const results = [];
+		for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {
+			const item = termList[itemIndex];
+			const rows = this._selectTerms("expression = ?", [item.term]);
+			for (const row of rows) {
+				if (row.reading !== item.reading || !dictionaries.has(row.dictionary)) continue;
+				results.push(this._createTerm("term", "exact", row, itemIndex));
+			}
+		}
+		return results;
+	}
+	async findTermsBySequenceBulk(items) {
+		const results = [];
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+			const item = items[itemIndex];
+			const rows = this._selectTerms("sequence = ?", [item.query]);
+			for (const row of rows) {
+				if (row.dictionary !== item.dictionary) continue;
+				results.push(this._createTerm("sequence", "exact", row, itemIndex));
+			}
+		}
+		return results;
+	}
+	async findTermMetaBulk(termList, dictionaries) {
+		const results = [];
+		for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {
+			const rows = this._selectJsonRows("termMeta", "expression = ?", [termList[itemIndex]]);
+			for (const row of rows) if (dictionaries.has(row.dictionary)) results.push(this._createTermMeta(row, itemIndex));
+		}
+		return results;
+	}
+	async findKanjiBulk(kanjiList, dictionaries) {
+		const results = [];
+		for (let itemIndex = 0; itemIndex < kanjiList.length; itemIndex += 1) {
+			const rows = this._selectJsonRows("kanji", "character = ?", [kanjiList[itemIndex]]);
+			for (const row of rows) if (dictionaries.has(row.dictionary)) results.push(this._createKanji(row, itemIndex));
+		}
+		return results;
+	}
+	async findKanjiMetaBulk(kanjiList, dictionaries) {
+		const results = [];
+		for (let itemIndex = 0; itemIndex < kanjiList.length; itemIndex += 1) {
+			const rows = this._selectJsonRows("kanjiMeta", "character = ?", [kanjiList[itemIndex]]);
+			for (const row of rows) {
+				if (!dictionaries.has(row.dictionary)) continue;
+				results.push({
+					index: itemIndex,
+					character: row.character,
+					mode: row.mode,
+					data: row.data,
+					dictionary: row.dictionary
+				});
+			}
+		}
+		return results;
+	}
+	async findTagMetaBulk(items) {
+		const results = new Array(items.length);
+		for (let i = 0; i < items.length; i += 1) {
+			const item = items[i];
+			results[i] = this._selectJsonRows("tagMeta", "name = ? AND dictionary = ?", [item.query, item.dictionary])[0];
+		}
+		return results;
+	}
+	async findTagForTitle(name, dictionary) {
+		return this._selectJsonRows("tagMeta", "name = ? AND dictionary = ?", [name, dictionary])[0];
+	}
+	async getMedia(items) {
+		const results = [];
+		const db = this._getDb();
+		const statement = db.prepare("SELECT * FROM media WHERE path = ? ORDER BY id");
+		for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+			const item = items[itemIndex];
+			const rows = statement.all(item.path);
+			for (const row of rows) {
+				if (row.dictionary !== item.dictionary || typeof row.content === "undefined") continue;
+				results.push({
+					index: itemIndex,
+					dictionary: row.dictionary,
+					path: item.path,
+					mediaType: row.mediaType,
+					width: row.width,
+					height: row.height,
+					content: bufferToArrayBuffer(row.content)
+				});
+			}
+		}
+		return results;
+	}
+	async getDictionaryInfo() {
+		return this._selectJsonRows("dictionaries");
+	}
+	async getDictionaryCounts(dictionaryNames, getTotal) {
+		const db = this._getDb();
+		const storeNames = [
+			"kanji",
+			"kanjiMeta",
+			"terms",
+			"termMeta",
+			"tagMeta",
+			"media"
+		];
+		const counts = [];
+		let total = null;
+		if (getTotal) {
+			total = {};
+			for (const storeName of storeNames) total[storeName] = getCount(db, storeName);
+		}
+		for (const dictionaryName of dictionaryNames) {
+			const countGroup = {};
+			for (const storeName of storeNames) countGroup[storeName] = getCount(db, storeName, dictionaryName);
+			counts.push(countGroup);
+		}
+		return {
+			total,
+			counts
+		};
+	}
+	async dictionaryExists(title) {
+		const row = this._getDb().prepare("SELECT id FROM dictionaries WHERE title = ? LIMIT 1").get(title);
+		return typeof row !== "undefined";
+	}
+	async bulkAdd(objectStoreName, items, start, count) {
+		if (start + count > items.length) count = items.length - start;
+		if (count <= 0) return;
+		const batch = items.slice(start, start + count);
+		const insert = this._getInsertStatement(objectStoreName);
+		const addBatch = this._getDb().transaction((entries) => {
+			for (const item of entries) insert(item);
+		});
+		addBatch(batch);
+	}
+	async addWithResult(objectStoreName, item) {
+		return this._getInsertStatement(objectStoreName)(item);
+	}
+	async bulkUpdate(objectStoreName, items, start, count) {
+		if (start + count > items.length) count = items.length - start;
+		if (count <= 0) return;
+		const batch = items.slice(start, start + count);
+		const update = this._getUpdateStatement(objectStoreName);
+		const updateBatch = this._getDb().transaction((entries) => {
+			for (const item of entries) update(item.primaryKey, item.data);
+		});
+		updateBatch(batch);
+	}
+	_getDb() {
+		if (this._db === null) throw new Error("Database is not ready");
+		return this._db;
+	}
+	_createSchema() {
+		const db = this._getDb();
+		db.exec(`
+            CREATE TABLE IF NOT EXISTS dictionaries (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                version INTEGER,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS dictionaries_title_idx ON dictionaries(title);
+
+            CREATE TABLE IF NOT EXISTS terms (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                expression TEXT NOT NULL,
+                reading TEXT NOT NULL,
+                sequence INTEGER,
+                expressionReverse TEXT,
+                readingReverse TEXT,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS terms_expression_idx ON terms(expression);
+            CREATE INDEX IF NOT EXISTS terms_reading_idx ON terms(reading);
+            CREATE INDEX IF NOT EXISTS terms_sequence_idx ON terms(sequence);
+            CREATE INDEX IF NOT EXISTS terms_expression_reverse_idx ON terms(expressionReverse);
+            CREATE INDEX IF NOT EXISTS terms_reading_reverse_idx ON terms(readingReverse);
+            CREATE INDEX IF NOT EXISTS terms_dictionary_idx ON terms(dictionary);
+
+            CREATE TABLE IF NOT EXISTS termMeta (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                expression TEXT NOT NULL,
+                mode TEXT NOT NULL,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS term_meta_expression_idx ON termMeta(expression);
+            CREATE INDEX IF NOT EXISTS term_meta_dictionary_idx ON termMeta(dictionary);
+
+            CREATE TABLE IF NOT EXISTS kanji (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                character TEXT NOT NULL,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS kanji_character_idx ON kanji(character);
+            CREATE INDEX IF NOT EXISTS kanji_dictionary_idx ON kanji(dictionary);
+
+            CREATE TABLE IF NOT EXISTS kanjiMeta (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                character TEXT NOT NULL,
+                mode TEXT NOT NULL,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS kanji_meta_character_idx ON kanjiMeta(character);
+            CREATE INDEX IF NOT EXISTS kanji_meta_dictionary_idx ON kanjiMeta(dictionary);
+
+            CREATE TABLE IF NOT EXISTS tagMeta (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                name TEXT NOT NULL,
+                data TEXT NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS tag_meta_name_idx ON tagMeta(name);
+            CREATE INDEX IF NOT EXISTS tag_meta_dictionary_idx ON tagMeta(dictionary);
+
+            CREATE TABLE IF NOT EXISTS media (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                dictionary TEXT NOT NULL,
+                path TEXT NOT NULL,
+                mediaType TEXT NOT NULL,
+                width INTEGER NOT NULL,
+                height INTEGER NOT NULL,
+                content BLOB NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS media_path_idx ON media(path);
+            CREATE INDEX IF NOT EXISTS media_dictionary_idx ON media(dictionary);
+        `);
+	}
+	_selectTerms(whereClause, parameters) {
+		return this._selectJsonRows("terms", whereClause, parameters);
+	}
+	_selectJsonRows(table, whereClause, parameters = []) {
+		const sql = `SELECT id, data FROM ${table}${whereClause ? ` WHERE ${whereClause}` : ""} ORDER BY id`;
+		return this._getDb().prepare(sql).all(...parameters).map((row) => ({
+			...parseJsonObject(row.data),
+			id: row.id
+		}));
+	}
+	_getInsertStatement(objectStoreName) {
+		const db = this._getDb();
+		switch (objectStoreName) {
+			case "dictionaries": {
+				const statement = db.prepare("INSERT INTO dictionaries (title, version, data) VALUES (?, ?, ?)");
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.title, row.version, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "terms": {
+				const statement = db.prepare(`INSERT INTO terms
+                    (dictionary, expression, reading, sequence, expressionReverse, readingReverse, data)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)`);
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.expression, row.reading, row.sequence ?? null, row.expressionReverse ?? null, row.readingReverse ?? null, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "termMeta": {
+				const statement = db.prepare("INSERT INTO termMeta (dictionary, expression, mode, data) VALUES (?, ?, ?, ?)");
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.expression, row.mode, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "kanji": {
+				const statement = db.prepare("INSERT INTO kanji (dictionary, character, data) VALUES (?, ?, ?)");
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.character, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "kanjiMeta": {
+				const statement = db.prepare("INSERT INTO kanjiMeta (dictionary, character, mode, data) VALUES (?, ?, ?, ?)");
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.character, row.mode, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "tagMeta": {
+				const statement = db.prepare("INSERT INTO tagMeta (dictionary, name, data) VALUES (?, ?, ?)");
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.name, JSON.stringify(row)).lastInsertRowid);
+				};
+			}
+			case "media": {
+				const statement = db.prepare(`INSERT INTO media
+                    (dictionary, path, mediaType, width, height, content)
+                    VALUES (?, ?, ?, ?, ?, ?)`);
+				return (item) => {
+					const row = item;
+					return Number(statement.run(row.dictionary, row.path, row.mediaType, row.width, row.height, Buffer.from(new Uint8Array(row.content))).lastInsertRowid);
+				};
+			}
+		}
+	}
+	_getUpdateStatement(objectStoreName) {
+		const db = this._getDb();
+		switch (objectStoreName) {
+			case "dictionaries": {
+				const statement = db.prepare("UPDATE dictionaries SET title = ?, version = ?, data = ? WHERE id = ?");
+				return (primaryKey, item) => {
+					const row = item;
+					statement.run(row.title, row.version, JSON.stringify(row), primaryKey);
+				};
+			}
+			case "terms":
+			case "termMeta":
+			case "kanji":
+			case "kanjiMeta":
+			case "tagMeta":
+			case "media": throw new Error(`Unsupported update store: ${objectStoreName}`);
+		}
+	}
+	_createTerm(matchSource, matchType, row, index) {
+		const { sequence } = row;
+		return {
+			index,
+			matchType,
+			matchSource,
+			term: row.expression,
+			reading: row.reading,
+			definitionTags: splitField(row.definitionTags || row.tags),
+			termTags: splitField(row.termTags),
+			rules: splitField(row.rules),
+			definitions: row.glossary,
+			score: row.score,
+			dictionary: row.dictionary,
+			id: row.id,
+			sequence: typeof sequence === "number" ? sequence : -1
+		};
+	}
+	_createTermMeta(row, index) {
+		const { expression: term, mode, data, dictionary } = row;
+		switch (mode) {
+			case "freq": return {
+				index,
+				term,
+				mode,
+				data,
+				dictionary
+			};
+			case "pitch": return {
+				index,
+				term,
+				mode,
+				data,
+				dictionary
+			};
+			case "ipa": return {
+				index,
+				term,
+				mode,
+				data,
+				dictionary
+			};
+			default: throw new Error(`Unknown mode: ${mode}`);
+		}
+	}
+	_createKanji(row, index) {
+		const { stats } = row;
+		return {
+			index,
+			character: row.character,
+			onyomi: splitField(row.onyomi),
+			kunyomi: splitField(row.kunyomi),
+			tags: splitField(row.tags),
+			definitions: row.meanings,
+			stats: typeof stats === "object" && stats !== null ? stats : {},
+			dictionary: row.dictionary
+		};
+	}
+};
+function createNodeSqliteDictionaryDB(options) {
+	return new NodeSqliteDictionaryDB(options);
+}
+function getCount(db, storeName, dictionaryName) {
+	const row = typeof dictionaryName === "string" ? db.prepare(`SELECT COUNT(*) AS count FROM ${storeName} WHERE dictionary = ?`).get(dictionaryName) : db.prepare(`SELECT COUNT(*) AS count FROM ${storeName}`).get();
+	return row.count;
+}
+function parseJsonObject(value) {
+	return JSON.parse(value ?? "{}");
+}
+function splitField(field) {
+	return typeof field === "string" && field.length > 0 ? field.split(" ") : [];
+}
+function bufferToArrayBuffer(buffer) {
+	return Uint8Array.from(buffer).buffer;
+}
+function escapeLike(value) {
+	return value.replace(/[\\%_]/g, (character) => `\\${character}`);
+}
+
+//#endregion
+export { NodeSqliteDictionaryDB, createNodeSqliteDictionaryDB };
+//# sourceMappingURL=node-sqlite.js.map

package/dist/database/node-sqlite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-sqlite.js","names":["DELETE_TARGETS: DictionaryDatabase.ObjectStoreName[]","options: NodeSqliteDictionaryDBOptions | string","dictionaryName: string","onProgress?: DictionaryDatabase.DeleteDictionaryProgressCallback","progressData: DictionaryDatabase.DeleteDictionaryProgressData","batch: number[]","termList: string[]","dictionaries: DictionaryDatabase.DictionarySet","matchType: DictionaryDatabase.MatchType","results: DictionaryDatabase.TermEntry[]","matchSource: DictionaryDatabase.MatchSource","actualMatchType: DictionaryDatabase.MatchType","termList: DictionaryDatabase.TermExactRequest[]","items: DictionaryDatabase.DictionaryAndQueryRequest[]","results: DictionaryDatabase.TermMeta[]","kanjiList: string[]","results: DictionaryDatabase.KanjiEntry[]","results: DictionaryDatabase.KanjiMeta[]","results: (DictionaryDatabase.Tag | undefined)[]","name: string","dictionary: string","items: DictionaryDatabase.MediaRequest[]","results: DictionaryDatabase.Media[]","dictionaryNames: string[]","getTotal: boolean","storeNames: DictionaryDatabase.ObjectStoreName[]","counts: DictionaryDatabase.DictionaryCountGroup[]","total: DictionaryDatabase.DictionaryCountGroup | null","countGroup: DictionaryDatabase.DictionaryCountGroup","title: string","objectStoreName: DictionaryDatabase.ObjectStoreName","items: unknown[]","start: number","count: number","entries: unknown[]","item: unknown","items: { primaryKey: number; data: unknown }[]","entries: { primaryKey: number; data: unknown }[]","whereClause: string","parameters: unknown[]","table: string","whereClause?: string","row: DictionaryDatabase.DatabaseTermEntryWithId","index: number","row: DictionaryDatabase.DatabaseTermMeta","row: DictionaryDatabase.DatabaseKanjiEntry","db: BetterSqliteDatabase","storeName: DictionaryDatabase.ObjectStoreName","dictionaryName?: string","value: string | undefined","field: unknown","buffer: Buffer","value: string"],"sources":["../../src/database/node-sqlite-dictionary-database.ts"],"sourcesContent":["import Database from 'better-sqlite3';\nimport type { Database as BetterSqliteDatabase } from 'better-sqlite3';\nimport type * as DictionaryDatabase from '../types/dictionary-database';\nimport type * as DictionaryImporter from '../types/dictionary-importer';\nimport { log } from '../util/log';\nimport { stringReverse } from '../util/utilities';\nimport type { DictionaryDatabaseBackend } from './backend';\n\ntype NodeSqliteDictionaryDBOptions = {\n    path: string;\n};\n\ntype Row = {\n    id: number;\n    dictionary?: string;\n    title?: string;\n    data?: string;\n    content?: Buffer;\n};\n\nconst DELETE_TARGETS: DictionaryDatabase.ObjectStoreName[] = [\n    'kanji',\n    'kanjiMeta',\n    'terms',\n    'termMeta',\n    'tagMeta',\n    'media',\n];\n\nexport class NodeSqliteDictionaryDB implements DictionaryDatabaseBackend {\n    private _path: string;\n    private _db: BetterSqliteDatabase | null = null;\n    private _isOpen = false;\n\n    constructor(options: NodeSqliteDictionaryDBOptions | string) {\n        this._path = typeof options === 'string' ? options : options.path;\n    }\n\n    async open(): Promise<void> {\n        if (this._isOpen) {\n            return;\n        }\n        this._db = new Database(this._path);\n        this._db.pragma('journal_mode = WAL');\n        this._db.pragma('foreign_keys = ON');\n        this._createSchema();\n        this._isOpen = true;\n    }\n\n    close(): void {\n        if (this._db !== null) {\n            this._db.close();\n        }\n        this._db = null;\n        this._isOpen = false;\n    }\n\n    get isOpen(): boolean {\n        return this._isOpen;\n    }\n\n    async purge(): Promise<boolean> {\n        try {\n            const db = this._getDb();\n            const purge = db.transaction(() => {\n                for (const storeName of ['dictionaries', ...DELETE_TARGETS]) {\n                    db.prepare(`DELETE FROM ${storeName}`).run();\n                    // Reset rowids so reopen/repoulate behavior stays aligned with a fresh IndexedDB database.\n                    db.prepare('DELETE FROM sqlite_sequence WHERE name = ?').run(storeName);\n                }\n            });\n            purge();\n            return true;\n        } catch (e) {\n            log.error(e);\n            return false;\n        }\n    }\n\n    async deleteDictionary(\n        dictionaryName: string,\n        onProgress?: DictionaryDatabase.DeleteDictionaryProgressCallback,\n    ): Promise<void> {\n        const db = this._getDb();\n        const progressData: DictionaryDatabase.DeleteDictionaryProgressData = {\n            count: 0,\n            processed: 0,\n            storeCount: DELETE_TARGETS.length + 1,\n            storesProcesed: 0,\n        };\n\n        for (const storeName of DELETE_TARGETS) {\n            const ids = db\n                .prepare(`SELECT id FROM ${storeName} WHERE dictionary = ? ORDER BY id`)\n                .all(dictionaryName)\n                .map((row) => (row as { id: number }).id);\n\n            progressData.storesProcesed += 1;\n            progressData.count += ids.length;\n            onProgress?.(progressData);\n\n            const deleteById = db.prepare(`DELETE FROM ${storeName} WHERE id = ?`);\n            const deleteBatch = db.transaction((batch: number[]) => {\n                for (const id of batch) {\n                    deleteById.run(id);\n                }\n            });\n\n            const batchSize = 1000;\n            for (let i = 0; i < ids.length; i += batchSize) {\n                const batch = ids.slice(i, i + batchSize);\n                deleteBatch(batch);\n                progressData.processed += batch.length;\n                onProgress?.(progressData);\n            }\n        }\n\n        db.prepare('DELETE FROM dictionaries WHERE title = ?').run(dictionaryName);\n        progressData.storesProcesed += 1;\n        onProgress?.(progressData);\n    }\n\n    async findTermsBulk(\n        termList: string[],\n        dictionaries: DictionaryDatabase.DictionarySet,\n        matchType: DictionaryDatabase.MatchType,\n    ): Promise<DictionaryDatabase.TermEntry[]> {\n        if (termList.length === 0) {\n            return [];\n        }\n\n        const visited = new Set<number>();\n        const results: DictionaryDatabase.TermEntry[] = [];\n        const indexNames = matchType === 'suffix' ? ['expressionReverse', 'readingReverse'] : ['expression', 'reading'];\n\n        for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {\n            const item = termList[itemIndex];\n            for (let indexIndex = 0; indexIndex < indexNames.length; indexIndex += 1) {\n                const indexName = indexNames[indexIndex];\n                const queryText = matchType === 'suffix' ? stringReverse(item) : item;\n                // LIKE uses the index for the prefix scan; startsWith then trims off SQLite's default\n                // case-insensitive matching so results stay byte-for-byte with the IndexedDB adapter.\n                const rows =\n                    matchType === 'exact'\n                        ? this._selectTerms(`${indexName} = ?`, [queryText])\n                        : this._selectTerms(`${indexName} LIKE ? ESCAPE '\\\\'`, [`${escapeLike(queryText)}%`]).filter(\n                              (row) =>\n                                  String(row[indexName as keyof DictionaryDatabase.DatabaseTermEntry] ?? '').startsWith(\n                                      queryText,\n                                  ),\n                          );\n\n                for (const row of rows) {\n                    if (!dictionaries.has(row.dictionary) || visited.has(row.id)) {\n                        continue;\n                    }\n                    visited.add(row.id);\n\n                    const matchSourceIsTerm = indexIndex === 0;\n                    const matchSource: DictionaryDatabase.MatchSource = matchSourceIsTerm ? 'term' : 'reading';\n                    const actualMatchType: DictionaryDatabase.MatchType =\n                        (matchSourceIsTerm ? row.expression : row.reading) === item ? 'exact' : matchType;\n                    results.push(this._createTerm(matchSource, actualMatchType, row, itemIndex));\n                }\n            }\n        }\n\n        return results;\n    }\n\n    async findTermsExactBulk(\n        termList: DictionaryDatabase.TermExactRequest[],\n        dictionaries: DictionaryDatabase.DictionarySet,\n    ): Promise<DictionaryDatabase.TermEntry[]> {\n        const results: DictionaryDatabase.TermEntry[] = [];\n        for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {\n            const item = termList[itemIndex];\n            const rows = this._selectTerms('expression = ?', [item.term]);\n            for (const row of rows) {\n                if (row.reading !== item.reading || !dictionaries.has(row.dictionary)) {\n                    continue;\n                }\n                results.push(this._createTerm('term', 'exact', row, itemIndex));\n            }\n        }\n        return results;\n    }\n\n    async findTermsBySequenceBulk(\n        items: DictionaryDatabase.DictionaryAndQueryRequest[],\n    ): Promise<DictionaryDatabase.TermEntry[]> {\n        const results: DictionaryDatabase.TermEntry[] = [];\n        for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {\n            const item = items[itemIndex];\n            const rows = this._selectTerms('sequence = ?', [item.query]);\n            for (const row of rows) {\n                if (row.dictionary !== item.dictionary) {\n                    continue;\n                }\n                results.push(this._createTerm('sequence', 'exact', row, itemIndex));\n            }\n        }\n        return results;\n    }\n\n    async findTermMetaBulk(\n        termList: string[],\n        dictionaries: DictionaryDatabase.DictionarySet,\n    ): Promise<DictionaryDatabase.TermMeta[]> {\n        const results: DictionaryDatabase.TermMeta[] = [];\n        for (let itemIndex = 0; itemIndex < termList.length; itemIndex += 1) {\n            const rows = this._selectJsonRows<DictionaryDatabase.DatabaseTermMeta>('termMeta', 'expression = ?', [\n                termList[itemIndex],\n            ]);\n            for (const row of rows) {\n                if (dictionaries.has(row.dictionary)) {\n                    results.push(this._createTermMeta(row, itemIndex));\n                }\n            }\n        }\n        return results;\n    }\n\n    async findKanjiBulk(\n        kanjiList: string[],\n        dictionaries: DictionaryDatabase.DictionarySet,\n    ): Promise<DictionaryDatabase.KanjiEntry[]> {\n        const results: DictionaryDatabase.KanjiEntry[] = [];\n        for (let itemIndex = 0; itemIndex < kanjiList.length; itemIndex += 1) {\n            const rows = this._selectJsonRows<DictionaryDatabase.DatabaseKanjiEntry>('kanji', 'character = ?', [\n                kanjiList[itemIndex],\n            ]);\n            for (const row of rows) {\n                if (dictionaries.has(row.dictionary)) {\n                    results.push(this._createKanji(row, itemIndex));\n                }\n            }\n        }\n        return results;\n    }\n\n    async findKanjiMetaBulk(\n        kanjiList: string[],\n        dictionaries: DictionaryDatabase.DictionarySet,\n    ): Promise<DictionaryDatabase.KanjiMeta[]> {\n        const results: DictionaryDatabase.KanjiMeta[] = [];\n        for (let itemIndex = 0; itemIndex < kanjiList.length; itemIndex += 1) {\n            const rows = this._selectJsonRows<DictionaryDatabase.DatabaseKanjiMeta>('kanjiMeta', 'character = ?', [\n                kanjiList[itemIndex],\n            ]);\n            for (const row of rows) {\n                if (!dictionaries.has(row.dictionary)) {\n                    continue;\n                }\n                results.push({\n                    index: itemIndex,\n                    character: row.character,\n                    mode: row.mode,\n                    data: row.data,\n                    dictionary: row.dictionary,\n                });\n            }\n        }\n        return results;\n    }\n\n    async findTagMetaBulk(\n        items: DictionaryDatabase.DictionaryAndQueryRequest[],\n    ): Promise<(DictionaryDatabase.Tag | undefined)[]> {\n        const results: (DictionaryDatabase.Tag | undefined)[] = new Array(items.length);\n        for (let i = 0; i < items.length; i += 1) {\n            const item = items[i];\n            results[i] = this._selectJsonRows<DictionaryDatabase.Tag>('tagMeta', 'name = ? AND dictionary = ?', [\n                item.query,\n                item.dictionary,\n            ])[0];\n        }\n        return results;\n    }\n\n    async findTagForTitle(name: string, dictionary: string): Promise<DictionaryDatabase.Tag | undefined> {\n        return this._selectJsonRows<DictionaryDatabase.Tag>('tagMeta', 'name = ? AND dictionary = ?', [\n            name,\n            dictionary,\n        ])[0];\n    }\n\n    async getMedia(items: DictionaryDatabase.MediaRequest[]): Promise<DictionaryDatabase.Media[]> {\n        const results: DictionaryDatabase.Media[] = [];\n        const db = this._getDb();\n        const statement = db.prepare('SELECT * FROM media WHERE path = ? ORDER BY id');\n\n        for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {\n            const item = items[itemIndex];\n            const rows = statement.all(item.path) as Array<\n                Row & {\n                    mediaType: string;\n                    width: number;\n                    height: number;\n                }\n            >;\n            for (const row of rows) {\n                if (row.dictionary !== item.dictionary || typeof row.content === 'undefined') {\n                    continue;\n                }\n                results.push({\n                    index: itemIndex,\n                    dictionary: row.dictionary,\n                    path: item.path,\n                    mediaType: row.mediaType,\n                    width: row.width,\n                    height: row.height,\n                    content: bufferToArrayBuffer(row.content),\n                });\n            }\n        }\n        return results;\n    }\n\n    async getDictionaryInfo(): Promise<DictionaryImporter.Summary[]> {\n        return this._selectJsonRows<DictionaryImporter.Summary>('dictionaries');\n    }\n\n    async getDictionaryCounts(\n        dictionaryNames: string[],\n        getTotal: boolean,\n    ): Promise<DictionaryDatabase.DictionaryCounts> {\n        const db = this._getDb();\n        const storeNames: DictionaryDatabase.ObjectStoreName[] = [\n            'kanji',\n            'kanjiMeta',\n            'terms',\n            'termMeta',\n            'tagMeta',\n            'media',\n        ];\n        const counts: DictionaryDatabase.DictionaryCountGroup[] = [];\n\n        let total: DictionaryDatabase.DictionaryCountGroup | null = null;\n        if (getTotal) {\n            total = {};\n            for (const storeName of storeNames) {\n                total[storeName] = getCount(db, storeName);\n            }\n        }\n\n        for (const dictionaryName of dictionaryNames) {\n            const countGroup: DictionaryDatabase.DictionaryCountGroup = {};\n            for (const storeName of storeNames) {\n                countGroup[storeName] = getCount(db, storeName, dictionaryName);\n            }\n            counts.push(countGroup);\n        }\n\n        return { total, counts };\n    }\n\n    async dictionaryExists(title: string): Promise<boolean> {\n        const row = this._getDb().prepare('SELECT id FROM dictionaries WHERE title = ? LIMIT 1').get(title);\n        return typeof row !== 'undefined';\n    }\n\n    async bulkAdd(\n        objectStoreName: DictionaryDatabase.ObjectStoreName,\n        items: unknown[],\n        start: number,\n        count: number,\n    ): Promise<void> {\n        if (start + count > items.length) {\n            count = items.length - start;\n        }\n        if (count <= 0) {\n            return;\n        }\n\n        const batch = items.slice(start, start + count);\n        const insert = this._getInsertStatement(objectStoreName);\n        const addBatch = this._getDb().transaction((entries: unknown[]) => {\n            for (const item of entries) {\n                insert(item);\n            }\n        });\n        addBatch(batch);\n    }\n\n    async addWithResult(objectStoreName: DictionaryDatabase.ObjectStoreName, item: unknown): Promise<number> {\n        return this._getInsertStatement(objectStoreName)(item);\n    }\n\n    async bulkUpdate(\n        objectStoreName: DictionaryDatabase.ObjectStoreName,\n        items: { primaryKey: number; data: unknown }[],\n        start: number,\n        count: number,\n    ): Promise<void> {\n        if (start + count > items.length) {\n            count = items.length - start;\n        }\n        if (count <= 0) {\n            return;\n        }\n\n        const batch = items.slice(start, start + count);\n        const update = this._getUpdateStatement(objectStoreName);\n        const updateBatch = this._getDb().transaction((entries: { primaryKey: number; data: unknown }[]) => {\n            for (const item of entries) {\n                update(item.primaryKey, item.data);\n            }\n        });\n        updateBatch(batch);\n    }\n\n    private _getDb(): BetterSqliteDatabase {\n        if (this._db === null) {\n            throw new Error('Database is not ready');\n        }\n        return this._db;\n    }\n\n    private _createSchema(): void {\n        const db = this._getDb();\n        db.exec(`\n            CREATE TABLE IF NOT EXISTS dictionaries (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                title TEXT NOT NULL,\n                version INTEGER,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS dictionaries_title_idx ON dictionaries(title);\n\n            CREATE TABLE IF NOT EXISTS terms (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                expression TEXT NOT NULL,\n                reading TEXT NOT NULL,\n                sequence INTEGER,\n                expressionReverse TEXT,\n                readingReverse TEXT,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS terms_expression_idx ON terms(expression);\n            CREATE INDEX IF NOT EXISTS terms_reading_idx ON terms(reading);\n            CREATE INDEX IF NOT EXISTS terms_sequence_idx ON terms(sequence);\n            CREATE INDEX IF NOT EXISTS terms_expression_reverse_idx ON terms(expressionReverse);\n            CREATE INDEX IF NOT EXISTS terms_reading_reverse_idx ON terms(readingReverse);\n            CREATE INDEX IF NOT EXISTS terms_dictionary_idx ON terms(dictionary);\n\n            CREATE TABLE IF NOT EXISTS termMeta (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                expression TEXT NOT NULL,\n                mode TEXT NOT NULL,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS term_meta_expression_idx ON termMeta(expression);\n            CREATE INDEX IF NOT EXISTS term_meta_dictionary_idx ON termMeta(dictionary);\n\n            CREATE TABLE IF NOT EXISTS kanji (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                character TEXT NOT NULL,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS kanji_character_idx ON kanji(character);\n            CREATE INDEX IF NOT EXISTS kanji_dictionary_idx ON kanji(dictionary);\n\n            CREATE TABLE IF NOT EXISTS kanjiMeta (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                character TEXT NOT NULL,\n                mode TEXT NOT NULL,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS kanji_meta_character_idx ON kanjiMeta(character);\n            CREATE INDEX IF NOT EXISTS kanji_meta_dictionary_idx ON kanjiMeta(dictionary);\n\n            CREATE TABLE IF NOT EXISTS tagMeta (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                name TEXT NOT NULL,\n                data TEXT NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS tag_meta_name_idx ON tagMeta(name);\n            CREATE INDEX IF NOT EXISTS tag_meta_dictionary_idx ON tagMeta(dictionary);\n\n            CREATE TABLE IF NOT EXISTS media (\n                id INTEGER PRIMARY KEY AUTOINCREMENT,\n                dictionary TEXT NOT NULL,\n                path TEXT NOT NULL,\n                mediaType TEXT NOT NULL,\n                width INTEGER NOT NULL,\n                height INTEGER NOT NULL,\n                content BLOB NOT NULL\n            );\n            CREATE INDEX IF NOT EXISTS media_path_idx ON media(path);\n            CREATE INDEX IF NOT EXISTS media_dictionary_idx ON media(dictionary);\n        `);\n    }\n\n    private _selectTerms(whereClause: string, parameters: unknown[]): DictionaryDatabase.DatabaseTermEntryWithId[] {\n        return this._selectJsonRows<DictionaryDatabase.DatabaseTermEntryWithId>('terms', whereClause, parameters);\n    }\n\n    private _selectJsonRows<T>(table: string, whereClause?: string, parameters: unknown[] = []): T[] {\n        const sql = `SELECT id, data FROM ${table}${whereClause ? ` WHERE ${whereClause}` : ''} ORDER BY id`;\n        // Scalar columns exist for indexed lookup; the canonical object still lives in `data` so importer and\n        // translator logic can reuse the existing in-memory shapes without a second SQLite-specific model.\n        return (\n            this._getDb()\n                .prepare(sql)\n                .all(...parameters) as Row[]\n        ).map((row) => ({\n            ...parseJsonObject<T>(row.data),\n            id: row.id,\n        }));\n    }\n\n    private _getInsertStatement(objectStoreName: DictionaryDatabase.ObjectStoreName): (item: unknown) => number {\n        const db = this._getDb();\n        switch (objectStoreName) {\n            case 'dictionaries': {\n                const statement = db.prepare('INSERT INTO dictionaries (title, version, data) VALUES (?, ?, ?)');\n                return (item) => {\n                    const row = item as DictionaryImporter.Summary;\n                    return Number(statement.run(row.title, row.version, JSON.stringify(row)).lastInsertRowid);\n                };\n            }\n            case 'terms': {\n                const statement = db.prepare(\n                    `INSERT INTO terms\n                    (dictionary, expression, reading, sequence, expressionReverse, readingReverse, data)\n                    VALUES (?, ?, ?, ?, ?, ?, ?)`,\n                );\n                return (item) => {\n                    const row = item as DictionaryDatabase.DatabaseTermEntry;\n                    return Number(\n                        statement.run(\n                            row.dictionary,\n                            row.expression,\n                            row.reading,\n                            row.sequence ?? null,\n                            row.expressionReverse ?? null,\n                            row.readingReverse ?? null,\n                            JSON.stringify(row),\n                        ).lastInsertRowid,\n                    );\n                };\n            }\n            case 'termMeta': {\n                const statement = db.prepare(\n                    'INSERT INTO termMeta (dictionary, expression, mode, data) VALUES (?, ?, ?, ?)',\n                );\n                return (item) => {\n                    const row = item as DictionaryDatabase.DatabaseTermMeta;\n                    return Number(\n                        statement.run(row.dictionary, row.expression, row.mode, JSON.stringify(row)).lastInsertRowid,\n                    );\n                };\n            }\n            case 'kanji': {\n                const statement = db.prepare('INSERT INTO kanji (dictionary, character, data) VALUES (?, ?, ?)');\n                return (item) => {\n                    const row = item as DictionaryDatabase.DatabaseKanjiEntry;\n                    return Number(statement.run(row.dictionary, row.character, JSON.stringify(row)).lastInsertRowid);\n                };\n            }\n            case 'kanjiMeta': {\n                const statement = db.prepare(\n                    'INSERT INTO kanjiMeta (dictionary, character, mode, data) VALUES (?, ?, ?, ?)',\n                );\n                return (item) => {\n                    const row = item as DictionaryDatabase.DatabaseKanjiMeta;\n                    return Number(\n                        statement.run(row.dictionary, row.character, row.mode, JSON.stringify(row)).lastInsertRowid,\n                    );\n                };\n            }\n            case 'tagMeta': {\n                const statement = db.prepare('INSERT INTO tagMeta (dictionary, name, data) VALUES (?, ?, ?)');\n                return (item) => {\n                    const row = item as DictionaryDatabase.Tag;\n                    return Number(statement.run(row.dictionary, row.name, JSON.stringify(row)).lastInsertRowid);\n                };\n            }\n            case 'media': {\n                const statement = db.prepare(\n                    `INSERT INTO media\n                    (dictionary, path, mediaType, width, height, content)\n                    VALUES (?, ?, ?, ?, ?, ?)`,\n                );\n                return (item) => {\n                    const row = item as DictionaryDatabase.MediaDataArrayBufferContent;\n                    return Number(\n                        statement.run(\n                            row.dictionary,\n                            row.path,\n                            row.mediaType,\n                            row.width,\n                            row.height,\n                            Buffer.from(new Uint8Array(row.content)),\n                        ).lastInsertRowid,\n                    );\n                };\n            }\n        }\n    }\n\n    private _getUpdateStatement(\n        objectStoreName: DictionaryDatabase.ObjectStoreName,\n    ): (primaryKey: number, item: unknown) => void {\n        const db = this._getDb();\n        switch (objectStoreName) {\n            case 'dictionaries': {\n                const statement = db.prepare('UPDATE dictionaries SET title = ?, version = ?, data = ? WHERE id = ?');\n                return (primaryKey, item) => {\n                    const row = item as DictionaryImporter.Summary;\n                    statement.run(row.title, row.version, JSON.stringify(row), primaryKey);\n                };\n            }\n            case 'terms':\n            case 'termMeta':\n            case 'kanji':\n            case 'kanjiMeta':\n            case 'tagMeta':\n            case 'media':\n                throw new Error(`Unsupported update store: ${objectStoreName}`);\n        }\n    }\n\n    private _createTerm(\n        matchSource: DictionaryDatabase.MatchSource,\n        matchType: DictionaryDatabase.MatchType,\n        row: DictionaryDatabase.DatabaseTermEntryWithId,\n        index: number,\n    ): DictionaryDatabase.TermEntry {\n        const { sequence } = row;\n        return {\n            index,\n            matchType,\n            matchSource,\n            term: row.expression,\n            reading: row.reading,\n            definitionTags: splitField(row.definitionTags || row.tags),\n            termTags: splitField(row.termTags),\n            rules: splitField(row.rules),\n            definitions: row.glossary,\n            score: row.score,\n            dictionary: row.dictionary,\n            id: row.id,\n            sequence: typeof sequence === 'number' ? sequence : -1,\n        };\n    }\n\n    private _createTermMeta(row: DictionaryDatabase.DatabaseTermMeta, index: number): DictionaryDatabase.TermMeta {\n        const { expression: term, mode, data, dictionary } = row;\n        switch (mode) {\n            case 'freq':\n                return { index, term, mode, data, dictionary };\n            case 'pitch':\n                return { index, term, mode, data, dictionary };\n            case 'ipa':\n                return { index, term, mode, data, dictionary };\n            default:\n                throw new Error(`Unknown mode: ${mode}`);\n        }\n    }\n\n    private _createKanji(row: DictionaryDatabase.DatabaseKanjiEntry, index: number): DictionaryDatabase.KanjiEntry {\n        const { stats } = row;\n        return {\n            index,\n            character: row.character,\n            onyomi: splitField(row.onyomi),\n            kunyomi: splitField(row.kunyomi),\n            tags: splitField(row.tags),\n            definitions: row.meanings,\n            stats: typeof stats === 'object' && stats !== null ? stats : {},\n            dictionary: row.dictionary,\n        };\n    }\n}\n\nexport function createNodeSqliteDictionaryDB(options: NodeSqliteDictionaryDBOptions | string): NodeSqliteDictionaryDB {\n    return new NodeSqliteDictionaryDB(options);\n}\n\nfunction getCount(\n    db: BetterSqliteDatabase,\n    storeName: DictionaryDatabase.ObjectStoreName,\n    dictionaryName?: string,\n): number {\n    const row =\n        typeof dictionaryName === 'string'\n            ? db.prepare(`SELECT COUNT(*) AS count FROM ${storeName} WHERE dictionary = ?`).get(dictionaryName)\n            : db.prepare(`SELECT COUNT(*) AS count FROM ${storeName}`).get();\n    return (row as { count: number }).count;\n}\n\nfunction parseJsonObject<T>(value: string | undefined): T {\n    return JSON.parse(value ?? '{}') as T;\n}\n\nfunction splitField(field: unknown): string[] {\n    return typeof field === 'string' && field.length > 0 ? field.split(' ') : [];\n}\n\nfunction bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {\n    return Uint8Array.from(buffer).buffer;\n}\n\nfunction escapeLike(value: string): string {\n    return value.replace(/[\\\\%_]/g, (character) => `\\\\${character}`);\n}\n"],"mappings":"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"}

package/dist/database.d.cts

@@ -1,4 +1,5 @@
 import "./dictionary-C3FUjHaZ.cjs";
 import "./dictionary-importer-CRUzc3YR.cjs";
-import { DictionaryDB, OBJECT_STORE_NAMES, YomitanDatabase } from "./dictionary-database-DpMxja_X.cjs";
-export { DictionaryDB, OBJECT_STORE_NAMES, YomitanDatabase };
+import { DictionaryDatabaseBackend } from "./backend-B8h0EWrF.cjs";
+import { DictionaryDB, OBJECT_STORE_NAMES, YomitanDatabase } from "./dictionary-database-DGIXks-8.cjs";
+export { DictionaryDB, DictionaryDatabaseBackend, OBJECT_STORE_NAMES, YomitanDatabase };

package/dist/database.d.ts

@@ -1,4 +1,5 @@
 import "./dictionary-o42ErAc-.js";
 import "./dictionary-importer-BUhx1hez.js";
-import { DictionaryDB$1 as DictionaryDB, OBJECT_STORE_NAMES$1 as OBJECT_STORE_NAMES, YomitanDatabase$1 as YomitanDatabase } from "./dictionary-database-DPUaJQOx.js";
-export { DictionaryDB, OBJECT_STORE_NAMES, YomitanDatabase };
+import { DictionaryDatabaseBackend } from "./backend-07mdJJW2.js";
+import { DictionaryDB$1 as DictionaryDB, OBJECT_STORE_NAMES$1 as OBJECT_STORE_NAMES, YomitanDatabase$1 as YomitanDatabase } from "./dictionary-database-VKx3UEgB.js";
+export { DictionaryDB, DictionaryDatabaseBackend, OBJECT_STORE_NAMES, YomitanDatabase };