@esgettext/runtime 1.0.0 → 1.1.0

package/dist/esgettext.esm.js

@@ -0,0 +1,863 @@
+import { readFile } from 'fs';
+
+let userLocalesSelected = ['C'];
+function userLocales(locales) {
+    if (typeof locales !== 'undefined') {
+        userLocalesSelected = locales;
+    }
+    return userLocalesSelected;
+}
+
+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 germanicPlural(numItems) {
+    return numItems === 1 ? 0 : 1;
+}
+
+class DataViewlet {
+    constructor(array, encoding = 'utf-8') {
+        this.array = array;
+        this.decoder = new TextDecoder(encoding);
+        this._encoding = encoding;
+    }
+    get encoding() {
+        return this._encoding;
+    }
+    set encoding(encoding) {
+        this.decoder = new TextDecoder(encoding);
+        this._encoding = encoding;
+    }
+    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);
+    }
+    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);
+    }
+    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));
+    }
+}
+
+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) {
+        reader = (buf, off) => buf.readUInt32LE(off);
+    }
+    else if (magic === 0xde120495) {
+        reader = (buf, off) => buf.readUInt32BE(off);
+    }
+    else {
+        throw new Error(`invalid MO magic 0x${magic.toString(16)}`);
+    }
+    offset += 4;
+    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) {
+    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');
+    }
+    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) {
+    if (udata === null || typeof udata === 'undefined') {
+        throw new Error('catalog is either null or undefined');
+    }
+    const entries = udata;
+    if (entries.constructor !== Object) ;
+    const catalog = {
+        major: 0,
+        minor: 1,
+        pluralFunction: () => 0,
+        entries: {},
+    };
+    for (const [msgid, msgstr] of Object.entries(entries)) {
+        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;
+}
+
+class CatalogCache {
+    constructor() {
+    }
+    static getInstance() {
+        if (!CatalogCache.instance) {
+            CatalogCache.instance = new CatalogCache();
+        }
+        return CatalogCache.instance;
+    }
+    static clear() {
+        CatalogCache.cache = {};
+    }
+    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) {
+            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) {
+    let transportInstance;
+    {
+        let transport;
+        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;
+    }
+    return new Promise((resolve, reject) => {
+        transportInstance
+            .loadFile(url)
+            .then(data => {
+            resolve(validator(data));
+        })
+            .catch(e => reject(e));
+    });
+}
+function assemblePath(base, id, domainname, extender) {
+    return `${base}/${id}/LC_MESSAGES/${domainname}.${extender}`;
+}
+function loadLanguageFromObject(ids, base, domainname) {
+    let catalog;
+    for (let i = 0; i < ids.length; ++i) {
+        const id = ids[0];
+        if (!Object.prototype.hasOwnProperty.call(base, id)) {
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(base[id], 'LC_MESSAGES')) {
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(base[id].LC_MESSAGES, domainname)) {
+            continue;
+        }
+        catalog = base[id].LC_MESSAGES[domainname];
+    }
+    return new Promise((resolve, reject) => {
+        if (catalog) {
+            resolve(catalog);
+        }
+        else {
+            reject();
+        }
+    });
+}
+async function loadLanguage(ids, base, domainname, format) {
+    if (typeof base === 'object' && base !== null) {
+        return loadLanguageFromObject(ids, base, domainname);
+    }
+    return new Promise((resolve, reject) => {
+        const tries = new Array();
+        ids.forEach(id => {
+            tries.push(() => loadCatalog(assemblePath(base, id, domainname, format), format));
+        });
+        tries
+            .reduce((promise, fn) => promise.catch(fn), Promise.reject())
+            .then(value => resolve(value))
+            .catch(e => reject(e));
+    });
+}
+async function loadDomain(exploded, localeKey, base, domainname, format) {
+    const entries = {};
+    const catalog = {
+        major: 0,
+        minor: 0,
+        pluralFunction: germanicPlural,
+        entries,
+    };
+    const cacheHit = CatalogCache.lookup(localeKey, domainname);
+    if (cacheHit !== null) {
+        if (Promise.resolve(cacheHit) === cacheHit) {
+            return cacheHit;
+        }
+        else {
+            return new Promise(resolve => resolve(cacheHit));
+        }
+    }
+    const promises = new Array();
+    const results = new Array();
+    exploded.forEach((tries, i) => {
+        const p = loadLanguage(tries, base, domainname, format)
+            .then(catalog => (results[i] = catalog))
+            .catch(() => {
+        });
+        promises.push(p);
+    });
+    await Promise.all(promises);
+    results.forEach(result => {
+        catalog.major = result.major;
+        catalog.minor = result.minor;
+        catalog.entries = Object.assign(Object.assign({}, catalog.entries), result.entries);
+    });
+    return new Promise(resolve => {
+        resolve(catalog);
+    });
+}
+function pluralExpression(str) {
+    const tokens = str
+        .replace(/[ \t\r\013\014]/g, '')
+        .replace(/;$/, '')
+        .split(/[<>!=]=|&&|\|\||[-!*/%+<>=?:;]/);
+    for (let i = 0; i < tokens.length; ++i) {
+        const token = tokens[i].replace(/^\(+/, '').replace(/\)+$/, '');
+        if (token !== 'nplurals' &&
+            token !== 'plural' &&
+            token !== 'n' &&
+            null === /^[0-9]+$/.exec(token)) {
+            throw new Error('invalid plural function');
+        }
+    }
+    const code = 'var nplurals = 1, plural = 0;' + str + '; return 0 + plural';
+    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(':');
+            catalog.pluralFunction = pluralExpression(code);
+        }
+    });
+    return catalog;
+}
+function resolveImpl(domainname, path, format, localeKey) {
+    const defaultCatalog = {
+        major: 0,
+        minor: 0,
+        pluralFunction: germanicPlural,
+        entries: {},
+    };
+    if (localeKey === 'C' || localeKey === 'POSIX') {
+        return new Promise(resolve => resolve(defaultCatalog));
+    }
+    return new Promise(resolve => {
+        const exploded = explodeLocale(splitLocale(localeKey));
+        loadDomain(exploded, localeKey, path, domainname, format)
+            .then(catalog => {
+            setPluralFunction(catalog);
+            CatalogCache.store(localeKey, domainname, catalog);
+            resolve(catalog);
+        })
+            .catch(() => {
+            CatalogCache.store(localeKey, domainname, defaultCatalog);
+            resolve(defaultCatalog);
+        });
+    });
+}
+
+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';
+}
+
+class Textdomain {
+    _(msgid) {
+        return gettextImpl({ msgid: msgid, catalog: this.catalog });
+    }
+    _n(msgid, msgidPlural, numItems) {
+        return gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        });
+    }
+    _p(msgctxt, msgid) {
+        return gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            catalog: this.catalog,
+        });
+    }
+    _np(msgctxt, msgid, msgidPlural, numItems) {
+        return gettextImpl({
+            msgctxt: msgctxt,
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        });
+    }
+    _x(msgid, placeholders) {
+        return Textdomain.expand(gettextImpl({ msgid: msgid, catalog: this.catalog }), placeholders || {});
+    }
+    _nx(msgid, msgidPlural, numItems, placeholders) {
+        return Textdomain.expand(gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: this.catalog,
+        }), placeholders || {});
+    }
+    _px(msgctxt, msgid, placeholders) {
+        return Textdomain.expand(gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: this.catalog }), placeholders || {});
+    }
+    _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;
+    }
+    _l(locale, msgid) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({ msgid: msgid, catalog: catalog });
+    }
+    _ln(locale, msgid, msgidPlural, numItems) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({
+            msgid: msgid,
+            msgidPlural: msgidPlural,
+            numItems: numItems,
+            catalog: catalog,
+        });
+    }
+    _lp(locale, msgctxt, msgid) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: catalog });
+    }
+    _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,
+        });
+    }
+    _lx(locale, msgid, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({ msgid: msgid, catalog: catalog }), placeholders || {});
+    }
+    _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 || {});
+    }
+    _lpx(locale, msgctxt, msgid, placeholders) {
+        const catalog = Textdomain.getCatalog(locale, this.textdomain());
+        return Textdomain.expand(gettextImpl({ msgctxt: msgctxt, msgid: msgid, catalog: catalog }), placeholders || {});
+    }
+    _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}}`;
+            }
+        });
+    }
+    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;
+        }
+    }
+    static clearInstances() {
+        Textdomain.boundDomains = {};
+    }
+    static forgetInstances() {
+        Textdomain.clearInstances();
+        Textdomain.domains = {};
+    }
+    static get locale() {
+        return Textdomain._locale;
+    }
+    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');
+        }
+        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.domain = domain;
+    }
+    textdomain() {
+        return this.domain;
+    }
+    bindtextdomain(path) {
+        if (typeof path !== 'undefined') {
+            Textdomain.boundDomains[this.domain] = path;
+        }
+        return Textdomain.boundDomains[this.domain];
+    }
+    async resolve(locale) {
+        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]));
+        });
+    }
+    async resolve1(locale) {
+        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 catalogFormat() {
+        return this._catalogFormat;
+    }
+    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}`);
+        }
+    }
+    static userLocales() {
+        return userLocales();
+    }
+    static selectLocale(supported, requested) {
+        return selectLocale(supported, requested !== null && requested !== void 0 ? requested : Textdomain.userLocales());
+    }
+    static N_(msgid) {
+        return msgid;
+    }
+    N_(msgid) {
+        return msgid;
+    }
+    N_x(msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    static N_x(msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    N_p(_msgctxt, msgid) {
+        return msgid;
+    }
+    static N_p(_msgctxt, msgid) {
+        return msgid;
+    }
+    N_px(_msgctxt, msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+    static N_px(_msgctxt, msgid, placeholders) {
+        return Textdomain.expand(msgid, placeholders !== null && placeholders !== void 0 ? placeholders : {});
+    }
+}
+Textdomain.domains = {};
+Textdomain.cache = CatalogCache.getInstance();
+Textdomain.boundDomains = {};
+Textdomain._locale = 'C';
+
+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