@esgettext/tools 1.0.0 → 1.2.0

package/dist/parser/po.js

@@ -1,41 +1,41 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoParser = void 0;
-var iconv_lite_1 = require("iconv-lite");
-var runtime_1 = require("@esgettext/runtime");
-var entry_1 = require("../pot/entry");
-var parser_1 = require("./parser");
-var gtx = runtime_1.Textdomain.getInstance('tools');
-var PoParser = (function (_super) {
-    __extends(PoParser, _super);
-    function PoParser() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.msgType = null;
-        return _this;
+const iconv_lite_1 = require("iconv-lite");
+const runtime_1 = require("@esgettext/runtime");
+const entry_1 = require("../pot/entry");
+const parser_1 = require("./parser");
+const gtx = runtime_1.Textdomain.getInstance('tools');
+class PoParser extends parser_1.Parser {
+    constructor() {
+        super(...arguments);
+        // All those get reset on each call to parse().
+        this.entry = undefined;
+        this.loc = undefined;
+        this.entryLoc = undefined;
+        this.msgType = undefined;
+        this.seen = {};
     }
-    PoParser.prototype.parse = function (buf, filename, encoding) {
+    /**
+     * Parse a po file into a catalog. This parser is very forgiving and
+     * accepts input that actually does not follow the standard in certain
+     * areas.
+     *
+     * The encoding will always be read from the PO header if present.
+     *
+     * @param input - the content of the po file
+     * @param filename - the filename
+     * @param encoding - an optional encoding
+     */
+    parse(buf, filename, encoding) {
         if (typeof encoding !== 'undefined') {
             if (!(0, iconv_lite_1.encodingExists)(encoding)) {
-                console.error(gtx._x('unsupported encoding "{encoding}"', { encoding: encoding }));
+                console.error(gtx._x('unsupported encoding "{encoding}"', { encoding }));
                 return false;
             }
         }
-        var input = typeof encoding === 'undefined' ? buf.toString() : (0, iconv_lite_1.decode)(buf, encoding);
+        const input = typeof encoding === 'undefined' ? buf.toString() : (0, iconv_lite_1.decode)(buf, encoding);
+        // Reset parser.
         this.entry = undefined;
         this.filename = filename;
         this.loc = {
@@ -44,16 +44,22 @@ var PoParser = (function (_super) {
                 column: 1,
                 index: 0,
             },
-            end: null,
-            filename: filename,
+            end: {
+                line: 0,
+                column: 0,
+                index: 0,
+            },
+            filename,
             identifierName: '',
         };
-        this.msgType = null;
+        this.msgType = undefined;
         this.seen = {};
         this.errors = 0;
-        var lines = input.split('\n');
-        for (var i = 0; i < lines.length; ++i) {
-            var line = lines[i];
+        // We cannot use forEach here because we may have to return from
+        // inside the loop.
+        const lines = input.split('\n');
+        for (let i = 0; i < lines.length; ++i) {
+            const line = lines[i];
             this.loc.start.column = 1;
             ++this.loc.start.line;
             if (line === '') {
@@ -61,17 +67,20 @@ var PoParser = (function (_super) {
                     this.entry.properties.msgid === '' &&
                     typeof this.entry.properties.msgctxt === 'undefined' &&
                     this.entry.properties.msgstr) {
-                    var charset = this.extractCharset(this.entry.properties.msgstr);
+                    const charset = this.extractCharset(this.entry.properties.msgstr);
                     if (charset &&
                         (typeof encoding === 'undefined' ||
                             charset.toLowerCase() !== encoding.toLowerCase())) {
+                        // FIXME! This must only happen, if the header is the first
+                        // entry that has been added. Otherwise, we'll add the entries
+                        // before this, twice.
                         return this.parse(buf, filename, charset);
                     }
                 }
                 this.flushEntry();
             }
             else {
-                var first = line[0];
+                const first = line[0];
                 switch (first) {
                     case '#':
                         if (line.length > 1 && line[1] === '~') {
@@ -112,10 +121,13 @@ var PoParser = (function (_super) {
             this.entry.properties.msgid === '' &&
             typeof this.entry.properties.msgctxt === 'undefined' &&
             this.entry.properties.msgstr) {
-            var charset = this.extractCharset(this.entry.properties.msgstr);
+            const charset = this.extractCharset(this.entry.properties.msgstr);
             if (charset &&
                 (typeof encoding === 'undefined' ||
                     charset.toLowerCase() !== encoding.toLowerCase())) {
+                // FIXME! This must only happen, if the header is the first
+                // entry that has been added. Otherwise, we'll add the entries
+                // before this, twice.
                 return this.parse(buf, filename, charset);
             }
         }
@@ -123,50 +135,53 @@ var PoParser = (function (_super) {
         if (this.errors) {
             return false;
         }
+        // FIXME! This must go into the caller!
         this.catalog.makePOT();
         return true;
-    };
-    PoParser.prototype.doParse = function (_input, _filename) {
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    doParse(_input, _filename) {
         throw new Error('not implemented');
-    };
-    PoParser.prototype.extractCharset = function (header) {
-        var headers = {};
+    }
+    extractCharset(header) {
+        const headers = {};
         header
             .split('\n')
-            .map(function (line) { return line.split(':'); })
-            .map(function (chunks) { return ({
+            .map(line => line.split(':'))
+            .map(chunks => ({
             name: chunks[0].toLowerCase(),
             value: chunks.slice(1).join(':').trim(),
-        }); })
-            .filter(function (header) { return header.name !== ''; })
-            .forEach(function (header) { return (headers[header.name] = header.value); });
-        var contentType = headers['content-type'];
+        }))
+            .filter(header => header.name !== '')
+            .forEach(header => (headers[header.name] = header.value));
+        const contentType = headers['content-type'];
         if (typeof contentType === 'undefined') {
             return null;
         }
-        var tokens = contentType.split('=').map(function (token) { return token.trim(); });
+        const tokens = contentType.split('=').map(token => token.trim());
         if (tokens.length <= 1) {
             return null;
         }
-        var charset = tokens[tokens.length - 1];
+        const charset = tokens[tokens.length - 1];
         if (!(0, iconv_lite_1.encodingExists)(charset)) {
             this.warn(gtx._x('the charset "{charset}" is not a portable encoding name.', {
-                charset: charset,
+                charset,
             }), this.loc);
             this.warn(gtx._('message conversion to the users charset might not work.'), this.loc);
             return null;
         }
         return charset;
-    };
-    PoParser.prototype.flushEntry = function () {
+    }
+    flushEntry() {
         if (this.errors) {
             this.entry = undefined;
             return;
         }
         if (this.entry) {
-            var msgctxt = this.entry.properties.msgctxt;
-            var msgid = this.entry.properties.msgid;
+            const msgctxt = this.entry.properties.msgctxt;
+            const msgid = this.entry.properties.msgid;
             if (typeof msgid === 'undefined') {
+                // TRANSLATORS: Do not translate "msgid".
                 this.error(gtx._('missing "msgid" section'), this.loc);
                 return;
             }
@@ -182,9 +197,9 @@ var PoParser = (function (_super) {
             this.catalog.addEntry(this.entry);
         }
         this.entry = undefined;
-    };
-    PoParser.prototype.parseCommentLine = function (line) {
-        var marker = line[1];
+    }
+    parseCommentLine(line) {
+        const marker = line[1];
         switch (marker) {
             case ',':
                 this.parseFlags(line);
@@ -202,44 +217,43 @@ var PoParser = (function (_super) {
                 this.entry.addTranslatorCommentLine(line.substr(1));
                 break;
         }
-    };
-    PoParser.prototype.parseKeywordLine = function (line) {
-        var _this = this;
-        var errorsBefore = this.errors;
-        var remainder = line.replace(/^[_A-Za-z0-9[\]]+/, function (keyword) {
+    }
+    parseKeywordLine(line) {
+        const errorsBefore = this.errors;
+        let remainder = line.replace(/^[_A-Za-z0-9[\]]+/, keyword => {
             switch (keyword) {
                 case 'msgid':
-                    _this.entryLoc = _this.copyLocation(_this.loc);
-                    _this.msgType = keyword;
-                    if (typeof _this.entry.properties.msgid !== 'undefined') {
-                        _this.error(gtx._x('duplicate "{keyword}" section', { keyword: keyword }), _this.loc);
+                    this.entryLoc = this.copyLocation(this.loc);
+                    this.msgType = keyword;
+                    if (typeof this.entry.properties.msgid !== 'undefined') {
+                        this.error(gtx._x('duplicate "{keyword}" section', { keyword }), this.loc);
                     }
                     break;
                 case 'msgstr':
-                    _this.msgType = keyword;
-                    if (typeof _this.entry.properties.msgstr !== 'undefined') {
-                        _this.error(gtx._x('duplicate "{keyword}" section', { keyword: keyword }), _this.loc);
+                    this.msgType = keyword;
+                    if (typeof this.entry.properties.msgstr !== 'undefined') {
+                        this.error(gtx._x('duplicate "{keyword}" section', { keyword }), this.loc);
                     }
                     break;
                 case 'msgid_plural':
-                    _this.msgType = keyword;
-                    if (typeof _this.entry.properties.msgidPlural !== 'undefined') {
-                        _this.error(gtx._x('duplicate "{keyword}" section', { keyword: keyword }), _this.loc);
+                    this.msgType = keyword;
+                    if (typeof this.entry.properties.msgidPlural !== 'undefined') {
+                        this.error(gtx._x('duplicate "{keyword}" section', { keyword }), this.loc);
                     }
                     break;
                 case 'msgctxt':
-                    _this.msgType = keyword;
-                    if (typeof _this.entry.properties.msgctxt !== 'undefined') {
-                        _this.error(gtx._x('duplicate "{keyword}" section', { keyword: keyword }), _this.loc);
+                    this.msgType = keyword;
+                    if (typeof this.entry.properties.msgctxt !== 'undefined') {
+                        this.error(gtx._x('duplicate "{keyword}" section', { keyword }), this.loc);
                     }
                     break;
                 default:
                     if (!/^msgstr\[[0-9]+\]/.exec(keyword)) {
-                        _this.error(gtx._x('keyword "{keyword}" unknown', { keyword: keyword }), _this.loc);
+                        this.error(gtx._x('keyword "{keyword}" unknown', { keyword }), this.loc);
                     }
-                    _this.msgType = keyword;
+                    this.msgType = keyword;
             }
-            _this.loc.start.column += keyword.length;
+            this.loc.start.column += keyword.length;
             return '';
         });
         if (errorsBefore !== this.errors) {
@@ -252,21 +266,20 @@ var PoParser = (function (_super) {
         else {
             this.syntaxError();
         }
-    };
-    PoParser.prototype.parseQuotedString = function (line) {
-        var _this = this;
+    }
+    parseQuotedString(line) {
         if (!line.endsWith('"')) {
             this.loc.start.column += line.length;
             this.error(gtx._('end-of-line within string'), this.loc);
             return;
         }
-        var raw = line.substr(1, line.length - 2);
+        const raw = line.substr(1, line.length - 2);
         if (raw.length && raw.endsWith('\\')) {
             this.error(gtx._('end-of-line within string'), this.loc);
             return;
         }
-        var msg = raw.replace(/\\./g, function (match, offset) {
-            var retval;
+        const msg = raw.replace(/\\./g, (match, offset) => {
+            let retval;
             switch (match[1]) {
                 case '\\':
                 case '"':
@@ -294,8 +307,9 @@ var PoParser = (function (_super) {
                     retval = '\r';
                     break;
                 default:
-                    _this.loc.start.column += offset + 1;
-                    _this.error(gtx._('invalid control sequence'), _this.loc);
+                    // We have to take the leading quote into account.
+                    this.loc.start.column += offset + 1;
+                    this.error(gtx._('invalid control sequence'), this.loc);
                     retval = '';
             }
             return retval;
@@ -317,78 +331,80 @@ var PoParser = (function (_super) {
                 this.entry.addToMsgctxt(msg);
                 break;
             default:
+                // Ignore plural translations.
                 break;
         }
-    };
-    PoParser.prototype.parseFlags = function (line) {
-        var _this = this;
-        var flags = line.substr(2).split(',');
-        flags.forEach(function (flag, i) {
+    }
+    parseFlags(line) {
+        const flags = line.substr(2).split(',');
+        flags.forEach((flag, i) => {
             if (i) {
-                ++_this.loc.start.column;
+                ++this.loc.start.column;
             }
-            var rspace = _this.rspace(flag);
-            flag = _this.trim(flag);
+            const rspace = this.rspace(flag);
+            flag = this.trim(flag);
             if (!flag.length) {
-                _this.warn(gtx._('ignoring empty flag'), _this.loc);
+                this.warn(gtx._('ignoring empty flag'), this.loc);
             }
             else {
-                _this.entry.addFlag(flag);
+                this.entry.addFlag(flag);
             }
-            _this.loc.start.column += rspace + flag.length;
+            this.loc.start.column += rspace + flag.length;
         });
-    };
-    PoParser.prototype.parseReferences = function (line) {
-        var _this = this;
+    }
+    parseReferences(line) {
         this.loc.start.column += 2;
-        var refs = line.substr(2).split(' ');
-        refs.forEach(function (reference, i) {
+        const refs = line.substr(2).split(' ');
+        refs.forEach((reference, i) => {
             if (i) {
-                ++_this.loc.start.column;
+                ++this.loc.start.column;
             }
-            reference = _this.trim(reference);
+            reference = this.trim(reference);
             if (/.+:[1-9][0-9]*$/.exec(reference)) {
-                _this.entry.addReference(reference);
+                this.entry.addReference(reference);
             }
             else if (reference !== '') {
-                _this.warn(gtx._x('ignoring mal-formed reference "{reference}"', {
-                    reference: reference,
-                }), _this.loc);
+                this.warn(gtx._x('ignoring mal-formed reference "{reference}"', {
+                    reference,
+                }), this.loc);
             }
-            _this.loc.start.column += reference.length;
+            this.loc.start.column += reference.length;
         });
-    };
-    PoParser.prototype.syntaxError = function () {
+    }
+    syntaxError() {
         this.error(gtx._('syntax error'), this.loc);
-    };
-    PoParser.prototype.trim = function (str) {
-        var _this = this;
+    }
+    trim(str) {
         return str
-            .replace(/^[\s\uFEFF\xA0]+/, function (match) {
-            _this.loc.start.column += match.length;
+            .replace(/^[\s\uFEFF\xA0]+/, match => {
+            this.loc.start.column += match.length;
             return '';
         })
             .trim();
-    };
-    PoParser.prototype.rspace = function (str) {
-        var space = /[\s\uFEFF\xA0]+$/.exec(str);
+    }
+    rspace(str) {
+        const space = /[\s\uFEFF\xA0]+$/.exec(str);
         if (space) {
             return space[0].length;
         }
         else {
             return 0;
         }
-    };
-    PoParser.prototype.copyLocation = function (loc) {
+    }
+    copyLocation(loc) {
         return {
             start: {
                 line: loc.start.line,
                 column: loc.start.column,
             },
-            end: null,
+            end: {
+                line: 0,
+                column: 0,
+                index: 0,
+            },
+            filename: '',
+            identifierName: null,
         };
-    };
-    return PoParser;
-}(parser_1.Parser));
+    }
+}
 exports.PoParser = PoParser;
-//# sourceMappingURL=po.js.map

package/dist/parser/typescript.js

@@ -1,35 +1,18 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptParser = void 0;
-var parser_1 = require("@babel/parser");
-var parser_2 = require("./parser");
-var TypeScriptParser = (function (_super) {
-    __extends(TypeScriptParser, _super);
-    function TypeScriptParser() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TypeScriptParser.prototype.doParse = function (input, filename) {
-        var ast = (0, parser_1.parse)(input, {
+const parser_1 = require("@babel/parser");
+const parser_2 = require("./parser");
+class TypeScriptParser extends parser_2.Parser {
+    doParse(input, filename) {
+        const ast = (0, parser_1.parse)(input, {
             allowAwaitOutsideFunction: true,
             allowImportExportEverywhere: true,
             allowReturnOutsideFunction: true,
             allowSuperOutsideMethod: true,
             allowUndeclaredExports: true,
+            // Documented but not supported. FIXME! Maybe only missing in types.
+            // errorRecovery: true,
             sourceFilename: filename,
             plugins: [
                 'typescript',
@@ -37,11 +20,10 @@ var TypeScriptParser = (function (_super) {
                 'classProperties',
                 'classPrivateMethods',
                 'classPrivateProperties',
+                'decorators',
             ],
         });
         return this.extract(filename, ast);
-    };
-    return TypeScriptParser;
-}(parser_2.Parser));
+    }
+}
 exports.TypeScriptParser = TypeScriptParser;
-//# sourceMappingURL=typescript.js.map