lingui-po-translate 1.0.0 → 1.0.2

package/dist/file-formats/common/format-cache.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatCache = void 0;
+/**
+ * We use format-caches to hold format-specific structures.
+ * A general pattern is:
+ * Prefer "same-file-caches" over other caches, and prefer newer caches over older caches.
+ */
+class FormatCache {
+    constructor() {
+        this.fileCaches = [];
+    }
+    findFileCache(path) {
+        var _a;
+        return (_a = this.fileCaches.find((fileCache) => fileCache.path === path)) !== null && _a !== void 0 ? _a : null;
+    }
+    lookupFileCache(path) {
+        return this.findFileCache(path);
+    }
+    insertFileCache(fileCache) {
+        this.fileCaches.push(fileCache);
+    }
+    insert(args) {
+        let fileCache = this.findFileCache(args.path);
+        if (!fileCache) {
+            fileCache = { path: args.path, entries: new Map(), auxData: null };
+            this.insertFileCache(fileCache);
+        }
+        fileCache.entries.set(args.key, args.entry);
+    }
+    lookup(args) {
+        const sameFileCache = this.findFileCache(args.path);
+        if (sameFileCache) {
+            const sameFileHit = sameFileCache.entries.get(args.key);
+            if (sameFileHit !== undefined) {
+                return sameFileHit;
+            }
+        }
+        for (let idx = this.fileCaches.length - 1; idx >= 0; idx--) {
+            const fileCache = this.fileCaches[idx];
+            const hit = fileCache.entries.get(args.key);
+            if (hit !== undefined) {
+                return hit;
+            }
+        }
+        return null;
+    }
+    lookupSameFileAuxdata(args) {
+        var _a, _b;
+        return (_b = (_a = this.findFileCache(args.path)) === null || _a === void 0 ? void 0 : _a.auxData) !== null && _b !== void 0 ? _b : null;
+    }
+    lookupAuxdata(args) {
+        const sameFileAuxdata = this.lookupSameFileAuxdata(args);
+        if (sameFileAuxdata) {
+            return sameFileAuxdata;
+        }
+        if (this.fileCaches.length) {
+            return this.fileCaches[this.fileCaches.length - 1].auxData;
+        }
+        return null;
+    }
+    getOldestAuxdata() {
+        if (!this.fileCaches.length) {
+            return null;
+        }
+        return this.fileCaches[0].auxData;
+    }
+    purge() {
+        this.fileCaches = [];
+    }
+}
+exports.FormatCache = FormatCache;

package/dist/file-formats/common/managed-json.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRawJson = exports.readManagedJson = exports.writeRawJson = exports.writeManagedJson = void 0;
+const util_1 = require("../../util/util");
+const managed_utf8_1 = require("./managed-utf8");
+function stringifyJson(obj) {
+    return JSON.stringify(obj, null, 2);
+}
+function writeManagedJson(args) {
+    const jsonString = stringifyJson(args.object);
+    return (0, managed_utf8_1.writeManagedUtf8)({
+        path: args.path,
+        utf8: jsonString,
+    });
+}
+exports.writeManagedJson = writeManagedJson;
+function writeRawJson(args) {
+    (0, util_1.writeUtf8File)(args.path, stringifyJson(args.object) + "\n");
+}
+exports.writeRawJson = writeRawJson;
+function readManagedJson(path) {
+    const { object, jsonString } = readRawJson(path);
+    (0, managed_utf8_1.insertUtf8Cache)({ path, utf8: jsonString });
+    return object;
+}
+exports.readManagedJson = readManagedJson;
+function readRawJson(path) {
+    try {
+        const jsonString = (0, util_1.readUtf8File)(path);
+        return { object: JSON.parse(jsonString), jsonString };
+    }
+    catch (e) {
+        console.error(e);
+        (0, util_1.logFatal)(`Failed to parse ${(0, util_1.getDebugPath)(path)}.`);
+    }
+}
+exports.readRawJson = readRawJson;

