@opra/common 0.5.0 → 0.7.0

package/cjs/filter/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unquoteFilterString = exports.quoteFilterString = void 0;
+const quotesRegEx = /'/g;
+const escapeRegEx = /(\\)/g;
+const unescapeRegEx = /\\(.)/g;
+function escapeString(s) {
+    return s.replace(escapeRegEx, '\\\\');
+}
+function unescapeString(s) {
+    return s.replace(unescapeRegEx, '$1');
+}
+function quoteFilterString(s) {
+    return "'" +
+        escapeString(s).replace(quotesRegEx, '\\\'') +
+        "'";
+}
+exports.quoteFilterString = quoteFilterString;
+function unquoteFilterString(s) {
+    if (s && (s.startsWith("'") || s.startsWith('"')) && s.endsWith(s.charAt(0))) {
+        return unescapeString(s.substring(1, s.length - 1));
+    }
+    /* istanbul ignore next */
+    return s;
+}
+exports.unquoteFilterString = unquoteFilterString;

package/cjs/helpers/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./responsive-map.js"), exports);

package/cjs/{classes → helpers}/responsive-map.js

@@ -9,7 +9,7 @@ class ResponsiveMap extends Map {
         super();
         if (wellKnownKeys)
             wellKnownKeys.forEach(k => this._wellKnownKeyMap.set(k.toLowerCase(), k));
-        if (data instanceof Map) {
+        if (typeof data?.forEach === 'function') {
             data.forEach((v, k) => this.set(k, v));
         }
         else if (data && typeof data === 'object')

package/cjs/{enums → http/enums}/http-headers.enum.js

@@ -180,6 +180,10 @@ var HttpHeaders;
      */
     HttpHeaders["Content_Disposition"] = "Content-Disposition";
     /* *** Message body information *** */
+    /**
+     * Indicates to uniquely identifies MIME entities in several contexts.
+     */
+    HttpHeaders["Content_ID"] = "Content-ID";
     /**
      * The size of the resource, in decimal number of bytes.
      */
@@ -188,6 +192,11 @@ var HttpHeaders;
      * Indicates the media type of the resource.
      */
     HttpHeaders["Content_Type"] = "Content-Type";
+    /**
+     * Indicates to specify how a MIME message or body part has been encoded,
+     * so that it can be decoded by its recipient.
+     */
+    HttpHeaders["Content_Transfer_Encoding"] = "Content-Transfer-Encoding";
     /**
      * Used to specify the compression algorithm.
      */

package/cjs/http/http-request.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequest = void 0;
+const http_parser_js_1 = require("http-parser-js");
+const stream_1 = require("stream");
+const crlfBuffer = Buffer.from('\r\n');
+const kHeaders = Symbol('kHeaders');
+const kHeadersCount = Symbol('kHeadersCount');
+const kTrailers = Symbol('kTrailers');
+const kTrailersCount = Symbol('kTrailersCount');
+class HttpRequest extends stream_1.Readable {
+    httpVersionMajor;
+    httpVersionMinor;
+    httpVersion;
+    complete;
+    rawHeaders;
+    rawTrailers;
+    aborted = false;
+    upgrade;
+    url;
+    originalUrl;
+    method;
+    shouldKeepAlive;
+    data;
+    body;
+    [kHeaders];
+    [kHeadersCount];
+    [kTrailers];
+    [kTrailersCount];
+    get headers() {
+        if (!this[kHeaders])
+            this[kHeaders] = arrayToHeaders(this.rawHeaders);
+        return this[kHeaders];
+    }
+    get headersCount() {
+        return this[kHeadersCount];
+    }
+    get trailers() {
+        if (!this[kTrailers])
+            this[kTrailers] = arrayToHeaders(this.rawTrailers);
+        return this[kTrailers];
+    }
+    get trailersCount() {
+        return this[kTrailersCount];
+    }
+    _read() {
+        if (this.data) {
+            this.push(this.data);
+        }
+        this.push(null);
+    }
+    static parse(input) {
+        const parser = new http_parser_js_1.HTTPParser(http_parser_js_1.HTTPParser.REQUEST);
+        const out = new HttpRequest();
+        const bodyChunks = [];
+        parser[http_parser_js_1.HTTPParser.kOnHeadersComplete] = function (req) {
+            out.shouldKeepAlive = req.shouldKeepAlive;
+            out.upgrade = req.upgrade;
+            out.method = http_parser_js_1.HTTPParser.methods[req.method];
+            out.url = req.url;
+            out.originalUrl = req.url;
+            out.httpVersionMajor = req.versionMajor;
+            out.httpVersionMinor = req.versionMinor;
+            out.httpVersion = req.versionMajor + '.' + req.versionMinor;
+            out.rawHeaders = req.headers;
+            out[kHeadersCount] = Math.ceil(req.headers.length / 2);
+            out[kTrailersCount] = 0;
+        };
+        parser[http_parser_js_1.HTTPParser.kOnBody] = function (chunk, offset, length) {
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        // This is actually the event for trailers, go figure.
+        parser[http_parser_js_1.HTTPParser.kOnHeaders] = function (t) {
+            out.rawTrailers = t;
+            out[kTrailersCount] = Math.ceil(t.length / 2);
+        };
+        parser[http_parser_js_1.HTTPParser.kOnMessageComplete] = function () {
+            out.complete = true;
+        };
+        // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
+        // The parser does not do _anything_ asynchronous.
+        // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
+        // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
+        parser.execute(input);
+        if (!out.complete)
+            parser.execute(crlfBuffer);
+        parser.finish();
+        if (!out.complete) {
+            throw new Error('Could not parse request');
+        }
+        out.rawTrailers = out.rawTrailers || [];
+        if (bodyChunks.length)
+            out.data = Buffer.concat(bodyChunks);
+        out.resume();
+        return out;
+    }
+}
+exports.HttpRequest = HttpRequest;
+function arrayToHeaders(arr) {
+    const headers = {};
+    for (let i = 0; i < arr.length; i++) {
+        const k = arr[i].toLowerCase();
+        const v = arr[++i];
+        const trgV = headers[k];
+        // Array header -- only Set-Cookie at the moment
+        if (trgV && k === 'set-cookie') {
+            const a = Array.isArray(trgV) ? trgV : [trgV];
+            a.push(v);
+            headers[k] = a;
+        }
+        else if (typeof trgV === 'string') {
+            headers[k] += (k === 'cookie' ? '; ' : ', ') + v;
+        }
+        else
+            headers[k] = v;
+    }
+    return headers;
+}

package/cjs/http/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./http-request.js"), exports);
+tslib_1.__exportStar(require("./enums/http-headers.enum.js"), exports);
+tslib_1.__exportStar(require("./enums/http-status.enum.js"), exports);
+tslib_1.__exportStar(require("./interfaces/client-http-headers.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/server-http-headers.interface.js"), exports);
+tslib_1.__exportStar(require("./utils/normalize-headers.js"), exports);

package/cjs/http/interfaces/client-http-headers.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/http/interfaces/server-http-headers.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/http/multipart/batch-multipart.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchMultipart = void 0;
+const tslib_1 = require("tslib");
+const highland_1 = tslib_1.__importDefault(require("highland"));
+const uid_1 = require("uid");
+const type_guards_js_1 = require("../../utils/type-guards.js");
+const http_headers_enum_js_1 = require("../enums/http-headers.enum.js");
+const http_status_enum_js_1 = require("../enums/http-status.enum.js");
+const normalize_headers_js_1 = require("../utils/normalize-headers.js");
+const http_request_content_js_1 = require("./http-request-content.js");
+const http_response_content_js_1 = require("./http-response-content.js");
+const CRLF = '\r\n';
+const CHARSET_PATTERN = / *charset=./i;
+class BatchMultipart {
+    _parts = [];
+    boundary;
+    constructor() {
+        this.boundary = 'batch_' + (0, uid_1.uid)(12);
+    }
+    addRequestPart(content, part) {
+        const headers = {
+            ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
+            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
+            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: new http_request_content_js_1.HttpRequestContent(content)
+        });
+        return this;
+    }
+    addHttpResponse(content, part) {
+        const headers = {
+            ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
+            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
+            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: new http_response_content_js_1.HttpResponseContent(content)
+        });
+        return this;
+    }
+    addBatch(batch, part) {
+        const headers = {
+            ...(0, normalize_headers_js_1.normalizeHeaders)(part?.headers || {}, true),
+            [http_headers_enum_js_1.HttpHeaders.Content_Type]: 'application/http',
+            [http_headers_enum_js_1.HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[http_headers_enum_js_1.HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: batch
+        });
+        return this;
+    }
+    stream() {
+        const chunks = [];
+        this._build(chunks);
+        return (0, highland_1.default)(chunks).flatten();
+    }
+    _build(target) {
+        for (const part of this._parts) {
+            if (part.content instanceof http_request_content_js_1.HttpRequestContent || part.content instanceof http_response_content_js_1.HttpResponseContent) {
+                let contentBody = part.content.data;
+                let contentLength = 0;
+                const contentHeaders = (0, normalize_headers_js_1.normalizeHeaders)(part.content.headers);
+                if (contentBody) {
+                    const contentType = String(contentHeaders['content-type'] || '').split(/\s*;\s*/);
+                    let charset = '';
+                    if ((0, type_guards_js_1.isReadable)(contentBody)) {
+                        contentLength = parseInt(String(contentHeaders['content-length']), 10) || 0;
+                        // const l = parseInt(String(contentHeaders['content-length']), 10);
+                        // if (isNaN(l))
+                        //   throw new TypeError('"content-length" header required for streamed responses');
+                    }
+                    else if (typeof contentBody === 'object') {
+                        if (typeof contentBody.stream === 'function') { // File and Blob
+                            contentType[0] = contentBody.type || 'binary';
+                            contentLength = contentBody.size;
+                            contentBody = contentBody.stream();
+                        }
+                        else if (Buffer.isBuffer(contentBody)) {
+                            contentHeaders['content-length'] = String(contentBody.length);
+                        }
+                        else {
+                            contentType[0] = contentType[0] || 'application/json';
+                            charset = 'utf-8';
+                            contentBody = Buffer.from(JSON.stringify(contentBody), 'utf-8');
+                            contentLength = contentBody.length;
+                        }
+                    }
+                    else {
+                        contentType[0] = contentType[0] || 'text/plain';
+                        charset = 'utf-8';
+                        contentBody = Buffer.from(String(contentBody), 'utf-8');
+                        contentLength = contentBody.length;
+                    }
+                    if (contentType[0]) {
+                        if (charset) {
+                            const i = contentType.findIndex(x => CHARSET_PATTERN.test(String(x)));
+                            if (i > 0)
+                                contentType[i] = 'charset=' + charset;
+                            else
+                                contentType.join('charset=' + charset);
+                        }
+                        contentHeaders['content-type'] = contentType.join(';');
+                    }
+                    if (contentLength)
+                        contentHeaders['content-length'] = String(contentLength);
+                }
+                let s = '--' + this.boundary + CRLF;
+                for (const [k, v] of Object.entries(part.headers)) {
+                    if (!(v === '' || v == null))
+                        s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF;
+                }
+                s += CRLF;
+                if (part.content instanceof http_request_content_js_1.HttpRequestContent)
+                    s += (part.content.method || 'GET').toUpperCase() + ' ' + part.content.url + ' HTTP/1.1' + CRLF;
+                else
+                    s += 'HTTP/1.1 ' + part.content.status + (http_status_enum_js_1.HttpStatus[part.content.status] || 'Unknown') + CRLF;
+                if (part.content.headers) {
+                    for (const [k, v] of Object.entries(part.content.headers)) {
+                        if (v === '' || v == null)
+                            continue;
+                        if (k === 'set-cookie' && Array.isArray(v)) {
+                            v.forEach(x => s += k + ': ' + x);
+                        }
+                        else
+                            s += k + ': ' + (Array.isArray(v) ? v.join(';') : v) + CRLF;
+                    }
+                }
+                s += CRLF;
+                target.push(Buffer.from(s, 'utf-8'));
+                if (contentBody) {
+                    target.push(contentBody);
+                    target.push(Buffer.from(CRLF + CRLF));
+                }
+            }
+            else
+                throw new Error('Not implemented yet');
+        }
+        target.push(Buffer.from('--' + this.boundary + '--' + CRLF, 'utf-8'));
+    }
+}
+exports.BatchMultipart = BatchMultipart;

package/cjs/http/multipart/http-request-content.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestContent = void 0;
+class HttpRequestContent {
+    method;
+    url;
+    headers;
+    data;
+    constructor(init) {
+        this.method = init.method;
+        this.url = encodeURI(decodeURI(init.url));
+        this.headers = init.headers;
+        this.data = init.data;
+    }
+}
+exports.HttpRequestContent = HttpRequestContent;

package/cjs/http/multipart/http-response-content.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponseContent = void 0;
+class HttpResponseContent {
+    status;
+    headers;
+    data;
+    constructor(init) {
+        this.status = init.status;
+        this.headers = init.headers;
+        this.data = init.data;
+    }
+}
+exports.HttpResponseContent = HttpResponseContent;

package/cjs/http/multipart/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./batch-multipart.js"), exports);

package/cjs/http/utils/normalize-headers.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeaders = void 0;
+const http_headers_enum_js_1 = require("../enums/http-headers.enum.js");
+const knownKeys = Object.keys(http_headers_enum_js_1.HttpHeaders);
+const knownKeysLower = knownKeys.map(x => x.toLowerCase());
+function normalizeHeaders(headers, normalCase) {
+    if (!headers)
+        return {};
+    return Object.keys(headers).reduce((o, k) => {
+        const v = headers[k];
+        const key = normalCase
+            ? knownKeys[knownKeysLower.indexOf(k.toLowerCase())] || camelize(k) :
+            k.toLowerCase();
+        if (k.toLowerCase() === 'set-cookie')
+            o[key] = Array.isArray(v) ? v : [v];
+        else {
+            o[key] = Array.isArray(v) ? v.join(';') : v;
+        }
+        return o;
+    }, {}) || {};
+}
+exports.normalizeHeaders = normalizeHeaders;
+function camelize(str) {
+    return str.replace(/(^\w|[A-Z]|\b\w)/g, function (word) {
+        return word.toUpperCase();
+    });
+}

package/cjs/i18n/i18n.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18n = exports.BaseI18n = void 0;
+const tslib_1 = require("tslib");
+const fast_tokenizer_1 = require("fast-tokenizer");
+const i18next_1 = tslib_1.__importDefault(require("i18next"));
+const index_js_1 = require("../utils/index.js");
+const string_utils_js_1 = require("./string-utils.js");
+exports.BaseI18n = Object.getPrototypeOf(i18next_1.default).constructor;
+const globalLocaleDirs = [];
+class I18n extends exports.BaseI18n {
+    async init(arg0, arg1) {
+        const options = typeof arg0 === 'object' ? arg0 : {};
+        const callback = typeof arg0 === 'function' ? arg0 : arg1;
+        try {
+            const t = await super.init(options);
+            // Add formatters
+            const formatter = this.services.formatter;
+            formatter.add('lowercase', (value, lng) => value.toLocaleLowerCase(lng));
+            formatter.add('uppercase', (value, lng) => value.toLocaleUpperCase(lng));
+            formatter.add('upperFirst', (value, lng) => value.charAt(0).toLocaleUpperCase(lng) + value.substring(1));
+            // Load globally registered resources
+            if (globalLocaleDirs.length)
+                await this.loadResourceDir(globalLocaleDirs, false, true);
+            // Load resource dirs and overwrite existing
+            if (options?.resourceDirs?.length) {
+                await this.loadResourceDir(options.resourceDirs, false, true);
+            }
+            // overwrite existing resources with options.resources
+            if (options?.resources) {
+                for (const lang of Object.keys(options.resources)) {
+                    const langObj = options.resources[lang];
+                    for (const ns of Object.keys(langObj)) {
+                        this.addResourceBundle(lang, ns, langObj[ns], false, true);
+                    }
+                }
+            }
+            if (callback)
+                callback(null, t);
+            return t;
+        }
+        catch (err) {
+            if (callback)
+                callback(err, this.t);
+            throw err;
+        }
+    }
+    deep(input, options) {
+        if (input == null)
+            return input;
+        const objectStack = new WeakMap();
+        return this._deepTranslate(input, objectStack, options);
+    }
+    registerLocaleDir(...dirname) {
+        globalLocaleDirs.push(...dirname);
+    }
+    async loadResourceBundle(lang, ns, filePath, deep, overwrite) {
+        let obj;
+        if ((0, index_js_1.isUrl)(filePath)) {
+            obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
+        }
+        else {
+            const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+            const content = await fs.readFile(filePath, 'utf8');
+            obj = JSON.parse(content);
+        }
+        this.addResourceBundle(lang, ns, obj, deep, overwrite);
+    }
+    async loadResourceDir(dirnames, deep, overwrite) {
+        const fs = await Promise.resolve().then(() => tslib_1.__importStar(require('fs/promises')));
+        const path = await Promise.resolve().then(() => tslib_1.__importStar(require('path')));
+        for (const dirname of Array.isArray(dirnames) ? dirnames : [dirnames]) {
+            /* istanbul ignore next */
+            if (!(await fs.stat(dirname)).isDirectory()) {
+                // eslint-disable-next-line no-console
+                console.warn(`Locale directory does not exists. (${dirname})`);
+                continue;
+            }
+            const languageDirs = await fs.readdir(dirname);
+            for (const lang of languageDirs) {
+                const langDir = path.join(dirname, lang);
+                if ((await fs.stat(langDir)).isDirectory()) {
+                    const nsDirs = await fs.readdir(langDir);
+                    for (const nsfile of nsDirs) {
+                        const nsFilePath = path.join(langDir, nsfile);
+                        const ext = path.extname(nsfile);
+                        if (ext === '.json' && (await fs.stat(nsFilePath)).isFile()) {
+                            const ns = path.basename(nsfile, ext);
+                            await this.loadResourceBundle(lang, ns, nsFilePath, deep, overwrite);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    createInstance(options = {}, callback) {
+        return new I18n(options, callback);
+    }
+    static createInstance(options, callback) {
+        return new I18n(options, callback);
+    }
+    _deepTranslate(input, objectStack, options) {
+        if (input == null)
+            return input;
+        if (options?.ignore && options.ignore(input, this))
+            return input;
+        if (typeof input === 'object' && objectStack.has(input))
+            return objectStack.get(input);
+        if (typeof input === 'string') {
+            let s = '';
+            for (let token of (0, fast_tokenizer_1.tokenize)(input, {
+                brackets: { '$t(': ')' },
+                quotes: true,
+                keepQuotes: true,
+                keepBrackets: true,
+                keepDelimiters: true,
+            })) {
+                if (token.startsWith('$t(') && token.endsWith(')')) {
+                    token = token.substring(3, token.length - 1);
+                    const a = (0, fast_tokenizer_1.splitString)(token, { delimiters: '?', quotes: true, brackets: { '{': '}' } });
+                    const fallback = (0, string_utils_js_1.unescapeString)(token.substring((a[0] || '').length + 1));
+                    token = a[0] || '';
+                    const keys = [];
+                    let opts = null;
+                    for (const token2 of (0, fast_tokenizer_1.tokenize)(token, { delimiters: ',', quotes: true, brackets: { '{': '}' } })) {
+                        if (token2.startsWith('{')) {
+                            opts = JSON.parse(token2);
+                            continue;
+                        }
+                        keys.push(token2);
+                    }
+                    const k = keys.length > 1 ? '$t(' + keys.join(',') + ')' : keys[0];
+                    s += fallback
+                        ? this.t(k, fallback, { ...options, ...opts })
+                        : this.t(k, { ...options, ...opts });
+                    continue;
+                }
+                s += token;
+            }
+            return s;
+        }
+        if (Array.isArray(input)) {
+            const out = Array(input.length);
+            objectStack.set(input, out);
+            for (let i = 0, l = input.length; i < l; i++) {
+                out[i] = this._deepTranslate(input[i], objectStack, options);
+            }
+            objectStack.delete(input);
+            return out;
+        }
+        if (typeof input === 'object') {
+            if (Buffer.isBuffer(input))
+                return input;
+            if (Buffer.isBuffer(input) || input instanceof Symbol ||
+                input instanceof RegExp || input instanceof Map || input instanceof Set ||
+                input instanceof WeakMap || input instanceof WeakSet)
+                return input;
+            const out = {};
+            objectStack.set(input, out);
+            const keys = Object.keys(input);
+            for (let i = 0, l = keys.length; i < l; i++) {
+                const k = keys[i];
+                out[k] = this._deepTranslate(input[k], objectStack, options);
+            }
+            objectStack.delete(input);
+            return out;
+        }
+        return input;
+    }
+    static get defaultInstance() {
+        return defaultInstance;
+    }
+}
+exports.I18n = I18n;
+const defaultInstance = I18n.createInstance();

package/cjs/i18n/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18n = void 0;
+const tslib_1 = require("tslib");
+const i18n_js_1 = require("./i18n.js");
+tslib_1.__exportStar(require("./i18n.js"), exports);
+tslib_1.__exportStar(require("./translate.js"), exports);
+const i18n = i18n_js_1.I18n.createInstance();
+exports.i18n = i18n;
+i18n.init().catch(() => void 0);

package/cjs/i18n/string-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescapeString = exports.escapeString = void 0;
+const unescapeRegEx = /\\(.)/g;
+const escapeRegEx = /(\\)/g;
+function escapeString(s) {
+    return s.replace(escapeRegEx, '\\\\');
+}
+exports.escapeString = escapeString;
+function unescapeString(s) {
+    return s.replace(unescapeRegEx, '$1');
+}
+exports.unescapeString = unescapeString;

package/cjs/i18n/translate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translate = void 0;
+const string_utils_js_1 = require("./string-utils.js");
+const bracketRegEx = /(\))/g;
+function translate(key, arg0, arg1) {
+    const options = arg0 && typeof arg0 === 'object' ? arg0 : undefined;
+    const fallback = typeof arg0 === 'string' ? arg0 : arg1;
+    return '$t(' +
+        key +
+        (options ? ',' + JSON.stringify(options) : '') +
+        (fallback ? '?' + (0, string_utils_js_1.escapeString)(fallback).replace(bracketRegEx, '\\$1') : '') +
+        ')';
+}
+exports.translate = translate;

package/cjs/index.js

@@ -1,8 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.uid = void 0;
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./classes/headers-map.js"), exports);
-tslib_1.__exportStar(require("./classes/responsive-map.js"), exports);
-tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./enums/http-headers.enum.js"), exports);
-tslib_1.__exportStar(require("./enums/http-status.enum.js"), exports);
+tslib_1.__exportStar(require("./exception/index.js"), exports);
+tslib_1.__exportStar(require("./i18n/index.js"), exports);
+tslib_1.__exportStar(require("./filter/index.js"), exports); // todo. review
+tslib_1.__exportStar(require("./http/multipart/index.js"), exports);
+tslib_1.__exportStar(require("./schema/index.js"), exports);
+tslib_1.__exportStar(require("./url/index.js"), exports);
+tslib_1.__exportStar(require("./http/index.js"), exports);
+tslib_1.__exportStar(require("./helpers/index.js"), exports);
+tslib_1.__exportStar(require("./utils/index.js"), exports);
+var uid_1 = require("uid");
+Object.defineProperty(exports, "uid", { enumerable: true, get: function () { return uid_1.uid; } });