lingui-po-translate 1.0.0 → 1.0.1

package/dist/file-formats/po/po-files.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoFile = exports.getParsedComments = exports.potCache = void 0;
+const gettext_parser_1 = require("gettext-parser");
+const format_cache_1 = require("../common/format-cache");
+const managed_utf8_1 = require("../common/managed-utf8");
+const po_ops_1 = require("./po-ops");
+exports.potCache = new format_cache_1.FormatCache();
+/**
+ * Get parsed comments for all keys in a file
+ */
+function getParsedComments(path) {
+    const result = new Map();
+    const fileCache = exports.potCache.lookupFileCache(path);
+    if (fileCache) {
+        fileCache.entries.forEach((entry, key) => {
+            result.set(key, entry.parsedComment);
+        });
+    }
+    return result;
+}
+exports.getParsedComments = getParsedComments;
+class PoFile {
+    readTFile(args) {
+        const rawFile = (0, managed_utf8_1.readManagedUtf8)(args.path);
+        if (!rawFile) {
+            return Promise.resolve(new Map());
+        }
+        const potFile = (0, po_ops_1.parsePotFile)(args, rawFile);
+        exports.potCache.insertFileCache({
+            path: args.path,
+            entries: new Map(),
+            auxData: { potFile, rawFile },
+        });
+        const tSet = (0, po_ops_1.extractPotTranslations)(args, potFile);
+        return Promise.resolve(tSet);
+    }
+    writeTFile(args) {
+        var _a;
+        const sourcePot = (_a = exports.potCache.getOldestAuxdata()) === null || _a === void 0 ? void 0 : _a.potFile;
+        let output;
+        if (!sourcePot) {
+            output = createUncachedPot(args);
+        }
+        else {
+            output = createCachedPot(args, sourcePot);
+        }
+        (0, managed_utf8_1.writeManagedUtf8)({ path: args.path, utf8: output });
+        exports.potCache.purge();
+    }
+}
+exports.PoFile = PoFile;
+const compileOptions = {
+    foldLength: 100,
+    sort: false,
+};
+function createCachedPot(args, sourcePot) {
+    (0, po_ops_1.updatePotTranslations)(args, sourcePot);
+    const buffer = gettext_parser_1.po.compile(sourcePot, compileOptions);
+    return buffer.toString("utf-8");
+}
+function createUncachedPot(args) {
+    const potFile = {
+        charset: "utf-8",
+        headers: {},
+        translations: {},
+    };
+    args.tSet.forEach((value, key) => {
+        potFile.translations[key] = {
+            key: {
+                msgid: key,
+                msgstr: [value !== null && value !== void 0 ? value : ""],
+            },
+        };
+    });
+    const buffer = gettext_parser_1.po.compile(potFile, compileOptions);
+    return buffer.toString("utf-8") + "\n";
+}