package/dist/file-formats/common/managed-utf8.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readManagedUtf8 = exports.insertUtf8Cache = exports.writeManagedUtf8 = void 0;
+const format_cache_1 = require("./format-cache");
+const util_1 = require("../../util/util");
+const os_1 = require("os");
+/**
+ * Divergent line-endings can be painful in IDEs like WebStorm.
+ * Therefore, we remember line-endings that were previously present.
+ */
+const utf8Cache = new format_cache_1.FormatCache();
+const possibleEndings = ["\n", "\r", os_1.EOL];
+function writeManagedUtf8(args) {
+    var _a, _b;
+    const endings = (_b = (_a = utf8Cache.lookupAuxdata({ path: args.path })) === null || _a === void 0 ? void 0 : _a.endings) !== null && _b !== void 0 ? _b : null;
+    const expandedContent = endings !== null
+        ? replaceLineEndings({ str: args.utf8, endings })
+        : args.utf8;
+    (0, util_1.writeUtf8File)(args.path, expandedContent);
+    return expandedContent;
+}
+exports.writeManagedUtf8 = writeManagedUtf8;
+function insertUtf8Cache(args) {
+    const endings = extractLineEndings(args.utf8);
+    utf8Cache.insertFileCache({
+        path: args.path,
+        entries: new Map(),
+        auxData: { endings },
+    });
+}
+exports.insertUtf8Cache = insertUtf8Cache;
+function readManagedUtf8(path) {
+    const utf8 = (0, util_1.readUtf8File)(path);
+    insertUtf8Cache({ path, utf8 });
+    return utf8;
+}
+exports.readManagedUtf8 = readManagedUtf8;
+function replaceLineEndings(args) {
+    const beginOfEnd = beginOfEndIndex(args.str);
+    if (beginOfEnd === null) {
+        return `${args.str}${args.endings}`;
+    }
+    const shorterStr = args.str.slice(0, beginOfEnd);
+    return `${shorterStr}${args.endings}`;
+}
+function extractLineEndings(str) {
+    const beginOfEnd = beginOfEndIndex(str);
+    if (beginOfEnd !== null) {
+        return str.slice(beginOfEnd);
+    }
+    else {
+        return "";
+    }
+}
+function beginOfEndIndex(str) {
+    if (!str.length) {
+        return null;
+    }
+    let beginOfEnd = null;
+    for (let idx = str.length - 1; idx >= 0; idx--) {
+        if (possibleEndings.includes(str[idx])) {
+            beginOfEnd = idx;
+        }
+        else {
+            break;
+        }
+    }
+    return beginOfEnd;
+}

package/dist/file-formats/common/parse-utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logParseWarning = exports.logParseError = void 0;
+const util_1 = require("../../util/util");
+function logParseError(rawMsg, args) {
+    const msg = `Failed to parse ${(0, util_1.getDebugPath)(args.path)} with expected format '${args.format}': ${rawMsg}`;
+    (0, util_1.logFatal)(msg);
+}
+exports.logParseError = logParseError;
+function logParseWarning(rawMsg, args) {
+    const msg = `Warning: Parsing '${args.path}': ${rawMsg}`;
+    console.log(msg);
+}
+exports.logParseWarning = logParseWarning;

