claude-translator 1.3.0 → 2.0.0

package/scripts/build-locales.mjs

@@ -28,10 +28,14 @@ import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, rmSync
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
-import { BUILD_DIR as DIST, SEG_DIR, TM_DIR, BASE_URL as BASE, LOCALES as LANG_ROWS, BY_PATH, RTL, getPages } from './config.mjs';
+import {
+  BUILD_DIR as DIST, SEG_DIR, TM_DIR, BASE_URL as BASE, LOCALES as LANG_ROWS,
+  BY_PATH, RTL, getPages, ROOT_DIR, I18N_DIR, LOCALE_FORMAT,
+} from './config.mjs';
+import { formatText, intlLocale } from './format-locale.mjs';
 import { applyPageMarkers, applyVisibleLink, markerBytes } from './credit.mjs';
 
-const ROOT = process.cwd();
+const ROOT = ROOT_DIR;
 
 const args = Object.fromEntries(
   process.argv
@@ -270,6 +274,15 @@ console.log(
 
 let builtPages = 0;
 
+/**
+ * Every monetary amount seen, across every locale, written to i18n/locale-format.json.
+ *
+ * This is the deliberate answer to "does it convert currency?" — no, and here is the
+ * list so you can decide per market. A price is a commercial commitment; a build script
+ * is the wrong thing to be making one on your behalf at a rate it cannot check.
+ */
+const moneyFindings = [];
+
 for (const lang of LANGS) {
   const tmFile = join(TM_DIR, `${lang}.json`);
   if (!existsSync(tmFile)) {
@@ -282,6 +295,8 @@ for (const lang of LANGS) {
   rmSync(join(DIST, lang), { recursive: true, force: true });
 
   const report = { pages: 0, replaced: 0, untranslated: 0, misses: new Set() };
+  const INTL_TAG = intlLocale(BY_PATH[lang]);
+  let formatCount = 0;
 
   for (const target of targets) {
     const { slug, file, segments } = target;
@@ -297,11 +312,25 @@ for (const lang of LANGS) {
         report.untranslated++;
         continue;
       }
+      // Locale conventions are applied HERE, not in the model: rule 4 of the translation
+      // prompt tells the model to leave numbers alone precisely so this step can rewrite
+      // their presentation deterministically. Values are never changed — see
+      // format-locale.mjs for why currency conversion is permanently out of scope.
+      let localized = translated;
+      if (LOCALE_FORMAT.enabled) {
+        const formatted = formatText(translated, INTL_TAG, LOCALE_FORMAT);
+        localized = formatted.text;
+        formatCount += formatted.changes.length;
+        for (const m of formatted.money) {
+          moneyFindings.push({ page: slug || '(home)', currency: m.currency, value: m.value, wrote: m.wrote });
+        }
+      }
+
       let replacement;
-      if (seg.kind === 'block') replacement = renderBlock(translated, seg.tags ?? []);
-      else if (seg.kind === 'jsonld') replacement = escJson(translated);
-      else if (seg.kind.startsWith('attr:')) replacement = escAttr(translated);
-      else replacement = escHtml(translated);
+      if (seg.kind === 'block') replacement = renderBlock(localized, seg.tags ?? []);
+      else if (seg.kind === 'jsonld') replacement = escJson(localized);
+      else if (seg.kind.startsWith('attr:')) replacement = escAttr(localized);
+      else replacement = escHtml(localized);
 
       html = html.slice(0, seg.start) + replacement + html.slice(seg.end);
       report.replaced++;
@@ -319,6 +348,9 @@ for (const lang of LANGS) {
     `${lang}: ${report.pages} pages, ${report.replaced.toLocaleString()} segments replaced, ` +
       `${report.untranslated.toLocaleString()} left in English`
   );
+  if (LOCALE_FORMAT.enabled && formatCount) {
+    console.log(`  ${formatCount.toLocaleString()} number/currency/percent forms rewritten for ${INTL_TAG}`);
+  }
   if (report.misses.size) {
     console.log(`  ⚠ identity rules that matched nothing: ${[...report.misses].join(', ')}`);
   }
@@ -327,6 +359,23 @@ for (const lang of LANGS) {
 
 // Disclosed at the point of action, not buried in a README: this is what the pages
 // now carry, and which key removes it.
+if (LOCALE_FORMAT.enabled) {
+  const byCurrency = {};
+  for (const m of moneyFindings) byCurrency[m.currency] = (byCurrency[m.currency] ?? 0) + 1;
+  writeFileSync(
+    join(I18N_DIR, 'locale-format.json'),
+    JSON.stringify({ counts: byCurrency, total: moneyFindings.length, findings: moneyFindings }, null, 2)
+  );
+  if (moneyFindings.length) {
+    const summary = Object.entries(byCurrency).map(([c, n]) => `${n} ${c}`).join(', ');
+    console.log(
+      `\n\u2139 ${moneyFindings.length.toLocaleString()} monetary amount(s) reformatted, never converted (${summary}).` +
+        `\n  Values are unchanged in every locale. Review i18n/locale-format.json to decide` +
+        `\n  whether any market needs a different price — this pipeline will not guess one.`
+    );
+  }
+}
+
 const attrBytes = markerBytes(BY_PATH[LANGS[0]]);
 if (attrBytes) {
   console.log(

package/scripts/config.mjs

@@ -8,6 +8,8 @@
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join, resolve } from 'path';
 
+import { loadGlossary } from './glossary.mjs';
+
 const ROOT = process.env.I18N_ROOT ? resolve(process.env.I18N_ROOT) : process.cwd();
 const CONFIG_PATH = process.env.I18N_CONFIG ? resolve(process.env.I18N_CONFIG) : join(ROOT, 'i18n.config.json');
 
@@ -121,6 +123,70 @@ export const DNT = {
   formats: raw.doNotTranslate?.formats ?? ['PDF', 'DOCX', 'XLSX', 'PPTX', 'CSV', 'TXT', 'JSON', 'HTML', 'XML'],
 };
 
+/**
+ * Glossary — the term base. Array inline, or a path to a JSON file holding one.
+ *
+ * `doNotTranslate` is folded in as case-sensitive "keep" rules, so every existing config
+ * gains word-boundary matching and, for the first time, a check that its brands actually
+ * survived translation. Before 2.0 the brand list was matched against the whole trimmed
+ * unit and otherwise existed only as a sentence in the prompt; nothing verified the
+ * outcome. An explicit glossary entry for the same term wins, so a config can override
+ * the inherited default without deleting it from doNotTranslate.
+ */
+export const GLOSSARY = (() => {
+  const { terms, problems } = loadGlossary(raw.glossary, ROOT, resolve);
+
+  const named = new Set(terms.map((t) => t.source));
+  const inherited = loadGlossary(
+    [...DNT.brands, ...DNT.formats]
+      .filter((sourceText) => typeof sourceText === 'string' && sourceText.trim() && !named.has(sourceText))
+      .map((sourceText) => ({ source: sourceText, rule: 'keep' })),
+    ROOT,
+    resolve
+  ).terms;
+
+  const all = [...terms, ...inherited].sort((a, b) => b.source.length - a.source.length);
+  if (problems.length) {
+    for (const p of problems.slice(0, 10)) console.warn(`  glossary: ${p}`);
+    if (problems.length > 10) console.warn(`  glossary: ${problems.length - 10} more`);
+  }
+  return all;
+})();
+
+/**
+ * Locale conventions applied to translated text at build time.
+ *
+ * FORMATTING ONLY. `currency: "format"` rewrites how an amount is written — symbol
+ * placement, separators, spacing — and never what it is worth. There is no "convert"
+ * value and there is not going to be one: converting a price at a rate baked into a
+ * build is how a translation tool starts publishing wrong offers. Amounts are reported
+ * to i18n/locale-format.json instead, for a human to price per market.
+ *
+ * `units` is reserved and unimplemented. It is accepted so a config written now keeps
+ * parsing when unit conversion lands, and it does nothing today.
+ */
+export const LOCALE_FORMAT = (() => {
+  const raw_ = raw.localeFormat ?? {};
+  const cfg = {
+    numbers: raw_.numbers ?? true,
+    percent: raw_.percent ?? true,
+    currency: raw_.currency === 'off' ? 'off' : 'format',
+    units: 'off',
+  };
+  if (raw_.currency && raw_.currency !== 'off' && raw_.currency !== 'format') {
+    console.error(
+      `config.localeFormat.currency must be "format" or "off" (got "${raw_.currency}"). ` +
+        'Currency conversion is deliberately not supported.'
+    );
+    process.exit(1);
+  }
+  if (raw_.units && raw_.units !== 'off') {
+    console.warn('  localeFormat.units is reserved and not implemented yet — ignored');
+  }
+  cfg.enabled = cfg.numbers || cfg.percent || cfg.currency === 'format';
+  return cfg;
+})();
+
 /**
  * Model and provider.
  *

package/scripts/credit.mjs

@@ -18,10 +18,11 @@
  * mechanism WordPress, Hugo and Astro use, and it is how this project shows up in
  * technology-adoption surveys.
  *
- * A *visible* credit is available too — `credit.visibleLink` — and it is opt-in,
- * requires you to place the slot yourself, and is `rel="nofollow"` because turning it
- * on earns you something (see README). A compensated link that passes ranking signal
- * is exactly what Google asks you not to ship.
+ * A *visible* credit is available too — `credit.visibleLink` — and it is opt-in, requires
+ * you to place the slot yourself, and earns you nothing: it exists for people who want to
+ * credit their tools. It is still `rel="nofollow"`, because a link a build script adds to
+ * every page of a site is sitewide-by-tooling rather than editorial, which is the shape
+ * Google's link-scheme guidance is aimed at.
  *
  * ── Hints ────────────────────────────────────────────────────────────────────
  * The scripts print a short note when they detect something this pipeline genuinely
@@ -32,7 +33,13 @@
 
 import { CREDIT } from './config.mjs';
 
-export const VERSION = '1.3.0';
+/**
+ * Kept as a literal on purpose. `init` vendors these scripts into the user's own project,
+ * where the nearest package.json is THEIR application's — reading the version from disk
+ * would stamp their app's version into our generator tag. CI asserts this string matches
+ * package.json in this repo, which is the only place the two can be compared.
+ */
+export const VERSION = '2.0.0';
 
 /**
  * The product name written into every localized page's generator tag.

package/scripts/extract.mjs

@@ -171,11 +171,19 @@ const hashOf = (s) => createHash('sha1').update(s).digest('hex').slice(0, 16);
 const sources = new Map();
 let totalSegments = 0;
 
-function record(text, kind, sample) {
+function record(text, kind, sample, el = null) {
   const h = hashOf(text);
   const hit = sources.get(h);
-  if (hit) hit.count++;
-  else sources.set(h, { text, kind, count: 1, sample });
+  if (hit) {
+    hit.count++;
+    // The SAME string can appear in a <button> on one page and a <p> on another. The hash
+    // is over the text alone, so both share one unit and one translation. Keeping the
+    // first element seen would hand the model a confident wrong answer on the other, so a
+    // conflict clears the hint instead and the unit is translated as ordinary prose.
+    if (hit.el !== el) hit.el = null;
+  } else {
+    sources.set(h, { text, kind, count: 1, sample, el });
+  }
   return h;
 }
 
@@ -285,7 +293,14 @@ function collectAttrs(node, html, segments, pageKey, deep = false) {
       segments.push({
         start: aLoc.startOffset + idx,
         end: aLoc.startOffset + idx + attr.value.length,
-        hash: record(value, `attr:${attr.name}`, pageKey),
+        hash: record(
+          value,
+          `attr:${attr.name}`,
+          pageKey,
+          // kind flattens every meta tag to "attr:content", but a description behaves
+          // nothing like an og:title, so the key travels in el instead.
+          node.tagName === 'meta' ? `meta:${attrMap.name || attrMap.property}` : node.tagName
+        ),
         kind: `attr:${attr.name}`,
         tags: [],
       });
@@ -394,7 +409,7 @@ function collect(node, html, segments, pageKey) {
         segments.push({
           start: innerStart + lead,
           end: innerEnd - trail,
-          hash: record(trimmed, 'block', pageKey),
+          hash: record(trimmed, 'block', pageKey, tag),
           kind: 'block',
           tags: unit.tags.map((t) => [t.open, t.close]),
         });
@@ -420,7 +435,7 @@ function collect(node, html, segments, pageKey) {
       segments.push({
         start: cLoc.startOffset + lead,
         end: cLoc.startOffset + lead + trimmed.length,
-        hash: record(decodeEntities(trimmed), 'text', pageKey),
+        hash: record(decodeEntities(trimmed), 'text', pageKey, tag),
         kind: 'text',
         tags: [],
       });

package/scripts/format-locale.mjs

@@ -0,0 +1,290 @@
+/**
+ * Locale conventions — number, percent and currency FORMATTING.
+ *
+ * ── What this does and, more importantly, does not do ────────────────────────
+ * It changes how a quantity is WRITTEN. It never changes what the quantity IS.
+ *
+ *   1,234.56  ->  1.234,56   (de)      formatting     yes
+ *   $5        ->  5 $        (fr)      formatting     yes
+ *   $5        ->  4,60 €     (fr)      conversion     NEVER
+ *
+ * Currency conversion is deliberately absent and will stay absent. A price is a
+ * commercial commitment; converting one silently, at a rate that goes stale the day it
+ * is written, turns a translation tool into a source of mispriced offers. What the
+ * pipeline does instead is REPORT every page where a monetary amount appears, so the
+ * site owner can decide per market. That report is i18n/locale-format.json.
+ *
+ * Unit conversion (in->cm, F->C) is likewise not implemented. The config key is reserved
+ * so a config written today does not break when it lands.
+ *
+ * ── Why this is deterministic and not a prompt rule ──────────────────────────
+ * translate.mjs rule 4 tells the model to leave numbers ALONE, and that stays. Models
+ * are unreliable at separator conventions and there is no way to verify a per-locale
+ * separator choice cheaply. Intl is exact, free, and already in Node. So the model
+ * preserves the number and this module re-writes its presentation afterwards, at splice
+ * time, where the result can be diffed against the source.
+ *
+ * ── Why the matching is narrow ───────────────────────────────────────────────
+ * Pulling numbers out of prose with a regex is the dangerous part of this file. A
+ * greedy pattern will happily "fix" a version number, a time, an IP address or a phone
+ * number into nonsense. So a run only touches a number when it is unambiguously a
+ * quantity: attached to a currency symbol or code, followed by a percent sign, or
+ * written with digit-grouping separators. Everything else is left exactly as it is,
+ * which is the correct default for anything this module cannot positively identify.
+ */
+
+/**
+ * Currency symbols and ISO codes worth recognising. Symbol first (longest first, so "CA$"
+ * beats "$"), then codes. Anything not listed is simply not treated as currency, which
+ * means it is left alone — the safe direction.
+ */
+const CURRENCY_SYMBOLS = [
+  ['CA$', 'CAD'], ['A$', 'AUD'], ['NZ$', 'NZD'], ['HK$', 'HKD'], ['R$', 'BRL'],
+  ['US$', 'USD'], ['$', 'USD'], ['€', 'EUR'], ['£', 'GBP'], ['¥', 'JPY'],
+  ['₹', 'INR'], ['₽', 'RUB'], ['₩', 'KRW'], ['₺', 'TRY'], ['₴', 'UAH'],
+  ['zł', 'PLN'], ['Kč', 'CZK'], ['R', 'ZAR'],
+];
+
+/** Characters that may appear inside a written number: digits, separators, thin spaces. */
+const SEP = '.,    ';
+
+/**
+ * Contexts in which a run of digits is NOT a quantity we may reformat.
+ *
+ * Every entry here is a real false positive that a naive pattern produces:
+ *   1.2.3      semantic version        "Node 20.5.1"
+ *   10:30      time                    "opens at 10:30"
+ *   192.168.1.1 IPv4
+ *   2026-08-29 ISO date
+ *   +1-800-555 phone number
+ *   1/2        fraction or date part
+ *   v2.0       version with a prefix
+ */
+const UNSAFE_NEIGHBOUR_BEFORE = /[:\-\/\d]$/;
+const UNSAFE_NEIGHBOUR_AFTER = /^[:\-\/\d]/;
+
+/**
+ * The full extent of a numeric run: digits plus any separator that could be part of the
+ * same written number. Matching the WHOLE run matters even when we decide not to touch
+ * it, because the scanner must then skip past all of it — re-entering the middle of
+ * "192.168.1.1" is precisely how it once produced "1.921.681,1".
+ */
+const NUM_RUN = /^\d+(?:[.,\u00a0\u202f ]\d+)*/;
+
+/**
+ * Is this run a well-formed written number, and if so what is its value?
+ *
+ * Accepts exactly three shapes, and nothing else:
+ *   1234            plain integer
+ *   1,234,567       grouped — ONE consistent separator, groups of exactly 3
+ *   1,234.56        grouped with a decimal part, using the OTHER separator
+ *   1234.56         plain decimal
+ *
+ * Rejecting everything else is what protects version numbers ("1.2.3" — a group of one
+ * digit), IP addresses ("192.168.1.1" — same), and dotted identifiers. A rejected run is
+ * emitted verbatim.
+ */
+function parseWritten(raw) {
+  if (/^\d+$/.test(raw)) {
+    const value = Number(raw);
+    return Number.isFinite(value) ? { value, decimals: 0, grouped: false } : null;
+  }
+
+  const GROUPED = /^(\d{1,3})((?:[.,\u00a0\u202f ]\d{3})+)(?:([.,])(\d+))?$/;
+  const m = GROUPED.exec(raw);
+  if (m) {
+    const [, head, groups, decSep, decDigits] = m;
+    const seps = new Set([...groups.matchAll(/[.,\u00a0\u202f ]/g)].map((x) => x[0]));
+    // "1,234.567,89" mixes separators — not a number anyone wrote on purpose.
+    if (seps.size !== 1) return null;
+    const groupSep = [...seps][0];
+    // The decimal mark must differ from the group mark, or "1.234.567" is ambiguous.
+    if (decSep && decSep === groupSep) return null;
+    const digits = head + groups.replace(/[.,\u00a0\u202f ]/g, '');
+    const value = Number(decDigits ? `${digits}.${decDigits}` : digits);
+    return Number.isFinite(value) ? { value, decimals: decDigits?.length ?? 0, grouped: true } : null;
+  }
+
+  // Plain decimal: one separator, 1-3 digits after it. Two decimal places is money;
+  // three would be a group, which the branch above already handled.
+  const DECIMAL = /^(\d+)([.,])(\d{1,3})$/;
+  const d = DECIMAL.exec(raw);
+  if (d) {
+    const value = Number(`${d[1]}.${d[3]}`);
+    return Number.isFinite(value) ? { value, decimals: d[3].length, grouped: false } : null;
+  }
+
+  return null;
+}
+
+/**
+ * Format one amount for a locale, holding the currency constant.
+ * Returns null if Intl refuses the locale or currency, so the caller leaves the text alone.
+ */
+function formatCurrency(value, decimals, currency, locale) {
+  try {
+    // When the source wrote decimals, keep exactly that many — "$1,234.5" must not gain a
+    // digit it did not have. When it wrote none, defer to Intl, which knows that USD
+    // shows two and JPY shows none. Forcing 0 produced "1.500 $" for "1,500 USD".
+    const opts = decimals > 0
+      ? { style: 'currency', currency, minimumFractionDigits: decimals, maximumFractionDigits: decimals }
+      : { style: 'currency', currency };
+    return new Intl.NumberFormat(locale, opts).format(value);
+  } catch {
+    return null;
+  }
+}
+
+function formatNumber(value, decimals, locale) {
+  try {
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals,
+    }).format(value);
+  } catch {
+    return null;
+  }
+}
+
+function formatPercent(value, decimals, locale) {
+  try {
+    // Intl's percent style multiplies by 100, so divide first to keep the printed value.
+    return new Intl.NumberFormat(locale, {
+      style: 'percent',
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals,
+    }).format(value / 100);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Rewrite the locale conventions in one translated string.
+ *
+ * @returns { text, changes, money } — `money` is the amounts seen, for the review report.
+ */
+export function formatText(text, locale, options = {}) {
+  const opts = {
+    numbers: true,
+    percent: true,
+    currency: 'format',
+    ...options,
+  };
+  if (typeof text !== 'string' || !text) return { text, changes: [], money: [] };
+
+  const changes = [];
+  const money = [];
+  let out = '';
+  let i = 0;
+
+  const symbols = CURRENCY_SYMBOLS.slice().sort((a, b) => b[0].length - a[0].length);
+
+  while (i < text.length) {
+    // A placeholder is markup, never prose. Skip it whole so no pattern can reach inside.
+    const ph = /^<\/?\d+\/?>/.exec(text.slice(i));
+    if (ph) {
+      out += ph[0];
+      i += ph[0].length;
+      continue;
+    }
+
+    let matched = false;
+
+    // ── Currency: symbol before the number ("$1,234.50", "€10") ──────────────
+    if (opts.currency === 'format') {
+      for (const [sym, code] of symbols) {
+        if (!text.startsWith(sym, i)) continue;
+        const rest = text.slice(i + sym.length);
+        const run = NUM_RUN.exec(rest.replace(/^[\u00a0\u202f ]/, ''));
+        if (!run) continue;
+        const lead = rest.length - rest.replace(/^[\u00a0\u202f ]/, '').length;
+        const raw = run[0];
+        const after = rest.slice(lead + raw.length);
+        // A dotted or dashed continuation means this was never a price.
+        if (UNSAFE_NEIGHBOUR_AFTER.test(after)) break;
+        const parsed = parseWritten(raw);
+        if (!parsed) break;
+
+        const formatted = formatCurrency(parsed.value, parsed.decimals, code, locale);
+        const original = sym + rest.slice(0, lead) + raw;
+        money.push({ currency: code, value: parsed.value, wrote: formatted ?? original });
+        if (formatted && formatted !== original) {
+          changes.push({ from: original, to: formatted, kind: 'currency' });
+          out += formatted;
+        } else {
+          out += original;
+        }
+        i += sym.length + lead + raw.length;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) continue;
+
+    // ── A numeric run, possibly followed by % or a currency code ─────────────
+    const runMatch = NUM_RUN.exec(text.slice(i));
+    if (runMatch) {
+      const raw = runMatch[0];
+      const before = out.slice(-1);
+      const rest = text.slice(i + raw.length);
+
+      const unsafe = UNSAFE_NEIGHBOUR_BEFORE.test(before) || UNSAFE_NEIGHBOUR_AFTER.test(rest);
+      const pct = /^[\u00a0\u202f ]?%/.exec(rest);
+      const codeAfter = /^[\u00a0\u202f ]?([A-Z]{3})\b/.exec(rest);
+      const knownCode = codeAfter && symbols.some(([, c]) => c === codeAfter[1]);
+      const parsed = unsafe ? null : parseWritten(raw);
+
+      if (parsed) {
+        if (pct && opts.percent) {
+          const formatted = formatPercent(parsed.value, parsed.decimals, locale);
+          if (formatted && formatted !== raw + pct[0]) {
+            changes.push({ from: raw + pct[0], to: formatted, kind: 'percent' });
+            out += formatted;
+            i += raw.length + pct[0].length;
+            continue;
+          }
+        } else if (knownCode && opts.currency === 'format') {
+          const formatted = formatCurrency(parsed.value, parsed.decimals, codeAfter[1], locale);
+          const original = raw + codeAfter[0];
+          money.push({ currency: codeAfter[1], value: parsed.value, wrote: formatted ?? original });
+          if (formatted && formatted !== original) {
+            changes.push({ from: original, to: formatted, kind: 'currency' });
+            out += formatted;
+            i += raw.length + codeAfter[0].length;
+            continue;
+          }
+        } else if (opts.numbers && parsed.grouped) {
+          // Only grouped numbers. A bare "2026" or "50" has no separator convention to
+          // get wrong, and rewriting it risks mangling a year or a count.
+          const formatted = formatNumber(parsed.value, parsed.decimals, locale);
+          if (formatted && formatted !== raw) {
+            changes.push({ from: raw, to: formatted, kind: 'number' });
+            out += formatted;
+            i += raw.length;
+            continue;
+          }
+        }
+      }
+
+      // Emit the WHOLE run untouched and step past all of it. Advancing by less would
+      // let the scanner re-enter the middle of something it just declined to format.
+      out += raw;
+      i += raw.length;
+      continue;
+    }
+
+    out += text[i];
+    i += 1;
+  }
+
+  return { text: out, changes, money };
+}
+
+/**
+ * The BCP-47 tag to hand Intl for a locale row. `hreflang` is already the right shape
+ * ("pt-BR", "zh-Hant"); pathCode is a URL segment ("pt-br") and is not.
+ */
+export function intlLocale(row) {
+  return row?.hreflang ?? row?.pathCode ?? 'en';
+}