@aalis/api-webui 0.11.1 → 0.13.0

package/dist/frame/schema-i18n/format.js

@@ -0,0 +1,160 @@
+import { isTextRef } from './text-ref.js';
+const FAILED = new Error('参数不合要求');
+function fail() {
+    throw FAILED;
+}
+// Intl 对象构造比格式化贵得多，按语言、选项与时区缓存，条目数封顶
+const intlCache = new Map();
+function cached(key, make) {
+    let value = intlCache.get(key);
+    if (value === undefined) {
+        value = make();
+        if (intlCache.size >= 512)
+            intlCache.clear();
+        intlCache.set(key, value);
+    }
+    return value;
+}
+const numberFormat = (language, unit, display, digits) => cached(`number\0${language}\0${unit}\0${display}\0${digits}`, () => new Intl.NumberFormat(language, unit === undefined ? undefined : { style: 'unit', unit, unitDisplay: display, maximumFractionDigits: digits }));
+/** 时区由调用方给，缺省按进程的时区；Intl 不认的当作没给，同样按进程时区：不让整句回落成原文 */
+function dateFormat(type, style, o) {
+    return cached(`${type}\0${style}\0${o.language}\0${o.timeZone}`, () => {
+        const options = {};
+        if (type !== 'time')
+            options.dateStyle = style;
+        if (type !== 'date')
+            options.timeStyle = style;
+        try {
+            return new Intl.DateTimeFormat(o.language, { ...options, timeZone: o.timeZone });
+        }
+        catch {
+            return new Intl.DateTimeFormat(o.language, options);
+        }
+    });
+}
+const MARKDOWN_SPECIAL = /[\\`*_{}[\]()#+\-.!|<>~=&$]/g;
+/** 按 Markdown 转义：转义后的文字在 Markdown 里显示为原样 */
+export function escapeMarkdown(text) {
+    return text.replace(MARKDOWN_SPECIAL, '\\$&');
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fail();
+}
+function list(value) {
+    return Array.isArray(value) ? value : fail();
+}
+/** 普通参数与列表元素：字符串（按需转义）、数原样、文字对象交给 nested */
+function item(value, o) {
+    if (typeof value === 'string')
+        return o.escape === 'markdown' ? escapeMarkdown(value) : value;
+    if (typeof value === 'number')
+        return String(value);
+    return isTextRef(value) ? o.nested(value) : fail();
+}
+const DURATION_UNITS = ['day', 'hour', 'minute', 'second'];
+const DURATION_SECONDS = [86_400, 3_600, 60, 1];
+/** 时长：天、时、分、秒最多两级，按显示的最小一级四舍五入；负数只在第一级带负号 */
+function duration(ms, o) {
+    const seconds = Math.abs(ms) / 1000;
+    let top = DURATION_SECONDS.findIndex(size => seconds >= size);
+    if (top < 0)
+        top = DURATION_SECONDS.length - 1;
+    let step;
+    let rounded;
+    for (;;) {
+        step = DURATION_SECONDS[Math.min(top + 1, DURATION_SECONDS.length - 1)];
+        rounded = Math.round(seconds / step) * step;
+        // 进位跨过上一级（59.6 秒成了 60 秒）就升一级重算
+        if (top === 0 || rounded < DURATION_SECONDS[top - 1])
+            break;
+        top--;
+    }
+    const high = Math.floor(rounded / DURATION_SECONDS[top]);
+    const low = Math.round((rounded - high * DURATION_SECONDS[top]) / step);
+    const unit = (index, value) => numberFormat(o.language, DURATION_UNITS[index], 'short').format(value);
+    const parts = [unit(top, ms < 0 && rounded > 0 ? -high : high)];
+    if (low > 0)
+        parts.push(unit(top + 1, low));
+    return cached(`unit-list\0${o.language}`, () => new Intl.ListFormat(o.language, { type: 'unit', style: 'short' })).format(parts);
+}
+const SIZE_UNITS = ['byte', 'kilobyte', 'megabyte', 'gigabyte'];
+/** 字节数：B、kB、MB、GB（Intl 单位的 narrow 写法），按 1024 进位，B 以上至多一位小数、整数不带小数；按显示精度舍入后到了 1024 就升一级 */
+function size(bytes, o) {
+    let value = Math.abs(bytes);
+    let index = 0;
+    const shown = () => (index === 0 ? Math.round(value) : Math.round(value * 10) / 10);
+    while (shown() >= 1024 && index < SIZE_UNITS.length - 1) {
+        value /= 1024;
+        index++;
+    }
+    return numberFormat(o.language, SIZE_UNITS[index], 'narrow', index === 0 ? 0 : 1).format(bytes < 0 ? -value : value);
+}
+/** 行内代码：围栏比参数里最长的反引号串多一个，参数以反引号开头或结尾时两侧加空格；参数原样，不转义 */
+function code(value) {
+    const longest = Math.max(0, ...(value.match(/`+/g) ?? []).map(run => run.length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = value.startsWith('`') || value.endsWith('`') ? ' ' : '';
+    return `${fence}${pad}${value}${pad}${fence}`;
+}
+function formatArgument(arg, params, o, count) {
+    if (arg.type === 'pound')
+        return numberFormat(o.language).format(count);
+    const value = Object.hasOwn(params, arg.name) ? params[arg.name] : undefined;
+    switch (arg.type) {
+        case 'plain':
+            return item(value, o);
+        case 'number':
+            return numberFormat(o.language).format(finite(value));
+        case 'plural': {
+            const n = finite(value);
+            const category = cached(`plural\0${o.language}`, () => new Intl.PluralRules(o.language)).select(n);
+            const branch = arg.branches.get(`=${n}`) ?? arg.branches.get(category) ?? arg.branches.get('other');
+            return render(branch ?? fail(), params, o, n);
+        }
+        case 'select': {
+            if (typeof value !== 'string')
+                fail();
+            const branch = arg.branches.get(value) ?? arg.branches.get('other');
+            return render(branch ?? fail(), params, o, count);
+        }
+        case 'date':
+        case 'time':
+        case 'datetime':
+            return dateFormat(arg.type, arg.style, o).format(finite(value));
+        case 'list': {
+            const items = list(value).map(element => item(element, o));
+            // 罗列只用分隔符拼接，不加「和」「and」：Intl 的窄写法各语言、各浏览器带不带连接词不一。「或」照常用 Intl
+            if (arg.listType === 'conjunction')
+                return items.join(o.listSeparator());
+            return cached(`list-or\0${o.language}`, () => new Intl.ListFormat(o.language, { type: 'disjunction' })).format(items);
+        }
+        case 'lines':
+            return list(value)
+                .map(element => item(element, o))
+                .join('\n');
+        case 'duration':
+            return duration(finite(value), o);
+        case 'size':
+            return size(finite(value), o);
+        case 'code':
+            if (typeof value === 'number')
+                return code(String(value));
+            return typeof value === 'string' ? code(value) : fail();
+    }
+}
+function render(message, params, o, count) {
+    let out = '';
+    for (const part of message)
+        out += typeof part === 'string' ? part : formatArgument(part, params, o, count);
+    return out;
+}
+/** 渲染整句；失败（含 Intl 报错，如不认识的时区）返回 undefined */
+export function formatMessage(message, params, options) {
+    try {
+        return render(message, params, options, Number.NaN);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=format.js.map

package/dist/frame/schema-i18n/index.js

@@ -0,0 +1,17 @@
+// ============================================================
+// @aalis/schema-i18n — 给人看的文字对象
+//
+// 要翻译的文字是文字对象（TextRef）：取自所属包原文字典的一个键，带参数与按原文渲染的整句，纯数据、可落盘。
+// 产出文字的一方只依赖本包；出口在 i18n 服务在场时按读者语言渲染，不在场时按原文语言渲染（resolveSource）。
+// 本包零运行时依赖、不用 node: 模块，浏览器里同样可用。
+// ============================================================
+export { catalogEntries, catalogIssues, registerCatalogEntry, } from './catalog.js';
+export { checkTexts } from './check.js';
+export { defineLocale, defineTexts, truncateParams, } from './define.js';
+export { isTextError, TextError, textOf, withText } from './errors.js';
+export { matchLanguage, normalizeLanguages, pickLanguage, selfName } from './locale.js';
+export { fingerprint, indexPacks, } from './packs.js';
+export { listSeparator, resolveSource, resolveText } from './resolve.js';
+export { asText, isTextRef, localize, sameText, toSource, toSourceReplacer, } from './text-ref.js';
+export { linesOf, textClauses, textLines } from './texts.js';
+//# sourceMappingURL=index.js.map

package/dist/frame/schema-i18n/locale.js

@@ -0,0 +1,100 @@
+// 语言标签的规范化与匹配
+/** 系统与手填的写法先整理：下划线换连字符，去掉 `.UTF-8`、`@euro` 这类后缀 */
+const tidy = (tag) => tag.replace(/[.@].*$/, '').replace(/_/g, '-');
+/** 规范写法（`zh-cn` → `zh-CN`），不合法时 undefined */
+export function canonicalLanguage(tag) {
+    try {
+        return Intl.getCanonicalLocales(tag)[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** 读者给的列表只看前几项：超长的列表不逐项规范化 */
+const MAX_INPUT = 32;
+/** 语言链最多几种：再多也轮不到 */
+const MAX_LANGUAGES = 8;
+/**
+ * 读者给的语言列表规范化：整理写法、过 getCanonicalLocales，不合法的（含不是字符串的）丢掉，去重保序。列表来自会话设置与调用方
+ * （可能是手写的配置），只看前 32 项，至多给出 8 种
+ */
+export function normalizeLanguages(tags) {
+    const out = [];
+    for (const tag of tags.slice(0, MAX_INPUT)) {
+        if (out.length === MAX_LANGUAGES)
+            break;
+        if (typeof tag !== 'string')
+            continue;
+        const canonical = canonicalLanguage(tidy(tag));
+        if (canonical !== undefined && !out.includes(canonical))
+            out.push(canonical);
+    }
+    return out;
+}
+// 标签来自设置与调用方，条目数封顶
+const subtagCache = new Map();
+/** maximize 之后的语言、文字与地区：zh、zh-CN、zh-SG 都是 zh-Hans，zh-TW、zh-HK 是 zh-Hant */
+function subtags(tag) {
+    let found = subtagCache.get(tag);
+    if (found === undefined) {
+        try {
+            const { language, script, region } = new Intl.Locale(tidy(tag)).maximize();
+            found = { language, script, region };
+        }
+        catch {
+            found = null;
+        }
+        if (subtagCache.size >= 512)
+            subtagCache.clear();
+        subtagCache.set(tag, found);
+    }
+    return found ?? undefined;
+}
+/**
+ * 读者语言链在可用语言里对得上的一种，返回下标：①链里逐项找语言与文字都相同的，同文字内地区相同者优先，
+ * 其余按 available 的先后；②链里逐项找语言相同、文字不同的（zh-TW 读者遇到只有简体时用简体）。都没有时 undefined。
+ * 不含 en 兜底（见 {@link pickLanguage}）：判「某种语言有没有字典提供」用它
+ */
+export function matchLanguage(chain, available) {
+    const offered = available.map(subtags);
+    const sameScript = (reader) => {
+        let first;
+        for (const [i, candidate] of offered.entries()) {
+            if (candidate?.language !== reader.language || candidate.script !== reader.script)
+                continue;
+            if (candidate.region === reader.region)
+                return i;
+            first ??= i;
+        }
+        return first;
+    };
+    const readers = chain.map(subtags).filter(reader => reader !== undefined);
+    for (const reader of readers) {
+        const found = sameScript(reader);
+        if (found !== undefined)
+            return found;
+    }
+    for (const reader of readers) {
+        const found = offered.findIndex(candidate => candidate?.language === reader.language);
+        if (found >= 0)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * 渲染时按读者语言链在可用语言里选一种，返回下标：链里对得上的（{@link matchLanguage}），没有时找 en。
+ * 都没有时 undefined，由调用方用原文
+ */
+export function pickLanguage(chain, available) {
+    return matchLanguage(chain, available) ?? matchLanguage(['en'], available);
+}
+/** 该语言的自称（English、日本語 (日本)）；带扩展的标签这类 DisplayNames 不收的，用标签本身 */
+export function selfName(tag) {
+    try {
+        return new Intl.DisplayNames([tag], { type: 'language' }).of(tag) ?? tag;
+    }
+    catch {
+        return tag;
+    }
+}
+//# sourceMappingURL=locale.js.map

package/dist/frame/schema-i18n/locales/en.js

@@ -0,0 +1,3 @@
+import { defineLocale } from '../define.js';
+export default defineLocale()({ lines: '{items, lines}', clauses: '{head}; {tail}', listSeparator: ', ' });
+//# sourceMappingURL=en.js.map

package/dist/frame/schema-i18n/message.js

@@ -0,0 +1,249 @@
+// 消息格式（ICU 子集）的解析：文法见 README「消息格式」一节。解析失败不抛，返回 undefined，由调用方回落。
+const MAX_DEPTH = 16;
+const NAME = /[A-Za-z_][A-Za-z0-9_]*/y;
+const WORD = /[A-Za-z0-9_-]+/y;
+const PLURAL_SELECTOR = /=-?\d+(?:\.\d+)?|[a-z]+/y;
+const PLURAL_CATEGORIES = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
+const DATE_STYLES = new Set(['short', 'medium', 'long']);
+const POUND = { type: 'pound' };
+const FAILED = new Error('消息模板不合文法');
+function fail() {
+    throw FAILED;
+}
+class Reader {
+    src;
+    pos = 0;
+    constructor(src) {
+        this.src = src;
+    }
+    skipSpace() {
+        while (/[ \t\n\r]/.test(this.src[this.pos] ?? ''))
+            this.pos++;
+    }
+    eat(char) {
+        if (this.src[this.pos] !== char)
+            return false;
+        this.pos++;
+        return true;
+    }
+    expect(char) {
+        if (!this.eat(char))
+            fail();
+    }
+    match(pattern) {
+        pattern.lastIndex = this.pos;
+        const found = pattern.exec(this.src)?.[0];
+        if (found !== undefined)
+            this.pos += found.length;
+        return found;
+    }
+}
+/**
+ * 引号（ICU 的 DOUBLE_OPTIONAL，`#` 不分是否在 plural 分支里）：`''` 是一个撇号；`'` 紧跟 `{`、`}`、`#` 时引用到
+ * 下一个单独的 `'`，引用里的 `''` 仍是撇号，没闭合就到串尾；其余单个 `'` 是字面。读者停在 `'` 上，返回这一段的字面文字
+ */
+function readQuote(r) {
+    const next = r.src[r.pos + 1];
+    if (next === "'") {
+        r.pos += 2;
+        return "'";
+    }
+    r.pos++;
+    if (next !== '{' && next !== '}' && next !== '#')
+        return "'";
+    let text = '';
+    while (r.pos < r.src.length) {
+        if (r.src[r.pos] === "'") {
+            if (r.src[r.pos + 1] !== "'") {
+                r.pos++;
+                return text;
+            }
+            r.pos++;
+        }
+        text += r.src[r.pos++];
+    }
+    return text;
+}
+/** 消息体：顶层读到串尾，分支读到收尾的 }（不吃掉它）。`inPlural`：直接所在的是 plural 分支，# 是数 */
+function readMessage(r, depth, inPlural) {
+    if (depth > MAX_DEPTH)
+        fail();
+    const parts = [];
+    let text = '';
+    const flush = () => {
+        if (text)
+            parts.push(text);
+        text = '';
+    };
+    while (r.pos < r.src.length) {
+        const char = r.src[r.pos];
+        if (char === "'") {
+            text += readQuote(r);
+        }
+        else if (char === '{') {
+            flush();
+            parts.push(readArgument(r, depth));
+        }
+        else if (char === '}') {
+            if (depth === 0)
+                fail();
+            break;
+        }
+        else if (char === '#' && inPlural) {
+            flush();
+            parts.push(POUND);
+            r.pos++;
+        }
+        else {
+            text += char;
+            r.pos++;
+        }
+    }
+    if (depth > 0 && r.src[r.pos] !== '}')
+        fail();
+    flush();
+    return parts;
+}
+/** 读者停在 { 上，读完收尾的 } */
+function readArgument(r, depth) {
+    r.pos++;
+    r.skipSpace();
+    const name = r.match(NAME) ?? fail();
+    r.skipSpace();
+    if (r.eat('}'))
+        return { type: 'plain', name };
+    r.expect(',');
+    r.skipSpace();
+    const type = r.match(WORD);
+    r.skipSpace();
+    switch (type) {
+        case 'plural':
+        case 'select': {
+            r.expect(',');
+            const branches = new Map();
+            for (r.skipSpace(); !r.eat('}'); r.skipSpace()) {
+                const key = type === 'plural' ? pluralSelector(r) : (r.match(WORD) ?? fail());
+                if (branches.has(key))
+                    fail();
+                r.skipSpace();
+                r.expect('{');
+                branches.set(key, readMessage(r, depth + 1, type === 'plural'));
+                r.expect('}');
+            }
+            if (!branches.has('other'))
+                fail();
+            return { type, name, branches };
+        }
+        case 'number':
+        case 'lines':
+        case 'duration':
+        case 'size':
+        case 'code':
+            r.expect('}');
+            return { type, name };
+        case 'list': {
+            let listType = 'conjunction';
+            if (r.eat(',')) {
+                r.skipSpace();
+                if (r.match(WORD) !== 'or')
+                    fail();
+                listType = 'disjunction';
+                r.skipSpace();
+            }
+            r.expect('}');
+            return { type, name, listType };
+        }
+        case 'date':
+        case 'time':
+        case 'datetime': {
+            let style = 'medium';
+            if (r.eat(',')) {
+                r.skipSpace();
+                const word = r.match(WORD);
+                if (word === undefined || !DATE_STYLES.has(word))
+                    fail();
+                style = word;
+                r.skipSpace();
+            }
+            r.expect('}');
+            return { type, name, style };
+        }
+        default:
+            return fail();
+    }
+}
+/** plural 的选择子：`=N`（规范成 `=` 加数的字符串写法，好与值直接比）或 CLDR 类别 */
+function pluralSelector(r) {
+    const key = r.match(PLURAL_SELECTOR) ?? fail();
+    if (key.startsWith('='))
+        return `=${Number(key.slice(1))}`;
+    return PLURAL_CATEGORIES.has(key) ? key : fail();
+}
+const parsed = new Map();
+/** 解析消息模板，结果按模板缓存（模板只来自原文字典与语言包） */
+export function parseMessage(template) {
+    let message = parsed.get(template);
+    if (message === undefined) {
+        try {
+            message = readMessage(new Reader(template), 0, false);
+        }
+        catch {
+            message = null;
+        }
+        parsed.set(template, message);
+    }
+    return message ?? undefined;
+}
+// 参数收的值的种类，按位组合：同名参数取交集，译文的参数收得下原文交来的值才算兼容
+const STRING = 1;
+const NUMBER = 2;
+const TEXT = 4;
+const ARRAY = 8;
+const ACCEPTS = {
+    plain: STRING | NUMBER | TEXT,
+    select: STRING,
+    plural: NUMBER,
+    number: NUMBER,
+    date: NUMBER,
+    time: NUMBER,
+    datetime: NUMBER,
+    duration: NUMBER,
+    size: NUMBER,
+    list: ARRAY,
+    lines: ARRAY,
+    code: STRING | NUMBER,
+};
+function collectKinds(message, kinds) {
+    for (const part of message) {
+        if (typeof part === 'string' || part.type === 'pound')
+            continue;
+        kinds.set(part.name, (kinds.get(part.name) ?? ~0) & ACCEPTS[part.type]);
+        if (part.type === 'plural' || part.type === 'select') {
+            for (const branch of part.branches.values())
+                collectKinds(branch, kinds);
+        }
+    }
+}
+// 解析结果按模板缓存，种类跟着解析结果缓存
+const kindsCache = new WeakMap();
+/** 消息用到的参数与各自收的值（与类型层推参同一规则），按出现先后；同名参数的用法互不相容时为 0 */
+export function paramKinds(message) {
+    let kinds = kindsCache.get(message);
+    if (kinds === undefined) {
+        const collected = new Map();
+        collectKinds(message, collected);
+        kinds = collected;
+        kindsCache.set(message, kinds);
+    }
+    return kinds;
+}
+/** 译文与原文不兼容的参数：原文没有的、或原文交来的值译文收不下的 */
+export function incompatibleParams(source, translation) {
+    return [...paramKinds(translation)]
+        .filter(([name, accepts]) => {
+        const given = source.get(name);
+        return given === undefined || (given & ~accepts) !== 0;
+    })
+        .map(([name]) => name);
+}
+//# sourceMappingURL=message.js.map

package/dist/frame/schema-i18n/packs.js

@@ -0,0 +1,52 @@
+// 语言包：给字典补它没有的语言。条目带翻译时原文的指纹，原文改了措辞的条目当作缺失
+import { normalizeLanguages } from './locale.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/**
+ * 建语言包索引，同一语言按交来的先后取先（plugin-i18n 按贡献点的全局键交来，包的实例 id 在前）。语言包来自第三方：
+ * 形状不对或访问时抛错的包、语言标签不合法的包、形状不对的表与条目都跳过，不影响别的包；
+ * 取舍（只补缺、指纹、解析失败与参数不兼容）在解析时做
+ */
+export function indexPacks(packs) {
+    const index = new Map();
+    for (const pack of packs) {
+        for (const [ns, key, candidate] of readPack(pack)) {
+            const keys = index.get(ns) ?? new Map();
+            keys.set(key, [...(keys.get(key) ?? []), candidate]);
+            index.set(ns, keys);
+        }
+    }
+    return index;
+}
+/** 一个包里有效的条目；读包时抛错（第三方的 getter、Proxy）整包跳过 */
+function readPack(pack) {
+    const found = [];
+    try {
+        const [language] = normalizeLanguages([pack.language]);
+        const entries = pack.entries;
+        if (language === undefined || !isRecord(entries))
+            return [];
+        for (const [ns, table] of Object.entries(entries)) {
+            if (!isRecord(table))
+                continue;
+            for (const [key, entry] of Object.entries(table)) {
+                const { text, from } = (entry ?? {});
+                if (typeof text === 'string' && typeof from === 'string')
+                    found.push([ns, key, { language, text, from }]);
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return found;
+}
+/** 原文模板的指纹：FNV-1a 32 位，按 UTF-16 码元，写成 8 位十六进制 */
+export function fingerprint(template) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < template.length; i++) {
+        hash ^= template.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+//# sourceMappingURL=packs.js.map

package/dist/frame/schema-i18n/params.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=params.js.map

package/dist/frame/schema-i18n/resolve.js

@@ -0,0 +1,85 @@
+// 按读者语言链把一个文字对象渲染成字符串（纯函数，出口与前端共用）
+import { catalogEntry, entryText } from './catalog.js';
+import { escapeMarkdown, formatMessage } from './format.js';
+import { pickLanguage } from './locale.js';
+import { incompatibleParams, paramKinds, parseMessage } from './message.js';
+import { fingerprint } from './packs.js';
+import { SOURCE } from './source.js';
+/** 本包字典里罗列的分隔符那一键，同 texts.ts 的 t('listSeparator')（原文没有参数，source 就是原文） */
+const LIST_SEPARATOR = { i18n: '@aalis/schema-i18n', key: 'listSeparator', source: SOURCE.listSeparator };
+/**
+ * 一次渲染里参数中的文字对象最多渲染几个：再多的用那一个的 source。伪造的参数每层把下一层用两次，30 层就是 2^30 个，
+ * 环更是无穷，靠总量封顶
+ */
+const MAX_NESTED = 1024;
+/** 参数里的文字对象最多嵌套几层：再深的用那一层的 source，只防栈太深 */
+const MAX_DEPTH = 32;
+/**
+ * 按读者的语言链渲染文字对象。可用语言 = 原文语言 ∪ 字典自带译文的语言 ∪ 语言包补的语言（只补缺，原文指纹相符才算），
+ * 解析失败与参数和原文不兼容的译文不算。选法见 pickLanguage：读者链里文字相同的 → 语言相同、文字不同的 → en → 原文；
+ * 命中原文语言就用原文。ns 不在目录、键不存在、原文解析失败、渲染失败时用 `text.source`（转义模式下整句转义）。
+ * 参数里的文字对象用同一条链递归：一次渲染至多渲染 1024 个、嵌套 32 层，超出的用那一个的 source
+ */
+export function resolveText(text, chain, options = {}) {
+    return resolve(text, chain, options, 0, { left: MAX_NESTED });
+}
+/**
+ * 罗列（`{x, list}`）的分隔符：本包字典的 listSeparator 按 language 取，可用语言与选法同 {@link resolveText}（链里只有这一种
+ * 语言），字典与语言包都没有这种语言时回落到 en 的「, 」。`{x, list}` 按句子选中的语言取它；自己罗列的出口（如前端）同样用它
+ */
+export function listSeparator(language, packs) {
+    return resolveText(LIST_SEPARATOR, [language], { packs });
+}
+/**
+ * 只按原文语言渲染文字对象：出口在 i18n 服务缺席时用（日志与交给模型的用 toSource）。参数里的文字对象同样取各自的原文，
+ * 回落规则同 {@link resolveText}
+ */
+export function resolveSource(text, options = {}) {
+    return resolve(text, undefined, options, 0, { left: MAX_NESTED });
+}
+/** chain 为 undefined 时只取原文；budget 是这次顶层渲染里参数中的文字对象还能渲染几个 */
+function resolve(text, chain, options, depth, budget) {
+    const fallback = () => (options.escape === 'markdown' ? escapeMarkdown(text.source) : text.source);
+    const within = depth === 0 || (depth <= MAX_DEPTH && budget.left-- > 0);
+    const entry = within ? catalogEntry(text.i18n) : undefined;
+    const template = entry && entryText(entry.source, text.key);
+    const source = template === undefined ? undefined : parseMessage(template);
+    if (entry === undefined || template === undefined || source === undefined)
+        return fallback();
+    const languages = [entry.language];
+    const messages = [source];
+    if (chain !== undefined) {
+        const expected = paramKinds(source);
+        const offer = (language, translation) => {
+            const message = parseMessage(translation);
+            if (message === undefined || incompatibleParams(expected, message).length > 0)
+                return;
+            languages.push(language);
+            messages.push(message);
+        };
+        for (const [language, table] of Object.entries(entry.locales)) {
+            const translation = entryText(table, text.key);
+            if (translation !== undefined)
+                offer(language, translation);
+        }
+        const packed = options.packs?.get(text.i18n)?.get(text.key);
+        if (packed) {
+            const from = fingerprint(template);
+            for (const candidate of packed) {
+                if (candidate.from !== from || languages.includes(candidate.language))
+                    continue;
+                offer(candidate.language, candidate.text);
+            }
+        }
+    }
+    const chosen = chain === undefined ? 0 : (pickLanguage(chain, languages) ?? 0);
+    const rendered = formatMessage(messages[chosen], text.params ?? {}, {
+        language: languages[chosen],
+        timeZone: options.timeZone,
+        escape: options.escape,
+        nested: nested => resolve(nested, chain, options, depth + 1, budget),
+        listSeparator: () => listSeparator(languages[chosen], options.packs),
+    });
+    return rendered ?? fallback();
+}
+//# sourceMappingURL=resolve.js.map

package/dist/frame/schema-i18n/source.js

@@ -0,0 +1,4 @@
+// 本包自己的原文表，没有依赖：texts.ts 用它登记字典，resolve.ts 用它取罗列的分隔符（从 texts.ts 取会成
+// define → resolve → texts → define 的环）
+export const SOURCE = { lines: '{items, lines}', clauses: '{head}；{tail}', listSeparator: '、' };
+//# sourceMappingURL=source.js.map