@aalis/api-webui 0.12.0 → 0.13.0

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

package/dist/frame/schema-i18n/text-ref.js

@@ -0,0 +1,94 @@
+const TEXT_REF_KEYS = new Set(['i18n', 'key', 'params', 'source']);
+/**
+ * 是不是文字对象：只按形状判（i18n、key、source 是字符串，params 缺省或为普通对象，没有别的键），
+ * 从 JSON 读回的、另一份本包产出的都认
+ */
+export function isTextRef(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const v = value;
+    if (typeof v.i18n !== 'string' || typeof v.key !== 'string' || typeof v.source !== 'string')
+        return false;
+    if (v.params !== undefined && (typeof v.params !== 'object' || v.params === null || Array.isArray(v.params))) {
+        return false;
+    }
+    return Object.keys(v).every(key => TEXT_REF_KEYS.has(key));
+}
+/** 展示值（core 的插件显示名、服务 label 这类 unknown 字段）收窄成文字：字符串与文字对象原样，其余 undefined */
+export function asText(value) {
+    return typeof value === 'string' || isTextRef(value) ? value : undefined;
+}
+/**
+ * 两段文字是不是同一句：有一方是字符串时按原文比；文字对象之间按所属包、键与参数认，原文的措辞
+ * 变了也还是同一句。参数按结构比：参数键的先后不算，参数里的文字对象同样按包、键与参数认，数组逐个按位置比，
+ * 别的值（落盘读回的 null 一类）按 === 比
+ */
+export function sameText(a, b) {
+    if (typeof a === 'string' || typeof b === 'string')
+        return toSource(a) === toSource(b);
+    if (a.i18n !== b.i18n || a.key !== b.key)
+        return false;
+    const left = a.params ?? {};
+    const right = b.params ?? {};
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every(key => Object.hasOwn(right, key) && sameParam(left[key], right[key])));
+}
+const isList = (value) => Array.isArray(value);
+function sameParam(a, b) {
+    if (isList(a) || isList(b)) {
+        return isList(a) && isList(b) && a.length === b.length && a.every((item, i) => sameParam(item, b[i]));
+    }
+    return isTextRef(a) && isTextRef(b) ? sameText(a, b) : a === b;
+}
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * 把值里的文字对象换成 `render(text)`。只进普通对象与数组（类实例原样），没有文字对象的子树原样返回、不复制，
+ * 有改动时只复制通往文字对象的那一路。`skip(key, parent)` 为真的属性不进：出口用它避开原样数据
+ * （工具参数与结果、审批的逐字参数、用户消息正文），那里形如文字对象的值可能是伪造的。
+ */
+export function localize(value, render, skip) {
+    const walk = (v) => {
+        if (typeof v !== 'object' || v === null)
+            return v;
+        if (isTextRef(v))
+            return render(v);
+        if (Array.isArray(v)) {
+            let out;
+            v.forEach((item, i) => {
+                const next = walk(item);
+                if (Object.is(next, item))
+                    return;
+                out ??= [...v];
+                out[i] = next;
+            });
+            return out ?? v;
+        }
+        if (!isPlainObject(v))
+            return v;
+        let out;
+        for (const [key, item] of Object.entries(v)) {
+            if (skip?.(key, v))
+                continue;
+            const next = walk(item);
+            if (Object.is(next, item))
+                continue;
+            out ??= { ...v };
+            out[key] = next;
+        }
+        return out ?? v;
+    };
+    return walk(value);
+}
+/** 值里的文字对象换成 source（生成时的整句）：写日志、交给模型时用 */
+export function toSource(value) {
+    return localize(value, text => text.source);
+}
+/** 给 `JSON.stringify` 的 replacer：文字对象写成 source */
+export function toSourceReplacer(_key, value) {
+    return isTextRef(value) ? value.source : value;
+}
+//# sourceMappingURL=text-ref.js.map

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

@@ -0,0 +1,29 @@
+// 本包自己的原文字典（原文表在 source.ts）
+import { defineTexts } from './define.js';
+import en from './locales/en.js';
+import { SOURCE } from './source.js';
+const t = defineTexts({ ns: '@aalis/schema-i18n', language: 'zh-CN', source: SOURCE, locales: { en } });
+/** 把若干段（字符串或文字对象）按行连成一个文字对象：多行报告、列表类回复用它，每段按读者语言各自渲染 */
+export function textLines(parts) {
+    return t('lines', { items: parts });
+}
+/**
+ * textLines 的逆：是 textLines 生成的文字对象（落盘读回的同样认）就给出各段，否则 undefined。要逐行加工（缩进、加前缀）
+ * 又不能先渲染的一方用它；段本身可能是多行的字符串或别的文字对象
+ */
+export function linesOf(text) {
+    const items = text.i18n === t.ns && text.key === 'lines' ? text.params?.items : undefined;
+    return Array.isArray(items) ? items : undefined;
+}
+/**
+ * 把若干分句（字符串或文字对象）连成一句：原文以「；」相连，英文以「; 」。并列的几条原因、几个问题用它。两两二分着嵌套，
+ * 层数随句数按对数增长；n 句约占 2n 个参数里的文字对象，每句另带文字对象参数时更多（见 resolveText 的渲染上限）
+ */
+export function textClauses(parts) {
+    if (parts.length < 2)
+        return textLines(parts);
+    const half = Math.ceil(parts.length / 2);
+    const side = (slice) => (slice.length === 1 ? slice[0] : textClauses(slice));
+    return t('clauses', { head: side(parts.slice(0, half)), tail: side(parts.slice(half)) });
+}
+//# sourceMappingURL=texts.js.map