package/dist/file-formats/csv/csv.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCsv = void 0;
+const parse_utils_1 = require("../common/parse-utils");
+const managed_utf8_1 = require("../common/managed-utf8");
+// We might make this configurable if the need arises.
+const CSV_SEPARATOR = ",";
+function parseCsvStruct(args) {
+    const lines = args.utf8.split("\n");
+    if (!lines || lines.length < 2) {
+        (0, parse_utils_1.logParseError)("Expected at least 2 CSV lines (header + content)", args.args);
+    }
+    const rawHeader = lines[0];
+    const header = rawHeader.split(CSV_SEPARATOR);
+    if (!header || header.length < 2) {
+        (0, parse_utils_1.logParseError)(`Expected at least 2 columns in CSV header with separator '${CSV_SEPARATOR}'`, args.args);
+    }
+    const languageCodes = header.slice(1);
+    const languageIndex = 1 + languageCodes.findIndex((value) => value.trim() === args.args.lng);
+    if (languageIndex <= 0) {
+        (0, parse_utils_1.logParseError)(`Did not find language '${args.args.lng}' in CSV header '${rawHeader}'`, args.args);
+    }
+    const contentLines = lines.slice(1);
+    contentLines.forEach((line, index) => {
+        contentLines[index] = line.replace("\r", "");
+    });
+    return {
+        rawHeader,
+        languageIndex,
+        contentLines,
+    };
+}
+class SimpleCsv {
+    readTFile(args) {
+        const utf8 = (0, managed_utf8_1.readManagedUtf8)(args.path);
+        const csvStruct = parseCsvStruct({ utf8, args });
+        const tSet = new Map();
+        csvStruct.contentLines.forEach((line) => {
+            const tokens = line.split(CSV_SEPARATOR);
+            if (tokens.length <= csvStruct.languageIndex) {
+                return;
+            }
+            const key = tokens[0];
+            const value = tokens[csvStruct.languageIndex];
+            if (tSet.has(key)) {
+                (0, parse_utils_1.logParseError)(`duplicate key '${key}' -> Currently, the usage of duplicate translation-keys is discouraged.`, args);
+            }
+            tSet.set(key, value);
+        });
+        return Promise.resolve(tSet);
+    }
+    writeTFile(args) {
+        console.log("Warning: Currently, 'lingui-po-translate' may overwrite pre-existing CSV-content. This might change in future versions.");
+        const lines = [];
+        const header = ["keys", args.lng].join(CSV_SEPARATOR);
+        lines.push(header);
+        args.tSet.forEach((value, key) => {
+            lines.push([key, value].join(CSV_SEPARATOR));
+        });
+        const csv = lines.join("\n");
+        (0, managed_utf8_1.writeManagedUtf8)({ path: args.path, utf8: csv });
+    }
+}
+exports.SimpleCsv = SimpleCsv;

package/dist/file-formats/file-format-definitions.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantiateTFileFormat = exports.getTFileFormatList = void 0;
+const flat_json_1 = require("./flat-json/flat-json");
+const nested_json_1 = require("./nested-json/nested-json");
+function getTFileFormatList() {
+    return Object.keys(fileFormatMap);
+}
+exports.getTFileFormatList = getTFileFormatList;
+const fileFormatMap = {
+    "flat-json": null,
+    "nested-json": null,
+    yaml: null,
+    po: null,
+    xml: null,
+    "ios-strings": null,
+    arb: null,
+    csv: null,
+};
+async function instantiateTFileFormat(fileFormat) {
+    /**
+     * To improve launch-performance, we import file-formats dynamically.
+     */
+    switch (fileFormat) {
+        case "flat-json":
+            return new flat_json_1.FlatJson();
+        case "nested-json":
+            return new nested_json_1.NestedJson();
+        case "yaml":
+            return new (await Promise.resolve().then(() => __importStar(require("./yaml/yaml-generic")))).YamlGeneric();
+        case "po":
+            return new (await Promise.resolve().then(() => __importStar(require("./po/po-files")))).PoFile();
+        case "arb":
+            return new (await Promise.resolve().then(() => __importStar(require("./flutter-arb/flutter-arb")))).FlutterArb();
+        case "xml":
+            return new (await Promise.resolve().then(() => __importStar(require("./xml/xml-generic")))).XmlGeneric();
+        case "ios-strings":
+            return new (await Promise.resolve().then(() => __importStar(require("./ios-strings/ios-strings")))).IosStrings();
+        case "csv":
+            return new (await Promise.resolve().then(() => __importStar(require("./csv/csv")))).SimpleCsv();
+    }
+}
+exports.instantiateTFileFormat = instantiateTFileFormat;

