waybetter 0.1.1 → 0.7.0

package/dist/runtime/stringPacks.js

@@ -0,0 +1,610 @@
+// String packs: data-only packs that replace the wrapped site's own UI strings (published as
+// `waybetter/runtime/stringPacks`). A pack adds a language the site does not offer, fixes its
+// translation or rewords it. This file is the data side: the pack and inventory formats, the
+// validator, the ordered application engine, coverage and the drift report. It touches no DOM and
+// runs the same in the page, in the shell and in Node (`waybetter strings check`).
+//
+// The rules (they are the owner's, and every function here keeps them):
+// - Idempotent. The result is a pure function of (the site's own values, the ordered pack list):
+//   applying twice equals applying once, and a later pack wins over an earlier one per key.
+// - The site's own language is the fallback. A key no pack changes keeps exactly the site's value
+//   (the same object, not a copy).
+// - An inventory of the site's known keys. A pack may change only inventory keys, and only keys
+//   whose kind can be replaced by data; unknown keys are reported, never applied.
+// - Packs are data: plain text in an ICU MessageFormat subset ({param}, plural, select). Never
+//   HTML, never code. A message is interpreted by closures here; nothing is evaluated.
+//
+// One site can have several catalogs (each with its own key space, inventory and hook adapter,
+// see stringPackHook.ts); a pack names the one it is for.
+import { parseMessage } from "./i18n.js";
+export const STRING_PACK_LIMITS = Object.freeze({ strings: 40000, value: 2000, name: 80, authors: 16 });
+export const MAIN_GROUP = 'main';
+const TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
+const IDENT = /^[a-z][a-z0-9-]{0,31}$/;
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f‪-‮⁦-⁩]/;
+const REWRITE_FROM = /^[\p{L}\p{N}]{1,40}$/u;
+const REWRITE_TO = /^[\p{L}\p{N}][\p{L}\p{N}'’-]{0,39}$/u;
+const MAX_REWRITES = 64;
+const CATEGORIES = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
+/** Whether a pack can replace a value of this kind (a `rich` one only with known `slots`: pass the shape). */
+export function translatable(kind) {
+    const { kind: k, slots } = typeof kind === 'string' ? { kind, slots: undefined } : kind;
+    return k === 'text' || k === 'message' || (k === 'rich' && slots !== undefined);
+}
+/** Whether `language` (the site's) satisfies a pack's `when`. */
+export function conditionHolds(when, language) {
+    if (!when?.languages)
+        return true;
+    if (!language)
+        return false;
+    const have = language.toLowerCase();
+    return when.languages.some(tag => { const want = tag.toLowerCase(); return have === want || have.startsWith(`${want}-`); });
+}
+/** 53-bit hash of a text as 11 base-36 characters. Same result in every runtime. */
+export function hashText(text) {
+    let h1 = 0xdeadbeef;
+    let h2 = 0x41c6ce57;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36).padStart(11, '0');
+}
+function compact(site, catalog, shapes) {
+    const text = [];
+    const closed = [];
+    const message = {};
+    const rich = {};
+    for (const [id, entry] of shapes) {
+        if (entry.kind === 'rich' && entry.slots !== undefined && !entry.tags?.length)
+            rich[id] = entry.slots;
+        else if (entry.kind === 'text' && !entry.tags?.length)
+            text.push(id);
+        else if (entry.kind === 'message' && !entry.tags?.length) {
+            message[id] = (entry.params ?? []).map(name => `${name}${entry.plural?.includes(name) ? '*' : ''}${entry.select?.includes(name) ? '?' : ''}`).join(' ');
+        }
+        else
+            closed.push(id);
+    }
+    return { site, catalog, text: text.join(' '), message, closed: closed.join(' '), ...(Object.keys(rich).length ? { rich } : {}) };
+}
+export function packInventory(inventory) {
+    return compact(inventory.site, inventory.catalog, Object.entries(inventory.entries));
+}
+/**
+ * The part of an inventory that the given keys need: what travels to a page together with the
+ * packs it should apply (a page never needs the rest). Keys the inventory does not have are left
+ * out, so they stay unknown there too.
+ */
+export function sliceInventory(inventory, ids) {
+    const lookup = inventoryLookup(inventory);
+    const shapes = [];
+    for (const id of new Set(ids)) {
+        const shape = lookup(id);
+        if (shape)
+            shapes.push([id, shape]);
+    }
+    return { ...compact(inventory.site, inventory.catalog, shapes), partial: true };
+}
+/** Whether untrusted data has the shape of a page inventory (ids and parameter names only). */
+export function isPageInventory(input) {
+    if (!isRecord(input))
+        return false;
+    const ids = (value) => typeof value === 'string' && value.length <= 2_000_000 && /^[\w$. -]*$/.test(value);
+    return typeof input.site === 'string' && IDENT.test(input.site) && typeof input.catalog === 'string' && IDENT.test(input.catalog)
+        && ids(input.text) && ids(input.closed) && isRecord(input.message)
+        && Object.entries(input.message).every(([id, names]) => /^[\w$.-]+$/.test(id) && typeof names === 'string' && /^[\w$*? ]*$/.test(names))
+        && (input.rich === undefined || (isRecord(input.rich) && Object.entries(input.rich).every(([id, n]) => /^[\w$.-]+$/.test(id) && Number.isInteger(n) && n >= 0 && n <= 32)))
+        && (input.partial === undefined || typeof input.partial === 'boolean');
+}
+const TEXT_SHAPE = Object.freeze({ kind: 'text' });
+const CLOSED_SHAPE = Object.freeze({ kind: 'rich' });
+/** A lookup over either form. The page form is decoded on first use. */
+export function inventoryLookup(inventory) {
+    if ('entries' in inventory) {
+        const entries = inventory.entries;
+        return id => (Object.prototype.hasOwnProperty.call(entries, id) ? entries[id] : undefined);
+    }
+    let table = null;
+    const decode = () => {
+        const map = new Map();
+        if (inventory.text)
+            for (const id of inventory.text.split(' '))
+                map.set(id, TEXT_SHAPE);
+        if (inventory.closed)
+            for (const id of inventory.closed.split(' '))
+                map.set(id, CLOSED_SHAPE);
+        if (inventory.rich)
+            for (const [id, slots] of Object.entries(inventory.rich))
+                map.set(id, { kind: 'rich', slots });
+        for (const [id, spec] of Object.entries(inventory.message)) {
+            const names = spec ? spec.split(' ') : [];
+            map.set(id, {
+                kind: 'message',
+                params: names.map(name => name.replace(/[*?]+$/, '')),
+                plural: names.filter(name => name.includes('*')).map(name => name.replace(/[*?]+$/, '')),
+                select: names.filter(name => name.includes('?')).map(name => name.replace(/[*?]+$/, '')),
+            });
+        }
+        return map;
+    };
+    return id => (table ??= decode()).get(id);
+}
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Checks the document envelope. Errors mean the pack is not applied at all. */
+export function checkPackShape(input) {
+    const issues = [];
+    const error = (message) => { issues.push({ level: 'error', message }); };
+    if (!isRecord(input))
+        return [{ level: 'error', message: 'a string pack is a JSON object' }];
+    if (input.format !== 1)
+        error('"format" must be 1');
+    for (const field of ['site', 'catalog']) {
+        if (typeof input[field] !== 'string' || !IDENT.test(input[field]))
+            error(`"${field}" must be a short lowercase id`);
+    }
+    if (typeof input.language !== 'string' || !TAG.test(input.language))
+        error('"language" must be a language tag (en, pt-BR, en-x-pirate)');
+    if (input.base !== undefined && (typeof input.base !== 'string' || !TAG.test(input.base)))
+        error('"base" must be a language tag');
+    if (typeof input.name !== 'string' || !input.name.trim() || input.name.length > STRING_PACK_LIMITS.name || CONTROL.test(input.name) || /[<>]/.test(input.name)) {
+        error(`"name" must be 1 to ${STRING_PACK_LIMITS.name} characters of plain text`);
+    }
+    if (!Array.isArray(input.authors) || input.authors.length > STRING_PACK_LIMITS.authors
+        || input.authors.some(author => typeof author !== 'string' || !author.trim() || author.length > STRING_PACK_LIMITS.name || CONTROL.test(author) || /[<>]/.test(author))) {
+        error(`"authors" must be a list of at most ${STRING_PACK_LIMITS.authors} plain-text names`);
+    }
+    if (input.when !== undefined) {
+        const when = input.when;
+        if (!isRecord(when) || Object.keys(when).some(key => key !== 'languages'))
+            error('"when" is an object with "languages"');
+        else if (when.languages !== undefined && (!Array.isArray(when.languages) || !when.languages.length || when.languages.length > 16
+            || when.languages.some(tag => typeof tag !== 'string' || !TAG.test(tag))))
+            error('"when.languages" must be a list of 1 to 16 language tags');
+    }
+    if (input.rewrite !== undefined) {
+        const rewrite = input.rewrite;
+        const words = isRecord(rewrite) ? rewrite.words : undefined;
+        if (!isRecord(rewrite) || Object.keys(rewrite).some(key => key !== 'words') || !isRecord(words) || !Object.keys(words).length || Object.keys(words).length > MAX_REWRITES
+            || Object.entries(words).some(([from, to]) => !REWRITE_FROM.test(from) || typeof to !== 'string' || !REWRITE_TO.test(to))) {
+            error(`"rewrite" is { "words": { "Word": "Replacement" } } with 1 to ${MAX_REWRITES} plain words`);
+        }
+    }
+    for (const field of ['version', 'description']) {
+        const value = input[field];
+        if (value !== undefined && (typeof value !== 'string' || value.length > 400 || CONTROL.test(value) || /[<>]/.test(value)))
+            error(`"${field}" must be plain text`);
+    }
+    if (!isRecord(input.strings))
+        error('"strings" must be an object of key id -> text');
+    else if (Object.keys(input.strings).length > STRING_PACK_LIMITS.strings)
+        error(`"strings" has more than ${STRING_PACK_LIMITS.strings} entries`);
+    const known = new Set(['$schema', 'format', 'site', 'catalog', 'language', 'base', 'when', 'rewrite', 'name', 'authors', 'version', 'description', 'strings']);
+    for (const key of Object.keys(input))
+        if (!known.has(key))
+            issues.push({ level: 'warning', message: `unknown field "${key}" is ignored` });
+    return issues;
+}
+const TAG_TOKEN = /<\/?([A-Za-z][A-Za-z0-9-]*)>/g;
+/** Tag rule: only the original's tag slots, each opened and closed; any other `<` or `>` is refused. */
+function checkTags(value, tags) {
+    if (!value.includes('<') && !value.includes('>')) {
+        return tags.length ? `the original's tags are missing: ${tags.map(tag => `<${tag}>`).join(' ')}` : null;
+    }
+    if (!tags.length)
+        return 'markup is not allowed: a pack is text, < and > cannot be used';
+    const open = [];
+    const seen = new Set();
+    for (const match of value.matchAll(TAG_TOKEN)) {
+        const name = match[1];
+        if (!tags.includes(name))
+            return `<${name}> is not a tag of the original`;
+        if (match[0].startsWith('</')) {
+            if (open.pop() !== name)
+                return `</${name}> does not close an open tag`;
+        }
+        else {
+            open.push(name);
+            seen.add(name);
+        }
+    }
+    if (open.length)
+        return `<${open[open.length - 1]}> is not closed`;
+    if (/[<>]/.test(value.replace(TAG_TOKEN, '')))
+        return '< and > may only be used for the original\'s tags';
+    const missing = tags.filter(tag => !seen.has(tag));
+    return missing.length ? `the original's tags are missing: ${missing.map(tag => `<${tag}>`).join(' ')}` : null;
+}
+/** Walks a parsed message against the key's shape; returns the first problem. */
+function checkParts(parts, shape) {
+    const params = shape.params ?? [];
+    for (const part of parts) {
+        if (typeof part === 'string' || part.kind === 'pound')
+            continue;
+        if (!params.includes(part.name)) {
+            return params.length ? `{${part.name}} is not a parameter of the original (it has: ${params.join(', ')})` : `{${part.name}}: the original takes no parameters`;
+        }
+        if (part.kind === 'arg') {
+            if (part.format)
+                return `{${part.name}, ${part.format}} is not supported: only {name}, plural and select`;
+            continue;
+        }
+        if (part.kind === 'plural') {
+            if (part.ordinal)
+                return `{${part.name}, selectordinal} is not supported: only {name}, plural and select`;
+            if (part.offset)
+                return `{${part.name}, plural, offset:…} is not supported`;
+            if (!shape.plural?.includes(part.name))
+                return `{${part.name}} is not a plural of the original`;
+            for (const selector of Object.keys(part.options)) {
+                if (!CATEGORIES.has(selector) && !/^=\d+$/.test(selector))
+                    return `"${selector}" is not a plural form (zero, one, two, few, many, other, =N)`;
+            }
+        }
+        else if (!shape.select?.includes(part.name)) {
+            return `{${part.name}} is not a select of the original`;
+        }
+        for (const option of Object.values(part.options)) {
+            const nested = checkParts(option, shape);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+/**
+ * Validates one pack value against the key's inventory entry. Returns the parsed message, or the
+ * reason it is refused (the original then stays).
+ */
+export function validateString(shape, value) {
+    if (!translatable(shape))
+        return { reason: `not translatable yet (${shape.kind})` };
+    if (typeof value !== 'string')
+        return { reason: 'the value must be text' };
+    if (!value)
+        return { reason: 'the value is empty' };
+    if (value.length > STRING_PACK_LIMITS.value)
+        return { reason: `longer than ${STRING_PACK_LIMITS.value} characters` };
+    if (CONTROL.test(value))
+        return { reason: 'control or bidi-override characters are not allowed' };
+    const tags = checkTags(value, shape.tags ?? []);
+    if (tags)
+        return { reason: tags };
+    let parts;
+    try {
+        parts = parseMessage(value);
+    }
+    catch (error) {
+        return { reason: `invalid message syntax: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (shape.kind === 'rich') {
+        // Element slots: `{e0}` … `{e<slots-1>}`, each exactly once (the last may be left out); no plural, select or other parameter.
+        const slots = Array.from({ length: shape.slots ?? 0 }, (_, index) => `e${index}`);
+        const bad = checkParts(parts, { kind: 'message', params: slots });
+        if (bad)
+            return { reason: bad };
+        const used = parts.flatMap(part => (typeof part !== 'string' && part.kind === 'arg' ? [part.name] : []));
+        for (const name of slots) {
+            const count = used.filter(item => item === name).length;
+            // The element after the last piece is not always there: that one slot may be left out.
+            if (count === 0 && name === slots[slots.length - 1] && slots.length > 0)
+                continue;
+            if (count !== 1)
+                return { reason: count ? `{${name}} (the original's element) must appear once, not ${count} times` : `the original's element {${name}} is missing` };
+        }
+        return { parts };
+    }
+    const problem = checkParts(parts, shape.kind === 'message' ? shape : { kind: 'text' });
+    return problem ? { reason: problem } : { parts };
+}
+/** A message without arguments as its literal text (quotes resolved). */
+function literal(parts) {
+    return parts.map(part => (typeof part === 'string' ? part : '')).join('');
+}
+/** The word-for-word rewriting of a validated `rewrite` rule. */
+function compileRewrite(rule) {
+    const words = new Map(Object.entries(rule.words));
+    // Words are letters and digits only (checked), so they need no escaping.
+    const alternatives = [...words.keys()].sort((a, b) => b.length - a.length).join('|');
+    const pattern = new RegExp(String.raw `(?<![\p{L}\p{N}_])(?:${alternatives})(?![\p{L}\p{N}_])`, 'gu');
+    return text => text.replace(pattern, word => words.get(word) ?? word);
+}
+/** A validated rich value as pieces and element order. */
+function richTemplate(parts) {
+    const pieces = [];
+    const order = [];
+    let current = '';
+    for (const part of parts) {
+        if (typeof part === 'string')
+            current += part;
+        else if (part.kind === 'arg') {
+            pieces.push(current);
+            order.push(Number(part.name.slice(1)));
+            current = '';
+        }
+    }
+    pieces.push(current);
+    return Object.freeze({ pieces: Object.freeze(pieces), order: Object.freeze(order) });
+}
+/**
+ * Validates a pack against an inventory. Throws on a malformed envelope or a pack for another
+ * site/catalog; every other problem is per key and lands in `report`.
+ */
+export function compilePack(input, inventory) {
+    const shapeErrors = checkPackShape(input).filter(issue => issue.level === 'error');
+    if (shapeErrors.length)
+        throw new Error(`invalid string pack: ${shapeErrors.map(issue => issue.message).join('; ')}`);
+    const pack = input;
+    if (pack.site !== inventory.site || pack.catalog !== inventory.catalog) {
+        throw new Error(`the pack is for ${pack.site}/${pack.catalog}, the inventory is ${inventory.site}/${inventory.catalog}`);
+    }
+    const lookup = inventoryLookup(inventory);
+    const values = new Map();
+    const report = { total: 0, valid: 0, unknown: [], rejected: [] };
+    for (const [id, value] of Object.entries(pack.strings)) {
+        report.total += 1;
+        const shape = lookup(id);
+        if (!shape) {
+            report.unknown.push(id);
+            continue;
+        }
+        const result = validateString(shape, value);
+        if ('reason' in result) {
+            report.rejected.push({ id, reason: result.reason });
+            continue;
+        }
+        values.set(id, shape.kind === 'text' ? { text: literal(result.parts) } : shape.kind === 'rich' ? { rich: richTemplate(result.parts) } : { parts: result.parts });
+        report.valid += 1;
+    }
+    return { name: pack.name, language: pack.language, base: pack.base, when: pack.when, rewrite: pack.rewrite ? compileRewrite(pack.rewrite) : undefined, site: pack.site, catalog: pack.catalog, values, report };
+}
+// -------------------------------------------------------------------------------------------
+// Interpreting a message (closures over the parsed parts; nothing is evaluated)
+const rulesCache = new Map();
+/** Plural rules of the first language the runtime knows; `null` = every number is `other`. */
+function rulesFor(languages) {
+    const key = languages.join('|');
+    let rules = rulesCache.get(key);
+    if (rules !== undefined)
+        return rules;
+    rules = null;
+    for (const language of languages) {
+        if (!language)
+            continue;
+        const tag = language.split(/-x-/i)[0];
+        try {
+            if (Intl.PluralRules.supportedLocalesOf([tag]).length) {
+                rules = new Intl.PluralRules(tag);
+                break;
+            }
+        }
+        catch {
+            // Not a tag this runtime accepts: try the next.
+        }
+    }
+    rulesCache.set(key, rules);
+    return rules;
+}
+/**
+ * Renders a validated message. A parameter is inserted the way string concatenation would
+ * (`String(value)`, nothing for a missing one); `#` is the plural's own value.
+ */
+export function renderMessage(parts, params, languages, pound = undefined) {
+    let out = '';
+    for (const part of parts) {
+        if (typeof part === 'string') {
+            out += part;
+            continue;
+        }
+        // The parser only yields `#` inside a plural, so there is always a value it stands for.
+        if (part.kind === 'pound') {
+            out += pound === undefined || pound === null ? '' : String(pound);
+            continue;
+        }
+        const value = params[part.name];
+        if (part.kind === 'arg') {
+            out += value === undefined || value === null ? '' : String(value);
+            continue;
+        }
+        if (part.kind === 'select') {
+            out += renderMessage(part.options[String(value)] ?? part.options.other, params, languages, pound);
+            continue;
+        }
+        const n = typeof value === 'number' ? value : Number(value);
+        const option = Number.isFinite(n)
+            ? part.options[`=${n}`] ?? part.options[rulesFor(languages)?.select(n) ?? 'other'] ?? part.options.other
+            : part.options.other;
+        out += renderMessage(option, params, languages, value);
+    }
+    return out;
+}
+/** The site's (or a pack's) value of one key with `rewrite` applied; a message keeps its parameters' values as they are. */
+function rewriteValue(shape, value, rewrite) {
+    if (typeof value === 'string')
+        return rewrite(value);
+    if (Array.isArray(value)) {
+        const mapped = value.map(piece => (typeof piece === 'string' ? rewrite(piece) : piece));
+        return mapped.some((piece, index) => piece !== value[index]) ? mapped : value;
+    }
+    if (typeof value === 'function') {
+        const message = value;
+        const plural = new Set(shape.plural ?? []);
+        return function (params) {
+            const input = isRecord(params) ? params : {};
+            // The parameters go through as private markers, so only the site's own words are reworded.
+            const forward = { ...input };
+            const held = [];
+            for (const name of shape.params ?? []) {
+                if (plural.has(name) || !(name in input))
+                    continue;
+                const marker = `\uE000${held.length}\uE001`;
+                held.push([marker, input[name]]);
+                forward[name] = marker;
+            }
+            try {
+                const out = message.call(this, forward);
+                if (typeof out !== 'string')
+                    return message.call(this, params);
+                let text = rewrite(out);
+                for (const [marker, original] of held)
+                    text = text.split(marker).join(String(original));
+                return text;
+            }
+            catch {
+                return message.call(this, params);
+            }
+        };
+    }
+    if (typeof value === 'object' && value !== null && 'pieces' in value) {
+        const template = value;
+        return Object.freeze({ pieces: Object.freeze(template.pieces.map(rewrite)), order: template.order });
+    }
+    return value;
+}
+const MAX_LISTED = 200;
+/** `packs` in application order: a later pack wins over an earlier one for the same key. */
+export function createStringEngine(inventory, packs) {
+    const lookup = typeof inventory === 'function' ? inventory : inventoryLookup(inventory);
+    // A slice only knows the packs' keys: what it lacks is not a new key of the site.
+    const whole = typeof inventory === 'function' || !('partial' in inventory && inventory.partial);
+    const originals = new Map();
+    const applied = new Map();
+    const produced = new WeakMap();
+    const seen = new Set();
+    const unlisted = new Set();
+    const mismatched = new Set();
+    let siteLanguage;
+    const winner = (id) => {
+        for (let index = packs.length - 1; index >= 0; index -= 1) {
+            if (!conditionHolds(packs[index].when, siteLanguage))
+                continue;
+            const value = packs[index].values.get(id);
+            if (value)
+                return { pack: packs[index], value, index };
+        }
+        return null;
+    };
+    const resolve = (id, incoming) => {
+        let original = incoming;
+        // A value of ours coming back in (a second application): work from the site's own value again.
+        if ((typeof incoming === 'function' || (typeof incoming === 'object' && incoming !== null)) && produced.has(incoming))
+            original = produced.get(incoming);
+        else if (typeof incoming === 'string' && applied.has(id) && applied.get(id) === incoming)
+            original = originals.get(id);
+        seen.add(id);
+        const found = winner(id);
+        // Word rewriting of the packs after the one whose text won (all of them when none did).
+        const rewrites = packs.flatMap((pack, index) => (index > (found?.index ?? -1) && pack.rewrite && conditionHolds(pack.when, siteLanguage) ? [pack.rewrite] : []));
+        if (!found && !rewrites.length) {
+            if (whole && unlisted.size < MAX_LISTED && !lookup(id))
+                unlisted.add(id);
+            return original;
+        }
+        const shape = lookup(id);
+        if (!shape || shape.kind === 'format' || (found && !translatable(shape)))
+            return original;
+        if (shape.kind === 'text' ? typeof original !== 'string' : shape.kind === 'rich' ? !Array.isArray(original) : typeof original !== 'function') {
+            if (mismatched.size < MAX_LISTED)
+                mismatched.add(id);
+            return original;
+        }
+        if (originals.has(id) && originals.get(id) === original)
+            return applied.get(id);
+        let next = original;
+        if (found) {
+            if ('text' in found.value) {
+                next = found.value.text;
+            }
+            else if ('rich' in found.value) {
+                next = found.value.rich;
+            }
+            else {
+                const parts = found.value.parts;
+                const languages = [found.pack.language, found.pack.base];
+                next = (params) => renderMessage(parts, isRecord(params) ? params : {}, languages);
+            }
+        }
+        for (const rewrite of rewrites)
+            next = rewriteValue(shape, next, rewrite);
+        if (next === original)
+            return original;
+        if (typeof next === 'function' || typeof next === 'object')
+            produced.set(next, original);
+        originals.set(id, original);
+        applied.set(id, next);
+        return next;
+    };
+    return {
+        resolve,
+        setLanguage(language) { siteLanguage = language; },
+        originals: () => originals,
+        stats: () => ({ seen: seen.size, applied: applied.size, unlisted: [...unlisted], mismatched: [...mismatched] }),
+    };
+}
+/**
+ * The whole catalog at once: a new object with the packs applied; `catalog` itself is not
+ * changed. `applyPacks(applyPacks(c, …), …)` with one engine equals `applyPacks(c, …)`.
+ */
+export function applyPacks(catalog, engine) {
+    const out = {};
+    for (const id of Object.keys(catalog))
+        out[id] = engine.resolve(id, catalog[id]);
+    return out;
+}
+/** The inverse: every value a pack changed is the site's own again; `catalog` is not changed. */
+export function restoreCatalog(catalog, engine) {
+    const originals = engine.originals();
+    const out = {};
+    for (const id of Object.keys(catalog))
+        out[id] = originals.has(id) ? originals.get(id) : catalog[id];
+    return out;
+}
+/** Coverage of a compiled pack per group of the inventory, plus `all`. */
+export function coverage(inventory, pack) {
+    const out = { all: { translatable: 0, translated: 0, closed: 0 } };
+    for (const [id, entry] of Object.entries(inventory.entries)) {
+        const group = (out[entry.group ?? MAIN_GROUP] ??= { translatable: 0, translated: 0, closed: 0 });
+        for (const bucket of [group, out.all]) {
+            if (!translatable(entry)) {
+                bucket.closed += 1;
+                continue;
+            }
+            bucket.translatable += 1;
+            if (pack.values.has(id))
+                bucket.translated += 1;
+        }
+    }
+    return out;
+}
+const sameList = (a = [], b = []) => a.length === b.length && [...a].sort().join('\n') === [...b].sort().join('\n');
+/**
+ * Compares an inventory with what was observed now. `loaded` names the groups whose base catalog
+ * was actually read: a key can only be called vanished when its group was (a lazily loaded group
+ * that never arrived says nothing about its keys).
+ */
+export function driftReport(inventory, observed, loaded) {
+    const report = { added: [], reworded: [], reshaped: [], vanished: [] };
+    for (const [id, now] of Object.entries(observed)) {
+        const before = Object.prototype.hasOwnProperty.call(inventory.entries, id) ? inventory.entries[id] : undefined;
+        if (!before) {
+            report.added.push(id);
+            continue;
+        }
+        if (before.kind !== now.kind || before.slots !== now.slots || !sameList(before.params, now.params) || !sameList(before.plural, now.plural) || !sameList(before.select, now.select) || !sameList(before.tags, now.tags)) {
+            report.reshaped.push(id);
+        }
+        else if (before.hash !== now.hash) {
+            report.reworded.push(id);
+        }
+    }
+    const groups = new Set(loaded);
+    for (const [id, entry] of Object.entries(inventory.entries)) {
+        if (!Object.prototype.hasOwnProperty.call(observed, id) && groups.has(entry.group ?? MAIN_GROUP))
+            report.vanished.push(id);
+    }
+    return report;
+}
+//# sourceMappingURL=stringPacks.js.map