intl-template 1.0.5 → 1.0.7

package/README.md

@@ -1,19 +1,8 @@
-# intel-template
+# intl-template
 
-A tiny i18n/l10n TTL(Tagged Template Literals) function
+A tiny i18n/l10n helper built on JavaScript Tagged Template Literals.
 
-## Table of Contents
-
-- [intel-template](#intel-template)
-  - [Table of Contents](#table-of-contents)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [Use browser specifies locale](#use-browser-specifies-locale)
-    - [Use with React](#use-with-react)
-    - [Specify slot order](#specify-slot-order)
-    - [Nested](#nested)
-    - [Function slot](#function-slot)
-    - [Call as function](#call-as-function)
+`intl-template` lets source strings stay close to your UI code while translations live in a simple locale-indexed template map.
 
 ## Installation
 
@@ -21,96 +10,187 @@ A tiny i18n/l10n TTL(Tagged Template Literals) function
 npm install intl-template
 ```
 
-## Usage
+## Quick Start
 
-```
-import translation from "intl-template"
+```javascript
+import translation, { l10n } from "intl-template"
 
+translation.locale = "es-ES"
 translation.templates["es-ES"] = {
-    "hello {}": "hola {}"
+    "hello {}": "hola {}",
 }
 
-const l10n = translation.translate.bind(null, "es-ES")
+const name = "Willow"
 
-const name = "willow";
-
-console.log(l10n`hello ${name}`)
-// => hola willow
+console.log(l10n`hello ${name}`.toString())
+// => hola Willow
 ```
 
-### Use browser specifies locale
+Every interpolation in a tagged template becomes `{}` in the translation key. For example, `l10n`hello ${name}`` looks up the key `"hello {}"`.
+
+By default, translations return a `Runes` array so React nodes and other non-string values can pass through unchanged. Call `.toString()` when you need plain text, or create a `Translation` instance in `"string"` mode.
+
+## Templates
+
+```javascript
+translation.templates["en-US"] = {
+    "hello {}": "hello {}",
+    "{} invited {}": "{} invited {}",
+}
+
+translation.templates["de-DE"] = {
+    "hello {}": "hallo {}",
+    "{} invited {}": "{1} wurde von {0} eingeladen",
+}
 ```
+
+Use `{}` to keep the original slot order. Use `{0}`, `{1}`, and later indexes when a locale needs a different order.
+
+## Locale
+
+The shared `translation` instance uses `navigator.language` when it is available, then falls back to `"en"`. You can also set the locale explicitly.
+
+```javascript
 import translation, { l10n } from "intl-template"
 
-translation.templates["es-ES"] = {
-    "hello {}": "hola {}"
+const browserLocale = navigator.language
+
+translation.locale = browserLocale
+translation.templates[browserLocale] = {
+    "hello {}": "hola {}",
 }
 
-// l10n = translation.translate.bind(null, navigator,language)
+console.log(l10n`hello ${"Willow"}`.toString())
+// => hola Willow
+```
 
-const name = "willow";
+## Examples
 
-console.log(l10n`hello ${name}`)
-// => hola willow
-```
+### React
 
-### Use with React
+The default `"react"` mode keeps interpolated values as values, so JSX can be used inside a translation.
 
-```javascript
+```jsx
+import translation, { l10n } from "intl-template"
 
-function SomeComponent({ name }) {
+translation.locale = "es-ES"
+translation.templates["es-ES"] = {
+    "hello {}": "hola {}",
+}
+
+function Greeting({ name }) {
     return (
-        <div>
-            {l10n`hello ${<b>{name}</b>}`}
-        </div>
+        <p>
+            {l10n`hello ${<strong key="name">{name}</strong>}`}
+        </p>
     )
 }
 ```
 
-### Specify slot order
+### Slot Order
 
-```
+```javascript
+translation.locale = "de-DE"
 translation.templates["de-DE"] = {
-    "hello {} and {}": "hallo {1} und {0}"
+    "{} invited {}": "{1} wurde von {0} eingeladen",
 }
 
-const l10n = translation.translate.bind(null, "de-DE")
+const inviter = "Willow"
+const guest = "Jack"
+
+console.log(l10n`${inviter} invited ${guest}`.toString())
+// => Jack wurde von Willow eingeladen
+```
+
+### Nested Translations
 
-const name1 = "willow"
-const name2 = "jack"
+```javascript
+translation.locale = "de-DE"
+translation.templates["de-DE"] = {
+    "Bill": "Schmidt",
+    "hello {}": "hallo {}",
+}
 
-console.log(l10n`hello ${name1} and ${name2}`)
-// => holla jack und willow
+console.log(l10n`hello ${l10n`Bill`}`.toString())
+// => hallo Schmidt
 ```
 
-### Nested
+### Function Slots
+
+When a slot is a function, it receives the active locale.
 
 ```javascript
+translation.locale = "de-DE"
 translation.templates["de-DE"] = {
-    "bill": "schmidt",
-    "hello {}": "hallo {1}"
+    "current locale: {}": "aktuelle Sprache: {}",
 }
 
-const l10n = translation.translate.bind(null, "de-DE")
+console.log(l10n`current locale: ${locale => locale}`.toString())
+// => aktuelle Sprache: de-DE
+```
+
+### Call as a Function
+
+Tagged templates and function calls use the same placeholder format.
 
-l10n`hello ${l10n`bill`}` // => hallo schmidt
+```javascript
+translation.locale = "es-ES"
+translation.templates["es-ES"] = {
+    "hello {}": "hola {}",
+}
+
+console.log(l10n("hello {}", "Willow").toString())
+// => hola Willow
 ```
 
-### Function slot
+### String Mode
 
 ```javascript
-translation.templates["de-DE"] = {
-    "bill": "schmidt",
-    "hello {}": "hallo {1}"
+import { Translation } from "intl-template"
+
+const translation = new Translation("es-ES", "string")
+
+translation.templates["es-ES"] = {
+    "hello {}": "hola {}",
 }
 
-const l10n = translation.translate.bind(null, "de-DE")
+const t = translation.translate
 
-l10n`hello ${(locale) => 123}` // => hallo 123
+console.log(t`hello ${"Willow"}`)
+// => hola Willow
 ```
 
-### Call as function
+## API
+
+### `translation`
+
+The default shared `Translation` instance.
+
+### `l10n`
+
+A shorthand for `translation.translate`.
+
+### `new Translation(defaultLocale, mode)`
+
+Creates an isolated translation instance.
+
+- `defaultLocale`: locale used by this instance.
+- `mode`: `"react"` by default, or `"string"` for plain string output.
+
+### `translation.locale`
+
+The active locale used by `translate`.
+
+### `translation.templates`
+
+Locale-indexed translation templates.
 
 ```javascript
-l10n("hello {}", name)
+translation.templates["es-ES"] = {
+    "source {}": "translated {}",
+}
 ```
+
+### `translation.translate(strings, ...parts)`
+
+Translates a tagged template or a string with `{}` placeholders.

package/intl.cjs

@@ -1 +1,172 @@
-var{defineProperty:J,getOwnPropertyNames:X,getOwnPropertyDescriptor:Y}=Object,Z=Object.prototype.hasOwnProperty;var V=new WeakMap,_=(q)=>{var j=V.get(q),z;if(j)return j;if(j=J({},"__esModule",{value:!0}),q&&typeof q==="object"||typeof q==="function")X(q).map((B)=>!Z.call(j,B)&&J(j,B,{get:()=>q[B],enumerable:!(z=Y(q,B))||z.enumerable}));return V.set(q,j),j};var $=(q,j)=>{for(var z in j)J(q,z,{get:j[z],enumerable:!0,configurable:!0,set:(B)=>j[z]=()=>B})};var E={};$(E,{parseTemplate:()=>K,l10n:()=>A,default:()=>w,Translation:()=>O,Runes:()=>N});module.exports=_(E);class N extends Array{toString(){return this.join("")}}function K(q){let j=[],z=[];return q.split(/({\d*})/).forEach((C)=>{if(C.match(/^{\d*}$/))if(C==="{}")j.push(j.length);else j.push(parseInt(C.slice(1,-1),10));else z.push(C)}),{template:z,order:j}}class O{mode="react";locale="";constructor(q,j="react"){this.mode=j,this.locale=q||globalThis?.navigator?.language||"en"}#j=new Proxy({},{get(q,j){return new Proxy(q[j]||{},{set(z,B,C){if(typeof C!=="string")throw Error("Template must be a string.");return z[B]=K(C),!0}})},set(q,j,z){return q[j]=Object.entries(z).reduce((B,[C,D])=>{return B[C]=K(D),B},{}),!0}});get templates(){return this.#j}set templates(q){return Object.entries(q).forEach(([j,z])=>{this.#j[j]=z}),!0}translate=(q,j,...z)=>{if(typeof j==="string")j=j.split("{}");let B=j.join("{}"),C=this.#j?.[q],{template:D,order:P}=C?.[B]||{};if(!D)console.debug(`[intl-template]not match translate key, ${B}`,{translation:C,locale:q,strings:j,parts:z}),D=j.slice(),P=z.map((F,G)=>G);if(z.length!==D.length-1)throw Error(`translate template parts length does not match. locale: ${q}, key: ${B}`);let Q=D.reduce((F,G,W)=>{F.push(G);let U=P[W];if(U>=0){let H=z[U];if(typeof H==="function")F.push(H(q));else F.push(H)}return F},new N);if(this.mode!=="react")return Q.toString();return Q}}var M=new O,w=M,A=(q,...j)=>M.translate(M.locale,q,...j);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// intl.js
+var exports_intl = {};
+__export(exports_intl, {
+  translation: () => translation,
+  parseTemplate: () => parseTemplate,
+  l10n: () => l10n,
+  default: () => intl_default,
+  Translation: () => Translation,
+  Runes: () => Runes
+});
+module.exports = __toCommonJS(exports_intl);
+
+class Runes extends Array {
+  toString() {
+    return this.join("");
+  }
+}
+var SLOT_RE = /\{(\d*)\}/g;
+var TEMPLATE_KEY_CACHE = new WeakMap;
+function parseTemplate(templateString) {
+  const template = [];
+  const order = [];
+  let lastIndex = 0;
+  let match;
+  SLOT_RE.lastIndex = 0;
+  while ((match = SLOT_RE.exec(templateString)) !== null) {
+    template.push(templateString.slice(lastIndex, match.index));
+    order.push(match[1] === "" ? order.length : +match[1]);
+    lastIndex = SLOT_RE.lastIndex;
+  }
+  template.push(templateString.slice(lastIndex));
+  return { template, order };
+}
+function compileRegionTemplates(regionTemplates) {
+  const region = {};
+  for (const key in regionTemplates) {
+    region[key] = parseTemplate(regionTemplates[key]);
+  }
+  return region;
+}
+function getTemplateKey(strings) {
+  if (!strings.raw) {
+    return strings.join("{}");
+  }
+  let key = TEMPLATE_KEY_CACHE.get(strings);
+  if (key === undefined) {
+    key = strings.join("{}");
+    TEMPLATE_KEY_CACHE.set(strings, key);
+  }
+  return key;
+}
+function toTemplateString(value) {
+  return value == null ? "" : value;
+}
+
+class Translation {
+  mode = "react";
+  locale = "";
+  constructor(defaultLocale, mode = "react") {
+    this.mode = mode;
+    this.locale = defaultLocale || globalThis?.navigator?.language || "en";
+  }
+  #regions = {};
+  #regionProxies = {};
+  #templates = new Proxy(this.#regions, {
+    get: (regions, locale) => {
+      const region = regions[locale];
+      if (!region) {
+        return new Proxy({}, REGION_HANDLER);
+      }
+      let proxy = this.#regionProxies[locale];
+      if (!proxy) {
+        proxy = new Proxy(region, REGION_HANDLER);
+        this.#regionProxies[locale] = proxy;
+      }
+      return proxy;
+    },
+    set: (regions, locale, regionTemplates) => {
+      const region = compileRegionTemplates(regionTemplates);
+      regions[locale] = region;
+      this.#regionProxies[locale] = new Proxy(region, REGION_HANDLER);
+      return true;
+    }
+  });
+  get templates() {
+    return this.#templates;
+  }
+  set templates(value) {
+    for (const locale in value) {
+      this.#templates[locale] = value[locale];
+    }
+  }
+  translate = (strings, ...parts) => {
+    const locale = this.locale;
+    const isStringInput = typeof strings === "string";
+    const key = isStringInput ? strings : getTemplateKey(strings);
+    const compiled = this.#regions[locale]?.[key];
+    let template;
+    let order;
+    if (compiled) {
+      template = compiled.template;
+      order = compiled.order;
+    } else {
+      template = isStringInput ? strings.split("{}") : strings.slice();
+    }
+    if (parts.length !== template.length - 1) {
+      throw new Error(`translate template parts length does not match. locale: ${locale}, key: ${key}`);
+    }
+    const len = template.length;
+    if (this.mode !== "react") {
+      let result = "";
+      for (let idx = 0;idx < len; idx++) {
+        result += template[idx];
+        if (idx < parts.length) {
+          const part = parts[order ? order[idx] : idx];
+          result += toTemplateString(typeof part === "function" ? part(locale) : part);
+        }
+      }
+      return result;
+    }
+    const runes = new Runes(len + parts.length);
+    let runeIdx = 0;
+    for (let idx = 0;idx < len; idx++) {
+      runes[runeIdx++] = template[idx];
+      if (idx < parts.length) {
+        const part = parts[order ? order[idx] : idx];
+        runes[runeIdx++] = typeof part === "function" ? part(locale) : part;
+      }
+    }
+    return runes;
+  };
+}
+var REGION_HANDLER = {
+  set(region, key, value) {
+    if (typeof value !== "string") {
+      throw new Error("Template must be a string.");
+    }
+    region[key] = parseTemplate(value);
+    return true;
+  }
+};
+var translation = new Translation;
+var intl_default = translation;
+var l10n = translation.translate;

package/intl.d.ts

@@ -16,7 +16,11 @@ export class Runes extends Array<any> {
  * Represents a Translation object that handles string translation based on locale and templates.
  */
 export class Translation {
-    constructor(defaultLocale: any, mode?: string);
+    /**
+     * @param {string} defaultLocale
+     * @param {"string" | "react"} mode
+     */
+    constructor(defaultLocale: string, mode?: "string" | "react");
     /** @type {"string" | "react"} */
     mode: "string" | "react";
     /**
@@ -24,20 +28,19 @@ export class Translation {
      * @type {string}
      **/
     locale: string;
-    set templates(value: Proxy);
-    get templates(): Proxy;
+    set templates(value: any);
+    get templates(): any;
     /**
      * Translates a string based on the provided locale and strings.
      *
-     * @param {string} locale - The locale to use for translation.
      * @param {TemplateStringsArray | string} strings - The string or array of strings to be translated.
      * @param {...any} parts - The dynamic parts to be inserted into the translated string.
-     * @returns {Runes} - The translated string with dynamic parts inserted.
+     * @returns {Runes | string} - The translated string with dynamic parts inserted.
      * @throws {Error} - If the length of the template parts does not match the length of the template.
      */
-    translate: (locale: string, strings: TemplateStringsArray | string, ...parts: any[]) => Runes;
+    translate: (strings: TemplateStringsArray | string, ...parts: any[]) => Runes | string;
     #private;
 }
+export const translation: Translation;
 export default translation;
-export function l10n(strings: any, ...parts: any[]): Runes;
-declare const translation: Translation;
+export function l10n(strings: TemplateStringsArray | string, ...parts: any[]): Runes | string;

package/intl.js

@@ -4,31 +4,59 @@ export class Runes extends Array {
 	}
 }
 
+const SLOT_RE = /\{(\d*)\}/g
+const TEMPLATE_KEY_CACHE = new WeakMap()
+
 /**
  * Parses a template string and extracts the template parts and order of slots.
  * @param {string} templateString - The template string to parse.
  * @returns {{ template: string[], order: number[] }}
  */
 export function parseTemplate(templateString) {
-	const order = [];
-	const template = [];
-	const parts = templateString.split(/({\d*})/)
-	parts.forEach((part) => {
-		if (part.match(/^{\d*}$/)) {
-			if (part === '{}') {
-				order.push(order.length)
-			} else {
-				// slot with order, e.g. `{2}abc{1}def{0}`
-				order.push(parseInt(part.slice(1, -1), 10))
-			}
-		} else {
-			template.push(part)
-		}
-	})
+	const template = []
+	const order = []
+	let lastIndex = 0
+	let match
+
+	SLOT_RE.lastIndex = 0
+	while ((match = SLOT_RE.exec(templateString)) !== null) {
+		template.push(templateString.slice(lastIndex, match.index))
+		// `{}` keeps original auto-numbering: index = current order length
+		order.push(match[1] === "" ? order.length : +match[1])
+		lastIndex = SLOT_RE.lastIndex
+	}
+	template.push(templateString.slice(lastIndex))
 
 	return { template, order }
 }
 
+function compileRegionTemplates(regionTemplates) {
+	const region = {}
+	for (const key in regionTemplates) {
+		region[key] = parseTemplate(regionTemplates[key])
+	}
+
+	return region
+}
+
+function getTemplateKey(strings) {
+	if (!strings.raw) {
+		return strings.join("{}")
+	}
+
+	let key = TEMPLATE_KEY_CACHE.get(strings)
+	if (key === undefined) {
+		key = strings.join("{}")
+		TEMPLATE_KEY_CACHE.set(strings, key)
+	}
+
+	return key
+}
+
+function toTemplateString(value) {
+	return value == null ? "" : value
+}
+
 /**
  * Represents a Translation object that handles string translation based on locale and templates.
  */
@@ -42,6 +70,10 @@ export class Translation {
 	 **/
 	locale = ""
 
+	/**
+	 * @param {string} defaultLocale 
+	 * @param {"string" | "react"} mode 
+	 */
 	constructor(defaultLocale, mode = "react") {
 		this.mode = mode
 		this.locale = defaultLocale || globalThis?.navigator?.language || "en"
@@ -51,26 +83,29 @@ export class Translation {
 	 * Templates object that stores the translation templates for each locale.
 	 * @type {Proxy}
 	 */
-	#templates = new Proxy({}, {
-		get(templates, locale) {
-			return new Proxy(templates[locale] || {}, {
-				set(region, key, value) {
-					if (typeof value !== "string") {
-						throw new Error("Template must be a string.")
-					}
+	#regions = {}
 
-					region[key] = parseTemplate(value)
+	#regionProxies = {}
 
-					return true
-				}
-			})
-		},
-		set(templates, locale, regionTemplates) {
-			templates[locale] = Object.entries(regionTemplates).reduce((region, [key, value]) => {
-				region[key] = parseTemplate(value)
+	#templates = new Proxy(this.#regions, {
+		get: (regions, locale) => {
+			const region = regions[locale]
+			if (!region) {
+				return new Proxy({}, REGION_HANDLER)
+			}
+
+			let proxy = this.#regionProxies[locale]
+			if (!proxy) {
+				proxy = new Proxy(region, REGION_HANDLER)
+				this.#regionProxies[locale] = proxy
+			}
 
-				return region
-			}, {})
+			return proxy
+		},
+		set: (regions, locale, regionTemplates) => {
+			const region = compileRegionTemplates(regionTemplates)
+			regions[locale] = region
+			this.#regionProxies[locale] = new Proxy(region, REGION_HANDLER)
 
 			return true
 		}
@@ -81,66 +116,78 @@ export class Translation {
 	}
 
 	set templates(value) {
-		Object.entries(value).forEach(([locale, regionTemplates]) => {
-			this.#templates[locale] = regionTemplates
-		})
-
-		return true
+		for (const locale in value) {
+			this.#templates[locale] = value[locale]
+		}
 	}
 
 	/**
 	 * Translates a string based on the provided locale and strings.
 	 *
-	 * @param {string} locale - The locale to use for translation.
 	 * @param {TemplateStringsArray | string} strings - The string or array of strings to be translated.
 	 * @param {...any} parts - The dynamic parts to be inserted into the translated string.
-	 * @returns {Runes} - The translated string with dynamic parts inserted.
+	 * @returns {Runes | string} - The translated string with dynamic parts inserted.
 	 * @throws {Error} - If the length of the template parts does not match the length of the template.
 	 */
-	translate = (locale, strings, ...parts) => {
-		if (typeof strings === "string") {
-			strings = strings.split("{}")
-		}
-
-		const key = strings.join("{}")
-		const translation = this.#templates?.[locale]
-		let { template, order } = translation?.[key] || {}
-		if (!template) {
-			console.debug(`[intl-template]not match translate key, ${key}`, { translation, locale, strings, parts })
-			template = strings.slice()
-			order = parts.map((_, i) => i)
+	translate = (strings, ...parts) => {
+		const locale = this.locale
+		const isStringInput = typeof strings === "string"
+		const key = isStringInput ? strings : getTemplateKey(strings)
+
+		const compiled = this.#regions[locale]?.[key]
+		let template
+		let order
+		if (compiled) {
+			template = compiled.template
+			order = compiled.order
+		} else {
+			template = isStringInput ? strings.split("{}") : strings.slice()
 		}
 
 		if (parts.length !== template.length - 1) {
 			throw new Error(`translate template parts length does not match. locale: ${locale}, key: ${key}`)
 		}
 
-		const runes = template.reduce((runes, template, idx) => {
-			runes.push(template)
-
-			const orderIdx = order[idx]
-			if (orderIdx >= 0) {
-				const part = parts[orderIdx]
-				if (typeof part === "function") {
-					runes.push(part(locale))
-				} else {
-					runes.push(part)
+		const len = template.length
+		if (this.mode !== "react") {
+			let result = ""
+			for (let idx = 0; idx < len; idx++) {
+				result += template[idx]
+				if (idx < parts.length) {
+					const part = parts[order ? order[idx] : idx]
+					result += toTemplateString(typeof part === "function" ? part(locale) : part)
 				}
 			}
 
-			return runes
-		}, new Runes())
+			return result
+		}
 
-		if (this.mode !== "react") {
-			return runes.toString()
+		const runes = new Runes(len + parts.length)
+		let runeIdx = 0
+		for (let idx = 0; idx < len; idx++) {
+			runes[runeIdx++] = template[idx]
+			if (idx < parts.length) {
+				const part = parts[order ? order[idx] : idx]
+				runes[runeIdx++] = typeof part === "function" ? part(locale) : part
+			}
 		}
 
 		return runes
 	}
 }
 
-const translation = new Translation()
+const REGION_HANDLER = {
+	set(region, key, value) {
+		if (typeof value !== "string") {
+			throw new Error("Template must be a string.")
+		}
+		region[key] = parseTemplate(value)
+		return true
+	}
+}
+
+export const translation = new Translation()
 
 export default translation
 
-export const l10n = (strings, ...parts) => translation.translate(translation.locale, strings, ...parts);
+export const l10n = translation.translate

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "intl-template",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "l10n tagged template literals",
   "type": "module",
-  "main": "intl.cjs",
-  "module": "intl.js",
+  "main": "./intl.cjs",
+  "module": "./intl.js",
+  "types": "./intl.d.ts",
   "repository": "github:performonkey/intl-template",
+  "files": [
+    "README.md",
+    "intl.js",
+    "intl.cjs",
+    "intl.d.ts"
+  ],
   "scripts": {
-    "build": "bun build --outfile intl.cjs --production --format cjs intl.js",
-    "postbuild": "tsc --emitDeclarationOnly --allowJs -d --outDir . *.js",
-    "postpublish": "rm -rf *.d.ts *.cjs"
+    "build": "bun build --outfile intl.cjs --format cjs intl.js",
+    "perf": "node --test intl.perf.test.js",
+    "postbuild": "rm *.d.ts && tsc --emitDeclarationOnly --allowJs -d --outDir . intl.js intl.test.js"
   },
   "keywords": [
     "i18n",

package/intl.test.d.ts

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

package/intl.test.js

@@ -1,132 +0,0 @@
-import assert from "node:assert"
-import test from "node:test"
-import { Translation, Runes } from "./intl.js"
-
-test("template", async (t) => {
-	await t.test("multiple locale template parse", () => {
-		const translation = new Translation()
-		translation.templates = {
-			"es-ES": {
-				"{}matched{}": "{}{}uno",
-			},
-			"zh-CN": {
-				"{}matched{}": "{}{}丁戊卯",
-			}
-		}
-
-		assert.deepEqual(
-			translation.templates["zh-CN"],
-			{
-				"{}matched{}": {
-					template: ["", "", "丁戊卯"],
-					order: [0, 1]
-				},
-			},
-		)
-	})
-
-	await t.test("template slot parse", () => {
-		const translation = new Translation()
-		const locale = "zh-CN"
-		translation.templates[locale] = {
-			"{}matched{}": "{}{}丁戊卯",
-		}
-
-		Object.assign(translation.templates[locale], {
-			"assign{}": "123{}"
-		})
-
-		assert.deepEqual(
-			translation.templates[locale],
-			{
-				"{}matched{}": {
-					template: ["", "", "丁戊卯"],
-					order: [0, 1]
-				},
-				"assign{}": {
-					template: ["123", ""],
-					order: [0]
-				}
-			},
-		)
-	})
-
-	await t.test("template slot order parse", () => {
-		const translation = new Translation()
-		const locale = "zh-CN"
-		const key = "{}matched{}"
-		translation.templates[locale] = {
-			[key]: "{1}{0}丁戊卯",
-		}
-
-		assert.deepEqual(
-			translation.templates[locale][key],
-			{
-				template: ["", "", "丁戊卯"],
-				order: [1, 0]
-			}
-		)
-	})
-})
-
-test("translation.translate", async (t) => {
-	await t.test("apply template", () => {
-		const translation = new Translation()
-		translation.templates["zh-CN"] = {
-			"abc {} def {}": "甲乙丙 {} {} 丁戊卯",
-		}
-		const l10n = translation.translate.bind(null, "zh-CN")
-		assert.deepEqual(l10n`abc ${123} def ${345}`, ["甲乙丙 ", 123, " ", 345, " 丁戊卯"])
-	})
-
-	await t.test("change slot order", () => {
-		const translation = new Translation()
-		translation.templates["zh-CN"] = {
-			"abc {} def {}": "甲乙丙 {1} {0} 丁戊卯",
-		}
-		const l10n = translation.translate.bind(null, "zh-CN")
-		assert.equal(l10n`abc ${123} def ${345}`.toString(), "甲乙丙 345 123 丁戊卯")
-	})
-
-	await t.test("slot function", () => {
-		const translation = new Translation()
-		translation.templates["zh-CN"] = {
-			"{} def {}": "{1} {0} 丁戊卯",
-		}
-		const l10n = translation.translate.bind(null, "zh-CN")
-		assert.equal(l10n`${locale => locale} def ${345}`.toString(), "345 zh-CN 丁戊卯")
-	})
-
-	await t.test("slot count match", () => {
-		const translation = new Translation()
-		translation.templates["zh-CN"] = {
-			"{} def {}": "{} 丁戊卯",
-			"{}matched{}": "{}{}丁戊卯",
-		}
-		const l10n = translation.translate.bind(null, "zh-CN")
-		try {
-			l10n`${locale => locale} def ${345}`
-		} catch (err) {
-			assert.equal(
-				err.message,
-				`translate template parts length does not match. locale: zh-CN, key: {} def {}`
-			)
-		}
-
-		assert.equal(l10n`${locale => locale}matched${345}`.toString(), `zh-CN345丁戊卯`)
-	})
-
-	await t.test("call as function", () => {
-		const translation = new Translation()
-		translation.templates["zh-CN"] = {}
-		const l10n = translation.translate.bind(null, "zh-CN")
-		assert.equal(l10n("{} def {} {}", 1, "a", "b").toString(), '1 def a b')
-	})
-})
-
-test("Runes", async (t) => {
-	assert.equal(
-		new Runes('a', ' b ', 1, 2).toString(),
-		'a b 12'
-	)
-})