@ngx-i18nsupport/ngx-i18nsupport-lib
Version:
A Typescript library to work with Angular generated i18n files (xliff, xmb)
286 lines • 35.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { FORMAT_XTB, FILETYPE_XTB, FORMAT_XMB } from '../api/constants';
import { format } from 'util';
import { DOMUtilities } from './dom-utilities';
import { AbstractTranslationMessagesFile } from './abstract-translation-messages-file';
import { XtbTransUnit } from './xtb-trans-unit';
/**
* Created by martin on 23.05.2017.
* xtb-File access.
* xtb is the translated counterpart to xmb.
*/
export class XtbFile extends AbstractTranslationMessagesFile {
// an xmb-file
/**
* Create an xmb-File from source.
* @param {?} _translationMessageFileFactory factory to create a translation file (xtb) for the xmb file
* @param {?} xmlString file content
* @param {?} path Path to file
* @param {?} encoding optional encoding of the xml.
* This is read from the file, but if you know it before, you can avoid reading the file twice.
* @param {?=} optionalMaster in case of xmb the master file, that contains the original texts.
* (this is used to support state infos, that are based on comparing original with translated version)
*/
constructor(_translationMessageFileFactory, xmlString, path, encoding, optionalMaster) {
super();
this._translationMessageFileFactory = _translationMessageFileFactory;
this._warnings = [];
this._numberOfTransUnitsWithMissingId = 0;
this.initializeFromContent(xmlString, path, encoding, optionalMaster);
}
/**
* @private
* @param {?} xmlString
* @param {?} path
* @param {?} encoding
* @param {?=} optionalMaster
* @return {?}
*/
initializeFromContent(xmlString, path, encoding, optionalMaster) {
this.parseContent(xmlString, path, encoding);
if (this._parsedDocument.getElementsByTagName('translationbundle').length !== 1) {
throw new Error(format('File "%s" seems to be no xtb file (should contain a translationbundle element)', path));
}
if (optionalMaster) {
try {
this._masterFile = this._translationMessageFileFactory.createFileFromFileContent(FORMAT_XMB, optionalMaster.xmlContent, optionalMaster.path, optionalMaster.encoding);
// check, wether this can be the master ...
/** @type {?} */
const numberInMaster = this._masterFile.numberOfTransUnits();
/** @type {?} */
const myNumber = this.numberOfTransUnits();
if (numberInMaster !== myNumber) {
this._warnings.push(format('%s trans units found in master, but this file has %s. Check if it is the correct master', numberInMaster, myNumber));
}
}
catch (error) {
throw new Error(format('File "%s" seems to be no xmb file. An xtb file needs xmb as master file.', optionalMaster.path));
}
}
return this;
}
/**
* @protected
* @return {?}
*/
initializeTransUnits() {
this.transUnits = [];
/** @type {?} */
const transUnitsInFile = this._parsedDocument.getElementsByTagName('translation');
for (let i = 0; i < transUnitsInFile.length; i++) {
/** @type {?} */
const msg = transUnitsInFile.item(i);
/** @type {?} */
const id = msg.getAttribute('id');
if (!id) {
this._warnings.push(format('oops, msg without "id" found in master, please check file %s', this._filename));
}
/** @type {?} */
let masterUnit = null;
if (this._masterFile) {
masterUnit = this._masterFile.transUnitWithId(id);
}
this.transUnits.push(new XtbTransUnit(msg, id, this, (/** @type {?} */ (masterUnit))));
}
}
/**
* File format as it is used in config files.
* Currently 'xlf', 'xlf2', 'xmb', 'xtb'
* Returns one of the constants FORMAT_..
* @return {?}
*/
i18nFormat() {
return FORMAT_XTB;
}
/**
* File type.
* Here 'XTB'
* @return {?}
*/
fileType() {
return FILETYPE_XTB;
}
/**
* return tag names of all elements that have mixed content.
* These elements will not be beautified.
* Typical candidates are source and target.
* @protected
* @return {?}
*/
elementsWithMixedContent() {
return ['translation'];
}
/**
* Get source language.
* Unsupported in xmb/xtb.
* Try to guess it from master filename if any..
* @return {?} source language.
*/
sourceLanguage() {
if (this._masterFile) {
return this._masterFile.sourceLanguage();
}
else {
return null;
}
}
/**
* Edit the source language.
* Unsupported in xmb/xtb.
* @param {?} language language
* @return {?}
*/
setSourceLanguage(language) {
// do nothing, xtb has no notation for this.
}
/**
* Get target language.
* @return {?} target language.
*/
targetLanguage() {
/** @type {?} */
const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');
if (translationbundleElem) {
return translationbundleElem.getAttribute('lang');
}
else {
return null;
}
}
/**
* Edit the target language.
* @param {?} language language
* @return {?}
*/
setTargetLanguage(language) {
/** @type {?} */
const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');
if (translationbundleElem) {
translationbundleElem.setAttribute('lang', language);
}
}
/**
* Add a new trans-unit to this file.
* The trans unit stems from another file.
* It copies the source content of the tu to the target content too,
* depending on the values of isDefaultLang and copyContent.
* So the source can be used as a dummy translation.
* (used by xliffmerge)
* @throws an error if trans-unit with same id already is in the file.
* @param {?} foreignTransUnit the trans unit to be imported.
* @param {?} isDefaultLang Flag, wether file contains the default language.
* Then source and target are just equal.
* The content will be copied.
* State will be final.
* @param {?} copyContent Flag, wether to copy content or leave it empty.
* Wben true, content will be copied from source.
* When false, content will be left empty (if it is not the default language).
* @param {?=} importAfterElement optional (since 1.10) other transunit (part of this file), that should be used as ancestor.
* Newly imported trans unit is then inserted directly after this element.
* If not set or not part of this file, new unit will be imported at the end.
* If explicity set to null, new unit will be imported at the start.
* @return {?} the newly imported trans unit (since version 1.7.0)
*/
importNewTransUnit(foreignTransUnit, isDefaultLang, copyContent, importAfterElement) {
if (this.transUnitWithId(foreignTransUnit.id)) {
throw new Error(format('tu with id %s already exists in file, cannot import it', foreignTransUnit.id));
}
/** @type {?} */
const newMasterTu = ((/** @type {?} */ (foreignTransUnit))).cloneWithSourceAsTarget(isDefaultLang, copyContent, this);
/** @type {?} */
const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');
if (!translationbundleElem) {
throw new Error(format('File "%s" seems to be no xtb file (should contain a translationbundle element)', this._filename));
}
/** @type {?} */
const translationElement = translationbundleElem.ownerDocument.createElement('translation');
translationElement.setAttribute('id', foreignTransUnit.id);
/** @type {?} */
let newContent = (copyContent || isDefaultLang) ? foreignTransUnit.sourceContent() : '';
if (!((/** @type {?} */ (foreignTransUnit))).isICUMessage(newContent)) {
newContent = this.getNewTransUnitTargetPraefix() + newContent + this.getNewTransUnitTargetSuffix();
}
DOMUtilities.replaceContentWithXMLContent(translationElement, newContent);
/** @type {?} */
const newTu = new XtbTransUnit(translationElement, foreignTransUnit.id, this, newMasterTu);
/** @type {?} */
let inserted = false;
/** @type {?} */
let isAfterElementPartOfFile = false;
if (!!importAfterElement) {
/** @type {?} */
const insertionPoint = this.transUnitWithId(importAfterElement.id);
if (!!insertionPoint) {
isAfterElementPartOfFile = true;
}
}
if (importAfterElement === undefined || (importAfterElement && !isAfterElementPartOfFile)) {
translationbundleElem.appendChild(newTu.asXmlElement());
inserted = true;
}
else if (importAfterElement === null) {
/** @type {?} */
const firstTranslationElement = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translation');
if (firstTranslationElement) {
DOMUtilities.insertBefore(newTu.asXmlElement(), firstTranslationElement);
inserted = true;
}
else {
// no trans-unit, empty file, so add to bundle at end
translationbundleElem.appendChild(newTu.asXmlElement());
inserted = true;
}
}
else {
/** @type {?} */
const refUnitElement = DOMUtilities.getElementByTagNameAndId(this._parsedDocument, 'translation', importAfterElement.id);
if (refUnitElement) {
DOMUtilities.insertAfter(newTu.asXmlElement(), refUnitElement);
inserted = true;
}
}
if (inserted) {
this.lazyInitializeTransUnits();
this.transUnits.push(newTu);
this.countNumbers();
return newTu;
}
else {
return null;
}
}
/**
* Create a new translation file for this file for a given language.
* Normally, this is just a copy of the original one.
* But for XMB the translation file has format 'XTB'.
* @param {?} lang Language code
* @param {?} filename expected filename to store file
* @param {?} isDefaultLang Flag, wether file contains the default language.
* Then source and target are just equal.
* The content will be copied.
* State will be final.
* @param {?} copyContent Flag, wether to copy content or leave it empty.
* Wben true, content will be copied from source.
* When false, content will be left empty (if it is not the default language).
* @return {?}
*/
createTranslationFileForLang(lang, filename, isDefaultLang, copyContent) {
throw new Error(format('File "%s", xtb files are not translatable, they are already translations', filename));
}
}
if (false) {
/**
* @type {?}
* @private
*/
XtbFile.prototype._masterFile;
/**
* @type {?}
* @private
*/
XtbFile.prototype._translationMessageFileFactory;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xtb-file.js","sourceRoot":"ng://@ngx-i18nsupport/ngx-i18nsupport-lib/","sources":["impl/xtb-file.ts"],"names":[],"mappings":";;;;AAGA,OAAO,EAAC,UAAU,EAAE,YAAY,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,MAAM,EAAC,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAC,+BAA+B,EAAC,MAAM,sCAAsC,CAAC;AACrF,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAC;;;;;;AAQ9C,MAAM,OAAO,OAAQ,SAAQ,+BAA+B;;;;;;;;;;;;IAiBxD,YAAoB,8BAA+D,EACvE,SAAiB,EAAE,IAAY,EAAE,QAAgB,EACjD,cAAuE;QAC/E,KAAK,EAAE,CAAC;QAHQ,mCAA8B,GAA9B,8BAA8B,CAAiC;QAI/E,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;QACpB,IAAI,CAAC,gCAAgC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;IAC1E,CAAC;;;;;;;;;IAEO,qBAAqB,CAAC,SAAiB,EAAE,IAAY,EAAE,QAAgB,EACjD,cAAuE;QACjG,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC7C,IAAI,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7E,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,gFAAgF,EAAE,IAAI,CAAC,CAAC,CAAC;SACnH;QACD,IAAI,cAAc,EAAE;YAChB,IAAI;gBACA,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,8BAA8B,CAAC,yBAAyB,CAC5E,UAAU,EACV,cAAc,CAAC,UAAU,EACzB,cAAc,CAAC,IAAI,EACnB,cAAc,CAAC,QAAQ,CAAC,CAAC;;;sBAEvB,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE;;sBACtD,QAAQ,GAAG,IAAI,CAAC,kBAAkB,EAAE;gBAC1C,IAAI,cAAc,KAAK,QAAQ,EAAE;oBAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CACtB,yFAAyF,EACzF,cAAc,EAAE,QAAQ,CAAC,CAAC,CAAC;iBAClC;aACJ;YAAC,OAAO,KAAK,EAAE;gBACZ,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,0EAA0E,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;aAC5H;SACJ;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;;;;;IAES,oBAAoB;QAC1B,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;;cACf,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,aAAa,CAAC;QACjF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;;kBACxC,GAAG,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;;kBAC9B,EAAE,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC;YACjC,IAAI,CAAC,EAAE,EAAE;gBACL,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,8DAA8D,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aAC/G;;gBACG,UAAU,GAAe,IAAI;YACjC,IAAI,IAAI,CAAC,WAAW,EAAE;gBAClB,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;aACrD;YACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAoB,UAAU,EAAA,CAAC,CAAC,CAAC;SACzF;IACL,CAAC;;;;;;;IAOM,UAAU;QACb,OAAO,UAAU,CAAC;IACtB,CAAC;;;;;;IAMM,QAAQ;QACX,OAAO,YAAY,CAAC;IACxB,CAAC;;;;;;;;IAOS,wBAAwB;QAC9B,OAAO,CAAC,aAAa,CAAC,CAAC;IAC3B,CAAC;;;;;;;IAQM,cAAc;QACjB,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;SAC5C;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;;;;;;;IAOM,iBAAiB,CAAC,QAAgB;QACrC,4CAA4C;IAChD,CAAC;;;;;IAMM,cAAc;;cACX,qBAAqB,GAAG,YAAY,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,EAAE,mBAAmB,CAAC;QAC9G,IAAI,qBAAqB,EAAE;YACvB,OAAO,qBAAqB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;SACrD;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;;;;;;IAMM,iBAAiB,CAAC,QAAgB;;cAC/B,qBAAqB,GAAG,YAAY,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,EAAE,mBAAmB,CAAC;QAC9G,IAAI,qBAAqB,EAAE;YACvB,qBAAqB,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;SACxD;IACL,CAAC;;;;;;;;;;;;;;;;;;;;;;;IAwBD,kBAAkB,CAAC,gBAA4B,EAAE,aAAsB,EAAE,WAAoB,EAAE,kBAA+B;QAE1H,IAAI,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,EAAE,CAAC,EAAE;YAC3C,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,wDAAwD,EAAE,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC;SAC1G;;cACK,WAAW,GAAG,CAAC,mBAAoB,gBAAgB,EAAA,CAAC,CAAC,uBAAuB,CAAC,aAAa,EAAE,WAAW,EAAE,IAAI,CAAC;;cAC9G,qBAAqB,GAAG,YAAY,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,EAAE,mBAAmB,CAAC;QAC9G,IAAI,CAAC,qBAAqB,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,gFAAgF,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;SAC7H;;cACK,kBAAkB,GAAG,qBAAqB,CAAC,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC;QAC3F,kBAAkB,CAAC,YAAY,CAAC,IAAI,EAAE,gBAAgB,CAAC,EAAE,CAAC,CAAC;;YACvD,UAAU,GAAG,CAAC,WAAW,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE;QACvF,IAAI,CAAC,CAAC,mBAAoB,gBAAgB,EAAA,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE;YAClE,UAAU,GAAG,IAAI,CAAC,4BAA4B,EAAE,GAAG,UAAU,GAAG,IAAI,CAAC,2BAA2B,EAAE,CAAC;SACtG;QACD,YAAY,CAAC,4BAA4B,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;;cACpE,KAAK,GAAG,IAAI,YAAY,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,EAAE,EAAE,IAAI,EAAE,WAAW,CAAC;;YACtF,QAAQ,GAAG,KAAK;;YAChB,wBAAwB,GAAG,KAAK;QACpC,IAAI,CAAC,CAAC,kBAAkB,EAAE;;kBAChB,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAC,EAAE,CAAC;YAClE,IAAI,CAAC,CAAC,cAAc,EAAE;gBAClB,wBAAwB,GAAG,IAAI,CAAC;aACnC;SACJ;QACD,IAAI,kBAAkB,KAAK,SAAS,IAAI,CAAC,kBAAkB,IAAI,CAAC,wBAAwB,CAAC,EAAE;YACvF,qBAAqB,CAAC,WAAW,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;YACxD,QAAQ,GAAG,IAAI,CAAC;SACnB;aAAM,IAAI,kBAAkB,KAAK,IAAI,EAAE;;kBAC9B,uBAAuB,GAAG,YAAY,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC;YAC1G,IAAI,uBAAuB,EAAE;gBACzB,YAAY,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,EAAE,EAAE,uBAAuB,CAAC,CAAC;gBACzE,QAAQ,GAAG,IAAI,CAAC;aACnB;iBAAM;gBACH,qDAAqD;gBACrD,qBAAqB,CAAC,WAAW,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;gBACxD,QAAQ,GAAG,IAAI,CAAC;aACnB;SACJ;aAAM;;kBACG,cAAc,GAAG,YAAY,CAAC,wBAAwB,CAAC,IAAI,CAAC,eAAe,EAAE,aAAa,EAAE,kBAAkB,CAAC,EAAE,CAAC;YACxH,IAAI,cAAc,EAAE;gBAChB,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,YAAY,EAAE,EAAE,cAAc,CAAC,CAAC;gBAC/D,QAAQ,GAAG,IAAI,CAAC;aACnB;SACJ;QACD,IAAI,QAAQ,EAAE;YACV,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC;SAChB;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;;;;;;;;;;;;;;;;IAgBM,4BAA4B,CAAC,IAAY,EAAE,QAAgB,EAAE,aAAsB,EAAE,WAAoB;QAE5G,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,0EAA0E,EAAE,QAAQ,CAAC,CAAC,CAAC;IAClH,CAAC;CACJ;;;;;;IA5OG,8BAA8C;;;;;IAalC,iDAAuE","sourcesContent":["import {ITranslationMessagesFileFactory} from '../api/i-translation-messages-file-factory';\r\nimport {ITranslationMessagesFile} from '../api/i-translation-messages-file';\r\nimport {ITransUnit} from '../api/i-trans-unit';\r\nimport {FORMAT_XTB, FILETYPE_XTB, FORMAT_XMB} from '../api/constants';\r\nimport {format} from 'util';\r\nimport {DOMUtilities} from './dom-utilities';\r\nimport {AbstractTranslationMessagesFile} from './abstract-translation-messages-file';\r\nimport {XtbTransUnit} from './xtb-trans-unit';\r\nimport {AbstractTransUnit} from './abstract-trans-unit';\r\n/**\r\n * Created by martin on 23.05.2017.\r\n * xtb-File access.\r\n * xtb is the translated counterpart to xmb.\r\n */\r\n\r\nexport class XtbFile extends AbstractTranslationMessagesFile implements ITranslationMessagesFile {\r\n\r\n    // attached master file, if any\r\n    // used as source to determine state ...\r\n    private _masterFile: ITranslationMessagesFile; // an xmb-file\r\n\r\n    /**\r\n     * Create an xmb-File from source.\r\n     * @param _translationMessageFileFactory factory to create a translation file (xtb) for the xmb file\r\n     * @param xmlString file content\r\n     * @param path Path to file\r\n     * @param encoding optional encoding of the xml.\r\n     * This is read from the file, but if you know it before, you can avoid reading the file twice.\r\n     * @param optionalMaster in case of xmb the master file, that contains the original texts.\r\n     * (this is used to support state infos, that are based on comparing original with translated version)\r\n     * @return XmbFile\r\n     */\r\n    constructor(private _translationMessageFileFactory: ITranslationMessagesFileFactory,\r\n                xmlString: string, path: string, encoding: string,\r\n                optionalMaster?: { xmlContent: string, path: string, encoding: string }) {\r\n        super();\r\n        this._warnings = [];\r\n        this._numberOfTransUnitsWithMissingId = 0;\r\n        this.initializeFromContent(xmlString, path, encoding, optionalMaster);\r\n    }\r\n\r\n    private initializeFromContent(xmlString: string, path: string, encoding: string,\r\n                                  optionalMaster?: { xmlContent: string, path: string, encoding: string }): XtbFile {\r\n        this.parseContent(xmlString, path, encoding);\r\n        if (this._parsedDocument.getElementsByTagName('translationbundle').length !== 1) {\r\n            throw new Error(format('File \"%s\" seems to be no xtb file (should contain a translationbundle element)', path));\r\n        }\r\n        if (optionalMaster) {\r\n            try {\r\n                this._masterFile = this._translationMessageFileFactory.createFileFromFileContent(\r\n                    FORMAT_XMB,\r\n                    optionalMaster.xmlContent,\r\n                    optionalMaster.path,\r\n                    optionalMaster.encoding);\r\n                // check, wether this can be the master ...\r\n                const numberInMaster = this._masterFile.numberOfTransUnits();\r\n                const myNumber = this.numberOfTransUnits();\r\n                if (numberInMaster !== myNumber) {\r\n                    this._warnings.push(format(\r\n                        '%s trans units found in master, but this file has %s. Check if it is the correct master',\r\n                        numberInMaster, myNumber));\r\n                }\r\n            } catch (error) {\r\n                throw new Error(format('File \"%s\" seems to be no xmb file. An xtb file needs xmb as master file.', optionalMaster.path));\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n\r\n    protected initializeTransUnits() {\r\n        this.transUnits = [];\r\n        const transUnitsInFile = this._parsedDocument.getElementsByTagName('translation');\r\n        for (let i = 0; i < transUnitsInFile.length; i++) {\r\n            const msg = transUnitsInFile.item(i);\r\n            const id = msg.getAttribute('id');\r\n            if (!id) {\r\n                this._warnings.push(format('oops, msg without \"id\" found in master, please check file %s', this._filename));\r\n            }\r\n            let masterUnit: ITransUnit = null;\r\n            if (this._masterFile) {\r\n                masterUnit = this._masterFile.transUnitWithId(id);\r\n            }\r\n            this.transUnits.push(new XtbTransUnit(msg, id, this, <AbstractTransUnit> masterUnit));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * File format as it is used in config files.\r\n     * Currently 'xlf', 'xlf2', 'xmb', 'xtb'\r\n     * Returns one of the constants FORMAT_..\r\n     */\r\n    public i18nFormat(): string {\r\n        return FORMAT_XTB;\r\n    }\r\n\r\n    /**\r\n     * File type.\r\n     * Here 'XTB'\r\n     */\r\n    public fileType(): string {\r\n        return FILETYPE_XTB;\r\n    }\r\n\r\n    /**\r\n     * return tag names of all elements that have mixed content.\r\n     * These elements will not be beautified.\r\n     * Typical candidates are source and target.\r\n     */\r\n    protected elementsWithMixedContent(): string[] {\r\n        return ['translation'];\r\n    }\r\n\r\n    /**\r\n     * Get source language.\r\n     * Unsupported in xmb/xtb.\r\n     * Try to guess it from master filename if any..\r\n     * @return source language.\r\n     */\r\n    public sourceLanguage(): string {\r\n        if (this._masterFile) {\r\n            return this._masterFile.sourceLanguage();\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Edit the source language.\r\n     * Unsupported in xmb/xtb.\r\n     * @param language language\r\n     */\r\n    public setSourceLanguage(language: string) {\r\n        // do nothing, xtb has no notation for this.\r\n    }\r\n\r\n    /**\r\n     * Get target language.\r\n     * @return target language.\r\n     */\r\n    public targetLanguage(): string {\r\n        const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');\r\n        if (translationbundleElem) {\r\n            return translationbundleElem.getAttribute('lang');\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Edit the target language.\r\n     * @param language language\r\n     */\r\n    public setTargetLanguage(language: string) {\r\n        const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');\r\n        if (translationbundleElem) {\r\n            translationbundleElem.setAttribute('lang', language);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Add a new trans-unit to this file.\r\n     * The trans unit stems from another file.\r\n     * It copies the source content of the tu to the target content too,\r\n     * depending on the values of isDefaultLang and copyContent.\r\n     * So the source can be used as a dummy translation.\r\n     * (used by xliffmerge)\r\n     * @param foreignTransUnit the trans unit to be imported.\r\n     * @param isDefaultLang Flag, wether file contains the default language.\r\n     * Then source and target are just equal.\r\n     * The content will be copied.\r\n     * State will be final.\r\n     * @param copyContent Flag, wether to copy content or leave it empty.\r\n     * Wben true, content will be copied from source.\r\n     * When false, content will be left empty (if it is not the default language).\r\n     * @param importAfterElement optional (since 1.10) other transunit (part of this file), that should be used as ancestor.\r\n     * Newly imported trans unit is then inserted directly after this element.\r\n     * If not set or not part of this file, new unit will be imported at the end.\r\n     * If explicity set to null, new unit will be imported at the start.\r\n     * @return the newly imported trans unit (since version 1.7.0)\r\n     * @throws an error if trans-unit with same id already is in the file.\r\n     */\r\n    importNewTransUnit(foreignTransUnit: ITransUnit, isDefaultLang: boolean, copyContent: boolean, importAfterElement?: ITransUnit)\r\n        : ITransUnit {\r\n        if (this.transUnitWithId(foreignTransUnit.id)) {\r\n            throw new Error(format('tu with id %s already exists in file, cannot import it', foreignTransUnit.id));\r\n        }\r\n        const newMasterTu = (<AbstractTransUnit> foreignTransUnit).cloneWithSourceAsTarget(isDefaultLang, copyContent, this);\r\n        const translationbundleElem = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translationbundle');\r\n        if (!translationbundleElem) {\r\n            throw new Error(format('File \"%s\" seems to be no xtb file (should contain a translationbundle element)', this._filename));\r\n        }\r\n        const translationElement = translationbundleElem.ownerDocument.createElement('translation');\r\n        translationElement.setAttribute('id', foreignTransUnit.id);\r\n        let newContent = (copyContent || isDefaultLang) ? foreignTransUnit.sourceContent() : '';\r\n        if (!(<AbstractTransUnit> foreignTransUnit).isICUMessage(newContent)) {\r\n            newContent = this.getNewTransUnitTargetPraefix() + newContent + this.getNewTransUnitTargetSuffix();\r\n        }\r\n        DOMUtilities.replaceContentWithXMLContent(translationElement, newContent);\r\n        const newTu = new XtbTransUnit(translationElement, foreignTransUnit.id, this, newMasterTu);\r\n        let inserted = false;\r\n        let isAfterElementPartOfFile = false;\r\n        if (!!importAfterElement) {\r\n            const insertionPoint = this.transUnitWithId(importAfterElement.id);\r\n            if (!!insertionPoint) {\r\n                isAfterElementPartOfFile = true;\r\n            }\r\n        }\r\n        if (importAfterElement === undefined || (importAfterElement && !isAfterElementPartOfFile)) {\r\n            translationbundleElem.appendChild(newTu.asXmlElement());\r\n            inserted = true;\r\n        } else if (importAfterElement === null) {\r\n            const firstTranslationElement = DOMUtilities.getFirstElementByTagName(this._parsedDocument, 'translation');\r\n            if (firstTranslationElement) {\r\n                DOMUtilities.insertBefore(newTu.asXmlElement(), firstTranslationElement);\r\n                inserted = true;\r\n            } else {\r\n                // no trans-unit, empty file, so add to bundle at end\r\n                translationbundleElem.appendChild(newTu.asXmlElement());\r\n                inserted = true;\r\n            }\r\n        } else {\r\n            const refUnitElement = DOMUtilities.getElementByTagNameAndId(this._parsedDocument, 'translation', importAfterElement.id);\r\n            if (refUnitElement) {\r\n                DOMUtilities.insertAfter(newTu.asXmlElement(), refUnitElement);\r\n                inserted = true;\r\n            }\r\n        }\r\n        if (inserted) {\r\n            this.lazyInitializeTransUnits();\r\n            this.transUnits.push(newTu);\r\n            this.countNumbers();\r\n            return newTu;\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Create a new translation file for this file for a given language.\r\n     * Normally, this is just a copy of the original one.\r\n     * But for XMB the translation file has format 'XTB'.\r\n     * @param lang Language code\r\n     * @param filename expected filename to store file\r\n     * @param isDefaultLang Flag, wether file contains the default language.\r\n     * Then source and target are just equal.\r\n     * The content will be copied.\r\n     * State will be final.\r\n     * @param copyContent Flag, wether to copy content or leave it empty.\r\n     * Wben true, content will be copied from source.\r\n     * When false, content will be left empty (if it is not the default language).\r\n     */\r\n    public createTranslationFileForLang(lang: string, filename: string, isDefaultLang: boolean, copyContent: boolean)\r\n        : ITranslationMessagesFile {\r\n        throw new Error(format('File \"%s\", xtb files are not translatable, they are already translations', filename));\r\n    }\r\n}\r\n"]}