package/dist/file-formats/po/po-ops.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePotFile = exports.updatePotTranslations = exports.extractPotTranslations = void 0;
+const gettext_parser_1 = require("gettext-parser");
+const parse_utils_1 = require("../common/parse-utils");
+const po_files_1 = require("./po-files");
+const comment_parser_1 = require("./comment-parser");
+function mergePotComments(args) {
+    if (!args.source) {
+        return args.oldTarget;
+    }
+    const source = args.source;
+    const oldTarget = args.oldTarget;
+    for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        if (!oldTarget[key]) {
+            oldTarget[key] = sourceValue;
+        }
+    }
+    return args.oldTarget;
+}
+function extractPotTranslations(args, potFile) {
+    const tSet = new Map();
+    traversePot(potFile, (getText) => {
+        const key = getText.msgid;
+        const value = getText.msgstr.join();
+        if (key) {
+            tSet.set(key, value);
+        }
+        const comments = getText.comments;
+        if (typeof key === "string") {
+            const parsedComment = (0, comment_parser_1.parseExtractedComment)(comments === null || comments === void 0 ? void 0 : comments.extracted);
+            po_files_1.potCache.insert({
+                path: args.path,
+                key,
+                entry: {
+                    comments: comments !== null && comments !== void 0 ? comments : {},
+                    parsedComment,
+                },
+            });
+        }
+    });
+    return tSet;
+}
+exports.extractPotTranslations = extractPotTranslations;
+function updatePotTranslations(args, potFile) {
+    const oldTarget = po_files_1.potCache.lookupSameFileAuxdata({ path: args.path });
+    if (oldTarget) {
+        potFile.headers = oldTarget.potFile.headers;
+    }
+    traversePot(potFile, (getText) => {
+        var _a, _b;
+        const key = getText.msgid;
+        const value = args.tSet.get(key);
+        if (value !== undefined) {
+            getText.msgstr = [value !== null && value !== void 0 ? value : ""];
+        }
+        const oldTargetComments = (_a = po_files_1.potCache.lookup({
+            path: args.path,
+            key,
+        })) === null || _a === void 0 ? void 0 : _a.comments;
+        if (typeof key === "string" && oldTargetComments) {
+            getText.comments = mergePotComments({
+                source: (_b = getText.comments) !== null && _b !== void 0 ? _b : null,
+                oldTarget: oldTargetComments,
+            });
+        }
+        if (args.changeSet.added.has(key)) {
+            // add a special marking for newly-added PO-entries
+            const newPoMarker = "NEEDS WORK";
+            if (getText.comments) {
+                if (typeof getText.comments.reference === "string") {
+                    getText.comments.reference += (" " + newPoMarker);
+                }
+                else {
+                    getText.comments.reference = newPoMarker;
+                }
+            }
+            else {
+                getText.comments = {
+                    reference: newPoMarker
+                };
+            }
+        }
+    });
+}
+exports.updatePotTranslations = updatePotTranslations;
+function parsePotFile(args, rawFile) {
+    try {
+        const potFile = gettext_parser_1.po.parse(rawFile);
+        if (!potFile.headers) {
+            potFile.headers = {};
+        }
+        potFile.headers["X-Generator"] = "lingui-po-translate";
+        return potFile;
+    }
+    catch (e) {
+        console.error(e);
+        (0, parse_utils_1.logParseError)("GetText parsing error", args);
+    }
+}
+exports.parsePotFile = parsePotFile;
+function traversePot(potFile, operation) {
+    for (const outerKey of Object.keys(potFile.translations)) {
+        const potEntry = potFile.translations[outerKey];
+        for (const innerKey of Object.keys(potEntry)) {
+            const getText = potEntry[innerKey];
+            operation(getText);
+        }
+    }
+}

