@common.js/po-parser 2.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jan Amann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @common.js/po-parser
+
+The [po-parser](https://www.npmjs.com/package/po-parser) package exported as CommonJS modules.
+
+Exported from [po-parser@2.1.1](https://www.npmjs.com/package/po-parser/v/2.1.1) using https://github.com/etienne-martin/common.js.

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+type Entry = {
+    msgctxt?: string;
+    msgid: string;
+    msgstr: string;
+    references?: Array<{
+        path: string;
+        line?: number;
+    }>;
+    extractedComments?: Array<string>;
+    flags?: Array<string>;
+};
+type Catalog = {
+    meta?: Record<string, string>;
+    messages?: Array<Entry>;
+};
+declare class POParser {
+    private static readonly KEYWORDS;
+    private static readonly COMMENTS;
+    private static readonly QUOTE;
+    private static readonly NEWLINE;
+    private static readonly FILE_COLUMN_SEPARATOR;
+    private static readonly META_SEPARATOR;
+    private static readonly FLAG_SEPARATOR;
+    private static readonly ESCAPE_LOOKUP;
+    private static readonly UNESCAPE_LOOKUP;
+    static parse(content: string): Catalog;
+    private static isMetaEntry;
+    static serialize(catalog: Catalog): string;
+    private static lineStartsWithPrefix;
+    private static throwWithLine;
+    private static splitLines;
+    private static ensureEntry;
+    private static finishEntry;
+    private static extractQuotedString;
+    private static escape;
+    private static unescape;
+}
+
+export { POParser as default };
+export type { Entry };

package/dist/index.js

@@ -0,0 +1,471 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return POParser;
+    }
+});
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+var POParser = /*#__PURE__*/ function() {
+    "use strict";
+    function POParser() {
+        _classCallCheck(this, POParser);
+    }
+    _createClass(POParser, null, [
+        {
+            key: "parse",
+            value: function parse(content) {
+                var lines = POParser.splitLines(content);
+                var messages = [];
+                var meta = {};
+                var state = "entry";
+                var entry;
+                for(var i = 0; i < lines.length; i++){
+                    var line = lines[i].trim();
+                    // An empty line indicates the end of an entry
+                    if (!line) {
+                        if (state === "entry" && entry) {
+                            messages.push(POParser.finishEntry(entry));
+                            entry = undefined;
+                        }
+                        state = "entry";
+                        continue;
+                    }
+                    if (state === "meta") {
+                        if (line.startsWith(POParser.QUOTE)) {
+                            var rawMetaLine = POParser.extractQuotedString(line, state);
+                            var metaLine = POParser.unescape(rawMetaLine);
+                            var cleaned = metaLine.endsWith("\n") ? metaLine.slice(0, -1) : metaLine;
+                            var separatorIndex = cleaned.indexOf(POParser.META_SEPARATOR);
+                            if (separatorIndex > 0) {
+                                var key = cleaned.substring(0, separatorIndex).trim();
+                                var value = cleaned.substring(separatorIndex + 1).trim();
+                                meta[key] = value;
+                            }
+                        } else {
+                            POParser.throwWithLine("Encountered unexpected non-quoted metadata line", line);
+                        }
+                    } else {
+                        // Unsupported comment types
+                        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.TRANSLATOR)) {
+                            POParser.throwWithLine("Translator comments (#) are not supported, use inline descriptions instead", line);
+                        }
+                        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.PREVIOUS)) {
+                            POParser.throwWithLine("Previous string key comments (#|) are not supported", line);
+                        }
+                        // Flag comments
+                        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.FLAG)) {
+                            entry = POParser.ensureEntry(entry);
+                            var flagsText = line.substring(POParser.COMMENTS.FLAG.length).trim();
+                            entry.flags = flagsText.split(",").map(function(flag) {
+                                return flag.trim();
+                            }).filter(Boolean);
+                            continue;
+                        }
+                        // Reference comments
+                        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.REFERENCE)) {
+                            var _entry;
+                            entry = POParser.ensureEntry(entry);
+                            var parts = line.substring(POParser.COMMENTS.REFERENCE.length).trim().split(POParser.FILE_COLUMN_SEPARATOR);
+                            var path = parts[0];
+                            var lineNumber = void 0;
+                            if (parts.length > 1) {
+                                var parsedLine = parseInt(parts[1]);
+                                if (!isNaN(parsedLine)) {
+                                    lineNumber = parsedLine;
+                                }
+                            }
+                            var _references;
+                            (_references = (_entry = entry).references) !== null && _references !== void 0 ? _references : _entry.references = [];
+                            var reference = {
+                                path: path
+                            };
+                            if (lineNumber) {
+                                reference.line = lineNumber;
+                            }
+                            entry.references.push(reference);
+                            continue;
+                        }
+                        // Extracted comments
+                        if (POParser.lineStartsWithPrefix(line, POParser.COMMENTS.EXTRACTED)) {
+                            var _entry1;
+                            entry = POParser.ensureEntry(entry);
+                            var comment = line.substring(POParser.COMMENTS.EXTRACTED.length).trim();
+                            var _extractedComments;
+                            (_extractedComments = (_entry1 = entry).extractedComments) !== null && _extractedComments !== void 0 ? _extractedComments : _entry1.extractedComments = [];
+                            entry.extractedComments.push(comment);
+                            continue;
+                        }
+                        // Check for unsupported features
+                        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGID_PLURAL)) {
+                            POParser.throwWithLine("Plural forms (msgid_plural) are not supported, use ICU pluralization instead", line);
+                        }
+                        // msgctxt
+                        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGCTXT)) {
+                            entry = POParser.ensureEntry(entry);
+                            entry.msgctxt = POParser.unescape(POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGCTXT.length + 1), state));
+                            continue;
+                        }
+                        // msgid
+                        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGID)) {
+                            entry = POParser.ensureEntry(entry);
+                            entry.msgid = POParser.unescape(POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGID.length + 1), state));
+                            if (POParser.isMetaEntry(entry, messages)) {
+                                state = "meta";
+                                entry = undefined;
+                            }
+                            continue;
+                        }
+                        // msgstr
+                        if (POParser.lineStartsWithPrefix(line, POParser.KEYWORDS.MSGSTR)) {
+                            entry = POParser.ensureEntry(entry);
+                            entry.msgstr = POParser.unescape(POParser.extractQuotedString(line.substring(POParser.KEYWORDS.MSGSTR.length + 1), state));
+                            if (POParser.isMetaEntry(entry, messages)) {
+                                state = "meta";
+                                entry = undefined;
+                            }
+                            continue;
+                        }
+                        // Multi-line strings are not supported in entry mode
+                        if (line.startsWith(POParser.QUOTE)) {
+                            POParser.throwWithLine("Multi-line strings are not supported, use single-line strings instead", line);
+                        }
+                    }
+                }
+                // Finish any remaining entry
+                if (state === "entry" && entry) {
+                    messages.push(POParser.finishEntry(entry));
+                }
+                return {
+                    meta: Object.keys(meta).length > 0 ? meta : undefined,
+                    messages: messages.length > 0 ? messages : undefined
+                };
+            }
+        },
+        {
+            key: "isMetaEntry",
+            value: function isMetaEntry(entry, messages) {
+                return messages.length === 0 && entry.msgid === "" && entry.msgstr === "";
+            }
+        },
+        {
+            key: "serialize",
+            value: function serialize(catalog) {
+                var lines = [];
+                // Metadata
+                if (catalog.meta) {
+                    lines.push("".concat(POParser.KEYWORDS.MSGID, " ").concat(POParser.QUOTE).concat(POParser.QUOTE));
+                    lines.push("".concat(POParser.KEYWORDS.MSGSTR, " ").concat(POParser.QUOTE).concat(POParser.QUOTE));
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = Object.entries(catalog.meta)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                            lines.push("".concat(POParser.QUOTE).concat(key).concat(POParser.META_SEPARATOR, " ").concat(POParser.escape(value)).concat(POParser.NEWLINE).concat(POParser.QUOTE));
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    lines.push("");
+                }
+                // Messages
+                if (catalog.messages) {
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = catalog.messages[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var entry = _step1.value;
+                            if (entry.extractedComments && entry.extractedComments.length > 0) {
+                                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                try {
+                                    for(var _iterator2 = entry.extractedComments[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                                        var comment = _step2.value;
+                                        lines.push("".concat(POParser.COMMENTS.EXTRACTED, " ").concat(comment));
+                                    }
+                                } catch (err) {
+                                    _didIteratorError2 = true;
+                                    _iteratorError2 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                            _iterator2.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError2) {
+                                            throw _iteratorError2;
+                                        }
+                                    }
+                                }
+                            }
+                            if (entry.references && entry.references.length > 0) {
+                                var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+                                try {
+                                    for(var _iterator3 = entry.references[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                                        var ref = _step3.value;
+                                        var refString = ref.path;
+                                        if (ref.line) {
+                                            refString += "".concat(POParser.FILE_COLUMN_SEPARATOR).concat(ref.line);
+                                        }
+                                        lines.push("".concat(POParser.COMMENTS.REFERENCE, " ").concat(refString));
+                                    }
+                                } catch (err) {
+                                    _didIteratorError3 = true;
+                                    _iteratorError3 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                            _iterator3.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError3) {
+                                            throw _iteratorError3;
+                                        }
+                                    }
+                                }
+                            }
+                            if (entry.flags && entry.flags.length > 0) {
+                                lines.push("".concat(POParser.COMMENTS.FLAG, " ").concat(entry.flags.join(POParser.FLAG_SEPARATOR)));
+                            }
+                            if (entry.msgctxt) {
+                                lines.push("".concat(POParser.KEYWORDS.MSGCTXT, " ").concat(POParser.QUOTE).concat(POParser.escape(entry.msgctxt)).concat(POParser.QUOTE));
+                            }
+                            lines.push("".concat(POParser.KEYWORDS.MSGID, " ").concat(POParser.QUOTE).concat(POParser.escape(entry.msgid)).concat(POParser.QUOTE));
+                            lines.push("".concat(POParser.KEYWORDS.MSGSTR, " ").concat(POParser.QUOTE).concat(POParser.escape(entry.msgstr)).concat(POParser.QUOTE));
+                            lines.push("");
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+                return lines.join("\n");
+            }
+        },
+        {
+            key: "lineStartsWithPrefix",
+            value: function lineStartsWithPrefix(line, prefix) {
+                return line.startsWith(prefix + " ");
+            }
+        },
+        {
+            key: "throwWithLine",
+            value: function throwWithLine(message, line) {
+                throw new Error("".concat(message, ":\n> ").concat(line));
+            }
+        },
+        {
+            key: "splitLines",
+            value: function splitLines(content) {
+                // Avoid overhead for Unix newlines only
+                if (content.includes("\r")) {
+                    content = content.replace(/\r\n/g, "\n");
+                }
+                return content.split("\n");
+            }
+        },
+        {
+            key: "ensureEntry",
+            value: function ensureEntry(entry) {
+                return entry || {};
+            }
+        },
+        {
+            key: "finishEntry",
+            value: function finishEntry(entry) {
+                if (entry.msgid == null || entry.msgstr == null) {
+                    throw new Error("Incomplete message entry: both msgid and msgstr are required");
+                }
+                return {
+                    msgctxt: entry.msgctxt,
+                    msgid: entry.msgid,
+                    msgstr: entry.msgstr,
+                    extractedComments: entry.extractedComments,
+                    references: entry.references,
+                    flags: entry.flags
+                };
+            }
+        },
+        {
+            key: "extractQuotedString",
+            value: function extractQuotedString(line, state) {
+                var trimmed = line.trim();
+                if (!trimmed.startsWith(POParser.QUOTE)) {
+                    POParser.throwWithLine("Incomplete quoted string", line);
+                }
+                if (!trimmed.endsWith(POParser.QUOTE)) {
+                    if (state === "meta") {
+                        return trimmed.substring(POParser.QUOTE.length);
+                    }
+                    POParser.throwWithLine("Incomplete quoted string", line);
+                }
+                var endIndex = trimmed.length - POParser.QUOTE.length;
+                return trimmed.substring(POParser.QUOTE.length, endIndex);
+            }
+        },
+        {
+            key: "escape",
+            value: function escape(value) {
+                var result = "";
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var char = _step.value;
+                        var mapped = POParser.ESCAPE_LOOKUP[char];
+                        result += mapped != null ? "\\".concat(mapped) : char;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return result;
+            }
+        },
+        {
+            key: "unescape",
+            value: function unescape(value) {
+                var result = "";
+                for(var i = 0; i < value.length; i++){
+                    var char = value[i];
+                    if (char === "\\" && i + 1 < value.length) {
+                        var nextChar = value[i + 1];
+                        var mapped = POParser.UNESCAPE_LOOKUP[nextChar];
+                        if (mapped != null) {
+                            result += mapped;
+                            i++;
+                            continue;
+                        }
+                    }
+                    result += char;
+                }
+                return result;
+            }
+        }
+    ]);
+    return POParser;
+}();
+POParser.KEYWORDS = {
+    MSGID: "msgid",
+    MSGSTR: "msgstr",
+    MSGCTXT: "msgctxt",
+    MSGID_PLURAL: "msgid_plural"
+};
+POParser.COMMENTS = {
+    REFERENCE: "#:",
+    EXTRACTED: "#.",
+    TRANSLATOR: "#",
+    FLAG: "#,",
+    PREVIOUS: "#|"
+};
+POParser.QUOTE = '"';
+POParser.NEWLINE = "\\n";
+POParser.FILE_COLUMN_SEPARATOR = ":";
+POParser.META_SEPARATOR = ":";
+POParser.FLAG_SEPARATOR = ", ";
+POParser.ESCAPE_LOOKUP = {
+    "\\": "\\",
+    '"': '"',
+    "\n": "n",
+    "\r": "r",
+    "	": "t"
+};
+POParser.UNESCAPE_LOOKUP = Object.entries(POParser.ESCAPE_LOOKUP).reduce(function(acc, param) {
+    var _param = _slicedToArray(param, 2), char = _param[0], code = _param[1];
+    acc[code] = char;
+    return acc;
+}, {});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@common.js/po-parser",
+  "version": "2.1.1",
+  "homepage": "https://github.com/etienne-martin/common.js#readme",
+  "repository": "etienne-martin/common.js",
+  "description": "po-parser package exported as CommonJS modules",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "scripts": {
+    "build": "bunchee",
+    "lint": "tsc --noEmit",
+    "test": "vitest"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "packageManager": "pnpm@10.17.1",
+  "publishConfig": {
+    "provenance": true
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^12.0.0",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "bunchee": "^6.6.2",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.9"
+  },
+  "dependencies": {}
+}