package/dist/file-formats/flat-json/flat-json.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlatJson = void 0;
+const parse_utils_1 = require("../common/parse-utils");
+const managed_json_1 = require("../common/managed-json");
+class FlatJson {
+    readTFile(args) {
+        const json = (0, managed_json_1.readManagedJson)(args.path);
+        const tMap = new Map();
+        for (const key of Object.keys(json)) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            const value = json[key];
+            if (typeof value !== "string" && value !== null) {
+                (0, parse_utils_1.logParseError)(`Property '${key}' is not a string or null`, args);
+            }
+            tMap.set(key, value);
+        }
+        return Promise.resolve(tMap);
+    }
+    writeTFile(args) {
+        const flatJson = {};
+        args.tSet.forEach((value, key) => {
+            flatJson[key] = value;
+        });
+        (0, managed_json_1.writeManagedJson)({ path: args.path, object: flatJson });
+    }
+}
+exports.FlatJson = FlatJson;

package/dist/file-formats/flutter-arb/flutter-arb.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlutterArb = void 0;
+const util_1 = require("../../util/util");
+const format_cache_1 = require("../common/format-cache");
+const managed_json_1 = require("../common/managed-json");
+const attributeCache = new format_cache_1.FormatCache();
+class FlutterArb {
+    readTFile(args) {
+        const json = (0, managed_json_1.readManagedJson)(args.path);
+        const tMap = new Map();
+        const globalAttributes = {};
+        for (const key of Object.keys(json)) {
+            const value = json[key];
+            if (key.startsWith("@@")) {
+                globalAttributes[key] = value;
+            }
+            else if (key.startsWith("@") && value && typeof value === "object") {
+                attributeCache.insert({
+                    path: args.path,
+                    key,
+                    entry: value,
+                });
+            }
+            else if (typeof value === "string") {
+                tMap.set(key, value);
+            }
+            else {
+                console.info(`Warning: '${key}-${value}' in ${(0, util_1.getDebugPath)(args.path)} is unexpected`);
+            }
+        }
+        const fileCache = attributeCache.findFileCache(args.path);
+        if (fileCache) {
+            fileCache.auxData = { globalAttributes };
+        }
+        return Promise.resolve(tMap);
+    }
+    writeTFile(args) {
+        const json = {};
+        args.tSet.forEach((value, key) => {
+            json[key] = value;
+            const attributeKey = `@${key}`;
+            const cachedAttributes = attributeCache.lookup({
+                path: args.path,
+                key: attributeKey,
+            });
+            if (cachedAttributes) {
+                const mergedAttributes = {
+                    ...cachedAttributes,
+                };
+                json[attributeKey] = mergedAttributes;
+            }
+        });
+        const auxData = attributeCache.lookupAuxdata({ path: args.path });
+        const mergedJson = {
+            ...auxData === null || auxData === void 0 ? void 0 : auxData.globalAttributes,
+            ...json,
+        };
+        (0, managed_json_1.writeManagedJson)({ path: args.path, object: mergedJson });
+    }
+}
+exports.FlutterArb = FlutterArb;

