@opra/common 0.5.0 → 0.7.0

package/esm/http/http-request.js

@@ -0,0 +1,114 @@
+import { HTTPParser } from 'http-parser-js';
+import { Readable } from 'stream';
+const crlfBuffer = Buffer.from('\r\n');
+const kHeaders = Symbol('kHeaders');
+const kHeadersCount = Symbol('kHeadersCount');
+const kTrailers = Symbol('kTrailers');
+const kTrailersCount = Symbol('kTrailersCount');
+export class HttpRequest extends 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 HTTPParser(HTTPParser.REQUEST);
+        const out = new HttpRequest();
+        const bodyChunks = [];
+        parser[HTTPParser.kOnHeadersComplete] = function (req) {
+            out.shouldKeepAlive = req.shouldKeepAlive;
+            out.upgrade = req.upgrade;
+            out.method = 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[HTTPParser.kOnBody] = function (chunk, offset, length) {
+            bodyChunks.push(chunk.subarray(offset, offset + length));
+        };
+        // This is actually the event for trailers, go figure.
+        parser[HTTPParser.kOnHeaders] = function (t) {
+            out.rawTrailers = t;
+            out[kTrailersCount] = Math.ceil(t.length / 2);
+        };
+        parser[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;
+    }
+}
+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/esm/http/index.d.ts

@@ -0,0 +1,6 @@
+export * from './http-request.js';
+export * from './enums/http-headers.enum.js';
+export * from './enums/http-status.enum.js';
+export * from './interfaces/client-http-headers.interface.js';
+export * from './interfaces/server-http-headers.interface.js';
+export * from './utils/normalize-headers.js';

package/esm/http/index.js

@@ -0,0 +1,6 @@
+export * from './http-request.js';
+export * from './enums/http-headers.enum.js';
+export * from './enums/http-status.enum.js';
+export * from './interfaces/client-http-headers.interface.js';
+export * from './interfaces/server-http-headers.interface.js';
+export * from './utils/normalize-headers.js';

package/esm/http/interfaces/client-http-headers.interface.d.ts

@@ -0,0 +1,65 @@
+export declare type ClientHttpHeaders = Record<string, string | string[]> & {
+    accept?: string;
+    'accept-language'?: string;
+    'accept-patch'?: string;
+    'accept-ranges'?: string;
+    'access-control-allow-credentials'?: string;
+    'access-control-allow-headers'?: string;
+    'access-control-allow-methods'?: string;
+    'access-control-allow-origin'?: string;
+    'access-control-expose-headers'?: string;
+    'access-control-max-age'?: string;
+    'access-control-request-headers'?: string;
+    'access-control-request-method'?: string;
+    age?: string;
+    allow?: string;
+    'alt-svc'?: string;
+    authorization?: string;
+    'cache-control'?: string;
+    connection?: string;
+    'content-disposition'?: string;
+    'content-encoding'?: string;
+    'content-language'?: string;
+    'content-length'?: string;
+    'content-location'?: string;
+    'content-range'?: string;
+    'content-type'?: string;
+    cookie?: string;
+    date?: string;
+    etag?: string;
+    expect?: string;
+    expires?: string;
+    forwarded?: string;
+    from?: string;
+    host?: string;
+    'if-match'?: string;
+    'if-modified-since'?: string;
+    'if-none-match'?: string;
+    'if-unmodified-since'?: string;
+    'last-modified'?: string;
+    location?: string;
+    origin?: string;
+    pragma?: string;
+    'proxy-authenticate'?: string;
+    'proxy-authorization'?: string;
+    'public-key-pins'?: string;
+    range?: string;
+    referer?: string;
+    'retry-after'?: string;
+    'sec-websocket-accept'?: string;
+    'sec-websocket-extensions'?: string;
+    'sec-websocket-key'?: string;
+    'sec-websocket-protocol'?: string;
+    'sec-websocket-version'?: string;
+    'set-cookie'?: string[];
+    'strict-transport-security'?: string;
+    tk?: string;
+    trailer?: string;
+    'transfer-encoding'?: string;
+    upgrade?: string;
+    'user-agent'?: string;
+    vary?: string;
+    via?: string;
+    warning?: string;
+    'www-authenticate'?: string;
+};

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

@@ -0,0 +1 @@
+export {};

package/esm/http/interfaces/server-http-headers.interface.d.ts

