@to-kn/koa-locales 2.0.2 → 2.1.1

package/dist/cjs/index.js

@@ -0,0 +1,250 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import util from "node:util";
+import Debug from "debug";
+import { ms } from "humanize-ms";
+import ini from "ini";
+import yaml from "js-yaml";
+const DEFAULT_OPTIONS = {
+    defaultLocale: "en-US",
+    queryField: "locale",
+    cookieField: "locale",
+    localeAlias: {},
+    writeCookie: true,
+    cookieMaxAge: "1y",
+    dir: undefined,
+    dirs: [path.join(process.cwd(), "locales")],
+    functionName: "__",
+};
+function locales(app, options = {}) {
+    options = Object.assign({}, DEFAULT_OPTIONS, options);
+    const defaultLocale = formatLocale(options.defaultLocale || "en-US");
+    const queryField = options.queryField || "locale";
+    const cookieField = options.cookieField || "locale";
+    const cookieDomain = options.cookieDomain;
+    const localeAlias = options.localeAlias || {};
+    const writeCookie = options.writeCookie !== false;
+    const cookieMaxAge = ms(options.cookieMaxAge || "1y");
+    const localeDir = options.dir;
+    const localeDirs = options.dirs || [path.join(process.cwd(), "locales")];
+    const functionName = options.functionName || "__";
+    const resources = {};
+    /**
+     * @Deprecated Use options.dirs instead.
+     */
+    if (localeDir && !localeDirs.includes(localeDir)) {
+        localeDirs.push(localeDir);
+    }
+    // Loop through all directories, merging resources for the same locale
+    // Later directories override earlier ones
+    for (let i = 0; i < localeDirs.length; i++) {
+        const dir = localeDirs[i];
+        if (!fs.existsSync(dir)) {
+            continue;
+        }
+        const names = fs.readdirSync(dir);
+        for (let j = 0; j < names.length; j++) {
+            const name = names[j];
+            const filepath = path.join(dir, name);
+            // support en_US.js => en-US.js
+            const locale = formatLocale(name.split(".")[0]);
+            let resource = {};
+            if (name.endsWith(".js") || name.endsWith(".cjs")) {
+                const require = createRequire(import.meta.url);
+                const mod = require(filepath);
+                resource = flattening((mod.default || mod));
+            }
+            else if (name.endsWith(".json")) {
+                const require = createRequire(import.meta.url);
+                resource = flattening(require(filepath));
+            }
+            else if (name.endsWith(".properties")) {
+                resource = ini.parse(fs.readFileSync(filepath, "utf8"));
+            }
+            else if (name.endsWith(".yml") || name.endsWith(".yaml")) {
+                resource = flattening(yaml.load(fs.readFileSync(filepath, "utf8")));
+            }
+            // Always merge, but let later dirs override earlier ones
+            resources[locale] = { ...resources[locale], ...resource };
+        }
+    }
+    const debug = Debug("koa-locales");
+    const debugSilly = Debug("koa-locales:silly");
+    debug("Init locales with %j, got %j resources", options, Object.keys(resources));
+    if (typeof app[functionName] !==
+        "undefined") {
+        console.warn('[koa-locales] will override exists "%s" function on app', functionName);
+    }
+    function gettext(locale, key, ...args) {
+        if (!key || key === "")
+            return "";
+        const resource = resources[locale] || {};
+        let text = resource[key];
+        if (typeof text !== "string") {
+            text = key;
+        }
+        debugSilly("%s: %j => %j", locale, key, text);
+        if (args.length === 0) {
+            // __(locale, key)
+            return text;
+        }
+        if (args.length === 1) {
+            const value = args[0];
+            if (isObject(value)) {
+                return formatWithObject(text, value);
+            }
+            if (Array.isArray(value)) {
+                return formatWithArray(text, value);
+            }
+            return util.format(text, value);
+        }
+        // __(locale, key, value1, ...)
+        return util.format(text, ...args);
+    }
+    // Attach to app and context using proper Koa extension
+    app[functionName] = gettext;
+    app.context[functionName] =
+        function (key, ...args) {
+            const ctx = this;
+            const locale = ctx.__getLocale ? ctx.__getLocale() : "";
+            return gettext(locale, key, ...args);
+        };
+    app.context.__getLocale =
+        function () {
+            const ctx = this;
+            if (typeof ctx.__locale === "string" && ctx.__locale) {
+                return ctx.__locale;
+            }
+            const cookieLocale = ctx.cookies.get(cookieField, { signed: false });
+            let locale = ctx.query[queryField];
+            let localeOrigin = "query";
+            if (!locale) {
+                locale = cookieLocale;
+                localeOrigin = "cookie";
+            }
+            if (!locale) {
+                let languages = ctx.acceptsLanguages();
+                if (languages) {
+                    if (Array.isArray(languages)) {
+                        if (languages[0] === "*") {
+                            languages = languages.slice(1);
+                        }
+                        if (languages.length > 0) {
+                            for (let i = 0; i < languages.length; i++) {
+                                const lang = formatLocale(String(languages[i]));
+                                if (resources[lang] || localeAlias[lang]) {
+                                    locale = lang;
+                                    localeOrigin = "header";
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if (typeof languages === "string") {
+                        locale = languages;
+                        localeOrigin = "header";
+                    }
+                }
+                if (!locale) {
+                    locale = defaultLocale;
+                    localeOrigin = "default";
+                }
+            }
+            if (locale && typeof locale !== "string") {
+                locale = String(locale);
+            }
+            if (locale && locale in localeAlias) {
+                const originalLocale = locale;
+                locale = localeAlias[locale];
+                debugSilly("Used alias, received %s but using %s", originalLocale, locale);
+            }
+            locale = formatLocale(locale || defaultLocale);
+            if (!resources[locale]) {
+                debugSilly("Locale %s is not supported. Using default (%s)", locale, defaultLocale);
+                locale = defaultLocale;
+            }
+            if (writeCookie && cookieLocale !== locale && !ctx.headerSent) {
+                updateCookie(ctx, locale);
+            }
+            debug("Locale: %s from %s", locale, localeOrigin);
+            debugSilly("Locale: %s from %s", locale, localeOrigin);
+            ctx.__locale = locale;
+            ctx.__localeOrigin = localeOrigin;
+            return String(locale);
+        };
+    app.context.__getLocaleOrigin =
+        function () {
+            const ctx = this;
+            if (typeof ctx.__localeOrigin === "string" && ctx.__localeOrigin)
+                return ctx.__localeOrigin;
+            ctx.__getLocale?.();
+            return String(ctx.__localeOrigin ?? "");
+        };
+    app.context.__setLocale =
+        function (locale) {
+            const ctx = this;
+            ctx.__locale = locale;
+            ctx.__localeOrigin = "set";
+            updateCookie(ctx, locale);
+        };
+    function updateCookie(ctx, locale) {
+        const cookieOptions = {
+            httpOnly: false,
+            maxAge: cookieMaxAge,
+            signed: false,
+            domain: cookieDomain,
+            overwrite: true,
+        };
+        ctx.cookies.set(cookieField, locale, cookieOptions);
+        debugSilly("Saved cookie with locale %s", locale);
+    }
+}
+function isObject(obj) {
+    return Object.prototype.toString.call(obj) === "[object Object]";
+}
+const ARRAY_INDEX_RE = /\{(\d+)\}/g;
+function formatWithArray(text, values) {
+    return text.replace(ARRAY_INDEX_RE, (orignal, matched) => {
+        const index = parseInt(matched);
+        if (index < values.length) {
+            return String(values[index]);
+        }
+        // not match index, return orignal text
+        return orignal;
+    });
+}
+const Object_INDEX_RE = /\{(.+?)\}/g;
+function formatWithObject(text, values) {
+    return text.replace(Object_INDEX_RE, (orignal, matched) => {
+        const value = values[matched];
+        if (value !== undefined && value !== null) {
+            return String(value);
+        }
+        // not match index, return orignal text
+        return orignal;
+    });
+}
+function formatLocale(locale) {
+    if (!locale)
+        return "";
+    return locale.replace(/_/g, "-").toLowerCase();
+}
+function flattening(data) {
+    const result = {};
+    function deepFlat(data, keys) {
+        Object.keys(data).forEach((key) => {
+            const value = data[key];
+            const k = keys ? `${keys}.${key}` : key;
+            if (isObject(value)) {
+                deepFlat(value, k);
+            }
+            else {
+                result[k] = String(value);
+            }
+        });
+    }
+    deepFlat(data, "");
+    return result;
+}
+export default locales;

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import type Koa from "koa";
+export interface LocalesOptions {
+    defaultLocale?: string;
+    queryField?: string;
+    cookieField?: string;
+    cookieDomain?: string;
+    localeAlias?: Record<string, string>;
+    writeCookie?: boolean;
+    cookieMaxAge?: string | number;
+    dir?: string;
+    dirs?: string[];
+    functionName?: string;
+}
+type GettextFunction = (locale: string, key: string, ...args: unknown[]) => string;
+declare module "koa" {
+    interface Context {
+        __: GettextFunction;
+        __getLocale(): string;
+        __setLocale(locale: string): void;
+        __getLocaleOrigin(): string;
+    }
+    interface Application {
+        __: GettextFunction;
+    }
+}
+declare function locales(app: Koa, options?: LocalesOptions): void;
+export default locales;

package/dist/index.js

@@ -1,276 +1,250 @@
-const Debug = require("debug");
-const debug = Debug("koa-locales");
-const debugSilly = Debug("koa-locales:silly");
-const ini = require("ini");
-const util = require("util");
-const fs = require("fs");
-const path = require("path");
-const ms = require("humanize-ms").default || require("humanize-ms");
-const assign = require("object-assign");
-const yaml = require("js-yaml");
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import util from "node:util";
+import Debug from "debug";
+import { ms } from "humanize-ms";
+import ini from "ini";
+import yaml from "js-yaml";
 const DEFAULT_OPTIONS = {
-	defaultLocale: "en-US",
-	queryField: "locale",
-	cookieField: "locale",
-	localeAlias: {},
-	writeCookie: true,
-	cookieMaxAge: "1y",
-	dir: undefined,
-	dirs: [path.join(process.cwd(), "locales")],
-	functionName: "__",
+    defaultLocale: "en-US",
+    queryField: "locale",
+    cookieField: "locale",
+    localeAlias: {},
+    writeCookie: true,
+    cookieMaxAge: "1y",
+    dir: undefined,
+    dirs: [path.join(process.cwd(), "locales")],
+    functionName: "__",
 };
 function locales(app, options = {}) {
-	options = assign({}, DEFAULT_OPTIONS, options);
-	const defaultLocale = formatLocale(options.defaultLocale || "en-US");
-	const queryField = options.queryField || "locale";
-	const cookieField = options.cookieField || "locale";
-	const cookieDomain = options.cookieDomain;
-	const localeAlias = options.localeAlias || {};
-	const writeCookie = options.writeCookie !== false;
-	const cookieMaxAge = ms(options.cookieMaxAge || "1y");
-	const localeDir = options.dir;
-	const localeDirs = options.dirs || [path.join(process.cwd(), "locales")];
-	const functionName = options.functionName || "__";
-	const resources = {};
-	/**
-	 * @Deprecated Use options.dirs instead.
-	 */
-	if (localeDir && !localeDirs.includes(localeDir)) {
-		localeDirs.push(localeDir);
-	}
-	for (let i = 0; i < localeDirs.length; i++) {
-		const dir = localeDirs[i];
-		if (!fs.existsSync(dir)) {
-			continue;
-		}
-		const names = fs.readdirSync(dir);
-		for (let j = 0; j < names.length; j++) {
-			const name = names[j];
-			const filepath = path.join(dir, name);
-			// support en_US.js => en-US.js
-			const locale = formatLocale(name.split(".")[0]);
-			let resource = {};
-			if (name.endsWith(".js") || name.endsWith(".json")) {
-				resource = flattening(require(filepath));
-			} else if (name.endsWith(".properties")) {
-				resource = ini.parse(fs.readFileSync(filepath, "utf8"));
-			} else if (name.endsWith(".yml") || name.endsWith(".yaml")) {
-				resource = flattening(yaml.safeLoad(fs.readFileSync(filepath, "utf8")));
-			}
-			resources[locale] = resources[locale] || {};
-			assign(resources[locale], resource);
-		}
-	}
-	debug(
-		"Init locales with %j, got %j resources",
-		options,
-		Object.keys(resources),
-	);
-	if (typeof app[functionName] !== "undefined") {
-		console.warn(
-			'[koa-locales] will override exists "%s" function on app',
-			functionName,
-		);
-	}
-	function gettext(locale, key, value) {
-		if (arguments.length === 0 || arguments.length === 1) {
-			// __()
-			// --('en')
-			return "";
-		}
-		const resource = resources[locale] || {};
-		let text = resource[key];
-		if (text === undefined) {
-			text = key;
-		}
-		debugSilly("%s: %j => %j", locale, key, text);
-		if (!text) {
-			return "";
-		}
-		if (arguments.length === 2) {
-			// __(locale, key)
-			return text;
-		}
-		if (arguments.length === 3) {
-			if (isObject(value)) {
-				// __(locale, key, object)
-				// __('zh', '{a} {b} {b} {a}', {a: 'foo', b: 'bar'})
-				// =>
-				// foo bar bar foo
-				return formatWithObject(text, value);
-			}
-			if (Array.isArray(value)) {
-				// __(locale, key, array)
-				// __('zh', '{0} {1} {1} {0}', ['foo', 'bar'])
-				// =>
-				// foo bar bar foo
-				return formatWithArray(text, value);
-			}
-			// __(locale, key, value)
-			return util.format(text, value);
-		}
-		// __(locale, key, value1, ...)
-		const args = new Array(arguments.length - 1);
-		args[0] = text;
-		for (let i = 2; i < arguments.length; i++) {
-			args[i - 1] = arguments[i];
-		}
-		return util.format.apply(util, args);
-	}
-	app[functionName] = gettext;
-	app.context[functionName] = function (key, value) {
-		if (arguments.length === 0) {
-			// __()
-			return "";
-		}
-		const locale = this.__getLocale();
-		if (arguments.length === 1) {
-			return gettext(locale, key);
-		}
-		if (arguments.length === 2) {
-			return gettext(locale, key, value);
-		}
-		const args = new Array(arguments.length + 1);
-		args[0] = locale;
-		for (let i = 0; i < arguments.length; i++) {
-			args[i + 1] = arguments[i];
-		}
-		// @ts-expect-error: dynamic argument forwarding
-		return gettext(...args);
-	};
-	app.context.__getLocale = function () {
-		if (this.__locale) {
-			return this.__locale;
-		}
-		const cookieLocale = this.cookies.get(cookieField, { signed: false });
-		// 1. Query
-		let locale = this.query[queryField];
-		let localeOrigin = "query";
-		// 2. Cookie
-		if (!locale) {
-			locale = cookieLocale;
-			localeOrigin = "cookie";
-		}
-		// 3. Header
-		if (!locale) {
-			let languages = this.acceptsLanguages();
-			if (languages) {
-				if (Array.isArray(languages)) {
-					if (languages[0] === "*") {
-						languages = languages.slice(1);
-					}
-					if (languages.length > 0) {
-						for (let i = 0; i < languages.length; i++) {
-							const lang = formatLocale(languages[i]);
-							if (resources[lang] || localeAlias[lang]) {
-								locale = lang;
-								localeOrigin = "header";
-								break;
-							}
-						}
-					}
-				} else {
-					locale = languages;
-					localeOrigin = "header";
-				}
-			}
-			if (!locale) {
-				locale = defaultLocale;
-				localeOrigin = "default";
-			}
-		}
-		if (locale && locale in localeAlias) {
-			const originalLocale = locale;
-			locale = localeAlias[locale];
-			debugSilly(
-				"Used alias, received %s but using %s",
-				originalLocale,
-				locale,
-			);
-		}
-		locale = formatLocale(locale || defaultLocale);
-		if (!resources[locale]) {
-			debugSilly(
-				"Locale %s is not supported. Using default (%s)",
-				locale,
-				defaultLocale,
-			);
-			locale = defaultLocale;
-		}
-		if (writeCookie && cookieLocale !== locale && !this.headerSent) {
-			updateCookie(this, locale);
-		}
-		debug("Locale: %s from %s", locale, localeOrigin);
-		debugSilly("Locale: %s from %s", locale, localeOrigin);
-		this.__locale = locale;
-		this.__localeOrigin = localeOrigin;
-		return locale;
-	};
-	app.context.__getLocaleOrigin = function () {
-		if (this.__localeOrigin) return this.__localeOrigin;
-		this.__getLocale();
-		return this.__localeOrigin;
-	};
-	app.context.__setLocale = function (locale) {
-		this.__locale = locale;
-		this.__localeOrigin = "set";
-		updateCookie(this, locale);
-	};
-	function updateCookie(ctx, locale) {
-		const cookieOptions = {
-			httpOnly: false,
-			maxAge: cookieMaxAge,
-			signed: false,
-			domain: cookieDomain,
-			overwrite: true,
-		};
-		ctx.cookies.set(cookieField, locale, cookieOptions);
-		debugSilly("Saved cookie with locale %s", locale);
-	}
+    options = Object.assign({}, DEFAULT_OPTIONS, options);
+    const defaultLocale = formatLocale(options.defaultLocale || "en-US");
+    const queryField = options.queryField || "locale";
+    const cookieField = options.cookieField || "locale";
+    const cookieDomain = options.cookieDomain;
+    const localeAlias = options.localeAlias || {};
+    const writeCookie = options.writeCookie !== false;
+    const cookieMaxAge = ms(options.cookieMaxAge || "1y");
+    const localeDir = options.dir;
+    const localeDirs = options.dirs || [path.join(process.cwd(), "locales")];
+    const functionName = options.functionName || "__";
+    const resources = {};
+    /**
+     * @Deprecated Use options.dirs instead.
+     */
+    if (localeDir && !localeDirs.includes(localeDir)) {
+        localeDirs.push(localeDir);
+    }
+    // Loop through all directories, merging resources for the same locale
+    // Later directories override earlier ones
+    for (let i = 0; i < localeDirs.length; i++) {
+        const dir = localeDirs[i];
+        if (!fs.existsSync(dir)) {
+            continue;
+        }
+        const names = fs.readdirSync(dir);
+        for (let j = 0; j < names.length; j++) {
+            const name = names[j];
+            const filepath = path.join(dir, name);
+            // support en_US.js => en-US.js
+            const locale = formatLocale(name.split(".")[0]);
+            let resource = {};
+            if (name.endsWith(".js") || name.endsWith(".cjs")) {
+                const require = createRequire(import.meta.url);
+                const mod = require(filepath);
+                resource = flattening((mod.default || mod));
+            }
+            else if (name.endsWith(".json")) {
+                const require = createRequire(import.meta.url);
+                resource = flattening(require(filepath));
+            }
+            else if (name.endsWith(".properties")) {
+                resource = ini.parse(fs.readFileSync(filepath, "utf8"));
+            }
+            else if (name.endsWith(".yml") || name.endsWith(".yaml")) {
+                resource = flattening(yaml.load(fs.readFileSync(filepath, "utf8")));
+            }
+            // Always merge, but let later dirs override earlier ones
+            resources[locale] = { ...resources[locale], ...resource };
+        }
+    }
+    const debug = Debug("koa-locales");
+    const debugSilly = Debug("koa-locales:silly");
+    debug("Init locales with %j, got %j resources", options, Object.keys(resources));
+    if (typeof app[functionName] !==
+        "undefined") {
+        console.warn('[koa-locales] will override exists "%s" function on app', functionName);
+    }
+    function gettext(locale, key, ...args) {
+        if (!key || key === "")
+            return "";
+        const resource = resources[locale] || {};
+        let text = resource[key];
+        if (typeof text !== "string") {
+            text = key;
+        }
+        debugSilly("%s: %j => %j", locale, key, text);
+        if (args.length === 0) {
+            // __(locale, key)
+            return text;
+        }
+        if (args.length === 1) {
+            const value = args[0];
+            if (isObject(value)) {
+                return formatWithObject(text, value);
+            }
+            if (Array.isArray(value)) {
+                return formatWithArray(text, value);
+            }
+            return util.format(text, value);
+        }
+        // __(locale, key, value1, ...)
+        return util.format(text, ...args);
+    }
+    // Attach to app and context using proper Koa extension
+    app[functionName] = gettext;
+    app.context[functionName] =
+        function (key, ...args) {
+            const ctx = this;
+            const locale = ctx.__getLocale ? ctx.__getLocale() : "";
+            return gettext(locale, key, ...args);
+        };
+    app.context.__getLocale =
+        function () {
+            const ctx = this;
+            if (typeof ctx.__locale === "string" && ctx.__locale) {
+                return ctx.__locale;
+            }
+            const cookieLocale = ctx.cookies.get(cookieField, { signed: false });
+            let locale = ctx.query[queryField];
+            let localeOrigin = "query";
+            if (!locale) {
+                locale = cookieLocale;
+                localeOrigin = "cookie";
+            }
+            if (!locale) {
+                let languages = ctx.acceptsLanguages();
+                if (languages) {
+                    if (Array.isArray(languages)) {
+                        if (languages[0] === "*") {
+                            languages = languages.slice(1);
+                        }
+                        if (languages.length > 0) {
+                            for (let i = 0; i < languages.length; i++) {
+                                const lang = formatLocale(String(languages[i]));
+                                if (resources[lang] || localeAlias[lang]) {
+                                    locale = lang;
+                                    localeOrigin = "header";
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else if (typeof languages === "string") {
+                        locale = languages;
+                        localeOrigin = "header";
+                    }
+                }
+                if (!locale) {
+                    locale = defaultLocale;
+                    localeOrigin = "default";
+                }
+            }
+            if (locale && typeof locale !== "string") {
+                locale = String(locale);
+            }
+            if (locale && locale in localeAlias) {
+                const originalLocale = locale;
+                locale = localeAlias[locale];
+                debugSilly("Used alias, received %s but using %s", originalLocale, locale);
+            }
+            locale = formatLocale(locale || defaultLocale);
+            if (!resources[locale]) {
+                debugSilly("Locale %s is not supported. Using default (%s)", locale, defaultLocale);
+                locale = defaultLocale;
+            }
+            if (writeCookie && cookieLocale !== locale && !ctx.headerSent) {
+                updateCookie(ctx, locale);
+            }
+            debug("Locale: %s from %s", locale, localeOrigin);
+            debugSilly("Locale: %s from %s", locale, localeOrigin);
+            ctx.__locale = locale;
+            ctx.__localeOrigin = localeOrigin;
+            return String(locale);
+        };
+    app.context.__getLocaleOrigin =
+        function () {
+            const ctx = this;
+            if (typeof ctx.__localeOrigin === "string" && ctx.__localeOrigin)
+                return ctx.__localeOrigin;
+            ctx.__getLocale?.();
+            return String(ctx.__localeOrigin ?? "");
+        };
+    app.context.__setLocale =
+        function (locale) {
+            const ctx = this;
+            ctx.__locale = locale;
+            ctx.__localeOrigin = "set";
+            updateCookie(ctx, locale);
+        };
+    function updateCookie(ctx, locale) {
+        const cookieOptions = {
+            httpOnly: false,
+            maxAge: cookieMaxAge,
+            signed: false,
+            domain: cookieDomain,
+            overwrite: true,
+        };
+        ctx.cookies.set(cookieField, locale, cookieOptions);
+        debugSilly("Saved cookie with locale %s", locale);
+    }
 }
 function isObject(obj) {
-	return Object.prototype.toString.call(obj) === "[object Object]";
+    return Object.prototype.toString.call(obj) === "[object Object]";
 }
 const ARRAY_INDEX_RE = /\{(\d+)\}/g;
 function formatWithArray(text, values) {
-	return text.replace(ARRAY_INDEX_RE, (orignal, matched) => {
-		const index = parseInt(matched);
-		if (index < values.length) {
-			return values[index];
-		}
-		// not match index, return orignal text
-		return orignal;
-	});
+    return text.replace(ARRAY_INDEX_RE, (orignal, matched) => {
+        const index = parseInt(matched);
+        if (index < values.length) {
+            return String(values[index]);
+        }
+        // not match index, return orignal text
+        return orignal;
+    });
 }
 const Object_INDEX_RE = /\{(.+?)\}/g;
 function formatWithObject(text, values) {
-	return text.replace(Object_INDEX_RE, (orignal, matched) => {
-		const value = values[matched];
-		if (value) {
-			return value;
-		}
-		// not match index, return orignal text
-		return orignal;
-	});
+    return text.replace(Object_INDEX_RE, (orignal, matched) => {
+        const value = values[matched];
+        if (value !== undefined && value !== null) {
+            return String(value);
+        }
+        // not match index, return orignal text
+        return orignal;
+    });
 }
 function formatLocale(locale) {
-	if (!locale) return "";
-	return locale.replace(/_/g, "-").toLowerCase();
+    if (!locale)
+        return "";
+    return locale.replace(/_/g, "-").toLowerCase();
 }
 function flattening(data) {
-	const result = {};
-	function deepFlat(data, keys) {
-		Object.keys(data).forEach((key) => {
-			const value = data[key];
-			const k = keys ? keys + "." + key : key;
-			if (isObject(value)) {
-				deepFlat(value, k);
-			} else {
-				result[k] = String(value);
-			}
-		});
-	}
-	deepFlat(data, "");
-	return result;
+    const result = {};
+    function deepFlat(data, keys) {
+        Object.keys(data).forEach((key) => {
+            const value = data[key];
+            const k = keys ? `${keys}.${key}` : key;
+            if (isObject(value)) {
+                deepFlat(value, k);
+            }
+            else {
+                result[k] = String(value);
+            }
+        });
+    }
+    deepFlat(data, "");
+    return result;
 }
-module.exports = locales;
+export default locales;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@to-kn/koa-locales",
-	"version": "2.0.2",
+	"version": "2.1.1",
 	"description": "koa locales, i18n solution for koa",
 	"keywords": [
 		"koa-locales",
@@ -23,17 +23,19 @@
 	"type": "module",
 	"exports": {
 		"import": "./dist/esm/index.js",
-		"require": "./dist/esm/index.js",
+		"require": "./dist/cjs/index.cjs",
 		"types": "./dist/types/index.d.ts"
 	},
-	"main": "./dist/esm/index.js",
+	"main": "./dist/cjs/index.js",
 	"module": "./dist/esm/index.js",
 	"types": "./dist/types/index.d.ts",
 	"files": [
 		"dist/"
 	],
 	"scripts": {
-		"build": "tsc",
+		"build:esm": "tsc --project tsconfig.json",
+		"build:cjs": "tsc --project tsconfig.cjs.json",
+		"build": "npm run build:esm && npm run build:cjs",
 		"ci": "npm run lint && npm run cov",
 		"contributors": "contributors -f plain -o AUTHORS",
 		"cov": "vitest run --coverage",