package/dist/file-formats/xml/xml-generic.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlGeneric = exports.DEFAULT_XML_HEADER = exports.DEFAULT_XML_INDENT = exports.sharedXmlOptions = exports.defaultExcludedContentKey = exports.defaultKeyAttribute = void 0;
+const xml_read_1 = require("./xml-read");
+const format_cache_1 = require("../common/format-cache");
+const xml_write_1 = require("./xml-write");
+const managed_utf8_1 = require("../common/managed-utf8");
+const xmlCache = new format_cache_1.FormatCache();
+exports.defaultKeyAttribute = "name";
+exports.defaultExcludedContentKey = "string";
+exports.sharedXmlOptions = {
+    attrkey: "attributesObj",
+    charkey: "characterContent",
+};
+/**
+ * Android Studio seems to auto-format XML-files with 4 spaces indentation.
+ */
+exports.DEFAULT_XML_INDENT = 4;
+exports.DEFAULT_XML_HEADER = '<?xml version="1.0" encoding="utf-8"?>';
+class XmlGeneric {
+    async readTFile(args) {
+        const xmlString = (0, managed_utf8_1.readManagedUtf8)(args.path);
+        const xmlFile = await (0, xml_read_1.parseRawXML)(xmlString, args);
+        if (!xmlFile) {
+            return new Map();
+        }
+        const firstLine = (0, xml_read_1.extractFirstLine)(xmlString);
+        const fileCache = {
+            path: args.path,
+            auxData: {
+                xmlHeader: firstLine.includes("<?") ? firstLine : null,
+                xmlFile,
+                detectedIntent: (0, xml_read_1.detectSpaceIndent)(xmlString),
+            },
+            entries: new Map(),
+        };
+        xmlCache.insertFileCache(fileCache);
+        return (0, xml_read_1.extractXmlContent)({ args, xmlFile });
+    }
+    writeTFile(args) {
+        var _a;
+        const sourceXml = (_a = xmlCache.getOldestAuxdata()) === null || _a === void 0 ? void 0 : _a.xmlFile;
+        let resultXml;
+        if (sourceXml) {
+            resultXml = this.extractCachedXml(args, sourceXml);
+        }
+        else {
+            resultXml = this.createUncachedXml(args);
+        }
+        (0, xml_write_1.writeXmlResourceFile)(resultXml, args, xmlCache.lookupAuxdata({ path: args.path }));
+        xmlCache.purge();
+    }
+    extractCachedXml(args, sourceXml) {
+        var _a, _b;
+        const oldTargetXml = (_b = (_a = xmlCache.lookupSameFileAuxdata({
+            path: args.path,
+        })) === null || _a === void 0 ? void 0 : _a.xmlFile) !== null && _b !== void 0 ? _b : null;
+        (0, xml_write_1.updateXmlContent)({ args, sourceXml, oldTargetXml });
+        return sourceXml;
+    }
+    createUncachedXml(args) {
+        const tagArray = [];
+        args.tSet.forEach((value, key) => {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            tagArray.push({
+                characterContent: value !== null && value !== void 0 ? value : "",
+                attributesObj: { name: key },
+            });
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const rootTag = {
+            string: tagArray,
+        };
+        return {
+            resources: rootTag,
+        };
+    }
+}
+exports.XmlGeneric = XmlGeneric;

package/dist/file-formats/xml/xml-read.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFirstLine = exports.detectSpaceIndent = exports.extractXmlContent = exports.parseRawXML = void 0;
+const xml_generic_1 = require("./xml-generic");
+const parse_utils_1 = require("../common/parse-utils");
+const xml_traverse_1 = require("./xml-traverse");
+async function parseRawXML(xmlString, args) {
+    try {
+        const options = {
+            ...xml_generic_1.sharedXmlOptions,
+            strict: true,
+            async: false,
+            //explicitChildren: true, // if true, then the resulting object will be entirely different
+            preserveChildrenOrder: true,
+            headless: true,
+            //emptyTag: " ",
+            includeWhiteChars: true,
+            trim: false,
+            normalize: false,
+            normalizeTags: false,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const xml2js = require("xml2js");
+        const result = await xml2js.parseStringPromise(xmlString, options);
+        return result;
+    }
+    catch (e) {
+        console.error(e);
+        (0, parse_utils_1.logParseError)("XML parsing error", args);
+    }
+}
+exports.parseRawXML = parseRawXML;
+function extractXmlContent(args) {
+    const tSet = new Map();
+    (0, xml_traverse_1.traverseXml)({
+        xml: args.xmlFile,
+        oldTargetXml: null,
+        operation: (context, xmlTag) => {
+            var _a;
+            const key = (0, xml_traverse_1.constructJsonKey)(context);
+            if (tSet.has(key)) {
+                (0, parse_utils_1.logParseError)(`duplicate key '${key}' -> Currently, the usage of duplicate translation-keys is discouraged.`, args.args);
+            }
+            if (typeof xmlTag === "string") {
+                tSet.set(key, xmlTag);
+            }
+            else {
+                tSet.set(key, (_a = xmlTag.characterContent) !== null && _a !== void 0 ? _a : "");
+            }
+            return null;
+        },
+    });
+    return tSet;
+}
+exports.extractXmlContent = extractXmlContent;
+function detectSpaceIndent(xmlString) {
+    var _a;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const detectModule = require("detect-indent");
+    return (_a = detectModule(xmlString).amount) !== null && _a !== void 0 ? _a : xml_generic_1.DEFAULT_XML_INDENT;
+}
+exports.detectSpaceIndent = detectSpaceIndent;
+function extractFirstLine(str) {
+    return str.split("\n", 1)[0];
+}
+exports.extractFirstLine = extractFirstLine;

package/dist/file-formats/xml/xml-traverse.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseXml = exports.constructJsonKey = void 0;
+const xml_generic_1 = require("./xml-generic");
+const flatten_1 = require("../../util/flatten");
+function constructJsonKey(context) {
+    return context.keyFragments.join(flatten_1.NESTED_JSON_SEPARATOR);
+}
+exports.constructJsonKey = constructJsonKey;
+function traverseXml(args) {
+    var _a;
+    const context = {
+        keyFragments: [],
+        operation: args.operation,
+    };
+    for (const contentKey of Object.keys(args.xml)) {
+        const xmlContent = args.xml[contentKey];
+        const oldTargetTag = args.oldTargetXml
+            ? (_a = args.oldTargetXml[contentKey]) !== null && _a !== void 0 ? _a : null
+            : null;
+        if (typeof xmlContent === "object") {
+            traverseRecursive({
+                context,
+                tag: xmlContent,
+                oldTargetTag,
+            });
+        }
+    }
+}
+exports.traverseXml = traverseXml;
+function traverseRecursive(args) {
+    if (typeof args.tag !== "object") {
+        return;
+    }
+    if (typeof args.oldTargetTag !== typeof args.tag) {
+        args.oldTargetTag = null;
+    }
+    else if (args.oldTargetTag && typeof args.oldTargetTag === "object") {
+        if (typeof args.oldTargetTag.attributesObj === "object") {
+            args.tag.attributesObj = {
+                ...args.tag.attributesObj,
+                ...args.oldTargetTag.attributesObj,
+            };
+        }
+        if (isNonEmptyArray(args.oldTargetTag.comments)) {
+            args.tag.comments = args.oldTargetTag.comments;
+        }
+    }
+    let hasChildTags = false;
+    for (const contentKey of Object.keys(args.tag)) {
+        const xmlContent = args.tag[contentKey];
+        if (contentKey !== "comments" && isNonEmptyArray(xmlContent)) {
+            hasChildTags = true;
+            const oldTargetChilds = extractOldTargetChilds(args.oldTargetTag, contentKey);
+            xmlContent.forEach((sourceChild, index) => {
+                const newKeyFragments = constructKeyFragments({
+                    tag: sourceChild,
+                    contentKey,
+                    index,
+                });
+                const newContext = {
+                    keyFragments: [...args.context.keyFragments, ...newKeyFragments],
+                    operation: args.context.operation,
+                };
+                if (typeof sourceChild === "string") {
+                    const newContent = args.context.operation(newContext, sourceChild);
+                    if (newContent !== null) {
+                        xmlContent[index] = newContent;
+                    }
+                }
+                else {
+                    traverseRecursive({
+                        context: newContext,
+                        tag: sourceChild,
+                        oldTargetTag: matchOldTargetChild({
+                            oldTargetChilds,
+                            sourceChild,
+                            index,
+                        }),
+                    });
+                }
+            });
+        }
+    }
+    if (!hasChildTags) {
+        const newContent = args.context.operation(args.context, args.tag);
+        if (newContent !== null) {
+            args.tag.characterContent = newContent;
+        }
+    }
+}
+function extractAttributeKey(tag) {
+    var _a;
+    if (typeof tag !== "object") {
+        return null;
+    }
+    const attributes = tag.attributesObj;
+    if (!attributes || typeof attributes !== "object") {
+        return null;
+    }
+    return (_a = attributes[xml_generic_1.defaultKeyAttribute]) !== null && _a !== void 0 ? _a : null;
+}
+function constructKeyFragments(args) {
+    const keyFragments = [];
+    const attributeKey = extractAttributeKey(args.tag);
+    if (attributeKey) {
+        if (args.contentKey !== xml_generic_1.defaultExcludedContentKey) {
+            keyFragments.push(args.contentKey);
+        }
+        keyFragments.push(attributeKey);
+    }
+    else {
+        keyFragments.push(args.contentKey + "_" + args.index);
+    }
+    return keyFragments;
+}
+function extractOldTargetChilds(oldTargetXml, contentKey) {
+    if (!oldTargetXml) {
+        return null;
+    }
+    if (typeof oldTargetXml !== "object") {
+        return null;
+    }
+    const xmlContent = oldTargetXml[contentKey];
+    if (xmlContent && typeof xmlContent === "object") {
+        return xmlContent;
+    }
+    return null;
+}
+function matchOldTargetChild(args) {
+    var _a;
+    if (!isNonEmptyArray(args.oldTargetChilds)) {
+        return null;
+    }
+    const sourceAttributeKey = extractAttributeKey(args.sourceChild);
+    if (sourceAttributeKey) {
+        return ((_a = args.oldTargetChilds.find((oldTargetChild) => {
+            const oldTargetAttributeKey = extractAttributeKey(oldTargetChild);
+            return (oldTargetAttributeKey && oldTargetAttributeKey === sourceAttributeKey);
+        })) !== null && _a !== void 0 ? _a : null);
+    }
+    else if (args.oldTargetChilds.length > args.index) {
+        return args.oldTargetChilds[args.index];
+    }
+    else {
+        return null;
+    }
+}
+function isNonEmptyArray(obj) {
+    if (!obj) {
+        return false;
+    }
+    if (!Array.isArray(obj)) {
+        return false;
+    }
+    if (!obj.length) {
+        return false;
+    }
+    return true;
+}

package/dist/file-formats/xml/xml-write.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeXmlResourceFile = exports.updateXmlContent = void 0;
+const xml_generic_1 = require("./xml-generic");
+const xml_traverse_1 = require("./xml-traverse");
+const managed_utf8_1 = require("../common/managed-utf8");
+function updateXmlContent(args) {
+    (0, xml_traverse_1.traverseXml)({
+        xml: args.sourceXml,
+        oldTargetXml: args.oldTargetXml,
+        operation: (context, xmlTag) => {
+            const key = (0, xml_traverse_1.constructJsonKey)(context);
+            const value = args.args.tSet.get(key);
+            if (value !== undefined) {
+                return value !== null && value !== void 0 ? value : "";
+            }
+            return null;
+        },
+    });
+}
+exports.updateXmlContent = updateXmlContent;
+function writeXmlResourceFile(xmlFile, args, auxData) {
+    var _a;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const xml2js = require("xml2js");
+    const stringIndent = " ".repeat((_a = auxData === null || auxData === void 0 ? void 0 : auxData.detectedIntent) !== null && _a !== void 0 ? _a : xml_generic_1.DEFAULT_XML_INDENT);
+    const options = {
+        ...xml_generic_1.sharedXmlOptions,
+        headless: true,
+        renderOpts: {
+            pretty: true,
+            indent: stringIndent,
+        },
+    };
+    // See https://github.com/oozcitak/xmlbuilder-js/wiki/Builder-Options for available xmlBuilderOptions
+    const xmlBuilderOptions = {
+        noValidation: false,
+        noDoubleEncoding: true,
+    };
+    const mergedOptions = { ...options, xmlBuilderOptions };
+    const builder = new xml2js.Builder(mergedOptions);
+    const rawXmlString = builder.buildObject(xmlFile);
+    let xmlHeader = xml_generic_1.DEFAULT_XML_HEADER + "\n";
+    if (auxData) {
+        if (auxData.xmlHeader) {
+            xmlHeader = auxData.xmlHeader + "\n";
+        }
+        else {
+            xmlHeader = "";
+        }
+    }
+    const xmlString = `${xmlHeader}${removeBlankLines(rawXmlString)}\n`;
+    (0, managed_utf8_1.writeManagedUtf8)({ path: args.path, utf8: xmlString });
+}
+exports.writeXmlResourceFile = writeXmlResourceFile;
+function removeBlankLines(str) {
+    const lines = str.split("\n");
+    const filteredLines = lines.filter((line) => {
+        return line.trim().length >= 1;
+    });
+    return filteredLines.join("\n");
+}

package/dist/file-formats/yaml/yaml-generic.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlGeneric = exports.isScalar = exports.isPair = exports.isCollection = exports.isSequence = void 0;
+const yaml_1 = require("yaml");
+const format_cache_1 = require("../common/format-cache");
+const flatten_1 = require("../../util/flatten");
+const types_1 = require("yaml/types");
+const yaml_manipulation_1 = require("./yaml-manipulation");
+const util_1 = require("yaml/util");
+const yaml_parse_1 = require("./yaml-parse");
+const managed_utf8_1 = require("../common/managed-utf8");
+function isSequence(node) {
+    if (!node.type) {
+        return false;
+    }
+    return [util_1.Type.SEQ, util_1.Type.FLOW_SEQ].includes(node.type);
+}
+exports.isSequence = isSequence;
+function isCollection(node) {
+    if (!node) {
+        return false;
+    }
+    if (!node.type) {
+        return false;
+    }
+    return [
+        util_1.Type.MAP,
+        util_1.Type.FLOW_MAP,
+        util_1.Type.SEQ,
+        util_1.Type.FLOW_SEQ,
+        util_1.Type.DOCUMENT,
+    ].includes(node.type);
+}
+exports.isCollection = isCollection;
+function isPair(node) {
+    if (!node) {
+        return false;
+    }
+    if (!node.type) {
+        return false;
+    }
+    return [types_1.Pair.Type.PAIR, types_1.Pair.Type.MERGE_PAIR].includes(node.type);
+}
+exports.isPair = isPair;
+function isScalar(node) {
+    if (!node.type) {
+        return false;
+    }
+    return [
+        util_1.Type.BLOCK_FOLDED,
+        util_1.Type.BLOCK_LITERAL,
+        util_1.Type.PLAIN,
+        util_1.Type.QUOTE_DOUBLE,
+        util_1.Type.QUOTE_SINGLE,
+    ].includes(node.type);
+}
+exports.isScalar = isScalar;
+const documentCache = new format_cache_1.FormatCache();
+class YamlGeneric {
+    constructor() {
+        // Do not mess with user's line breaks; preserve everything as is!
+        yaml_1.scalarOptions.str.fold = { lineWidth: 0, minContentWidth: 0 };
+        yaml_1.scalarOptions.str.doubleQuoted = {
+            minMultiLineLength: 1000,
+            jsonEncoding: false,
+        };
+        yaml_1.scalarOptions.null.nullStr = "";
+    }
+    readTFile(args) {
+        const document = (0, yaml_parse_1.parseYaml)(args);
+        if (!document) {
+            return Promise.resolve(new Map());
+        }
+        documentCache.insertFileCache({
+            path: args.path,
+            entries: new Map(),
+            auxData: document,
+        });
+        const tSet = (0, yaml_manipulation_1.extractYmlNodes)(args, document);
+        return Promise.resolve(tSet);
+    }
+    writeTFile(args) {
+        const sourceYml = documentCache.getOldestAuxdata();
+        let ymlString;
+        if (sourceYml) {
+            ymlString = this.createCachedYml(args, sourceYml);
+        }
+        else {
+            ymlString = this.createUncachedYml(args);
+        }
+        (0, managed_utf8_1.writeManagedUtf8)({ path: args.path, utf8: ymlString });
+        documentCache.purge();
+    }
+    createCachedYml(args, sourceYml) {
+        const oldTargetYml = documentCache.lookupSameFileAuxdata({
+            path: args.path,
+        });
+        (0, yaml_manipulation_1.updateYmlNodes)({ args, sourceYml, oldTargetYml });
+        return sourceYml.toString();
+    }
+    createUncachedYml(args) {
+        const flatJson = {};
+        args.tSet.forEach((value, key) => {
+            flatJson[key] = value;
+        });
+        const nestedJson = (0, flatten_1.unflatten)(flatJson);
+        const options = {
+            mapAsMap: false,
+        };
+        return (0, yaml_1.stringify)(nestedJson, options);
+    }
+}
+exports.YamlGeneric = YamlGeneric;