@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/rich-DCUKl5HM.js

@@ -0,0 +1,97 @@
+import { _ as DEV, n as S, x as warnOnce } from "./dir-zw6bGMKQ.js";
+import { T as formatPart, a as caseOf, c as valueOf, i as argText, s as poundOf, t as lookup } from "./t-DC-c9zE5.js";
+const ENTITIES = {
+	"&": "amp",
+	"<": "lt",
+	">": "gt",
+	"\"": "quot",
+	"'": "#39"
+};
+/** A node with the framework's element key (`State.richKey`, set by React and Preact glue). */
+const keyed = (node, key) => S.richKey?.(node, key) ?? node;
+/**
+* `rich` (nodes), `richParts` or `richHtml` (one string, or none) output for
+* `key`. Without `scope` it renders in the active scope and subscribes the
+* rendering computation; translators pass their own scope and never track.
+*/
+function richIn(key, values, mode, scope) {
+	const s = scope ?? S.resolve();
+	const html = mode === 2;
+	const out = [];
+	/**
+	* Appends text, joining it to a preceding string so renderers get few
+	* nodes; in `richHtml` it is escaped first, as only handler output is trusted.
+	*/
+	const text = (into, s, escape = html) => {
+		if (escape) s = s.replace(/[&<>"']/g, (c) => "&" + ENTITIES[c] + ";");
+		if (!s) return;
+		const last = into.length - 1;
+		if (typeof into[last] === "string") into[last] += s;
+		else into.push(s);
+	};
+	/**
+	* Walks `m` from index `from` (tags reuse their own array from index 2)
+	* into `into`. `n` is the `#` value of the innermost plural. Handler keys
+	* are part indexes (INTERNALS §3.1), so they never depend on argument
+	* values; in `rich`, parts that land in the parent's output from a nested
+	* list (a select or plural case, the children of a tag without handler)
+	* are offset by `k = (index + 1) * 1000` of their parent part, which keeps
+	* keys unique among the output siblings. `richHtml` output has no siblings
+	* to keep apart, so its handlers get the index in their own list.
+	*/
+	const walk = (m, from, n, into, k) => {
+		if (typeof m === "string") return text(into, m);
+		for (let i = from; i < m.length; i++) {
+			const p = m[i];
+			if (typeof p === "string") text(into, p);
+			else if (p === 0) text(into, formatPart(4, void 0, n, s));
+			else {
+				const op = p[1];
+				const value = valueOf(values, p[0]);
+				const nested = (k + i + 1) * 1e3;
+				if (DEV && value == null && op !== 1 && !(op > 6)) warnOnce(`no value for {${p[0]}} in ${JSON.stringify(m)}`);
+				if (op > 6) {
+					const fn = typeof value === "function" ? value : S.tags?.[mode + p[0]];
+					if (fn || mode === 1) {
+						const children = [];
+						if (op === 7) walk(p, 2, n, children, 0);
+						if (mode === 1) into.push({
+							tag: p[0],
+							children
+						});
+						else if (html) text(into, "" + fn(children.join(""), i), false);
+						else into.push(keyed(fn(children, k + i), k + i));
+					} else {
+						if (DEV) warnOnce(`no handler for <${p[0]}> in ${html ? "richHtml" : "rich"}()`);
+						if (op === 7) walk(p, 2, n, into, nested);
+					}
+				} else if (op === void 0) {
+					if (!mode && value != null && !"stringnumberbigint".includes(typeof value) && !(value instanceof Date)) into.push(keyed(value, k + i));
+					else text(into, argText(value, s));
+				} else if (op < 4) {
+					const c = caseOf(p, value, s.locale);
+					if (c !== void 0) walk(c, 0, op === 1 ? n : poundOf(p, value), into, nested);
+				} else text(into, formatPart(op, p[2], value, s));
+			}
+		}
+	};
+	walk(lookup(s, key, !scope), 0, 0, out, 0);
+	return out;
+}
+/**
+* Tag handlers come from `values` and receive `(children, key)`; React and
+* Preact glue keys their results, and nodes passed as values, through
+* `State.richKey`. A tag without a handler renders its children.
+*/
+const rich = (message, values) => richIn(message, values, 0);
+/**
+* Escapes `& < > " '` in every text part and value; handlers get escaped
+* children and only their output is trusted HTML.
+*/
+const html = (message, values) => richIn(message, values, 2).join("");
+const richHtml = html;
+/** `string | { tag, children }` parts; arguments are stringified. */
+const parts = (message, values) => richIn(message, values, 1);
+const richParts = parts;
+//#endregion
+export { richParts as i, richHtml as n, richIn as r, rich as t };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };