langsys-js-typescript 0.6.4 → 0.7.0

package/dist/pure-DkFXdgVa.d.ts

@@ -0,0 +1,933 @@
+/**
+ * Server messages (spec MSG family): the entries a server attaches to its
+ * framework's own error response, and how a client finds and renders them.
+ *
+ * What translation needs is small: the `template` — the framework's own
+ * sentence, unfilled, with the field's label written in — and the `params`
+ * that fill its `{name}` markers. `message` is the template already filled, the
+ * fallback a client shows when it cannot look the template up. Everything else
+ * is the framework's and passes through unchanged: `field` in the framework's
+ * own path format (a dotted string, Pydantic's `loc` array), and `code`, the
+ * framework's own identifier for the failure (Laravel's rule name, Pydantic's
+ * error `type`, Django's `code`), or none. The error body is the framework's
+ * too, so where the entries sit and what their pieces are called are the
+ * app's configuration.
+ *
+ * Everything here is pure except `renderServerMessage`, which renders through
+ * `t()`; that one is exported from the main entry only.
+ */
+/** One server message entry (MSG-1), in the SDK's own piece names. */
+interface ServerMessage {
+    template?: string;
+    params?: Record<string, unknown>;
+    message?: string;
+    /** The field, in the framework's own path format, unchanged. */
+    field?: unknown;
+    /** The framework's own identifier for the failure, unchanged. Absent where the framework has none. */
+    code?: unknown;
+}
+/** The piece names an app's entries use, where they differ from the SDK's. */
+type ServerMessagePieces = Partial<Record<'template' | 'params' | 'message' | 'field' | 'code', string>>;
+/** Where the entries sit in a response body (MSG-1). One of `key` or `resolver` is required. */
+interface ResolveServerMessagesOptions {
+    /**
+     * The dotted path the server attached the entries under, beside the
+     * framework's own error body — Laravel's package default is `langsys_errors`.
+     */
+    key?: string;
+    /** Maps a body to entries itself, for an app whose failures are carried some other way. */
+    resolver?: (body: unknown) => unknown;
+    /** The entries' piece names, when the server was configured with names of its own. */
+    pieces?: ServerMessagePieces;
+}
+/** The category templates are registered and rendered under unless configured otherwise (MSG-6). */
+declare const DEFAULT_SERVER_MESSAGE_CATEGORY = "Errors";
+/** The marker names in a template, once each, in the order they first appear. */
+declare function templateMarkers(template: string): string[];
+/**
+ * Fill a template's markers from params (MSG-4). A marker with no param stays
+ * as its literal marker rather than going blank, so a missing value is visible
+ * instead of producing a sentence that reads as complete. A structure is never
+ * printed into the sentence; its marker stays too.
+ */
+declare function fillTemplate(template: string, params?: Record<string, unknown>): string;
+/**
+ * An entry from its wire form, or null when it is not one. An entry needs a
+ * `template` to look up or a `message` to show; either is a string. `params`
+ * is kept when it is an object; `field` and `code` pass through as they are.
+ */
+declare function toServerMessage(value: unknown, pieces?: ServerMessagePieces): ServerMessage | null;
+/**
+ * The entries a response carries, found where the app's configuration says
+ * they are (MSG-1). The body is the framework's own and is never searched by
+ * shape: `key` names the dotted path the server attached the entries under,
+ * and `resolver` maps the body to entries itself. Throws when neither is given,
+ * since there is nowhere to look. `pieces` renames the entries' pieces.
+ *
+ * Accepts the decoded body or its JSON text, and never changes the body.
+ * Unreadable JSON, or a key the body does not carry, resolves to no entries:
+ * this runs in an error path already.
+ */
+declare function resolveServerMessages(body: unknown, options: ResolveServerMessagesOptions): ServerMessage[];
+
+/**
+ * Catalog snapshots (spec SNAP family): one file format every Langsys SDK
+ * writes and reads, so a snapshot exported by any core loads in any other.
+ *
+ * A snapshot is the flat catalog (`GET /translations`) for chosen locales and
+ * categories, carried as a file so a first render, a mobile bundle or an
+ * offline session has translations with no network call. It is a cache, never
+ * a source: Langsys produces it, a checksum over its canonical serialisation
+ * catches an edited one, and the refresh path is a new export.
+ *
+ * Everything here is pure. Seeding a loaded snapshot into the SDK is
+ * `LangsysApp.loadSnapshot`, on the main entry.
+ */
+/** The `format` member every snapshot carries. */
+declare const SNAPSHOT_FORMAT = "langsys-catalog-snapshot";
+/** The only `version` this SDK reads and writes. */
+declare const SNAPSHOT_VERSION = 1;
+/** A category's flat entries as `GET /translations` returns them: phrase → translation or null, or a block id → its phrase map. */
+type SnapshotCategory = Record<string, string | null | Record<string, string | null>>;
+/** locale → category → entries. A category the locale does not hold is absent; one it holds empty is `{}`. */
+type SnapshotCatalog = Record<string, Record<string, SnapshotCategory>>;
+/** The members the checksum covers. */
+interface SnapshotPayload {
+    project_id: string;
+    /** UTC, `YYYY-MM-DDTHH:MM:SSZ`. */
+    generated_at: string;
+    base_locale: string;
+    /** Lowercase `xx-yy`, sorted ascending. */
+    locales: string[];
+    /** Sorted ascending. */
+    categories: string[];
+    catalog: SnapshotCatalog;
+}
+/** A whole snapshot document. */
+interface CatalogSnapshot extends SnapshotPayload {
+    format: typeof SNAPSHOT_FORMAT;
+    version: typeof SNAPSHOT_VERSION;
+    /** `sha256:` and the lowercase hex digest of the canonical serialisation of the payload. */
+    checksum: string;
+}
+/** Why a snapshot was refused. */
+type SnapshotRefusal = 'not-json' | 'format' | 'version' | 'missing-member' | 'checksum';
+/** Thrown when a snapshot cannot be loaded. `reason` names why; the message says what to do. */
+declare class SnapshotError extends Error {
+    readonly reason: SnapshotRefusal;
+    constructor(message: string, reason: SnapshotRefusal);
+}
+/**
+ * The canonical serialisation the checksum is taken over, byte for byte the
+ * same in every SDK:
+ *
+ * - strings escaped as CID-1 serialises them — `"`, `\` and U+0000–U+001F only,
+ *   everything else (`/`, non-ASCII, U+2028) raw — which is `JSON.stringify`'s
+ *   own string escaping;
+ * - no whitespace;
+ * - object members sorted by key in Unicode code point order. Neither
+ *   `Object.keys` order (integer-like keys first) nor the default `sort()`
+ *   (UTF-16 code units, which puts a key above U+FFFF before one in
+ *   U+E000–U+FFFF) is that order, so both are avoided;
+ * - a map is `{}` even when empty; `null` is `null`.
+ */
+declare function canonicalSnapshotJson(value: unknown): string;
+/** `sha256:` and the lowercase hex SHA-256 of the canonical serialisation of the payload members. */
+declare function snapshotChecksum(payload: SnapshotPayload): string;
+/**
+ * Build a snapshot document from catalogs already fetched — the writing half,
+ * for an export tool. `catalogs` is locale → the catalog `GET /translations`
+ * returned; only the chosen categories are kept, and a category a locale does
+ * not hold stays absent for that locale. Locales are lowercased; both lists are
+ * sorted.
+ */
+declare function buildSnapshot(options: {
+    projectId: string;
+    baseLocale: string;
+    catalogs: Record<string, Record<string, SnapshotCategory>>;
+    categories: string[];
+    generatedAt?: Date;
+}): CatalogSnapshot;
+/**
+ * Read a snapshot from its JSON text or parsed document, refusing — with an
+ * error naming the reason — a different `format`, an unsupported `version`, a
+ * missing member, or a checksum the contents no longer match. The file may be
+ * any JSON encoding of the document; the checksum is recomputed from the
+ * canonical serialisation, never compared against the file's bytes.
+ */
+declare function parseSnapshot(input: string | unknown): CatalogSnapshot;
+
+/**
+ * Translation function type machinery.
+ *
+ * The big trick here is `ExtractParamKeys` — a recursive template-literal
+ * type that pulls placeholder names out of a phrase at compile time, so
+ * `t('Hello, {name}!', { name: 'Sarah' })` is type-checked: passing
+ * an object without `name`, or with a key not in the phrase, is a TS error.
+ */
+/** Allowed value types for interpolation. Mirrors what ICU MessageFormat will accept. */
+type ParamPrimitive = string | number | Date | boolean;
+/**
+ * Pull placeholder names out of a phrase.
+ * @example
+ *   ExtractParamKeys<"Hello, {name}!">        // "name"
+ *   ExtractParamKeys<"{first} and {last}">    // "first" | "last"
+ *   ExtractParamKeys<"no placeholders here">  // never
+ */
+type ExtractParamKeys<S extends string> = S extends `${string}{${infer K}}${infer Rest}` ? K | ExtractParamKeys<Rest> : never;
+/**
+ * Optional `<name>_gender` companions, one per placeholder. Langsys promotes a plain
+ * `{username}` to `{username_gender, select, …}` in gendered target locales, so the
+ * argument exists in the translation but never in the phrase you wrote. Optional because
+ * most apps don't know the gender; without it the neutral `other` branch renders.
+ * @example
+ *   GenderParamsFor<"{username} has been invited">  // { username_gender?: string }
+ */
+type GenderParamsFor<S extends string> = {
+    [K in ExtractParamKeys<S> as `${K}_gender`]?: string;
+};
+/** Build the params object type required for a given phrase. */
+type ParamsFor<S extends string> = {
+    [K in ExtractParamKeys<S>]: ParamPrimitive;
+} & GenderParamsFor<S>;
+/**
+ * Whether a phrase can be a legacy key (spec MIG-2): no whitespace and no
+ * placeholder, like `checkout.greet`. In the legacy-key mode such an argument
+ * resolves to a source value whose placeholders the call site cannot see, so its
+ * params are accepted rather than checked. A sentence is never key-shaped, so its
+ * placeholders stay checked. A phrase that is not a literal (`string`) is
+ * key-shaped too: nothing about its placeholders is known.
+ */
+type KeyShaped<P extends string> = P extends `${string}${' ' | '\n' | '\t'}${string}` ? false : P extends `${string}{${string}` ? false : true;
+/**
+ * Rest-tuple for the optional params argument.
+ * Placeholders in the phrase → the params they name must be passed.
+ * No placeholders, and the phrase is a sentence → no params.
+ * No placeholders, and the phrase is key-shaped → params are optional and free.
+ */
+type TArgs<P extends string> = [ExtractParamKeys<P>] extends [never] ? KeyShaped<P> extends true ? [params?: TranslationParams] : [] : [params: ParamsFor<P>];
+/** Loose params type — used inside generic stores where the phrase isn't a known literal. */
+type TranslationParams = Record<string, ParamPrimitive>;
+/**
+ * The translation function signature.
+ *
+ *   t('Save')                                     // no category, no params
+ *   t('Save', 'UI')                               // categorized
+ *   t('Hello, {name}!', { name: 'X' })            // no category, with params
+ *   t('Hello, {name}!', 'Greetings', { name: 'X' }) // category + params
+ *   t('checkout.greet', { name: 'X' })            // a legacy key: params accepted
+ *   t`Hello, ${{ name }}!`                        // a template tag: `{name}`, with its value
+ *
+ * The two phrase overloads discriminate on the type at position 2 (string →
+ * category, object → params). `category` is required for the second overload —
+ * pass any non-empty string. There is no "null category" wire concept:
+ * absent category means absent.
+ *
+ * As a template tag, each value written as a one-key object is a placeholder
+ * named by its key in snake_case (`${{ userName }}` is `{user_name}`), with the
+ * value as its param. With any other value, the tag returns the rendered text
+ * as written: nothing is looked up, translated or registered. A tag takes no
+ * category.
+ */
+interface TFunction {
+    <P extends string>(phrase: P, ...args: TArgs<P>): string;
+    <P extends string>(phrase: P, category: string, ...args: TArgs<P>): string;
+    (strings: TemplateStringsArray, ...values: unknown[]): string;
+}
+
+/**
+ * Legacy i18n values to Langsys/ICU source text (spec MIG-4).
+ *
+ * A migrated app keeps its source-language file and its keys; a key's value
+ * becomes the registered phrase after this conversion. The conversion decides
+ * the phrase, so it is identity: every JS entry point — the browser `t()`
+ * mode, a server `t()`, a vue-i18n or i18next bridge — converts through these
+ * functions, never a copy of them.
+ *
+ * Placeholders convert the same way whatever the file's format. Plurals
+ * convert by the format the file declares, because frameworks read the same
+ * characters differently: vue-i18n reserves `|`, i18next pairs suffixed keys.
+ * The conversion preserves the source framework's own selection. Anything a
+ * format does not recognise comes back exactly as written, with `recognised`
+ * false and the reason in `issue`, so it registers verbatim and is reported
+ * rather than silently mangled.
+ */
+/** The formats a file can declare anywhere in the fleet (MIG-7). */
+declare const LEGACY_FORMATS: readonly ["laravel", "vue-i18n", "i18next", "gettext", "rails-i18n", "plain"];
+/** The formats this core reads (MIG-7). Any other configured format is refused at load. */
+declare const SUPPORTED_LEGACY_FORMATS: readonly ["i18next", "vue-i18n", "plain"];
+type LegacyFormat = (typeof SUPPORTED_LEGACY_FORMATS)[number];
+/** A converted value. `text` is the phrase to register; when `recognised` is false it is the value as written. */
+interface LegacyConversion {
+    text: string;
+    recognised: boolean;
+    issue: string | null;
+}
+/** CLDR plural categories, in ICU's customary order. */
+declare const PLURAL_CATEGORIES: readonly ["zero", "one", "two", "few", "many", "other"];
+/**
+ * Convert a value under a format.
+ *
+ * `plain` converts placeholders and nothing else; a `|` in it is text, so such
+ * a value is returned verbatim and reported. `vue-i18n` reads any `|` as a
+ * plural selected by count. `i18next` has no in-string plural — its plurals are
+ * suffix-paired keys, see `convertLegacyPluralForms` — so a `|` is reported.
+ */
+declare function convertLegacyValue(value: string, format?: LegacyFormat): LegacyConversion;
+/**
+ * One ICU plural from forms keyed by CLDR category — i18next's `key_one` /
+ * `key_other` (and its older `key` / `key_plural` pair, as `one` / `other`).
+ * i18next selects by locale, so the forms keep their CLDR categories.
+ */
+declare function convertLegacyPluralForms(forms: Partial<Record<(typeof PLURAL_CATEGORIES)[number], string>>): LegacyConversion;
+/** A JS entry point that can receive legacy text (MIG-2). */
+type LegacyEntryPoint = 't' | 'vue-i18n' | 'i18next';
+/**
+ * Convert the text a call passed when it is not a key — a literal miss
+ * (MIG-2) — by the entry point that received it, not by any file: the text is
+ * written in the calling framework's syntax.
+ *
+ * Langsys `t()` converts nothing; its argument is already Langsys syntax. A
+ * vue-i18n `$t` or i18next `t` bridge converts under its own format's row.
+ */
+declare function convertLegacyCall(text: string, entryPoint: LegacyEntryPoint): LegacyConversion;
+
+/**
+ * Legacy i18n keys resolved against an app's kept source-language files
+ * (spec MIG-2, MIG-5, MIG-7).
+ *
+ * Pure and fs-free: each file is passed already parsed, as `{ name, format?,
+ * namespace?, data }`, so the browser `t()` mode and a server `t()` read one
+ * configuration through one resolver and register one phrase per key.
+ *
+ * - **Formats.** This core reads `i18next`, `vue-i18n` and `plain`, all JSON. A
+ *   file with no declared format is `plain`. A file declaring any other format,
+ *   or whose name marks it as another ecosystem's (`.php`, `.yml`, `.po`,
+ *   `.mo`), is refused when the resolver is built, with an error naming the
+ *   format and the file.
+ * - **Lookup.** A key is read as written first, then by dotted path. The first
+ *   configured file that holds it answers, and a key held by more than one file
+ *   is reported by `duplicates()`.
+ * - **Category.** A key shaped like a path (`checkout.submit`) contributes its
+ *   first segment; a file with a `namespace` answers only keys under it
+ *   (`checkout.submit` in a file with namespace `checkout`) and contributes the
+ *   namespace. A sentence used as its own key has none.
+ * - **Plurals.** In an `i18next` file, suffix-paired keys (`items_one`,
+ *   `items_other`, or the older `items` / `items_plural`) resolve together as
+ *   one plural under their base key.
+ */
+/** One configured source file. `data` is its parsed JSON object. */
+interface LegacyKeyFile {
+    /** The file's path or name, as errors and reports should name it. */
+    name: string;
+    /** `i18next`, `vue-i18n` or `plain`. Defaults to `plain`. */
+    format?: string;
+    /** When set, the file answers only keys prefixed `namespace.`, and the namespace is their category. */
+    namespace?: string;
+    data: unknown;
+}
+/** A key the files hold, converted. */
+interface LegacyKeyHit extends LegacyConversion {
+    /** The phrase to register: the converted value, or the value as written when not `recognised`. */
+    phrase: string;
+    /** The category the key contributes, or null for none (MIG-5). */
+    category: string | null;
+    key: string;
+    /** The file that answered. */
+    file: string;
+}
+/** What cannot be migrated as it stands, for a listing command (MIG-4, MIG-7). */
+interface LegacyKeyProblem {
+    file: string;
+    key: string | null;
+    issue: string;
+    fix: string;
+}
+interface LegacyKeys {
+    /** The key's converted source value, or null when no file holds it (the MIG-2 miss). */
+    resolve(key: string): LegacyKeyHit | null;
+    /** Keys held by more than one file, with those files in configured order; the first answers. */
+    duplicates(): Record<string, string[]>;
+    /** Every value that converts to nothing recognised, and every file that is not a JSON object. */
+    problems(): LegacyKeyProblem[];
+}
+/** Thrown when the configuration names a file this core cannot read (MIG-7). */
+declare class LegacyFormatError extends Error {
+    readonly file: string;
+    readonly format: string;
+    constructor(message: string, file: string, format: string);
+}
+/**
+ * Build a resolver over configured files. Throws `LegacyFormatError` for a file
+ * this core does not read — never silently, since a skipped file would turn
+ * every one of its keys into a literal phrase named after the key.
+ */
+declare function createLegacyKeys(files: LegacyKeyFile[]): LegacyKeys;
+
+interface iContentBlock {
+    custom_id: string;
+    category: string;
+    content: string;
+    label?: string;
+    tokens: string[];
+}
+
+/**
+ * The IDENTITY CONTRACT — everything that decides a `custom_id`, with no DOM
+ * and no module-scope side effects, so it can be imported from a server, a
+ * worker or a build script.
+ *
+ * It lives apart from `content-block.ts` because that module reaches the API
+ * client, the discovery lane and the persisted stores; importing it to hash a
+ * string pulled a network client and a storage probe along. `langsys-js-server`
+ * was sed-extracting these functions out of a published tarball under
+ * `@ts-nocheck` for exactly that reason — a copy that silently predates every
+ * id rule changed since. Re-exported by `content-block.ts`, so nothing that
+ * already imports from there needs to move.
+ *
+ * Reachable as the `langsys-js-typescript/pure` subpath. Nothing here may touch
+ * `window`, `document`, `navigator` or storage, at import time or on any call
+ * path — `tests/pure-subpath.test.ts` enforces that under a trapping global.
+ */
+/**
+ * HTML attributes whose values should be harvested for translation.
+ *
+ * THE LIST IS NOW IDENTICAL TO `langsys-php`'s, all twenty-seven, in its order.
+ *
+ * It used to be a subset of fifteen, and this docstring used to argue that the
+ * framework-convention attributes (Bootstrap `data-bs-*`, Rails `data-confirm`)
+ * were deliberately not mirrored because a JS app renders those strings through
+ * its own components. That reasoning is superseded and was left standing beside
+ * the list that contradicted it — the twelve below are exactly the attributes it
+ * said would never appear here.
+ *
+ * The reason it was wrong: on an SSR handoff the two SDKs tokenize the SAME
+ * markup, so an attribute only one side harvests produces a different token
+ * array and therefore a different `custom_id` for identical content. That is not
+ * a coverage hole to be argued about, it is a split identity.
+ *
+ * ORDER IS IDENTITY. `custom_id` hashes the token array, and where an element
+ * carries several of these the list order decides the sequence. The same set in
+ * a different order agrees on every single-attribute element and diverges on
+ * exactly the ones nobody notices, so the twelve are APPENDED — inserting would
+ * have re-keyed every block using one of the original fifteen.
+ */
+declare const TRANSLATABLE_ATTRIBUTES: string[];
+/**
+ * Elements holding code, inert content, or content no implementation can agree
+ * on. Measured before this existed: `<style>.plan{color:#fff}</style>`
+ * registered `.plan{color:#fff}` as a translatable phrase, and
+ * `<script>window.dataLayer.push(1)</script>` registered the statement. Both
+ * were then sent for machine translation.
+ *
+ * `<noscript>` IS HERE ON A REVERSAL, and the reasoning is worth keeping because
+ * the obvious answer is the wrong one. An earlier reading excluded it from this
+ * list: its text renders to a real visitor whenever scripting is off, so
+ * skipping it would leave a visitor-visible sentence permanently untranslated.
+ * That premise is true, and it does not survive two questions.
+ *
+ *  - WHO COULD TRANSLATE IT. With scripting off, a browser SDK is not running,
+ *    so it can translate nothing on that page — including this.
+ *  - WHAT THE TOKEN ACTUALLY IS. With scripting ENABLED, the spec's default, a
+ *    parser makes a `noscript` body RAW TEXT rather than markup. Chromium and
+ *    parse5 both yield the single token `<p>Enable JavaScript</p>`. Registering
+ *    that sends MARKUP to machine translation, which is this family's own
+ *    failure mode arriving through the rule meant to prevent it.
+ *
+ * And the implementations could not be made to agree cheaply. The axis is the
+ * parser's scripting flag, not browser-versus-server: Chromium and parse5 agree
+ * because parse5 defaults to scripting enabled, while PHP's libxml2 has no such
+ * flag and parses the children as elements. `happy-dom` and `jsdom` behave like
+ * libxml2, so a lane measuring in a test environment reproduces a
+ * browser-versus-server split that does not exist.
+ *
+ * `<template>` is named as intent and is NOT a vector HERE: its content lives on
+ * `HTMLTemplateElement.content`, so a walker over `childNodes` never reaches it
+ * and omitting it from this list changes nothing in a DOM or in parse5 — two
+ * lanes measured that independently. It is load-bearing elsewhere, which is why
+ * it stays named: libxml2 puts `<template>` children in the ordinary tree, so a
+ * PHP or Ruby walker that omitted it registers the template's text, and Ruby
+ * measured exactly that leak. 8.0.1 states the split rather than calling the
+ * exclusion free.
+ *
+ * `<math>` is notation, not prose. Translating a variable name or an operator
+ * corrupts the expression instead of localising it, and before this exclusion
+ * `<p>Area <math><mi>x</mi><mo>+</mo><mn>2</mn></math> units</p>` tokenized to
+ * `['Area','x','+','2','units']` — the operator and the bare variable registered
+ * as translatable phrases and sent for machine translation. Added by spec 8.0.1
+ * after v8 shipped without it.
+ *
+ * `<svg>` IS DELIBERATELY ABSENT and must stay absent. It is the exclusion people
+ * expect that is wrong: an `<svg><text>` renders visible words to a reader, so its
+ * text is translated like any other. 8.0.1 states that behaviourally because the
+ * structural reading — "walk `<svg>` as a block" — regressed the commonest markup
+ * there is when PHP implemented it: treating svg as a block dropped the PARENT's
+ * direct text, so `<p>Click <svg><path/></svg> to continue</p>` registered nothing
+ * and every icon-bearing heading, link and list item lost its words. Adding `svg`
+ * here would reproduce that, which is what `tokenizer-convergence` now pins.
+ */
+declare const NON_TRANSLATABLE_ELEMENTS: string[];
+/**
+ * True when an element opts out of translation entirely — it and its subtree
+ * are skipped by the tokenizer.
+ *
+ * Mirrors `langsys-php`'s `HtmlParser::isTranslationExcluded()` exactly:
+ *  - `translate="no"` — the HTML standard attribute, matched case-insensitively.
+ *  - `data-notrans` — PHP's author-facing alias, for hosts whose templating
+ *    strips unknown bare attributes or where `translate` collides with another
+ *    tool. Presence is intent; an explicit `"false"`/`"0"` opts out of the
+ *    opt-out, compared after trimming.
+ *
+ * Honoring PHP's alias matters for the same reason as the phrase marker: on SSR
+ * handoff there is ONE DOM, and content an author marked "do not translate"
+ * must not be extracted and registered by whichever SDK happens to walk it.
+ *
+ * Both this and `isPhraseMarked` trim before comparing. They briefly differed
+ * — PHP's phrase check predated the trim its exclusion check gained — and the
+ * gap was resolved by asking rather than tidying: mirror exactly, flag the
+ * wart, let the owner decide. Divergence-by-tidying is the same failure class
+ * as divergence-by-oversight, just better intentioned.
+ */
+declare function isTranslationExcluded(element: AttributeReader): boolean;
+/** The element shape the exclusion reads: the DOM's, or a tree view's. */
+interface AttributeReader {
+    readonly tagName: string;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+}
+/**
+ * THE definition. `phrase.ts` re-exports this rather than restating it — the
+ * literal used to appear in both files, so renaming one side left the other
+ * silently stale: the tokenizer would stop recognising the marker `Phrase`
+ * emits and would re-tokenize a subtree that manages itself.
+ */
+declare const PHRASE_MARKER_ATTR = "data-ls-phrase";
+/** PHP's spelling. Recognised so a catalog shared with langsys-php round-trips. */
+declare const PHRASE_MARKER_ATTR_LEGACY = "data-langsys-phrase";
+declare const PHRASE_MARKER_ATTRS: readonly ["data-ls-phrase", "data-langsys-phrase"];
+/**
+ * Marker the `Translate` host element carries, holding the resolved
+ * `custom_id` of the block rendered inside it.
+ *
+ * Mirrors how a `Phrase` host carries `PHRASE_MARKER_ATTR`, and exists so a
+ * server-rendered page can be read back: the id is otherwise derivable only by
+ * re-running the tokenizer over the same subtree, which a reader that only has
+ * the HTML cannot do identically.
+ */
+declare const CONTENT_BLOCK_MARKER_ATTR = "data-ls-contentblock";
+/** PHP's spelling, accepted on read for the same reason the phrase marker's is. */
+declare const CONTENT_BLOCK_MARKER_ATTR_LEGACY = "data-langsys-contentblock";
+declare const CONTENT_BLOCK_MARKER_ATTRS: readonly ["data-ls-contentblock", "data-langsys-contentblock"];
+/**
+ * A producer's statement that text inside this element is ALREADY RESOLVED: rendered by
+ * a server SDK in the visitor's language, not authored as source. A reader records no
+ * miss for it — neither a registration nor a discovery hint — because the catalog is
+ * keyed by source text and this is a translation.
+ *
+ * Distinct from the identity markers on purpose, and agreed that way with the PHP and
+ * Laravel lanes. A MARK stamp answers "which block is this", and a stamped block inside a
+ * resolved scope keeps its id and still translates on a later render; this attribute says
+ * only "never treated as source". It is also not `translate="no"`, which tells a browser
+ * not to machine-translate and would block a legitimate later render.
+ *
+ * The value is the locale it was resolved into, canonical lowercase, and is informational:
+ * presence decides. A bare attribute means the same, because a binding writing it into a
+ * layout often does not know the locale at that point. `="false"` and `="0"` opt a subtree
+ * back out, the convention `isPhraseMarked` already uses in both SDKs; `="no"` and
+ * `="off"` are NOT opt-outs under that shared rule.
+ */
+declare const RESOLVED_MARKER_ATTR = "data-ls-resolved";
+/** PHP's spelling, accepted on read for the same reason the other markers' is (MARK-2). */
+declare const RESOLVED_MARKER_ATTR_LEGACY = "data-langsys-resolved";
+declare const RESOLVED_MARKER_ATTRS: readonly ["data-ls-resolved", "data-langsys-resolved"];
+/**
+ * Canonical form of one token's text, applied identically to a TEXT NODE and to
+ * an ATTRIBUTE VALUE.
+ *
+ * It used to differ: text nodes collapsed internal whitespace while attributes
+ * were only trimmed. So the same authored sentence produced two different ids
+ * depending on where it sat —
+ *
+ *   <p>A long\n     description</p>        -> "A long description"
+ *   <img alt="A long\n     description">   -> "A long\n     description"
+ *
+ * — which also put this SDK and `langsys-php` on different ids for the same
+ * markup. One function now, used by both, so "the same content yields the same
+ * id" is true by construction rather than by two call sites agreeing.
+ *
+ * `\s` in JavaScript already covers U+00A0, so a non-breaking space collapses
+ * like any other whitespace without special handling. The C0 controls are
+ * removed first (`stripC0Controls`), so VT and FF never reach the collapse.
+ */
+declare function normalizeTokenText(value: string): string;
+/**
+ * Remove the 28 C0 control characters TOK-2 deletes before anything collapses:
+ * U+0001–U+0008, U+000B, U+000C and U+000E–U+001F. Applied to every string that becomes an
+ * id input or a catalog key — text nodes, translatable attributes, `t()` keys — on register
+ * and on lookup alike, and first: strip, then collapse, then trim.
+ *
+ * Removed rather than mapped to a space, because that is the only treatment every parser can
+ * agree with: libxml2 before 2.14 deletes these from DOM text before any SDK code runs, while
+ * libxml2 2.14+, parse5 and happy-dom keep them. So VT and FF, which are also in the collapse
+ * set, are deleted here before the collapse can see them: `a` VT `b` is `ab`, not `a b`.
+ *
+ * TAB, LF and CR are not in the set; they reach the collapse and become one space. NUL, U+007F
+ * and the C1 range, U+0085 included, are kept.
+ */
+declare function stripC0Controls(value: string): string;
+/**
+ * Normalize `%name%` markup placeholders to canonical `{name}`.
+ *
+ * Framework compilers consume bare `{name}` written in markup before the DOM
+ * walker ever sees it (Svelte compiles it to an expression; JSX evaluates it),
+ * so DOM content accepts `%name%` as a collision-free authoring escape.
+ * Normalization runs at every markup capture boundary (content-block
+ * tokenizer, `Translate` original-value snapshots, `Phrase` encoding), so the
+ * catalog, the wire, and translators only ever see the canonical `{name}`
+ * form — and plain `{name}` keeps working for vanilla-HTML authors.
+ *
+ * Keys must be identifiers (`[A-Za-z_][A-Za-z0-9_]*`), so literal `%` in
+ * prose ("20% off", "50% to 60%") can't match. `t()` phrases are JS strings
+ * with no compiler collision and stay `{name}`-only.
+ *
+ * It lives HERE, beside `normalizeTokenText`, because it decides a stored key:
+ * every capture boundary runs it, so the same authored content must pass through
+ * the same rewrite in every SDK or the key splits. It was in `interpolate.ts`,
+ * which is where the RENDER-time counterpart belongs, and where its docstring
+ * had drifted onto `adoptPercentPlaceholders` — two functions with one doc
+ * between them. `interpolate.ts` re-exports it, so no importer moves.
+ */
+declare function normalizeMarkupPlaceholders(text: string): string;
+/**
+ * Compute the deterministic content-block id from a `(category, tokens)` pair.
+ *
+ * JSON-stringifies the tuple so each token is unambiguously delimited
+ * (the previous `tokens.join('-')` was collision-prone for tokens
+ * containing a hyphen, e.g. `'e-mail'`).
+ *
+ * Pure function — same inputs always produce the same id. Exported so
+ * framework wrappers can compute the id themselves before deciding
+ * whether to call `registerContentBlock`.
+ */
+declare function generateCustomId(category: string, tokens: string[]): string;
+declare function canonicalContentBlockJson(category: string, tokens: string[]): string;
+/**
+ * The id this block would have had before the 0.6.0 MD5 fix.
+ *
+ * **Lookup only — never register under this.** Blocks registered by an older
+ * SDK are keyed by it, so `Translate` falls back to it when the corrected id
+ * misses, which keeps existing translations resolving instead of orphaning
+ * them. Registering under it would keep minting ids from a hash that both
+ * diverges across SDKs and can collide.
+ *
+ * Note the collision is a property of the FINAL hashed string, not the phrase:
+ * `JSON.stringify` shifts every character's offset, so the same phrase pair can
+ * collide standalone and not collide here — and changing `category` moves every
+ * character into different lanes. Always reason at this level, not at `md5()`.
+ *
+ * @deprecated Migration aid; will be removed once catalogs have been rebased.
+ */
+declare function generateLegacyCustomId(category: string, tokens: string[]): string;
+/**
+ * One node of a rich-phrase tree, in the host-neutral shape `encodeRichPhrase`
+ * walks.
+ *
+ * `{ text }` carries a text node's value VERBATIM — uncollapsed, untrimmed,
+ * because collapse runs once over the assembled string and not per node (see
+ * `encodeRichPhrase`). An element contributes its `children` plus an opaque
+ * `payload` handed straight back in `slots`, so a host keeps its own node handle
+ * without this module knowing what one is.
+ *
+ * Anything that is NEITHER text nor element — a comment, a CDATA section, a
+ * processing instruction — must contribute NO text and NO slot. The DOM adapter
+ * drops them outright.
+ *
+ * Measured, because the obvious wording here was wrong: mapping one to
+ * `{ text: '' }` is HARMLESS (`'a' + '' + 'b'` is still `'ab'`), so an adapter may
+ * do that freely. What splits the key is mapping it to its own DATA
+ * (`a<!-- note -->b` becoming `'a note b'`) or giving it a slot (`'a{m0o}{m0c}b'`,
+ * which also shifts every later slot index). Those two are the mistakes worth
+ * naming; "must be omitted" overstates the rule.
+ */
+type RichTextNode<T> = {
+    readonly text: string;
+}
+/** A marked value (VAR-3): its placeholder, `{NAME}`, never its text. */
+ | {
+    readonly param: string;
+} | {
+    readonly children: readonly RichTextNode<T>[];
+    readonly payload: T;
+};
+interface EncodedRichPhrase<T> {
+    /** The phrase string: the lookup key, and therefore the identity. */
+    phrase: string;
+    /** Each element's `payload`, in the order its markup token was assigned. */
+    slots: T[];
+}
+/**
+ * The `<Phrase>` identity rule, with no DOM in it.
+ *
+ * `<Phrase>` keys by a STRING, not by a token array and not by a `custom_id`:
+ * inline elements become neutral `{mNo}`/`{mNc}` markup-token pairs and the
+ * whole thing collapses to one sentence, which is then the catalog key. So this
+ * string is as load-bearing as `generateCustomId`'s output, and a second
+ * implementation of it re-keys every rich phrase the moment the two drift —
+ * silently, as a cache miss and a re-registration rather than an error.
+ *
+ * That is why it is here and generic over the host's node type: `langsys-js-server`
+ * renders `<Phrase>` from parse5 nodes and was otherwise going to write its own
+ * encoder. The DOM adapter is `encodeRichText` in `richtext.ts`, which is now
+ * nothing but a node-shape mapping over this function.
+ *
+ * Three details are identity and every adapter has to match them:
+ *
+ *  1. **Slot indices are assigned in pre-order**, parent before its children,
+ *     which is why `slots` comes back from here rather than being built by the
+ *     caller's walk. An adapter that numbered its own slots would have to
+ *     independently reproduce this order, and a nested phrase is where it would
+ *     not.
+ *  2. **Whitespace collapses ONCE, over the assembled string**, markup tokens
+ *     included — never per text node. `<p>a <em> b</em></p>` keeps the space
+ *     before `b` inside the markers; a per-node trim moves it outside them and
+ *     changes the key. This is the same mistake the attribute path made against
+ *     the text path, which is what split `custom_id` between this SDK and PHP.
+ *  3. **`%name%` normalizes after the collapse**, not before. The two orders
+ *     happen to agree today (an identifier cannot contain whitespace, so no
+ *     collapse creates or destroys a match) — stated because "it doesn't matter"
+ *     is not something a second implementation can verify, while "this order" is.
+ *
+ * The whitespace collapse is `normalizeTokenText`, deliberately SHARED with the
+ * token path so the disputed set (U+FEFF, U+0085, U+180E — see CONFORMANCE) has
+ * one definition to change when the spec rules. That sharing is about the
+ * whitespace set only: COALESCING adjacent text nodes stays opposite between the
+ * two paths, on purpose, and `content-block.ts` says so from its side.
+ */
+declare function encodeRichPhrase<T>(nodes: readonly RichTextNode<T>[]): EncodedRichPhrase<T>;
+
+/**
+ * Value markers (spec VAR-3): how an emitter tells a reader which printed text
+ * was a variable, and what it was called, so the reader registers a placeholder
+ * instead of one phrase per value (VAR-1).
+ *
+ *   <p>Hello <!--ls:name-->Ana<!--/ls-->, welcome back</p>
+ *   <p>Hello <span data-ls-param="name">Ana</span>, welcome back</p>
+ *   [{ text: 'Hello ' }, { comment: 'ls:name' }, { text: 'Ana' }, { comment: '/ls' }, { text: ', welcome back' }]
+ *
+ * all read as the one token `Hello {name}, welcome back`, with param `name` =
+ * `Ana`. The value is text only: an element inside the pair voids the marker,
+ * and its comments then split text as any comment does.
+ *
+ * Within one parent, the text on both sides of a marker, and every marker in
+ * between, merge into one run. Everything without a marker splits exactly as
+ * before, so no id derived from unmarked markup changes.
+ */
+/** The attribute form's attribute, for an emitter that cannot write comments. */
+declare const VAR_PARAM_ATTR = "data-ls-param";
+
+/**
+ * Placeholder names from source expressions (spec VAR-2). A name matches
+ * `[a-z][a-z0-9_]*`, so it is a valid ICU argument, and it is derived the same way
+ * by every SDK, because the name is part of the phrase: two SDKs naming the same
+ * expression differently register two phrases.
+ *
+ * Expressions are given as a language-neutral shape, the one the shared naming
+ * vectors (`var-naming-vectors.json`) use, so a binding maps its own AST onto it.
+ */
+/** An expression that produced a value, as the naming rules see it. */
+type ExpressionShape = {
+    identifier: string;
+} | {
+    member: string[];
+} | {
+    call: {
+        callee: string;
+        args: ExpressionShape[];
+    };
+} | {
+    other: 'binary' | 'conditional' | 'template' | 'computed' | 'call-multi' | string;
+};
+/** One value in a phrase: its expression, and the name the developer wrote, if any. */
+interface NamedExpression {
+    shape: ExpressionShape;
+    /** An explicit name always wins. */
+    explicit?: string;
+}
+/** A segment in snake_case, within the grammar, or null when nothing of it survives. */
+declare function snakeCase(segment: string): string | null;
+/**
+ * The placeholder name of each value in one phrase, in order (VAR-2):
+ *
+ * - an explicit name wins;
+ * - an identifier is itself in snake_case; a member chain its last segment; a
+ *   chain ending in `length`, `size` or `count` the segment before plus `_count`;
+ *   one ending in `value` or `current` the segment before; a call with one
+ *   argument the argument's name;
+ * - the same expression twice is the same placeholder, where the shape identifies
+ *   it: two shapes containing `other` are two placeholders, however equal;
+ * - names that collide are prefixed with their previous segment, then suffixed
+ *   `_2`, `_3`, and a reserved name (`m0o`) counts as taken;
+ * - anything else is `value`, `value_2`, ….
+ */
+declare function derivePlaceholderNames(expressions: readonly NamedExpression[]): string[];
+
+declare const isEmpty: (data: unknown) => boolean;
+/**
+ * MD5 of a string, matching a standard UTF-8 MD5 for all input.
+ *
+ * Content-block `custom_id`s are derived from this, so it's a wire identity —
+ * see `generateCustomId`. Before 0.6.0 this packed UTF-16 code units directly
+ * into byte lanes, which agreed with a real MD5 only for ASCII: non-ASCII
+ * input both diverged from every other Langsys SDK and could collide (a
+ * character's high byte was OR-ed into the neighbouring lane, vanishing
+ * whenever that lane already carried those bits — so `éa` and `ǩa` hashed
+ * alike). `md5Legacy` preserves the old behavior for migration lookups only.
+ */
+declare function md5(inputString: string): string;
+/**
+ * The pre-0.6.0 MD5, retained ONLY so existing content blocks stay resolvable:
+ * ids minted by an older SDK are keyed by this. Lookup-only — never register
+ * new content under it, or the colliding-id population keeps growing.
+ *
+ * @deprecated Migration aid; will be removed once catalogs have been rebased.
+ */
+declare function md5Legacy(inputString: string): string;
+
+/**
+ * Detects ICU MessageFormat syntax in a translation string.
+ *
+ *   - Matches `{var, plural, …}`, `{var, select, …}`, `{var, selectordinal, …}`,
+ *     `{var, number, …}`, `{var, date, …}`, `{var, time, …}`.
+ *   - Also matches the style-less forms `{var, number}`, `{var, date}`,
+ *     `{var, time}` — valid ICU with the locale-default style.
+ *   - Doesn't match plain interpolation slots like `{name}` or `{count}`.
+ *
+ * Exported because the Translation Manager UI needs the same detection logic
+ * to decide whether to render a plural-slot editor vs. a single text field.
+ */
+declare function isICU(template: string): boolean;
+/**
+ * Params keys that have NO matching placeholder in `texts`.
+ *
+ * A key counts as used when it appears as `{key}`, as the argument of an ICU
+ * slot (`{key, plural, …}`), or as `%key%`. Surrounding whitespace is tolerated
+ * in the brace forms.
+ *
+ * BOTH SPELLINGS, because `interpolate` resolves both. It used to accept the
+ * brace forms only, on the stated assumption that texts arrive canonical
+ * (post-`normalizeMarkupPlaceholders`). That held for the two internal callers
+ * and still does — `<Translate>` normalizes its tokens at capture and
+ * `<Phrase>`'s string comes out of `encodeRichText` already rewritten — but it
+ * stopped being true of the function itself once `interpolate` began adopting
+ * `%name%` at render time. A caller passing a raw stored translation then got
+ * `name` reported unused for a param that renders perfectly, and
+ * `warnUnmatchedParams` told them to "write %name% instead" — which is what they
+ * had written. This predicate and `adoptPercentPlaceholders` have to agree about
+ * what a placeholder is; they are two halves of one rule.
+ *
+ * The percent spelling is accepted only for keys that are IDENTIFIERS, matching
+ * `adoptPercentPlaceholders` exactly. A key like `a.b` never resolves from
+ * `%a.b%` — accepting it here would suppress a warning that is correct.
+ *
+ * A `<name>_gender` key counts as used wherever `name` is a placeholder. Langsys
+ * promotes a plain `{name}` to `{name_gender, select, …}` in gendered target
+ * locales, so an app passes the gender beside the value (`GenderParamsFor` types
+ * it), and the source text a caller checks never names it. Only a placeholder's
+ * companion: `team_gender` with no `{team}` in the text is still reported.
+ */
+declare function findUnusedParamKeys(texts: string[], params: Record<string, unknown> | undefined): string[];
+/**
+ * Substitute placeholders in a translated string with values from `params`.
+ *
+ * Two paths:
+ *   - ICU MessageFormat (target string contains `{var, plural|select|…, …}`):
+ *     parsed and formatted via `intl-messageformat`, which knows every
+ *     target locale's plural rules (Arabic's 6 categories, Russian's 4,
+ *     etc.) and gender-select branches.
+ *   - Simple `{name}` interpolation: cheap regex replacement. Unknown
+ *     placeholders are left untouched so missing data is visible to the
+ *     developer rather than silently rendering empty strings. Number and
+ *     Date values are formatted per the target locale's CLDR rules
+ *     (`Intl.NumberFormat` / `Intl.DateTimeFormat`) — pass numbers as
+ *     strings to opt out (e.g. IDs and codes that must not get grouping
+ *     separators).
+ *
+ * Malformed ICU falls through to simple interpolation rather than throwing,
+ * so the developer sees a broken-but-visible string instead of a runtime crash.
+ * Backend-side validation in langsys-ai is supposed to prevent this — the
+ * fall-through is defense in depth.
+ *
+ * `locale` is required for ICU formatting (drives plural-rule selection).
+ * Falls back to `'en'` if absent — simple-interpolation path ignores it.
+ *
+ * `params` may be omitted, and behaves as an empty map: a select or plural renders
+ * its `other` branch (ICU-1). Omitting it used to throw a TypeError inside recovery.
+ *
+ * `options` routes the two notices to the caller instead of this module's logger,
+ * for a host with a logger of its own — a server with a per-instance debug
+ * setting, where this module's process-wide logger is the wrong switch. See
+ * `InterpolateOptions`.
+ */
+declare function interpolate(template: string, params?: Record<string, unknown>, locale?: string, options?: InterpolateOptions): string;
+/**
+ * The argument names `interpolate` would default for these params (ICU-4): each
+ * `select`, `plural` or plain argument the template uses and `params` does not
+ * supply (`null` counts as not supplied), once each, in the order the recovery
+ * meets them. Empty for a plain template or one that does not parse.
+ *
+ * The same walk `interpolate` recovers with, so a host that emits the notice
+ * through its own logger names exactly the arguments the render defaulted.
+ */
+declare function defaultedArguments(template: string, params?: Record<string, unknown>, locale?: string): string[];
+/**
+ * Where `interpolate` reports what it recovered from. Each handler, when given,
+ * replaces this module's logger for that notice and is called on EVERY
+ * occurrence: gating and deduplication are then the caller's, so a host applies
+ * its own debug switch and its own `(template, locale)` dedupe. What the core
+ * logger does, and what a handler should reproduce:
+ *
+ * - `onDefaulted` (ICU-4): a missing argument was recovered with its neutral
+ *   branch. Debug level only; names every defaulted argument, once each, and the
+ *   locale.
+ * - `onFormatterFailure` (ICU-6): the formatter failed and the SDK's own branch
+ *   selection rendered the phrase. At every log level, naming the phrase, the
+ *   locale and the error.
+ */
+interface InterpolateOptions {
+    onDefaulted?: (names: string[], template: string, locale: string) => void;
+    onFormatterFailure?: (error: unknown, template: string, locale: string) => void;
+}
+
+/**
+ * Normalise a locale identifier to the SDK's single internal form: lowercase
+ * `xx-yy` — `en-US` → `en-us`, `zh-Hant-TW` → `zh-hant-tw`. Underscores are
+ * accepted and converted (`en_US` → `en-us`). Legacy aliases in the language,
+ * script and region are resolved through `Intl.getCanonicalLocales` (`iw` → `he`,
+ * `in-ID` → `id-id`, `sh-BA` → `sr-latn-ba`) BEFORE casing is flattened —
+ * lowercasing first would lose them, since the alias table is keyed on canonical
+ * tags.
+ *
+ * Variants and extensions are kept as written, lowercased: `en-US-POSIX` is
+ * `en-us-posix`. The API's locale codes are ICU locale ids (`en_US_POSIX`), and
+ * BCP 47 canonicalisation rewrites some of their variants into a code the API
+ * does not hold (`POSIX` becomes the extension `-u-va-posix`).
+ *
+ * Structurally invalid tags fall back to lowercasing rather than throwing, so a
+ * bad config value degrades to a failed catalog lookup instead of a crash — and
+ * warns, because that failure is otherwise indistinguishable from a legitimately
+ * untranslated locale.
+ */
+declare function canonicalizeLocale(locale: string): string;
+/**
+ * The `language-script` key of a locale after CLDR likely-subtags expansion
+ * (`Intl.Locale.maximize()`): `zh` → `zh-Hans`, `zh-TW` → `zh-Hant`,
+ * `sr` → `sr-Cyrl`. Two locales with the same key are mutually intelligible
+ * at the script level; two with different keys must not fall back to each
+ * other (a `zh-Hant` reader must never receive a `zh-Hans` catalog).
+ *
+ * Returns `null` when the tag can't be parsed — callers should treat that
+ * as "no match" rather than guessing.
+ */
+declare function maximizedLangScript(locale: string): string | null;
+
+export { createLegacyKeys as $, type AttributeReader as A, type SnapshotCatalog as B, CONTENT_BLOCK_MARKER_ATTR as C, DEFAULT_SERVER_MESSAGE_CATEGORY as D, type EncodedRichPhrase as E, type SnapshotCategory as F, SnapshotError as G, type SnapshotPayload as H, type InterpolateOptions as I, type SnapshotRefusal as J, type TFunction as K, LEGACY_FORMATS as L, TRANSLATABLE_ATTRIBUTES as M, NON_TRANSLATABLE_ELEMENTS as N, type TranslationParams as O, PHRASE_MARKER_ATTR as P, buildSnapshot as Q, RESOLVED_MARKER_ATTR as R, SNAPSHOT_FORMAT as S, type TArgs as T, canonicalContentBlockJson as U, VAR_PARAM_ATTR as V, canonicalSnapshotJson as W, canonicalizeLocale as X, convertLegacyCall as Y, convertLegacyPluralForms as Z, convertLegacyValue as _, CONTENT_BLOCK_MARKER_ATTRS as a, defaultedArguments as a0, derivePlaceholderNames as a1, encodeRichPhrase as a2, fillTemplate as a3, findUnusedParamKeys as a4, generateCustomId as a5, generateLegacyCustomId as a6, type iContentBlock as a7, interpolate as a8, isEmpty as a9, isICU as aa, isTranslationExcluded as ab, maximizedLangScript as ac, md5 as ad, md5Legacy as ae, normalizeMarkupPlaceholders as af, normalizeTokenText as ag, parseSnapshot as ah, resolveServerMessages as ai, snakeCase as aj, snapshotChecksum as ak, stripC0Controls as al, templateMarkers as am, toServerMessage as an, CONTENT_BLOCK_MARKER_ATTR_LEGACY as b, type CatalogSnapshot as c, type ExpressionShape as d, type ExtractParamKeys as e, type LegacyConversion as f, type LegacyEntryPoint as g, type LegacyFormat as h, LegacyFormatError as i, type LegacyKeyFile as j, type LegacyKeyHit as k, type LegacyKeyProblem as l, type LegacyKeys as m, type NamedExpression as n, PHRASE_MARKER_ATTRS as o, PHRASE_MARKER_ATTR_LEGACY as p, type ParamPrimitive as q, type ParamsFor as r, RESOLVED_MARKER_ATTRS as s, RESOLVED_MARKER_ATTR_LEGACY as t, type ResolveServerMessagesOptions as u, type RichTextNode as v, SNAPSHOT_VERSION as w, SUPPORTED_LEGACY_FORMATS as x, type ServerMessage as y, type ServerMessagePieces as z };