@@ -0,0 +1 @@
+export declare type ServerHttpHeaders = Record<string, string | string[]> & {};

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

@@ -0,0 +1 @@
+export {};

package/esm/http/multipart/batch-multipart.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { HttpRequestContent, IHttpRequestContent } from './http-request-content.js';
+import { HttpResponseContent, IHttpResponseContent } from './http-response-content.js';
+declare type Part = {
+    headers: Record<string, string | string[]>;
+    contentId?: string;
+    content: HttpRequestContent | HttpResponseContent | BatchMultipart;
+};
+export declare class BatchMultipart {
+    protected _parts: Part[];
+    readonly boundary: string;
+    constructor();
+    addRequestPart(content: IHttpRequestContent, part?: {
+        contentId?: string;
+        headers?: Record<string, string | string[]>;
+    }): this;
+    addHttpResponse(content: IHttpResponseContent, part?: {
+        contentId?: string;
+        headers?: Record<string, string | string[]>;
+    }): this;
+    addBatch(batch: BatchMultipart, part?: {
+        contentId?: string;
+        headers?: Record<string, string | string[]>;
+    }): this;
+    stream(): Highland.Stream<Readable | Buffer>;
+    protected _build(target: (Buffer | Readable)[]): void;
+}
+export {};

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

@@ -0,0 +1,150 @@
+import Highland from 'highland';
+import { uid } from 'uid';
+import { isReadable } from '../../utils/type-guards.js';
+import { HttpHeaders } from '../enums/http-headers.enum.js';
+import { HttpStatus } from '../enums/http-status.enum.js';
+import { normalizeHeaders } from '../utils/normalize-headers.js';
+import { HttpRequestContent } from './http-request-content.js';
+import { HttpResponseContent } from './http-response-content.js';
+const CRLF = '\r\n';
+const CHARSET_PATTERN = / *charset=./i;
+export class BatchMultipart {
+    _parts = [];
+    boundary;
+    constructor() {
+        this.boundary = 'batch_' + uid(12);
+    }
+    addRequestPart(content, part) {
+        const headers = {
+            ...normalizeHeaders(part?.headers || {}, true),
+            [HttpHeaders.Content_Type]: 'application/http',
+            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: new HttpRequestContent(content)
+        });
+        return this;
+    }
+    addHttpResponse(content, part) {
+        const headers = {
+            ...normalizeHeaders(part?.headers || {}, true),
+            [HttpHeaders.Content_Type]: 'application/http',
+            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: new HttpResponseContent(content)
+        });
+        return this;
+    }
+    addBatch(batch, part) {
+        const headers = {
+            ...normalizeHeaders(part?.headers || {}, true),
+            [HttpHeaders.Content_Type]: 'application/http',
+            [HttpHeaders.Content_Transfer_Encoding]: 'binary'
+        };
+        if (part?.contentId)
+            headers[HttpHeaders.Content_ID] = part.contentId;
+        this._parts.push({
+            headers,
+            contentId: part?.contentId,
+            content: batch
+        });
+        return this;
+    }
+    stream() {
+        const chunks = [];
+        this._build(chunks);
+        return Highland(chunks).flatten();
+    }
+    _build(target) {
+        for (const part of this._parts) {
+            if (part.content instanceof HttpRequestContent || part.content instanceof HttpResponseContent) {
+                let contentBody = part.content.data;
+                let contentLength = 0;
+                const contentHeaders = normalizeHeaders(part.content.headers);
+                if (contentBody) {
+                    const contentType = String(contentHeaders['content-type'] || '').split(/\s*;\s*/);
+                    let charset = '';
+                    if (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 HttpRequestContent)
+                    s += (part.content.method || 'GET').toUpperCase() + ' ' + part.content.url + ' HTTP/1.1' + CRLF;
+                else
+                    s += 'HTTP/1.1 ' + part.content.status + (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'));
+    }
+}

package/esm/http/multipart/http-request-content.d.ts

@@ -0,0 +1,8 @@
+export declare type IHttpRequestContent = Pick<HttpRequestContent, 'method' | 'url' | 'headers' | 'data'>;
+export declare class HttpRequestContent {
+    method: string;
+    url: string;
+    headers?: Record<string, string | string[]>;
+    data?: any;
+    constructor(init: IHttpRequestContent);
+}

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

@@ -0,0 +1,12 @@
+export 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;
+    }
+}

package/esm/http/multipart/http-response-content.d.ts

@@ -0,0 +1,7 @@
+export declare type IHttpResponseContent = Pick<HttpResponseContent, 'status' | 'headers' | 'data'>;
+export declare class HttpResponseContent {
+    status: number;
+    headers?: Record<string, string | string[]>;
+    data?: any;
+    constructor(init: IHttpResponseContent);
+}

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

@@ -0,0 +1,10 @@
+export class HttpResponseContent {
+    status;
+    headers;
+    data;
+    constructor(init) {
+        this.status = init.status;
+        this.headers = init.headers;
+        this.data = init.data;
+    }
+}

package/esm/http/multipart/index.d.ts

@@ -0,0 +1 @@
+export * from './batch-multipart.js';

package/esm/http/multipart/index.js

@@ -0,0 +1 @@
+export * from './batch-multipart.js';

package/esm/http/utils/normalize-headers.d.ts

@@ -0,0 +1 @@
+export declare function normalizeHeaders(headers: any, normalCase?: boolean): Record<string, string | string[]>;

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

@@ -0,0 +1,24 @@
+import { HttpHeaders } from '../enums/http-headers.enum.js';
+const knownKeys = Object.keys(HttpHeaders);
+const knownKeysLower = knownKeys.map(x => x.toLowerCase());
+export 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;
+    }, {}) || {};
+}
+function camelize(str) {
+    return str.replace(/(^\w|[A-Z]|\b\w)/g, function (word) {
+        return word.toUpperCase();
+    });
+}