package/dist/file-formats/ios-strings/ios-read.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseiOSFile = exports.VALUE_INDEX = void 0;
+const parse_utils_1 = require("../common/parse-utils");
+const managed_utf8_1 = require("../common/managed-utf8");
+const KEY_INDEX = 1;
+exports.VALUE_INDEX = 3;
+function parseiOSFile(args) {
+    const rawString = (0, managed_utf8_1.readManagedUtf8)(args.path);
+    const lines = rawString.split("\n");
+    if (!lines.length) {
+        (0, parse_utils_1.logParseError)("Empty file", args);
+    }
+    const iosFile = {
+        path: args.path,
+        entries: new Map(),
+        auxData: [],
+    };
+    let currentChunk = [];
+    lines.forEach((line) => {
+        const keyValue = parseiOSLine(args, line);
+        currentChunk.push(line);
+        if (keyValue) {
+            const key = keyValue.key;
+            const value = keyValue.value;
+            const lineChunk = {
+                value,
+                lines: currentChunk,
+            };
+            if (iosFile.entries.has(key)) {
+                (0, parse_utils_1.logParseError)(`duplicate key '${key}' -> Currently, the usage of duplicate translation-keys is discouraged.`, args);
+            }
+            iosFile.entries.set(key, lineChunk);
+            currentChunk = [];
+        }
+    });
+    if (!iosFile.entries.size) {
+        (0, parse_utils_1.logParseError)("Did not find any Strings in the expected format", args);
+    }
+    return iosFile;
+}
+exports.parseiOSFile = parseiOSFile;
+function parseiOSLine(args, line) {
+    if (!line.trim().length) {
+        return null;
+    }
+    if (isComment(line)) {
+        return null;
+    }
+    const token = line.split('"');
+    if (token.length < 5) {
+        (0, parse_utils_1.logParseWarning)(`Line '${line}' seems to be unexpected`, args);
+        return null;
+    }
+    const key = token[KEY_INDEX];
+    if (!key || !key.trim().length) {
+        (0, parse_utils_1.logParseWarning)(`Did not find a key in '${line}'`, args);
+        return null;
+    }
+    const value = token[exports.VALUE_INDEX];
+    return {
+        key,
+        value,
+    };
+}
+function isComment(line) {
+    const trimLine = line.trim();
+    if (trimLine.startsWith("//")) {
+        return true;
+    }
+    return trimLine.startsWith("/*") || trimLine.endsWith("*/");
+}

package/dist/file-formats/ios-strings/ios-strings.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosStrings = void 0;
+const ios_read_1 = require("./ios-read");
+const ios_write_1 = require("./ios-write");
+const format_cache_1 = require("../common/format-cache");
+const iOSCache = new format_cache_1.FormatCache();
+class IosStrings {
+    readTFile(args) {
+        const iosFile = (0, ios_read_1.parseiOSFile)(args);
+        iOSCache.insertFileCache(iosFile);
+        const result = new Map();
+        iosFile.entries.forEach((value, key) => {
+            result.set(key, value.value);
+        });
+        return Promise.resolve(result);
+    }
+    writeTFile(args) {
+        (0, ios_write_1.writeiOSFile)(args, iOSCache);
+    }
+}
+exports.IosStrings = IosStrings;

package/dist/file-formats/ios-strings/ios-write.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeiOSFile = void 0;
+const ios_read_1 = require("./ios-read");
+const managed_utf8_1 = require("../common/managed-utf8");
+function writeiOSFile(args, cache) {
+    const outLines = [];
+    args.tSet.forEach((value, key) => {
+        const oldChunk = cache.lookup({ path: args.path, key });
+        let newChunk;
+        if (oldChunk) {
+            newChunk = convertOldChunkIntoNewChunk(oldChunk, value);
+        }
+        else {
+            newChunk = createNewChunk(key, value);
+        }
+        outLines.push(...newChunk.lines);
+    });
+    outLines.push("\n");
+    const output = outLines.join("\n");
+    (0, managed_utf8_1.writeManagedUtf8)({ path: args.path, utf8: output });
+}
+exports.writeiOSFile = writeiOSFile;
+function createNewChunk(key, newValue) {
+    return {
+        value: newValue,
+        lines: ["", "", `"${key}" = "${newValue}";`],
+    };
+}
+function convertOldChunkIntoNewChunk(oldChunk, newValue) {
+    oldChunk.value = newValue;
+    const valueLine = oldChunk.lines[oldChunk.lines.length - 1];
+    const token = valueLine.split('"');
+    token[ios_read_1.VALUE_INDEX] = newValue !== null && newValue !== void 0 ? newValue : "";
+    oldChunk.lines[oldChunk.lines.length - 1] = token.join('"');
+    return oldChunk;
+}

