@esgettext/runtime 1.0.0 → 1.2.0

package/dist/esgettext.esm.js

@@ -0,0 +1,1406 @@
+import { readFile } from 'fs';
+
+let userLocalesSelected = ['C'];
+/*
+ * Force an execution environment. By default, the environment (NodeJS or
+ * browser) is auto-detected. You can force the library to assume a certain
+ * environment with this function.
+ *
+ * @param browser - whether to assume a browser or not
+ * @returns the new setting.
+ */
+function userLocales(locales) {
+    if (typeof locales !== 'undefined') {
+        userLocalesSelected = locales;
+    }
+    return userLocalesSelected;
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+class TransportHttp {
+    loadFile(url) {
+        return new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.responseType = 'arraybuffer';
+            xhr.open('GET', url, true);
+            xhr.onload = () => {
+                if (xhr.readyState === 4 && xhr.status === 200) {
+                    resolve(xhr.response);
+                }
+                else {
+                    reject(new Error('get failed with status ' + xhr.status));
+                }
+            };
+            xhr.onerror = err => reject(err);
+            xhr.send();
+        });
+    }
+}
+
+class TransportFs {
+    loadFile(url) {
+        return new Promise((resolve, reject) => {
+            readFile(url, (err, data) => {
+                return err ? reject(err) : resolve(data);
+            });
+        });
+    }
+}
+
+/*
+ * Function for germanic plural. Returns singular (0) for 1 item, and
+ * 1 for everything else.
+ *
+ * @param numItems - number of items
+ * @returns the index into the plural translations
+ */
+function germanicPlural(numItems) {
+    return numItems === 1 ? 0 : 1;
+}
+
+/*
+ * A minimalistic buffer implementation that can only read 32 bit unsigned
+ * integers and strings.
+ */
+class DataViewlet {
+    /*
+     * Create a DataViewlet instance. All encodings that are supported by
+     * the runtime environments `TextDecoder` interface.
+     *
+     * @param array - a `Unit8Array` view on the binary buffer
+     * @param encoding - encoding of strings, defaults to utf-8
+     */
+    constructor(array, encoding = 'utf-8') {
+        this.array = array;
+        this.decoder = new TextDecoder(encoding);
+        this._encoding = encoding;
+    }
+    /**
+     * Get the encoding for strings.
+     *
+     * @returns the encoding in use
+     */
+    get encoding() {
+        return this._encoding;
+    }
+    /**
+     * Switch to a new encoding.
+     *
+     * @param encoding - new encoding to use
+     */
+    set encoding(encoding) {
+        this.decoder = new TextDecoder(encoding);
+        this._encoding = encoding;
+    }
+    /*
+     * Reads an unsigned 32-bit integer from the buffer at
+     * the specified offset as big-endian.
+     *
+     * @param offset - Number of bytes to skip before starting to read.
+     *                 Must satisfy `0 <= offset <= buf.length - 4`.
+     *                 Default: 0.
+     * @returns the 32-bit unsigned integer at position `offset`.s
+     */
+    readUInt32BE(offset = 0) {
+        if (offset + 4 > this.array.byteLength + this.array.byteOffset) {
+            throw new Error('read past array end');
+        }
+        return ((((this.array[offset] << 24) >>> 0) |
+            (this.array[offset + 1] << 16) |
+            (this.array[offset + 2] << 8) |
+            this.array[offset + 3]) >>>
+            0);
+    }
+    /*
+     * Reads an unsigned 32-bit integer from the buffer at
+     * the specified offset as little-endian.
+     *
+     * @param offset - Number of bytes to skip before starting to read.
+     *                 Must satisfy `0 <= offset <= buf.length - 4`.
+     *                 Default: 0.
+     * @returns the 32-bit unsigned integer at position `offset`.s
+     */
+    readUInt32LE(offset = 0) {
+        if (offset + 4 > this.array.byteLength + this.array.byteOffset) {
+            throw new Error('read past array end');
+        }
+        return ((((this.array[offset + 3] << 24) >>> 0) |
+            (this.array[offset + 2] << 16) |
+            (this.array[offset + 1] << 8) |
+            this.array[offset]) >>>
+            0);
+    }
+    /*
+     * Read a string at a specified offset.
+     *
+     * @param offset - to beginning of buffer in bytes
+     * @param length - of the string to read in bytes or to the end of the
+     *                 buffer if not specified.
+     */
+    readString(offset = 0, length) {
+        if (offset + length >
+            this.array.byteLength + this.array.byteOffset) {
+            throw new Error('read past array end');
+        }
+        if (typeof length === 'undefined') {
+            length = this.array.byteLength - offset;
+        }
+        return this.decoder.decode(this.array.slice(offset, offset + length));
+    }
+}
+
+/*
+ * Parse an MO file.
+ *
+ * An exception is thrown for invalid data.
+ *
+ * @param raw - The input as either a binary `String`, any `Array`-like byte
+ *              storage (`Array`, `Uint8Array`, `Arguments`, `jQuery(Array)`, ...)
+ * @returns a Catalog
+ */
+function parseMoCatalog(raw) {
+    const catalog = {
+        major: 0,
+        minor: 0,
+        entries: {},
+        pluralFunction: germanicPlural,
+    };
+    let offset = 0;
+    const blob = new DataViewlet(new Uint8Array(raw), 'ascii');
+    const magic = blob.readUInt32LE(offset);
+    let reader;
+    if (magic === 0x950412de) {
+        /* eslint-disable-next-line @typescript-eslint/explicit-function-return-type */
+        reader = (buf, off) => buf.readUInt32LE(off);
+    }
+    else if (magic === 0xde120495) {
+        /* eslint-disable-next-line @typescript-eslint/explicit-function-return-type */
+        reader = (buf, off) => buf.readUInt32BE(off);
+    }
+    else {
+        throw new Error(`invalid MO magic 0x${magic.toString(16)}`);
+    }
+    offset += 4;
+    // The revision is encoded in two shorts, major and minor.  We don't care
+    // about the minor revision.
+    const major = reader(blob, offset) >> 16;
+    offset += 4;
+    if (major > 0) {
+        throw new Error(`unsupported major revision ${major}`);
+    }
+    const numStrings = reader(blob, offset);
+    offset += 4;
+    const msgidOffset = reader(blob, offset);
+    offset += 4;
+    const msgstrOffset = reader(blob, offset);
+    offset = msgidOffset;
+    const origTab = [];
+    for (let i = 0; i < numStrings; ++i) {
+        const l = reader(blob, offset);
+        offset += 4;
+        const stringOffset = reader(blob, offset);
+        offset += 4;
+        origTab.push([l, stringOffset]);
+    }
+    offset = msgstrOffset;
+    const transTab = [];
+    for (let i = 0; i < numStrings; ++i) {
+        const l = reader(blob, offset);
+        offset += 4;
+        const stringOffset = reader(blob, offset);
+        offset += 4;
+        transTab.push([l, stringOffset]);
+    }
+    const poHeader = {};
+    for (let i = 0; i < numStrings; ++i) {
+        const orig = origTab[i];
+        let l = orig[0];
+        offset = orig[1];
+        const msgid = blob.readString(offset, l).split('\u0000')[0];
+        const trans = transTab[i];
+        l = trans[0];
+        offset = trans[1];
+        const msgstr = blob.readString(offset, l).split('\u0000');
+        let pairs, kv;
+        if (i === 0 && msgid === '') {
+            pairs = msgstr[0].split('\n');
+            for (let j = 0; j < pairs.length; ++j) {
+                if (pairs[j] !== '') {
+                    kv = pairs[j].split(/[ \t]*:[ \t]*/);
+                    poHeader[kv[0].toLowerCase()] = kv[1];
+                }
+            }
+            if (poHeader['content-type'] !== undefined) {
+                const enc = poHeader['content-type'].replace(/.*=/, '');
+                if (enc !== poHeader['content-type']) {
+                    blob.encoding = enc;
+                }
+            }
+        }
+        catalog.entries[msgid] = msgstr;
+    }
+    return catalog;
+}
+
+function validateMoJsonCatalog(udata) {
+    // We could use ajv but it results in almost 300 k minimized code
+    // for the browser bundle. This validator instead is absolutely
+    // minimalistic, and only avoids exceptions that can occur, when
+    // accessing entries.
+    if (udata === null || typeof udata === 'undefined') {
+        throw new Error('catalog is either null or undefined');
+    }
+    const data = udata;
+    if (data.constructor !== Object) {
+        throw new Error('catalog must be a dictionary');
+    }
+    // We don't care about major and minor because they are actually not
+    // used.
+    if (!Object.prototype.hasOwnProperty.call(data, 'entries')) {
+        throw new Error('catalog.entries does not exist');
+    }
+    const entries = data.entries;
+    if (entries === null || typeof entries === 'undefined') {
+        throw new Error('catalog.entries are not defined or null');
+    }
+    if (entries.constructor !== Object) {
+        throw new Error('catalog.entries must be a dictionary');
+    }
+    for (const [key, value] of Object.entries(entries)) {
+        if (!Array.isArray(value)) {
+            throw new Error(`catalog entry for key '${key}' is not an array`);
+        }
+    }
+    return data;
+}
+function parseMoJsonCatalog(json) {
+    const text = new TextDecoder().decode(json);
+    const data = JSON.parse(text);
+    return validateMoJsonCatalog(data);
+}
+
+function validateJsonCatalog(udata) {
+    // We could use ajv but it results in almost 300 k minimized code
+    // for the browser bundle. This validator instead is absolutely
+    // minimalistic, and only avoids exceptions that can occur, when
+    // accessing entries.
+    if (udata === null || typeof udata === 'undefined') {
+        throw new Error('catalog is either null or undefined');
+    }
+    const entries = udata;
+    if (entries.constructor !== Object) ;
+    // Convert to a regular catalog.
+    const catalog = {
+        major: 0,
+        minor: 1,
+        pluralFunction: () => 0,
+        entries: {},
+    };
+    for (const [msgid, msgstr] of Object.entries(entries)) {
+        // Just stringify all values but do not complain.
+        catalog.entries[msgid] = [msgstr.toString()];
+    }
+    return catalog;
+}
+function parseJsonCatalog(json) {
+    const text = new TextDecoder().decode(json);
+    const data = JSON.parse(text);
+    return validateJsonCatalog(data);
+}
+
+const tagHyphenRegex = new RegExp('^[a-z0-9]+(?:-[a-z0-9]+)*$', 'i');
+const tagUnderscoreRegex = new RegExp('^[a-z0-9]+(?:_[a-z0-9]+)*$', 'i');
+function splitLocale(locale) {
+    let charset = '', modifier = '';
+    const underscoreSeparator = locale.includes('_');
+    locale = locale.replace(/@([a-z]+)$/i, (_, match) => {
+        modifier = match;
+        return '';
+    });
+    locale = locale.replace(/\.([-0-9a-z]+)$/i, (_, match) => {
+        charset = match;
+        return '';
+    });
+    if (underscoreSeparator) {
+        if (!tagUnderscoreRegex.exec(locale)) {
+            return null;
+        }
+    }
+    else {
+        if (!tagHyphenRegex.exec(locale)) {
+            return null;
+        }
+    }
+    const separator = underscoreSeparator ? '_' : '-';
+    const tags = locale.split(separator);
+    const split = { tags: tags, underscoreSeparator };
+    if (charset.length) {
+        split.charset = charset;
+    }
+    if (modifier.length) {
+        split.modifier = modifier;
+    }
+    return split;
+}
+
+/*
+ * Caches catalog lookups by path, locale, and textdomain.
+ *
+ * Failed lookups are stored as null values.
+ *
+ * It is also possible to store a Promise. In that case, if a request is
+ * made to bind the textdomain, the promise is settled. Note that this
+ * mechanism is never used for message lookup but only for loading the
+ * catalog via resolve.
+ */
+class CatalogCache {
+    constructor() {
+        /* Singleton. */
+    }
+    static getInstance() {
+        if (!CatalogCache.instance) {
+            CatalogCache.instance = new CatalogCache();
+        }
+        return CatalogCache.instance;
+    }
+    static clear() {
+        CatalogCache.cache = {};
+    }
+    /**
+     * Lookup a Catalog for a given base path, locale, and textdomain.
+     *
+     * The locale key is usually the locale identifier (e.g. de-DE or sr\@latin).
+     * But it can also be a colon separated list of such locale identifiers.
+     *
+     *
+     * @param localeKey - the locale key
+     * @param textdomain - the textdomain
+     * @returns the cached Catalog, a Promise or null for failure
+     */
+    static lookup(localeKey, textdomain) {
+        if (CatalogCache.cache[localeKey]) {
+            const ptr = CatalogCache.cache[localeKey];
+            if (Object.prototype.hasOwnProperty.call(ptr, textdomain)) {
+                return ptr[textdomain];
+            }
+        }
+        return null;
+    }
+    static store(localeKey, textdomain, entry) {
+        if (Promise.resolve(entry) !== entry) {
+            // Object.
+            entry = validateMoJsonCatalog(entry);
+        }
+        if (!CatalogCache.cache[localeKey]) {
+            CatalogCache.cache[localeKey] = {};
+        }
+        CatalogCache.cache[localeKey][textdomain] = entry;
+    }
+}
+CatalogCache.cache = {};
+
+function explodeLocale(locale, vary) {
+    const retval = [];
+    const lsep = locale.underscoreSeparator ? '_' : '-';
+    let i = 0 ;
+    const hasCharset = typeof locale.charset !== 'undefined';
+    const hasModifier = typeof locale.modifier !== 'undefined';
+    const charsets = hasCharset ? [locale.charset] : [''];
+    if (hasCharset) {
+        const charset = locale.charset;
+        const ucCharset = charset.toUpperCase();
+        if (ucCharset !== charset) {
+            charsets.push(ucCharset);
+        }
+        charsets.push('');
+    }
+    for (; i < locale.tags.length; ++i) {
+        const lingua = locale.tags.slice(0, i + 1).join(lsep);
+        const ids = new Array();
+        charsets.forEach(charset => {
+            let id = charset.length ? lingua + '.' + charset : lingua;
+            if (hasModifier) {
+                id += '@' + locale.modifier;
+            }
+            ids.push(id);
+        });
+        retval.push(ids);
+    }
+    return retval;
+}
+
+function loadCatalog(url, format) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let transportInstance;
+        {
+            let transport;
+            // Check whether this is a valid URL.
+            try {
+                const parsedURL = new URL(url);
+                if (parsedURL.protocol === 'https:' ||
+                    parsedURL.protocol === 'http:' ||
+                    parsedURL.protocol === 'file:') {
+                    transport = 'http';
+                }
+                else {
+                    throw new Error(`unsupported scheme ${parsedURL.protocol}`);
+                }
+            }
+            catch (e) {
+                {
+                    transport = 'fs';
+                }
+            }
+            if (transport === 'http') {
+                transportInstance = new TransportHttp();
+            }
+            else {
+                transportInstance = new TransportFs();
+            }
+        }
+        let validator;
+        if ('mo.json' === format) {
+            validator = parseMoJsonCatalog;
+        }
+        else if ('.json' === format) {
+            validator = parseJsonCatalog;
+        }
+        else {
+            validator = parseMoCatalog;
+        }
+        try {
+            const data = yield transportInstance.loadFile(url);
+            return validator(data);
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+function assemblePath(base, id, domainname, extender) {
+    return `${base}/${id}/LC_MESSAGES/${domainname}.${extender}`;
+}
+function loadLanguageFromObject(ids, base, domainname) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let i = 0; i < ids.length; ++i) {
+            const id = ids[i];
+            // Language exists?
+            if (!Object.prototype.hasOwnProperty.call(base, id)) {
+                continue;
+            }
+            // LC_MESSAGES?
+            if (!Object.prototype.hasOwnProperty.call(base[id], 'LC_MESSAGES')) {
+                continue;
+            }
+            // Textdomain?
+            if (!Object.prototype.hasOwnProperty.call(base[id].LC_MESSAGES, domainname)) {
+                continue;
+            }
+            return base[id].LC_MESSAGES[domainname];
+        }
+        return null;
+    });
+}
+/*
+ * First tries to load a catalog with the specified charset, then with the
+ * charset converted to uppercase (if it differs from the original charset),
+ * and finally without a charset.
+ */
+function loadLanguage(ids, base, domainname, format) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Check if `base` is an object (LocaleContainer).
+        if (typeof base === 'object' && base !== null) {
+            return loadLanguageFromObject(ids, base, domainname);
+        }
+        for (const id of ids) {
+            const catalog = yield loadCatalog(assemblePath(base, id, domainname, format), format);
+            if (catalog) {
+                return catalog;
+            }
+        }
+        return null;
+    });
+}
+function loadDomain(exploded, localeKey, base, domainname, format) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = {};
+        const catalog = {
+            major: 0,
+            minor: 0,
+            pluralFunction: germanicPlural,
+            entries,
+        };
+        const cacheHit = yield CatalogCache.lookup(localeKey, domainname);
+        if (cacheHit !== null) {
+            return cacheHit;
+        }
+        for (const tries of exploded) {
+            const result = yield loadLanguage(tries, base, domainname, format);
+            if (result) {
+                catalog.major = result.major;
+                catalog.minor = result.minor;
+                catalog.entries = Object.assign(Object.assign({}, catalog.entries), result.entries);
+            }
+        }
+        return catalog;
+    });
+}
+function pluralExpression(str) {
+    const tokens = str
+        .replace(/[ \t\r\013\014]/g, '')
+        .replace(/;$/, '')
+        // Do NOT allow square brackets here. JSFuck!
+        .split(/[<>!=]=|&&|\|\||[-!*/%+<>=?:;]/);
+    for (let i = 0; i < tokens.length; ++i) {
+        const token = tokens[i].replace(/^\(+/, '').replace(/\)+$/, '');
+        if (token !== 'nplurals' &&
+            token !== 'plural' &&
+            token !== 'n' &&
+            // Does not catch invalid octal numbers but the compiler
+            // takes care of that.
+            null === /^[0-9]+$/.exec(token)) {
+            throw new Error('invalid plural function');
+        }
+    }
+    const code = 'var nplurals = 1, plural = 0;' + str + '; return 0 + plural';
+    // This may throw an exception!
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    return new Function('n', code);
+}
+function setPluralFunction(catalog) {
+    if (!Object.prototype.hasOwnProperty.call(catalog.entries, '')) {
+        return catalog;
+    }
+    const headers = catalog.entries[''][0].split('\n');
+    headers.forEach(header => {
+        const tokens = header.split(':');
+        if ('plural-forms' === tokens.shift().toLowerCase()) {
+            const code = tokens.join(':');
+            try {
+                catalog.pluralFunction = pluralExpression(code);
+            }
+            catch (_a) {
+                catalog.pluralFunction = germanicPlural;
+            }
+        }
+    });
+    return catalog;
+}
+function resolveImpl(domainname, path, format, localeKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const defaultCatalog = {
+            major: 0,
+            minor: 0,
+            pluralFunction: germanicPlural,
+            entries: {},
+        };
+        if (localeKey === 'C' || localeKey === 'POSIX') {
+            return defaultCatalog;
+        }
+        const exploded = explodeLocale(splitLocale(localeKey));
+        const catalog = yield loadDomain(exploded, localeKey, path, domainname, format);
+        setPluralFunction(catalog);
+        CatalogCache.store(localeKey, domainname, catalog);
+        return catalog;
+    });
+}
+
+function gettextImpl(args) {
+    var _a;
+    const key = typeof args.msgctxt === 'undefined'
+        ? args.msgid
+        : args.msgctxt + '\u0004' + args.msgid;
+    const translations = args.catalog.entries[key];
+    const numItems = (_a = args.numItems) !== null && _a !== void 0 ? _a : 1;
+    if (translations && translations.length) {
+        if (typeof args.msgidPlural === 'undefined') {
+            return translations[0];
+        }
+        else {
+            let pluralForm = args.catalog.pluralFunction(numItems);
+            if (pluralForm >= translations.length) {
+                if (translations.length === 1) {
+                    return translations[0];
+                }
+                else {
+                    pluralForm = germanicPlural(numItems);
+                }
+            }
+            return translations[pluralForm];
+        }
+    }
+    else if (typeof args.msgidPlural !== 'undefined') {
+        const pluralform = args.catalog.pluralFunction(numItems);
+        if (pluralform === 1) {
+            return args.msgidPlural;
+        }
+    }
+    return args.msgid;
+}
+
+const isNode = typeof process !== 'undefined' &&
+    process.versions !== null &&
+    process.versions.node !== null;
+const pathSeparator = isNode && process.platform === 'win32' ? '\\' : '/';
+
+function tagsEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let i = 0; i < left.length; ++i) {
+        if (left[i].toLowerCase() !== right[i].toLowerCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+function selectLocale(supported, requested) {
+    let languageMatch = '';
+    for (let i = 0; i < requested.length; ++i) {
+        const wanted = splitLocale(requested[i]);
+        if (!wanted) {
+            continue;
+        }
+        for (let j = 0; j < supported.length; ++j) {
+            const got = splitLocale(supported[j]);
+            if (!got) {
+                continue;
+            }
+            if (tagsEqual(wanted.tags, got.tags)) {
+                return supported[j];
+            }
+            if (!languageMatch.length &&
+                wanted.tags[0].toLowerCase() === got.tags[0].toLowerCase()) {
+                languageMatch = supported[j];
+            }
+        }
+    }
+    if (languageMatch.length) {
+        return languageMatch;
+    }
+    return 'C';
+}
+
+/**
+ * A Textdomain is a container for an esgettext configuration and all loaded
+ * LocaleContainer for the textual domain selected.
+ *
+ * The actual translation methods have quite funny names like `_()` or
+ * `_x()`. The purpose of this naming convention is to make the
+ * internationalization of your programs as little obtrusive as possible.
+ * Most of the times you just have to exchange
+ *
+ * ```
+ * doSomething('Hello, world!');
+ * ```
+ *
+ * with
+ *
+ * ```
+ * doSomething(gtx._('Hello, world!'));
+ * ```
+ *
+ * Besides, depending on the string extractor you are using, it may be useful
+ * that the method names do not collide with method names from other packages.
+ */
+class Textdomain {
+    /**
+     * Retrieve a translation for a string.
+     *
+     * @param msgid - the string to translate
+     *
+     * @returns the translated string
+     */
+    _(msgid) {
+        return gettextImpl({ msgid: msgid, catalog: this.catalog });
+    }
+    /**
+     * Retrieve a translation for a string containing a possible plural.
+     * You will almost always want to call {@link _nx} instead so that
+     * you can interpolate the number of items into the strings.
+     *
+     * @param msgid - the string in the singular
+     * @param msgidPlural - the string in the plural
+     * @param numItems - the number of items
+     *
+     * @returns the translated string
+     */
+    _n(msgid, msgidPlural, numItems) {
+        return gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        });
+    }
+    /**
+     * Translate a string with a context.
+     *
+     * @param msgctxt - the message context
+     * @param msgid - the string to translate
+     *
+     * @returns the translated string
+     */
+    _p(msgctxt, msgid) {
+        return gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            catalog: this.catalog,
+        });
+    }
+    /**
+     * The method `_np()` combines `_n()` with `_p()`.
+     * You will almost always want to call {@link _npx} instead so that
+     * you can interpolate the number of items into the strings.
+
+     *
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param placeholders - a dictionary with placehoders
+     * @returns the translated string
+     */
+    _np(msgctxt, msgid, msgidPlural, numItems) {
+        return gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        });
+    }
+    /**
+     * Translate a string with placeholders. The placeholders should be
+     * wrapped into curly braces and must match the regular expression
+     * "[_a-zA-Z][_a-zA-Z0-9]*".
+     *
+     * @param msgid - the msgid to translate
+     * @param placeholders - an optional dictionary of placeholders
+     *
+     * @returns the translated string with placeholders expanded
+     */
+    _x(msgid, placeholders) {
+        return Textdomain.expand(gettextImpl({ msgid: msgid, catalog: this.catalog }), placeholders || {});
+    }
+    /**
+     * Translate a string with a plural expression with placeholders.
+     *
+     * @param msgid - the string in the singular
+     * @param msgidPlural - the string in the plural
+     * @param numItems - the number of items
+     * @param placeholders - an optional dictionary of placeholders
+     *
+     * @returns the translated string
+     */
+    _nx(msgid, msgidPlural, numItems, placeholders) {
+        return Textdomain.expand(gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        }), placeholders || {});
+    }
+    /**
+     * The method `_px()` combines `_p()` with `_x()`.
+     *
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param placeholders - an optional dictionary with placehoders
+     * @returns the translated string
+     */
+    _px(msgctxt, msgid, placeholders) {
+        return Textdomain.expand(gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: this.catalog }), placeholders || {});
+    }
+    /**
+     * The method `_npx()` brings it all together. It combines `_n()` and
+     * `_p()` and `_x()`.
+     *
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param msgidPlural - the plural string
+     * @param numItems - the number of items
+     * @param placeholders - an optional dictionary with placehoders
+     * @returns the translated string
+     */
+    _npx(msgctxt, msgid, msgidPlural, numItems, placeholders) {
+        return Textdomain.expand(gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        }), placeholders || {});
+    }
+    static getCatalog(locale, textdomain) {
+        const catalog = CatalogCache.lookup(locale, textdomain);
+        if (!catalog || Promise.resolve(catalog) === catalog) {
+            return {
+                major: 0,
+                minor: 0,
+                pluralFunction: germanicPlural,
+                entries: {},
+            };
+        }
+        return catalog;
+    }
+    /**
+     * Retrieve a translation for a string with a fixed locale.
+     *
+     * @param locale - the locale identifier
+     * @param msgid - the string to translate
+     *
+     * @returns the translated string
+     */
+    _l(locale, msgid) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({ msgid: msgid, catalog: catalog });
+    }
+    /**
+     * Retrieve a translation for a string containing a possible plural with
+     * a fixed locale.
+     * You will almost always want to call {@link _nx} instead so that
+     * you can interpolate the number of items into the strings.
+     *
+     * @param locale - the locale identifier
+     * @param msgid - the string in the singular
+     * @param msgidPlural - the string in the plural
+     * @param numItems - the number of items
+     *
+     * @returns the translated string
+     */
+    _ln(locale, msgid, msgidPlural, numItems) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: catalog,
+        });
+    }
+    /**
+     * Translate a string with a context with a fixed locale.
+     *
+     * @param locale - the locale identifier
+     * @param msgctxt - the message context
+     * @param msgid - the string to translate
+     *
+     * @returns the translated string
+     */
+    _lp(locale, msgctxt, msgid) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: catalog });
+    }
+    /**
+     * The method `_lnp()` combines `_ln()` with `_lp()`.
+     * You will almost always want to call {@link _npx} instead so that
+     * you can interpolate the number of items into the strings.
+
+     *
+     * @param locale - the locale identifier
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param placeholders - a dictionary with placehoders
+     * @returns the translated string
+     */
+    _lnp(locale, msgctxt, msgid, msgidPlural, numItems) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: catalog,
+        });
+    }
+    /**
+     * Translate a string with placeholders for a fixed locale.
+     * The placeholders should be
+     * wrapped into curly braces and must match the regular expression
+     * "[_a-zA-Z][_a-zA-Z0-9]*".
+     *
+     * @param locale - the locale identifier
+     * @param msgid - the msgid to translate
+     * @param placeholders - an optional dictionary of placeholders
+     *
+     * @returns the translated string with placeholders expanded
+     */
+    _lx(locale, msgid, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({ msgid: msgid, catalog: catalog }), placeholders || {});
+    }
+    /**
+     * Translate a string with a plural expression with placeholders into a
+     * fixed locale.
+     *
+     * @param locale - the locale identifier
+     * @param msgid - the string in the singular
+     * @param msgidPlural - the string in the plural
+     * @param numItems - the number of items
+     * @param placeholders - an optional dictionary of placeholders
+     *
+     * @returns the translated string
+     */
+    _lnx(locale, msgid, msgidPlural, numItems, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: catalog,
+        }), placeholders || {});
+    }
+    /**
+     * The method `_lpx()` combines `_lp()` with `_lx()`.
+     *
+     * @param locale - the locale identifier
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param placeholders - an optional dictionary with placehoders
+     * @returns the translated string
+     */
+    _lpx(locale, msgctxt, msgid, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: catalog }), placeholders || {});
+    }
+    /**
+     * The method `_lnpx()` brings it all together. It combines `_ln()` and
+     * `_lp()` and `_lx()`.
+     *
+     * @param locale - the locale identifier
+     * @param msgctxt - the message context
+     * @param msgid - the message id
+     * @param msgidPlural - the plural string
+     * @param numItems - the number of items
+     * @param placeholders - an optional dictionary with placehoders
+     * @returns the translated string
+     */
+    _lnpx(locale, msgctxt, msgid, msgidPlural, numItems, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: catalog,
+        }), placeholders || {});
+    }
+    static expand(msg, placeholders) {
+        return msg.replace(/\{([a-zA-Z][0-9a-zA-Z]*)\}/g, (_, match) => {
+            if (Object.prototype.hasOwnProperty.call(placeholders, match)) {
+                return placeholders[match];
+            }
+            else {
+                return `{${match}}`;
+            }
+        });
+    }
+    /**
+     * Instantiate a Textdomain object. Textdomain objects are singletons
+     * for each textdomain identifier.
+     *
+     * @param textdomain - the textdomain of your application or library.
+     *
+     * @returns a [[`Textdomain`]]
+     */
+    static getInstance(textdomain) {
+        if (typeof textdomain === 'undefined' ||
+            textdomain === null ||
+            textdomain === '') {
+            throw new Error('Cannot instantiate TextDomain without a textdomain');
+        }
+        if (Object.prototype.hasOwnProperty.call(Textdomain.domains, textdomain)) {
+            return Textdomain.domains[textdomain];
+        }
+        else {
+            const domain = new Textdomain(textdomain);
+            Textdomain.domains[textdomain] = domain;
+            domain.catalog = {
+                major: 0,
+                minor: 0,
+                pluralFunction: germanicPlural,
+                entries: {},
+            };
+            return domain;
+        }
+    }
+    /**
+     * Delete all existing singletons. This method should usually be called
+     * only, when you want to free memory.
+     */
+    static clearInstances() {
+        Textdomain.boundDomains = {};
+    }
+    /**
+     * This method is used for testing.  Do not use it yourself!
+     */
+    static forgetInstances() {
+        Textdomain.clearInstances();
+        Textdomain.domains = {};
+    }
+    /**
+     * Query the locale in use.
+     */
+    static get locale() {
+        return Textdomain._locale;
+    }
+    /**
+     * Change the locale.
+     *
+     * For the web you can use all valid language identifier tags that
+     * [BCP47](https://tools.ietf.org/html/bcp47) allows
+     * (and actually a lot more). The tag is always used unmodified.
+     *
+     * For server environments, the locale identifier has to match the following
+     * scheme:
+     *
+     *   `ll_CC.charset\@modifier`
+     *
+     * * `ll` is the two- or three-letter language code.
+     * * `CC` is the optional two-letter country code.
+     * * `charset` is an optional character set (letters, digits, and the hyphen).
+     * * `modifier` is an optional variant (letters and digits).
+     *
+     * The language code is always converted to lowercase, the country code is
+     * converted to uppercase, variant and charset are used as is.
+     *
+     * @param locale - the locale identifier
+     * @returns the locale in use
+     */
+    static set locale(locale) {
+        const ucLocale = locale.toUpperCase();
+        if (ucLocale === 'POSIX' || ucLocale === 'C') {
+            this._locale = 'POSIX';
+            return;
+        }
+        const split = splitLocale(locale);
+        if (!split) {
+            throw new Error('invalid locale identifier');
+        }
+        // Node.
+        split.tags[0] = split.tags[0].toLowerCase();
+        if (split.tags.length > 1) {
+            split.tags[1] = split.tags[1].toUpperCase();
+        }
+        const separator = split.underscoreSeparator ? '_' : '-';
+        this._locale = split.tags.join(separator);
+        if (typeof split.charset !== 'undefined') {
+            this._locale += '.' + split.charset;
+        }
+        if (typeof split.modifier !== 'undefined') {
+            this._locale += '@' + split.modifier;
+        }
+    }
+    constructor(domain) {
+        this._catalogFormat = 'mo.json';
+        this.catalog = undefined;
+        this.domain = domain;
+        const msg = "The property 'locale' is not an instance property but static. Use 'Textdomain.locale' instead!";
+        Object.defineProperty(this, 'locale', {
+            get: () => {
+                throw new Error(msg);
+            },
+            set: () => {
+                throw new Error(msg);
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    /**
+     * A textdomain is an identifier for your application or library. It is
+     * the basename of your translation files which are either
+     * TEXTDOMAIN.mo.json or TEXTDOMAIN.mo, depending on the format you have
+     * chosen.
+     *
+     * FIXME! This should be a getter!
+     *
+     * @returns the textdomain
+     */
+    textdomain() {
+        return this.domain;
+    }
+    /**
+     * Bind a textdomain to a certain path or queries the path that a
+     * textdomain is bound to. The catalog file will be searched
+     * in `${path}/LC_MESSAGES/${domainname}.EXT` where `EXT` is the
+     * selected catalog format (one of `mo.json`, `mo`, or `json`).
+     *
+     * Alternatively, you can pass a [[`LocaleContainer`]] that holds the
+     * catalogs in memory.
+     *
+     * The returned string or `LocaleContainer` is valid until the next
+     * `bindtextdomain` call with an argument.
+     *
+     * @param path - the base path or [[`LocaleContainer`]] for this textdomain
+     *
+     * @returns the current base directory or [[`LocaleContainer`]] for this domain, after possibly changing it.
+     */
+    bindtextdomain(path) {
+        if (typeof path !== 'undefined') {
+            Textdomain.boundDomains[this.domain] = path;
+        }
+        return Textdomain.boundDomains[this.domain];
+    }
+    /**
+     * Resolve a textdomain, i.e. load the LocaleContainer for this domain and all
+     * of its dependencies for the currently selected locale or the locale
+     * specified.
+     *
+     * The promise will always resolve. If no catalog was found, an empty
+     * catalog will be returned that is still usable.
+     *
+     * @param locale - an optional locale identifier, defaults to Textdomain.locale
+     *
+     * @returns a promise for a Catalog that will always resolve.
+     */
+    resolve(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [this.resolve1(locale)];
+            for (const td in Textdomain.domains) {
+                if (Object.prototype.hasOwnProperty.call(Textdomain.domains, td) &&
+                    Textdomain.domains[td] !== this) {
+                    promises.push(Textdomain.domains[td].resolve1(locale));
+                }
+            }
+            return Promise.all(promises).then(values => {
+                return new Promise(resolve => resolve(values[0]));
+            });
+        });
+    }
+    resolve1(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let path = this.bindtextdomain();
+            if (typeof path === 'undefined' || path === null) {
+                const parts = ['.', 'locale'];
+                path = parts.join(pathSeparator);
+            }
+            const resolvedLocale = locale ? locale : Textdomain.locale;
+            return resolveImpl(this.domain, path, this.catalogFormat, resolvedLocale).then(catalog => {
+                if (!locale) {
+                    this.catalog = catalog;
+                }
+                return new Promise(resolve => resolve(catalog));
+            });
+        });
+    }
+    /**
+     * Get the catalog format in use.
+     *
+     * @returns one of 'mo.json' or 'mo' (default is 'mo.json')
+     */
+    get catalogFormat() {
+        return this._catalogFormat;
+    }
+    /**
+     * Set the catalog format to use.
+     *
+     * @param format - one of 'mo.json' or 'mo'
+     */
+    set catalogFormat(format) {
+        format = format.toLowerCase();
+        if (format === 'mo.json') {
+            this._catalogFormat = 'mo.json';
+        }
+        else if (format === 'mo') {
+            this._catalogFormat = 'mo';
+        }
+        else {
+            throw new Error(`unsupported format ${format}`);
+        }
+    }
+    /**
+     * Queries the user's preferred locales. On the server it queries the
+     * environment variables `LANGUAGE`, `LC_ALL`, `LANG`, and `LC_MESSAGES`
+     * (in that order). In the browser, it parses it checks the user preferences
+     * in the variables `navigator.languages`, `navigator.language`,
+     * `navigator.userLanguage`, `navigator.browserLanguage`, and
+     * `navigator.systemLanguage`.
+     *
+     * @returns the set of locales in order of preference
+     *
+     * Added in \@runtime 0.1.0.
+     */
+    static userLocales() {
+        return userLocales();
+    }
+    /**
+     * Select one of the supported locales from a list of locales accepted by
+     * the user.
+     *
+     * @param supported - the list of locales supported by the application
+     * @param requested - the list of locales accepted by the user
+     *
+     * If called with just one argument, then the list of requested locales
+     * is determined by calling [[Textdomain.userLocales]].
+     *
+     * @returns the negotiated locale or 'C' if not possible.
+     */
+    static selectLocale(supported, requested) {
+        return selectLocale(supported, requested !== null && requested !== void 0 ? requested : Textdomain.userLocales());
+    }
+    /**
+     * A no-op method for string marking.
+     *
+     * Sometimes you want to mark strings for translation but do not actually
+     * want to translate them, at least not at the time of their definition.
+     * This is often the case, when you have to preserve the original string.
+     *
+     * Take this example:
+     *
+     * ```
+     * orangeColors = [gtx.N_('coral'), gtx.N_('tomato'), gtx.N_('orangered'),
+     *                 gtx.N_('gold'), gtx.N_('orange'), gtx.N_('darkorange')]
+     * ```
+     *
+     * These are standard CSS colors, and you cannot translate them inside
+     * CSS styles. But for presentation you may want to translate them later:
+     *
+     * ```
+     * console.log(gtx._x("The css color '{color}' is {translated}.",
+     *                    {
+     *                        color: orangeColors[2],
+     *                        translated: gtx._(orangeColors[2]),
+     *                    }
+     *            )
+     * );
+     * ```
+     *
+     * In other words: The method just marks strings for translation, so that
+     * the extractor `esgettext-xgettext` finds them but it does not actually
+     * translate anything.
+     *
+     * Similar methods are available for other cases (with placeholder
+     * expansion, context, or both). They are *not* available for plural
+     * methods because that would not make sense.
+     *
+     * Note that all of these methods are also available as instance methods.
+     *
+     * @param msgid - the message id
+     * @returns the original string
+     */
+    static N_(msgid) {
+        return msgid;
+    }
+    /**
+     * Does the same as the static method `N_()`.
+     *
+     * @param msgid - the message id
+     * @returns the original string
+     */
+    N_(msgid) {
+        return msgid;
+    }
+    /**
+     * Same as `N_()` but with placeholder expansion.
+     *
+     * @param msgid - the message id
+     * @param placeholders - a dictionary of placeholders
+     * @returns the original string with placeholders expanded
+     */
+    N_x(msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    /**
+     * Does the same as the static method `N_x()`.
+     *
+     * @param msgid - the message id
+     * @param placeholders - a dictionary of placeholders
+     * @returns the original string with placeholders expanded
+     */
+    static N_x(msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    /**
+     * Same as `N_()` but with context.
+     *
+     * @param _msgctxt - the message context (not used)
+     * @param msgid - the message id
+     * @returns the original string
+     */
+    N_p(_msgctxt, msgid) {
+        return msgid;
+    }
+    /**
+     * Does the same as the static method `N_p()`.
+     *
+     * @param _msgctxt - the message context (not used)
+     * @param msgid - the message id
+     * @returns the original string with placeholders expanded
+     */
+    static N_p(_msgctxt, msgid) {
+        return msgid;
+    }
+    /**
+     * Same as `N_()` but with context and placeholder expansion.
+     *
+     * @param _msgctxt - the message context (not used)
+     * @param msgid - the message id
+     * @param placeholders - a dictionary of placeholders
+     * @returns the original string with placeholders expanded
+     */
+    N_px(_msgctxt, msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    /**
+     * Does the same as the static method `N_px()`.
+     *
+     * @param _msgctxt - the message context (not used)
+     * @param msgid - the message id
+     * @param placeholders - a dictionary of placeholders
+     * @returns the original string with placeholders expanded
+     */
+    static N_px(_msgctxt, msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+}
+Textdomain.domains = {};
+Textdomain.boundDomains = {};
+Textdomain._locale = 'C';
+
+// FIXME! Windows!
+if (typeof process.env.LANGUAGE !== 'undefined') {
+    userLocales(process.env.LANGUAGE.split(':'));
+}
+else if (typeof process.env.LC_ALL !== 'undefined') {
+    userLocales([process.env.LC_ALL]);
+}
+else if (typeof process.env.LANG !== 'undefined') {
+    userLocales([process.env.LANG]);
+}
+else if (typeof process.env.LC_MESSAGES !== 'undefined') {
+    userLocales([process.env.LC_MESSAGES]);
+}
+
+export { CatalogCache, Textdomain, parseMoCatalog, parseMoJsonCatalog };
+//# sourceMappingURL=esgettext.esm.js.map