hybridtm 0.7.0 → 0.8.0

package/dist/hybridtm.js

@@ -9,13 +9,15 @@
  * Contributors:
  *     Maxprograms - initial API and implementation
  *******************************************************************************/
-import { connect } from '@lancedb/lancedb';
-import { pipeline } from '@xenova/transformers';
+import { pipeline } from '@huggingface/transformers';
+import { connect, Index } from '@lancedb/lancedb';
 import { Field, FixedSizeList, Float32, Int32, Schema, Utf8 } from 'apache-arrow';
-import { unlinkSync } from 'node:fs';
+import { createWriteStream, existsSync, unlinkSync } from 'node:fs';
 import { tmpdir } from "node:os";
 import { join } from 'node:path';
 import { TMReader } from 'sdltm';
+import { XMLAttribute, XMLElement } from 'typesxml';
+import { BackupReader } from './backupReader.js';
 import { BatchImporter } from './batchImporter.js';
 import { resolveImportOptions } from './importOptions.js';
 import { Match } from './match.js';
@@ -25,18 +27,19 @@ import { Utils } from './utils.js';
 import { XLIFFReader } from './xliffReader.js';
 export class HybridTM {
     // OPTIMIZED MODELS
-    static SPEED_MODEL = 'Xenova/bge-small-en-v1.5'; // 384-dim, optimized for real-time
-    static QUALITY_MODEL = 'Xenova/LaBSE'; // 768-dim, optimized for accuracy
-    static RESOURCE_MODEL = 'Xenova/multilingual-e5-small'; // 384-dim, optimized for modest hardware
+    static COMPACT_MODEL = 'Xenova/multilingual-e5-small'; // 384-dim, smallest footprint
+    static STANDARD_MODEL = 'Xenova/paraphrase-multilingual-MiniLM-L12-v2'; // 384-dim, same footprint as compact
+    static LARGE_MODEL = 'onnx-community/gte-multilingual-base'; // 768-dim, largest footprint
     name;
     db = null;
     table = null;
     dbPath = '';
     embedder = null;
+    embedderPromise = null;
     modelName = '';
     initialized = false;
     initializationPromise = null;
-    constructor(name, filePath, modelName = HybridTM.QUALITY_MODEL) {
+    constructor(name, filePath, modelName = HybridTM.LARGE_MODEL) {
         this.name = name;
         this.dbPath = filePath;
         this.modelName = modelName;
@@ -117,6 +120,10 @@ export class HybridTM {
                 ]);
                 // Create table with the schema
                 this.table = await this.db.createEmptyTable('langEntry', schema);
+                // "id" is looked up by exact match constantly (storeLangEntry/storeBatchEntries
+                // dedup, entryExists, getLangEntry, deleteLangEntry, findTargetEntry); without a
+                // scalar index each lookup is a full table scan.
+                await this.table.createIndex('id', { config: Index.btree(), waitTimeoutSeconds: 30 });
             }
             else {
                 this.table = await this.db.openTable('langEntry');
@@ -127,11 +134,21 @@ export class HybridTM {
             throw err;
         }
     }
-    async initializeEmbedder() {
+    initializeEmbedder() {
+        if (!this.embedderPromise) {
+            this.embedderPromise = this.loadEmbedder();
+        }
+        return this.embedderPromise;
+    }
+    async loadEmbedder() {
         try {
-            this.embedder = await pipeline('feature-extraction', this.modelName);
+            // dtype must be explicit: some models ship an unquantized model.onnx that
+            // requires an external model.onnx_data file Transformers.js does not reliably
+            // fetch/mount; quantized variants are single-file and avoid it.
+            this.embedder = await pipeline('feature-extraction', this.modelName, { dtype: 'q8' });
         }
         catch (err) {
+            this.embedderPromise = null;
             console.error('Error initializing embedder:', err);
             throw err;
         }
@@ -408,9 +425,21 @@ export class HybridTM {
     }
     async close() {
         try {
+            if (this.table) {
+                this.table.close();
+                this.table = null;
+            }
             if (this.db) {
-                // LanceDB connections are automatically managed
+                this.db.close();
+                this.db = null;
+            }
+            if (this.embedder) {
+                await this.embedder.dispose();
+                this.embedder = null;
             }
+            this.embedderPromise = null;
+            this.initialized = false;
+            this.initializationPromise = null;
         }
         catch (err) {
             console.error('Error closing database:', err);
@@ -423,9 +452,12 @@ export class HybridTM {
         // Enhanced concordance search: finds text fragments and returns all language variants for matching units
         try {
             const table = await this.ensureTable();
-            const escapeLiteral = (value) => value.replaceAll("'", "''");
-            const escapedFragment = escapeLiteral(textFragment);
-            const whereFragment = 'language = ' + '\'' + language + '\'' + ' AND contains(pureText, ' + '\'' + escapedFragment + '\')';
+            const normalizedLang = Utils.normalizeLanguage(language);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + language + '"');
+            }
+            const escapedFragment = Utils.replaceQuotes(textFragment);
+            const whereFragment = 'language = ' + '\'' + normalizedLang + '\'' + ' AND contains(pureText, ' + '\'' + escapedFragment + '\')';
             const fragmentEntries = this.hydrateEntries(await table
                 .query()
                 .where(whereFragment)
@@ -452,7 +484,7 @@ export class HybridTM {
             const result = [];
             for (const descriptor of segmentDescriptors.values()) {
                 const segmentPrefix = descriptor.fileId + ':' + descriptor.unitId + ':' + descriptor.segmentIndex + ':';
-                const sanitizedPrefix = escapeLiteral(segmentPrefix);
+                const sanitizedPrefix = Utils.replaceQuotes(segmentPrefix);
                 const segmentVariants = this.hydrateEntries(await table
                     .query()
                     .where('starts_with(id, ' + '\'' + sanitizedPrefix + '\')')
@@ -488,10 +520,14 @@ export class HybridTM {
     async semanticSearch(queryText, language, limit = 10, filters) {
         try {
             const table = await this.ensureTable();
+            const normalizedLang = Utils.normalizeLanguage(language);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + language + '"');
+            }
             const queryEmbedding = await this.generateEmbedding(queryText);
             const results = this.hydrateEntries(await table
                 .vectorSearch(queryEmbedding)
-                .where('language = ' + '\'' + language + '\'')
+                .where('language = ' + '\'' + normalizedLang + '\'')
                 .limit(limit)
                 .toArray());
             const filtered = filters
@@ -507,12 +543,24 @@ export class HybridTM {
     async semanticTranslationSearch(searchStr, srcLang, tgtLang, similarity, limit = 100, filters) {
         try {
             const table = await this.ensureTable();
+            const normalizedSrc = Utils.normalizeLanguage(srcLang);
+            if (!normalizedSrc) {
+                throw new Error('Invalid language code "' + srcLang + '"');
+            }
+            const normalizedTgt = Utils.normalizeLanguage(tgtLang);
+            if (!normalizedTgt) {
+                throw new Error('Invalid language code "' + tgtLang + '"');
+            }
             // Generate embedding for the search string
             const queryEmbedding = await this.generateEmbedding(searchStr);
-            // Get all entries for the source language
+            // Fetch a candidate pool well beyond the requested output size: hybrid re-ranking
+            // below can reorder results relative to raw vector distance, so a tight candidate
+            // pool can silently exclude the true best match before re-ranking ever sees it.
+            const candidateLimit = Math.max(limit * 5, 50);
             const sourceEntries = this.hydrateEntries(await table
                 .vectorSearch(queryEmbedding)
-                .where('language = ' + '\'' + srcLang + '\'')
+                .where('language = ' + '\'' + normalizedSrc + '\'')
+                .limit(candidateLimit)
                 .toArray());
             const rankedMatches = [];
             const sourceCriteria = filters?.source;
@@ -536,7 +584,7 @@ export class HybridTM {
                 const hybridScore = Math.round((semanticScore + fuzzyScore) / 2);
                 // Only include matches that meet the minimum similarity threshold
                 if (hybridScore >= similarity) {
-                    const targetEntry = await this.findTargetEntry(table, sourceEntry, tgtLang, targetCriteria);
+                    const targetEntry = await this.findTargetEntry(table, sourceEntry, normalizedTgt, targetCriteria);
                     if (!targetEntry) {
                         continue;
                     }
@@ -560,7 +608,7 @@ export class HybridTM {
         }
         catch (err) {
             console.error('Error performing semantic search with quality:', err);
-            return [];
+            throw err;
         }
     }
     async findTargetEntry(table, sourceEntry, tgtLang, filters) {
@@ -578,10 +626,9 @@ export class HybridTM {
         }
         const unitPrefix = sourceEntry.fileId + ':' + sourceEntry.unitId + ':';
         const sanitizedPrefix = Utils.replaceQuotes(unitPrefix);
-        const sanitizedLang = Utils.replaceQuotes(tgtLang);
         const unitMatches = this.hydrateEntries(await table
             .query()
-            .where('starts_with(id, ' + '\'' + sanitizedPrefix + '\') AND language = ' + '\'' + sanitizedLang + '\'')
+            .where('starts_with(id, ' + '\'' + sanitizedPrefix + '\') AND language = ' + '\'' + tgtLang + '\'')
             .limit(50)
             .toArray());
         if (unitMatches.length === 0) {
@@ -720,40 +767,51 @@ export class HybridTM {
     async storeLangEntry(fileId, original, unitId, lang, pureText, element, embeddings, segmentIndex = 0, segmentCount = 1, metadata) {
         try {
             const table = await this.ensureTable();
-            const sanitizedFileId = Utils.replaceQuotes(fileId);
-            const sanitizedUnitId = Utils.replaceQuotes(unitId);
+            const normalizedLang = Utils.normalizeLanguage(lang);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + lang + '"');
+            }
             const safeSegmentIndex = typeof segmentIndex === 'number' ? segmentIndex : 0;
             const safeSegmentCount = typeof segmentCount === 'number' && segmentCount > 0 ? segmentCount : 1;
-            const entryId = this.buildEntryId(sanitizedFileId, sanitizedUnitId, safeSegmentIndex, lang);
+            const entryId = this.buildEntryId(fileId, unitId, safeSegmentIndex, normalizedLang);
             const existingEntries = this.hydrateEntries(await table
                 .query()
-                .where('id = ' + '\'' + entryId + '\'')
+                .where('id = ' + '\'' + Utils.replaceQuotes(entryId) + '\'')
                 .toArray());
+            let existingVector;
             if (existingEntries.length > 0) {
                 const existingEntry = existingEntries[0];
                 const contentChanged = (existingEntry.pureText !== pureText ||
                     existingEntry.element !== element.toString() ||
                     existingEntry.original !== original);
-                if (!contentChanged) {
+                const metadataChanged = JSON.stringify(this.flattenMetadata(existingEntry.metadata))
+                    !== JSON.stringify(this.flattenMetadata(metadata));
+                if (!contentChanged && !metadataChanged) {
                     return;
                 }
+                if (!contentChanged) {
+                    existingVector = existingEntry.vector;
+                }
             }
             // Generate embeddings if not provided
             let vectorEmbeddings;
             if (embeddings && embeddings.length > 0) {
                 vectorEmbeddings = embeddings;
             }
+            else if (existingVector && existingVector.length > 0) {
+                vectorEmbeddings = existingVector;
+            }
             else {
                 vectorEmbeddings = await this.generateEmbedding(pureText);
             }
             const entry = {
                 id: entryId,
-                language: lang,
+                language: normalizedLang,
                 pureText: pureText,
                 element: element.toString(),
-                fileId: sanitizedFileId,
+                fileId: fileId,
                 original: original,
-                unitId: sanitizedUnitId,
+                unitId: unitId,
                 vector: vectorEmbeddings,
                 segmentIndex: safeSegmentIndex,
                 segmentCount: safeSegmentCount,
@@ -761,7 +819,7 @@ export class HybridTM {
             };
             // Delete existing entry first (LanceDB upsert approach)
             try {
-                await table.delete('id = ' + '\'' + entryId + '\'');
+                await table.delete('id = ' + '\'' + Utils.replaceQuotes(entryId) + '\'');
             }
             catch (deleteErr) {
                 // Entry might not exist, which is fine
@@ -781,20 +839,22 @@ export class HybridTM {
             const entryIds = [];
             // Generate embeddings one by one and build LangEntry objects
             for (const entry of entries) {
-                const sanitizedFileId = Utils.replaceQuotes(entry.fileId);
-                const sanitizedUnitId = Utils.replaceQuotes(entry.unitId);
+                const normalizedLang = Utils.normalizeLanguage(entry.language);
+                if (!normalizedLang) {
+                    throw new Error('Invalid language code "' + entry.language + '"');
+                }
                 const vectorEmbeddings = await this.generateEmbedding(entry.pureText);
                 const safeSegmentIndex = typeof entry.segmentIndex === 'number' ? entry.segmentIndex : 0;
                 const safeSegmentCount = typeof entry.segmentCount === 'number' && entry.segmentCount > 0 ? entry.segmentCount : 1;
-                const entryId = this.buildEntryId(sanitizedFileId, sanitizedUnitId, safeSegmentIndex, entry.language);
+                const entryId = this.buildEntryId(entry.fileId, entry.unitId, safeSegmentIndex, normalizedLang);
                 const langEntry = {
                     id: entryId,
-                    language: entry.language,
+                    language: normalizedLang,
                     pureText: entry.pureText,
                     element: entry.element.toString(),
-                    fileId: sanitizedFileId,
+                    fileId: entry.fileId,
                     original: entry.original,
-                    unitId: sanitizedUnitId,
+                    unitId: entry.unitId,
                     vector: vectorEmbeddings,
                     segmentIndex: safeSegmentIndex,
                     segmentCount: safeSegmentCount,
@@ -806,7 +866,7 @@ export class HybridTM {
             // Delete any existing entries with these IDs to prevent duplicates
             // This ensures that if the same file is imported twice, entries are overwritten
             if (entryIds.length > 0) {
-                const idsFilter = entryIds.map(id => '\'' + id + '\'').join(',');
+                const idsFilter = entryIds.map(id => '\'' + Utils.replaceQuotes(id) + '\'').join(',');
                 try {
                     await table.delete('id IN (' + idsFilter + ')');
                 }
@@ -825,18 +885,15 @@ export class HybridTM {
     }
     async entryExists(fileId, unitId, lang, segmentIndex = 0) {
         try {
-            if (!this.table) {
-                await this.initializeDatabase();
-            }
-            if (!this.table) {
-                throw new Error('Failed to initialize database table');
+            const table = await this.ensureTable();
+            const normalizedLang = Utils.normalizeLanguage(lang);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + lang + '"');
             }
-            const sanitizedFileId = Utils.replaceQuotes(fileId);
-            const sanitizedUnitId = Utils.replaceQuotes(unitId);
-            const entryId = this.buildEntryId(sanitizedFileId, sanitizedUnitId, segmentIndex, lang);
-            const existingEntries = this.hydrateEntries(await this.table
+            const entryId = this.buildEntryId(fileId, unitId, segmentIndex, normalizedLang);
+            const existingEntries = this.hydrateEntries(await table
                 .query()
-                .where('id = ' + '\'' + entryId + '\'')
+                .where('id = ' + '\'' + Utils.replaceQuotes(entryId) + '\'')
                 .toArray());
             return existingEntries.length > 0;
         }
@@ -847,18 +904,15 @@ export class HybridTM {
     }
     async getLangEntry(fileId, unitId, lang, segmentIndex = 0) {
         try {
-            if (!this.table) {
-                await this.initializeDatabase();
-            }
-            if (!this.table) {
-                throw new Error('Failed to initialize database table');
+            const table = await this.ensureTable();
+            const normalizedLang = Utils.normalizeLanguage(lang);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + lang + '"');
             }
-            const sanitizedFileId = Utils.replaceQuotes(fileId);
-            const sanitizedUnitId = Utils.replaceQuotes(unitId);
-            const entryId = this.buildEntryId(sanitizedFileId, sanitizedUnitId, segmentIndex, lang);
-            const existingEntries = this.hydrateEntries(await this.table
+            const entryId = this.buildEntryId(fileId, unitId, segmentIndex, normalizedLang);
+            const existingEntries = this.hydrateEntries(await table
                 .query()
-                .where('id = ' + '\'' + entryId + '\'')
+                .where('id = ' + '\'' + Utils.replaceQuotes(entryId) + '\'')
                 .toArray());
             return existingEntries.length > 0 ? existingEntries[0] : null;
         }
@@ -869,22 +923,19 @@ export class HybridTM {
     }
     async deleteLangEntry(fileId, unitId, lang, segmentIndex = 0) {
         try {
-            if (!this.table) {
-                await this.initializeDatabase();
-            }
-            if (!this.table) {
-                throw new Error('Failed to initialize database table');
+            const table = await this.ensureTable();
+            const normalizedLang = Utils.normalizeLanguage(lang);
+            if (!normalizedLang) {
+                throw new Error('Invalid language code "' + lang + '"');
             }
-            const sanitizedFileId = Utils.replaceQuotes(fileId);
-            const sanitizedUnitId = Utils.replaceQuotes(unitId);
-            const entryId = this.buildEntryId(sanitizedFileId, sanitizedUnitId, segmentIndex, lang);
+            const entryId = this.buildEntryId(fileId, unitId, segmentIndex, normalizedLang);
             // Check if entry exists first
             const exists = await this.entryExists(fileId, unitId, lang, segmentIndex);
             if (!exists) {
                 return false;
             }
             // Delete the entry
-            await this.table.delete('id = \'' + entryId + '\'');
+            await table.delete('id = \'' + Utils.replaceQuotes(entryId) + '\'');
             return true;
         }
         catch (err) {
@@ -923,13 +974,157 @@ export class HybridTM {
         const productName = packageJson.default.productName;
         const version = packageJson.default.version;
         const tmReader = new TMReader({ 'productName': productName, 'version': version });
-        const data = await tmReader.convert(filePath, tempFilePath);
-        if (data.status !== 'Success') {
-            throw new Error('SDL TM conversion failed for file ' + filePath);
+        try {
+            const data = await tmReader.convert(filePath, tempFilePath);
+            if (data.status !== 'Success') {
+                throw new Error('SDL TM conversion failed for file ' + filePath);
+            }
+            return await this.importTMX(tempFilePath, options);
+        }
+        finally {
+            if (existsSync(tempFilePath)) {
+                unlinkSync(tempFilePath);
+            }
+        }
+    }
+    async restore(filePath) {
+        const reader = new BackupReader(filePath);
+        await reader.parse();
+        const importer = new BatchImporter(this, reader.getTempFilePath(), reader.getEntryCount());
+        await importer.import();
+        return reader.getEntryCount();
+    }
+    async backup(outputPath) {
+        try {
+            const table = await this.ensureTable();
+            const schema = await table.schema();
+            const columns = schema.fields
+                .map((field) => field.name)
+                .filter((name) => name !== 'vector');
+            const writeStream = createWriteStream(outputPath, { encoding: 'utf8' });
+            const completionPromise = new Promise((resolve, reject) => {
+                writeStream.once('finish', resolve);
+                writeStream.once('error', reject);
+            });
+            const rootElement = new XMLElement('backup');
+            rootElement.setAttribute(new XMLAttribute('name', this.name));
+            rootElement.setAttribute(new XMLAttribute('model', this.modelName));
+            rootElement.setAttribute(new XMLAttribute('date', new Date().toISOString()));
+            writeStream.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+            writeStream.write(rootElement.getHead() + '\n');
+            let entryCount = 0;
+            for await (const batch of table.query().select(columns)) {
+                for (const row of batch) {
+                    const entry = this.hydrateEntry(row);
+                    writeStream.write(this.buildBackupEntryElement(entry).toString() + '\n');
+                    entryCount++;
+                }
+            }
+            writeStream.write(rootElement.getTail() + '\n');
+            writeStream.end();
+            await completionPromise;
+            return entryCount;
+        }
+        catch (err) {
+            console.error('Error creating backup:', err);
+            throw err;
+        }
+    }
+    buildBackupEntryElement(entry) {
+        const entryElement = new XMLElement('entry');
+        entryElement.setAttribute(new XMLAttribute('id', entry.id));
+        entryElement.setAttribute(new XMLAttribute('language', entry.language));
+        entryElement.setAttribute(new XMLAttribute('fileId', entry.fileId));
+        entryElement.setAttribute(new XMLAttribute('original', entry.original));
+        entryElement.setAttribute(new XMLAttribute('unitId', entry.unitId));
+        entryElement.setAttribute(new XMLAttribute('segmentIndex', entry.segmentIndex.toString()));
+        entryElement.setAttribute(new XMLAttribute('segmentCount', entry.segmentCount.toString()));
+        const pureTextElement = new XMLElement('pureText');
+        pureTextElement.addString(entry.pureText);
+        entryElement.addElement(pureTextElement);
+        const elementWrapper = new XMLElement('element');
+        elementWrapper.addElement(Utils.buildXMLElement(entry.element));
+        entryElement.addElement(elementWrapper);
+        const metadataElement = this.buildBackupMetadataElement(entry.metadata);
+        if (metadataElement) {
+            entryElement.addElement(metadataElement);
+        }
+        return entryElement;
+    }
+    buildBackupMetadataElement(metadata) {
+        if (!metadata || Object.keys(metadata).length === 0) {
+            return undefined;
+        }
+        const metadataElement = new XMLElement('metadata');
+        this.appendTextElement(metadataElement, 'state', metadata.state);
+        this.appendTextElement(metadataElement, 'subState', metadata.subState);
+        this.appendTextElement(metadataElement, 'quality', typeof metadata.quality === 'number' ? metadata.quality.toString() : undefined);
+        this.appendTextElement(metadataElement, 'creationDate', metadata.creationDate);
+        this.appendTextElement(metadataElement, 'creationId', metadata.creationId);
+        this.appendTextElement(metadataElement, 'changeDate', metadata.changeDate);
+        this.appendTextElement(metadataElement, 'changeId', metadata.changeId);
+        this.appendTextElement(metadataElement, 'creationTool', metadata.creationTool);
+        this.appendTextElement(metadataElement, 'creationToolVersion', metadata.creationToolVersion);
+        this.appendTextElement(metadataElement, 'context', metadata.context);
+        this.appendTextElement(metadataElement, 'usageCount', typeof metadata.usageCount === 'number' ? metadata.usageCount.toString() : undefined);
+        this.appendTextElement(metadataElement, 'lastUsageDate', metadata.lastUsageDate);
+        if (metadata.notes && metadata.notes.length > 0) {
+            const notesElement = new XMLElement('notes');
+            metadata.notes.forEach((note) => {
+                const noteElement = new XMLElement('note');
+                noteElement.addString(note);
+                notesElement.addElement(noteElement);
+            });
+            metadataElement.addElement(notesElement);
+        }
+        if (metadata.properties && Object.keys(metadata.properties).length > 0) {
+            const propertiesElement = new XMLElement('properties');
+            Object.entries(metadata.properties).forEach(([key, value]) => {
+                const propertyElement = new XMLElement('property');
+                propertyElement.setAttribute(new XMLAttribute('name', key));
+                propertyElement.addString(value);
+                propertiesElement.addElement(propertyElement);
+            });
+            metadataElement.addElement(propertiesElement);
+        }
+        if (metadata.segment) {
+            const segment = metadata.segment;
+            const segmentElement = new XMLElement('segment');
+            if (segment.provider) {
+                segmentElement.setAttribute(new XMLAttribute('provider', segment.provider));
+            }
+            if (segment.fileHash) {
+                segmentElement.setAttribute(new XMLAttribute('fileHash', segment.fileHash));
+            }
+            if (segment.fileId) {
+                segmentElement.setAttribute(new XMLAttribute('fileId', segment.fileId));
+            }
+            if (segment.unitId) {
+                segmentElement.setAttribute(new XMLAttribute('unitId', segment.unitId));
+            }
+            if (segment.segmentId) {
+                segmentElement.setAttribute(new XMLAttribute('segmentId', segment.segmentId));
+            }
+            if (segment.segmentKey) {
+                segmentElement.setAttribute(new XMLAttribute('segmentKey', segment.segmentKey));
+            }
+            if (typeof segment.segmentIndex === 'number') {
+                segmentElement.setAttribute(new XMLAttribute('segmentIndex', segment.segmentIndex.toString()));
+            }
+            if (typeof segment.segmentCount === 'number') {
+                segmentElement.setAttribute(new XMLAttribute('segmentCount', segment.segmentCount.toString()));
+            }
+            metadataElement.addElement(segmentElement);
+        }
+        return metadataElement;
+    }
+    appendTextElement(parent, name, value) {
+        if (!value) {
+            return;
         }
-        const count = await this.importTMX(tempFilePath, options);
-        unlinkSync(tempFilePath);
-        return count;
+        const child = new XMLElement(name);
+        child.addString(value);
+        parent.addElement(child);
     }
 }
 //# sourceMappingURL=hybridtm.js.map