package/dist/file-formats/nested-json/nested-json.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedJson = void 0;
+const flatten_1 = require("../../util/flatten");
+const managed_json_1 = require("../common/managed-json");
+const format_cache_1 = require("../common/format-cache");
+const jsonCache = new format_cache_1.FormatCache();
+class NestedJson {
+    readTFile(args) {
+        const tMap = new Map();
+        const json = (0, managed_json_1.readManagedJson)(args.path);
+        traverseJson("", json, (entry) => {
+            tMap.set(entry[0], entry[1]);
+            return null;
+        });
+        jsonCache.insertFileCache({
+            path: args.path,
+            entries: new Map(),
+            auxData: json,
+        });
+        return Promise.resolve(tMap);
+    }
+    writeTFile(args) {
+        const sourceJson = jsonCache.getOldestAuxdata();
+        let json;
+        if (sourceJson) {
+            json = sourceJson;
+            replaceTranslatableProperties(args, json);
+        }
+        else {
+            json = constructNestedJsonFromFlatMap(args);
+        }
+        (0, managed_json_1.writeManagedJson)({ path: args.path, object: json });
+        jsonCache.purge();
+    }
+}
+exports.NestedJson = NestedJson;
+function traverseJson(path, node, operation) {
+    for (const key of Object.keys(node)) {
+        const value = node[key];
+        const newPath = path ? path + "." + key : key;
+        if (typeof value === "string") {
+            const newValue = operation([newPath, value]);
+            if (newValue) {
+                node[key] = newValue;
+            }
+        }
+        else if (value && typeof value === "object") {
+            traverseJson(newPath, value, operation);
+        }
+    }
+}
+function replaceTranslatableProperties(args, json) {
+    traverseJson("", json, (entry) => {
+        var _a;
+        const path = entry[0];
+        return (_a = args.tSet.get(path)) !== null && _a !== void 0 ? _a : null;
+    });
+}
+function constructNestedJsonFromFlatMap(args) {
+    const flatJson = {};
+    args.tSet.forEach((value, key) => {
+        flatJson[key] = value;
+    });
+    return (0, flatten_1.unflatten)(flatJson);
+}

package/dist/file-formats/po/comment-parser.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasManualMarking = exports.shouldSkipForManual = exports.parseExtractedComment = void 0;
+/**
+ * Parse extracted comments from PO file
+ *
+ * Supports:
+ * - @manual:zh-Hans,zh-Hant - languages requiring manual translation
+ * - @context:text - context for AI translation
+ * - Plain text (without @) - also treated as context
+ *
+ * Example:
+ * #. @manual:zh-Hans
+ * #. @context:This is a save button
+ * #. Some additional context
+ *
+ * @param extracted - The extracted comment string from PO file
+ * @returns ParsedComment with manual languages and context
+ */
+function parseExtractedComment(extracted) {
+    const result = {
+        manual: [],
+        context: "",
+    };
+    if (!extracted) {
+        return result;
+    }
+    const lines = extracted.split("\n");
+    const contextParts = [];
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith("@manual:")) {
+            // Parse @manual:zh-Hans,zh-Hant
+            const langList = trimmedLine.substring("@manual:".length).trim();
+            if (langList) {
+                result.manual = langList.split(",").map((lang) => lang.trim()).filter(Boolean);
+            }
+        }
+        else if (trimmedLine.startsWith("@context:")) {
+            // Parse @context:text
+            const contextText = trimmedLine.substring("@context:".length).trim();
+            if (contextText) {
+                contextParts.push(contextText);
+            }
+        }
+        else if (trimmedLine && !trimmedLine.startsWith("@")) {
+            // Plain text without @ prefix is also context
+            contextParts.push(trimmedLine);
+        }
+    }
+    result.context = contextParts.join("\n");
+    return result;
+}
+exports.parseExtractedComment = parseExtractedComment;
+/**
+ * Check if a target language should be skipped (manual translation required)
+ */
+function shouldSkipForManual(parsedComment, targetLng) {
+    return parsedComment.manual.includes(targetLng);
+}
+exports.shouldSkipForManual = shouldSkipForManual;
+/**
+ * Check if this entry has any @manual marking
+ */
+function hasManualMarking(parsedComment) {
+    return parsedComment.manual.length > 0;
+}
+exports.hasManualMarking = hasManualMarking;