package/esm/i18n/i18n.d.ts

@@ -0,0 +1,28 @@
+import { FallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from 'i18next';
+import * as I18next from 'i18next';
+import { Type } from 'ts-gems';
+export declare type BaseI18n = Type<I18next.i18n>;
+export declare const BaseI18n: BaseI18n;
+export declare type DeepTranslateOptions = TOptions & {
+    ignore?: (input: any, inst: i18n) => boolean;
+};
+export declare type InitCallback = I18next.Callback;
+export declare type TranslateFunction = I18nextTFunction;
+export declare type Formatter = I18nextFormatter;
+export declare type LanguageResource = I18nextResource;
+export { FallbackLng };
+export interface InitOptions extends I18nextInitOptions {
+    resourceDirs?: string[];
+}
+export declare class I18n extends BaseI18n {
+    init(callback?: InitCallback): Promise<TranslateFunction>;
+    init(options: InitOptions, callback?: InitCallback): Promise<TranslateFunction>;
+    deep(input: any, options?: DeepTranslateOptions): any;
+    registerLocaleDir(...dirname: string[]): void;
+    loadResourceBundle(lang: string, ns: string, filePath: string, deep?: boolean, overwrite?: boolean): Promise<void>;
+    loadResourceDir(dirnames: string | string[], deep?: boolean, overwrite?: boolean): Promise<void>;
+    createInstance(options: {} | undefined, callback: any): I18n;
+    static createInstance(options?: InitOptions, callback?: InitCallback): I18n;
+    protected _deepTranslate(input: any, objectStack: WeakMap<object, any>, options?: DeepTranslateOptions): any;
+    static get defaultInstance(): I18n;
+}

package/esm/i18n/i18n.js

@@ -0,0 +1,170 @@
+import { splitString, tokenize } from 'fast-tokenizer';
+import i18next from 'i18next';
+import { isUrl } from '../utils/index.js';
+import { unescapeString } from './string-utils.js';
+export const BaseI18n = Object.getPrototypeOf(i18next).constructor;
+const globalLocaleDirs = [];
+export class I18n extends 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 (isUrl(filePath)) {
+            obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
+        }
+        else {
+            const fs = await import('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 import('fs/promises');
+        const path = await import('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 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 = splitString(token, { delimiters: '?', quotes: true, brackets: { '{': '}' } });
+                    const fallback = unescapeString(token.substring((a[0] || '').length + 1));
+                    token = a[0] || '';
+                    const keys = [];
+                    let opts = null;
+                    for (const token2 of 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;
+    }
+}
+const defaultInstance = I18n.createInstance();

package/esm/i18n/index.d.ts

@@ -0,0 +1,5 @@
+import { I18n } from './i18n.js';
+export * from './i18n.js';
+export * from './translate.js';
+declare const i18n: I18n;
+export { i18n };