langsys-js-react 0.6.7 → 0.7.0

package/dist/babel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transform/naming.ts","../src/transform/babel.ts"],"names":["derivePlaceholderNames","NON_TRANSLATABLE_ELEMENTS","TRANSLATABLE_ATTRIBUTES","stripC0Controls","unwrap","tag"],"mappings":"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","file":"babel.js","sourcesContent":["/**\n * Placeholder names for interpolated expressions (spec VAR-2).\n *\n * The names are the core's: `derivePlaceholderNames` decides them for every SDK from each\n * expression's shape, so the same expression gets the same name everywhere. This module only maps\n * a Babel expression onto that shape:\n *\n * - an identifier → `{ identifier }`\n * - a member chain (optional or not, type wrappers ignored) → `{ member: [segments] }`\n * - a call → `{ call: { callee, args: [shapes] } }`, `callee` its dotted name or `''` when it cannot\n *   be spelled (the core names a call with a single argument)\n * - a computed member, a binary, logical or conditional expression, a template literal, a call\n *   with a spread argument, anything else → `{ other }`\n *\n * A name the developer wrote explicitly elsewhere in the phrase — a `%name%` in its text, a key of\n * its `params` — is passed to the core as taken, so a derived name avoids it.\n */\nimport type { types as t } from '@babel/core';\nimport { derivePlaceholderNames, type ExpressionShape } from 'langsys-js-typescript/pure';\n\n/** An expression with type-only wrappers removed. */\nfunction unwrap(e: t.Node): t.Node {\n    let n = e;\n    while (\n        n.type === 'TSAsExpression' ||\n        n.type === 'TSNonNullExpression' ||\n        n.type === 'TSSatisfiesExpression' ||\n        n.type === 'TSTypeAssertion' ||\n        n.type === 'ParenthesizedExpression'\n    ) {\n        n = n.expression;\n    }\n    return n;\n}\n\n/** The static segments of a member chain; null when any segment is computed. */\nfunction segments(e: t.Node): string[] | null {\n    const n = unwrap(e);\n    if (n.type === 'Identifier') return [n.name];\n    if (n.type === 'ThisExpression') return [];\n    if (n.type === 'MemberExpression' || n.type === 'OptionalMemberExpression') {\n        if (n.computed || n.property.type !== 'Identifier') return null;\n        const head = segments(n.object);\n        return head ? [...head, n.property.name] : null;\n    }\n    return null;\n}\n\n/** The shape of an expression, as the core's naming reads it. */\nexport function shapeOf(e: t.Node): ExpressionShape {\n    const n = unwrap(e);\n    if (n.type === 'Identifier') return { identifier: n.name };\n    if (n.type === 'MemberExpression' || n.type === 'OptionalMemberExpression') {\n        const segs = segments(n);\n        return segs && segs.length ? { member: segs } : { other: 'computed' };\n    }\n    if (n.type === 'CallExpression' || n.type === 'OptionalCallExpression') {\n        const args = n.arguments;\n        if (args.some((x) => x.type === 'SpreadElement' || x.type === 'ArgumentPlaceholder')) return { other: 'call-multi' };\n        const callee = segments(n.callee);\n        // A callee that cannot be spelled (`getA()(n)`, `fmt[a](x)`) is '': the core then knows the\n        // call does not identify its expression, so two of them are two placeholders.\n        return { call: { callee: callee ? callee.join('.') : '', args: args.map((x) => shapeOf(x)) } };\n    }\n    if (n.type === 'BinaryExpression' || n.type === 'LogicalExpression') return { other: 'binary' };\n    if (n.type === 'ConditionalExpression') return { other: 'conditional' };\n    if (n.type === 'TemplateLiteral') return { other: 'template' };\n    return { other: n.type };\n}\n\n/** Whether the core can derive a name from this shape rather than numbering it `value`. */\nfunction derivable(shape: ExpressionShape): boolean {\n    if ('identifier' in shape || 'member' in shape) return true;\n    if ('call' in shape) return shape.call.args.length === 1 && derivable(shape.call.args[0]);\n    return false;\n}\n\nexport interface Named {\n    /** The expression's source text; the same text is the same placeholder. */\n    source: string;\n    expression: t.Expression;\n    name: string;\n    /** True when no name could be derived and the core numbered it `value`. */\n    unnameable: boolean;\n}\n\n/**\n * Name the values of one phrase, in order, index-aligned with `expressions`. `taken` holds names\n * the developer wrote explicitly in the same phrase.\n */\nexport function nameAll(\n    expressions: Array<{ source: string; expression: t.Expression }>,\n    taken: Iterable<string> = [],\n): Named[] {\n    const explicit = [...taken];\n    const shapes = expressions.map((x) => shapeOf(x.expression));\n    const names = derivePlaceholderNames([\n        ...explicit.map((name) => ({ shape: { other: 'explicit' } as ExpressionShape, explicit: name })),\n        ...shapes.map((shape) => ({ shape })),\n    ]).slice(explicit.length);\n    return expressions.map((x, i) => ({ ...x, name: names[i], unnameable: !derivable(shapes[i]) }));\n}\n","/**\n * langsys-js-react/babel — the placeholder transform (spec VAR-6), as a Babel plugin.\n *\n * A value interpolated into translated text becomes a named placeholder, and the value travels as\n * its param, so one sentence registers once however many users it is shown to (VAR-1):\n *\n *   <Translate>Hello {user.name}</Translate>\n *     → <Translate params={{ name: user.name }}>Hello %name%</Translate>\n *\n *   t(`You have ${items.length} items`)\n *     → t('You have {items_count} items', undefined, { items_count: items.length })\n *\n * A subtree the core shows as written — `<DontTranslate>`, a host element with `translate=\"no\"` or\n * `data-notrans`, or code and notation (`<template>`, `<noscript>`, `<math>`) — is never translated:\n * a phrase keys it as one opaque element and restores its content, and a block keeps it in its\n * stored content. A value there therefore stays where it is, in both components, and is marked as a\n * value (VAR-3) rather than replaced, so the page shows the value and a block's stored content holds\n * its placeholder; where no marker can stand (below) it is left as written instead. A `translate`\n * or `data-notrans` whose value is an expression is known only at runtime. In a `<Translate>` a\n * value under it is marked and passed as a param too, so excluded it shows as written, and\n * translated the core reads the marker as its placeholder and fills it from the param, which wins\n * over the marked text. In a `<Phrase>` it is a placeholder like any other: translated, the phrase\n * fills it; excluded, the core keys the element as one empty pair and fills the caller's params into\n * an author's exclusion. A `<Phrase>` holding a marker of its own in its text (inside a conditional\n * or a component too) is served as its source until a translation exists, so its other values are\n * marked too, and passed as params; one in its translated text where no marker can stand is left\n * as written, and the phrase gets `data-ls-unnamed`. A name a marker already carries is taken, as an\n * explicit `%name%` is. An opt-out passed through a spread is not seen. Where no marker element\n * can stand — inside MathML and SVG an HTML `<span>` draws nothing, and `<textarea>`, `<title>` and\n * `<option>` hold text only — a value in such a subtree is left as written, and a `<Translate>`,\n * which would store it, gets `data-ls-unnamed` and registers nothing (VAR-7); a `<Phrase>` keys the\n * subtree as one empty pair. `<script>`, `<style>` and `<plaintext>` hold raw text, which a block\n * stores as written and a phrase keys as one empty pair: a value there is left as written, and a `<Translate>`\n * holding one gets `data-ls-unnamed`.\n *\n *   <Translate>Signed in as <DontTranslate>{user.email}</DontTranslate></Translate>\n *     → <Translate>Signed in as <DontTranslate><span data-ls-param=\"email\">{user.email}</span></DontTranslate></Translate>\n *\n * A block's tokens begin with each element's attributes a translator reads (TOK-3: the core's\n * `TRANSLATABLE_ATTRIBUTES`, and the value of a button or a submit or button input), so in a\n * `<Translate>` a value in one is a placeholder too. A value only in attributes' text travels as the\n * string JavaScript writes there; one that is the whole attribute, or also in the content, travels\n * as given and fills its placeholder as a value fills text, and one React renders as nodes (a list,\n * an object) is put back as a whole prop and fills an attribute's text as JavaScript writes it into a\n * string (`withNodeParams`). On an element whose opt-out or input type is\n * an expression, which only the page decides, the value is left as written and the `<Translate>`\n * gets `data-ls-unnamed`. A `<Phrase>` keys none of its elements' attributes, so they are left as\n * written there.\n *\n *   <Translate><img alt={`Photo of ${user.name}`} /> Hi {user.name}</Translate>\n *     → <Translate params={{ name: user.name }}><img alt={\"Photo of %name%\"} /> Hi %name%</Translate>\n *\n * The core reads `%name%` left to right, so where the text before a value ends in a `%` and a name\n * it has not closed (`%s{x}`), the placeholder's own `%` would close it; there the placeholder is\n * written in the stored form, `{name}`, which the core reads the same way (`%s{x}`). The text is read\n * as the core registers it (C0 control characters dropped) and as it renders it (kept).\n *\n * Only `<Translate>` and `<Phrase>` imported from `langsys-js-react` are rewritten, and only the\n * children a host element, a fragment or `<DontTranslate>` renders as text: an expression inside a\n * nested host element (`<b>{x}</b>`) is included; one that is itself JSX or holds JSX\n * (`items.map((i) => <li>…`), a conditional, already marked (`data-ls-param`), or sits inside\n * another component or a nested `<Translate>` / `<Phrase>` is left alone, since React renders nodes\n * from it rather than a value's text. `{children}` (under any TypeScript cast) that is all the\n * text of its run in translated text (what React renders between two elements) is content to\n * translate and is left alone; beside text, or in a subtree that is not translated, it is a value. A value whose type only the page knows, an element held in a variable, is rewritten like\n * any other, and `<Translate>` / `<Phrase>` render it in its placeholder's place\n * (`withNodeParams`). String, number and plain template literals (`{' '}`, `{3}`) are static text,\n * and a fragment (`<>…</>`, React's `Fragment`) is unwrapped, as React passes its children on. A\n * children list the transform changes reaches React as a JSX compiler hands it over from the\n * source, each run of text one string (JSX's whitespace rule applied, a comment dropped), so the\n * runtime never takes a unit's own text for a value split from it (VAR-7); this holds in the JSX\n * compiler's own Babel pass and when the output is compiled again. `t()` calls are rewritten where\n * `t` is the binding a `useT()` call made (and `<Translate>` / `<Phrase>` matched by their import's\n * binding), so another function named `t` is left alone. A `+` chain joins as JavaScript joins it:\n * a sum before the first string, or in parentheses, is one value. A key built in the call (its own\n * text has no space: `errors.${code}`, `status_${status}`) is left as it is, since legacy-key mode\n * looks it up as built. A name the developer wrote (`%name%` anywhere in a unit, a key of a params\n * literal, `{name}` in a `t()` text whose params the build cannot read into: a variable, a spread)\n * is never given to a value. Names follow VAR-2 (`./naming`); an expression\n * no name can be derived from is named `value`, `value_2`, … and reported in\n * `file.metadata.langsys.warnings`, which the Vite plugin and the Next loader surface as build\n * warnings.\n */\nimport type { NodePath, PluginObj, PluginPass, types as t } from '@babel/core';\nimport { NON_TRANSLATABLE_ELEMENTS, TRANSLATABLE_ATTRIBUTES, stripC0Controls } from 'langsys-js-typescript/pure';\nimport { nameAll, type Named } from './naming.js';\n\nconst SOURCE = 'langsys-js-react';\nconst TARGETS = new Set(['Translate', 'Phrase']);\nconst VERBATIM = 'DontTranslate';\n/**\n * Elements whose content is raw text, which a block stores as written: a value there is left as\n * written. A parser reads everything after a `<plaintext>` start tag as text, to the end of the input.\n */\nconst RAW_TEXT = new Set(['script', 'style', 'plaintext']);\n/** Elements that hold text only, where a marker element is not drawn or not allowed. */\nconst TEXT_ONLY = new Set(['textarea', 'title', 'option']);\n/**\n * A button's value, and a submit or button input's, is a label the core reads as text: its\n * VALUE_TRANSLATABLE_ELEMENTS and VALUE_TRANSLATABLE_INPUT_TYPES, which no entry exports.\n */\nconst VALUE_ELEMENTS = new Set(['button']);\nconst VALUE_INPUT_TYPES = new Set(['submit', 'button']);\n\n/**\n * How a value is written where it stands: `text` in translated text, replaced by `%name%` and a\n * param; `shown` where the core shows the content as written, marked (VAR-3); `unknown`, in a\n * `<Translate>` only, under an opt-out whose value only the page knows, marked and passed as a param\n * too.\n */\ntype Mode = 'text' | 'shown' | 'unknown';\n\ninterface Where {\n    mode: Mode;\n    /** The foreign namespace the value is in, MathML or SVG, where an HTML `<span>` draws nothing. */\n    foreign: 'math' | 'svg' | null;\n    /** Whether no marker element can stand here: in a foreign namespace, or in an element that holds text only. */\n    markerless: boolean;\n}\n\n/** Set on a `<Translate>` that would store a value the transform left as written: it registers nothing (VAR-7). */\nconst UNNAMED = 'data-ls-unnamed';\nconst EXPLICIT = /%([A-Za-z_][A-Za-z0-9_]*)%/g;\n/** A placeholder as a `t()` text writes it: `{name}`, or an ICU argument `{name, plural, …}`. */\nconst BRACED = /\\{\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*[,}]/g;\n\nexport interface LangsysTransformMetadata {\n    /** One entry per unnameable expression: where it is, and the name it was given. */\n    warnings: Array<{ line: number | null; column: number | null; source: string; name: string }>;\n    /** How many units were rewritten. */\n    rewritten: number;\n}\n\ninterface State extends PluginPass {\n    targets: Set<string>;\n    /** Local names of `<Phrase>`, which keys code, notation and an author's exclusion as one empty pair. */\n    phrases: Set<string>;\n    verbatim: Set<string>;\n    /** Local names of React's `Fragment`, and of the `react` module itself (`React.Fragment`). */\n    fragments: Set<string>;\n    reactModules: Set<string>;\n    hooks: Set<string>;\n    /**\n     * The declaring identifiers of `<Translate>` / `<Phrase>` and `useT` imported from the package, and\n     * of each `t` a `useT()` call bound: a binding's identifier is the same node after another plugin\n     * in the pass crawls the scope again, where its `Binding` object is not.\n     */\n    targetBindings: Set<t.Identifier>;\n    hookBindings: Set<t.Identifier>;\n    tBindings: Set<t.Identifier>;\n    meta: LangsysTransformMetadata;\n}\n\ntype Babel = { types: typeof t };\n\nexport default function langsysPlaceholders({ types: T }: Babel): PluginObj<State> {\n    const sourceOf = (state: State, node: t.Node) => state.file.code.slice(node.start ?? 0, node.end ?? 0);\n\n    const warn = (state: State, n: Named) => {\n        if (!n.unnameable) return;\n        const loc = n.expression.loc?.start;\n        state.meta.warnings.push({ line: loc?.line ?? null, column: loc?.column ?? null, source: n.source, name: n.name });\n    };\n\n    /**\n     * Names the developer already wrote: as `%name%` (or, in a `t()` text, `{name}`) in static text,\n     * or as keys of a params literal.\n     */\n    const explicitNames = (texts: string[], params: t.Expression | null, written = EXPLICIT): Set<string> => {\n        const out = new Set<string>();\n        for (const s of texts) for (const m of s.matchAll(written)) out.add(m[1]);\n        if (params && params.type === 'ObjectExpression') {\n            for (const p of params.properties) {\n                if (p.type === 'ObjectProperty' && !p.computed) {\n                    if (p.key.type === 'Identifier') out.add(p.key.name);\n                    else if (p.key.type === 'StringLiteral') out.add(p.key.value);\n                }\n            }\n        }\n        return out;\n    };\n\n    /**\n     * Whether the core shows a host element's subtree as written: `shown` for code and notation\n     * (`NON_TRANSLATABLE_ELEMENTS`) or an opt-out in its attributes as `isTranslationExcluded` reads\n     * them (`translate` equal to `no` in any case, or `data-notrans` present and not `false` / `0`);\n     * `unknown` when such an attribute's value is an expression, which only the page knows; null\n     * otherwise.\n     */\n    const optOut = (tag: string, opening: t.JSXOpeningElement): 'shown' | 'unknown' | null => {\n        if (NON_TRANSLATABLE_ELEMENTS.includes(tag)) return 'shown';\n        let unknown = false;\n        for (const a of opening.attributes) {\n            if (a.type !== 'JSXAttribute' || a.name.type !== 'JSXIdentifier') continue;\n            if (a.name.name !== 'translate' && a.name.name !== 'data-notrans') continue;\n            const text = attributeText(a);\n            if (text === undefined) unknown = true;\n            else if (a.name.name === 'translate' ? text.toLowerCase() === 'no' : !['false', '0'].includes(text.trim().toLowerCase())) {\n                return 'shown';\n            }\n        }\n        return unknown ? 'unknown' : null;\n    };\n\n    /**\n     * Whether the core reads an attribute as text to translate: one of its `TRANSLATABLE_ATTRIBUTES`,\n     * or the value of a button or of a submit or button input; `undefined` when an expression\n     * decides the input's type.\n     */\n    const readsAsText = (tag: string, opening: t.JSXOpeningElement, name: string): boolean | undefined => {\n        if ((TRANSLATABLE_ATTRIBUTES as readonly string[]).includes(name)) return true;\n        if (name !== 'value') return false;\n        if (VALUE_ELEMENTS.has(tag)) return true;\n        if (tag !== 'input') return false;\n        let type: string | undefined = '';\n        for (const a of opening.attributes) {\n            if (a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'type') type = attributeText(a);\n        }\n        return type === undefined ? undefined : VALUE_INPUT_TYPES.has(type.toLowerCase());\n    };\n\n    /** `children`, or `x.children`, under any TypeScript cast or assertion: the content a wrapper is given. */\n    const isChildren = (e: t.Expression): boolean => {\n        while (\n            e.type === 'TSAsExpression' ||\n            e.type === 'TSSatisfiesExpression' ||\n            e.type === 'TSNonNullExpression' ||\n            e.type === 'TSTypeAssertion' ||\n            e.type === 'ParenthesizedExpression'\n        ) {\n            e = e.expression;\n        }\n        return (\n            (e.type === 'Identifier' && e.name === 'children') ||\n            ((e.type === 'MemberExpression' || e.type === 'OptionalMemberExpression') &&\n                !e.computed &&\n                e.property.type === 'Identifier' &&\n                e.property.name === 'children')\n        );\n    };\n\n    /** An expression holding JSX: React renders nodes from it, not a value's text. */\n    const holdsJsx = (e: t.Node): boolean => {\n        let jsx = false;\n        T.traverseFast(e, (n) => {\n            if (n.type === 'JSXElement' || n.type === 'JSXFragment') jsx = true;\n        });\n        return jsx;\n    };\n\n    /** A literal's text, for the literals that are static text: string, number, and a template with no expression. */\n    const literalOf = (e: t.Node): string | undefined =>\n        e.type === 'StringLiteral' || e.type === 'NumericLiteral'\n            ? String(e.value)\n            : e.type === 'TemplateLiteral' && !e.expressions.length\n              ? (e.quasis[0].value.cooked ?? undefined)\n              : undefined;\n\n    /** Whether an element is React's `Fragment` (`<Fragment>`, `<React.Fragment>`), imported from `react`. */\n    const isFragment = (state: State, name: t.JSXOpeningElement['name']): boolean =>\n        (name.type === 'JSXIdentifier' && state.fragments.has(name.name)) ||\n        (name.type === 'JSXMemberExpression' &&\n            name.object.type === 'JSXIdentifier' &&\n            state.reactModules.has(name.object.name) &&\n            name.property.name === 'Fragment');\n\n    /** Every static text in a unit, where a `%name%` may be written: its text, attributes and string literals. */\n    const staticTexts = (unit: t.JSXElement): string[] => {\n        const out: string[] = [];\n        for (const child of unit.children) {\n            T.traverseFast(child, (n) => {\n                if (n.type === 'JSXText' || n.type === 'StringLiteral') out.push(n.value);\n                else if (n.type === 'TemplateElement') out.push(n.value.cooked ?? n.value.raw);\n            });\n        }\n        return out;\n    };\n\n    /** Whether a node holds a value marker anywhere in it. */\n    const holdsMarker = (node: t.Node): boolean => {\n        let found = false;\n        T.traverseFast(node, (n) => {\n            if (n.type === 'JSXOpeningElement' && marks(n)) found = true;\n        });\n        return found;\n    };\n\n    /** The names the value markers in a unit already carry: taken, as an explicit `%name%` is. */\n    const markedNames = (unit: t.JSXElement): Set<string> => {\n        const out = new Set<string>();\n        for (const child of unit.children) {\n            T.traverseFast(child, (n) => {\n                if (n.type !== 'JSXAttribute' || n.name.type !== 'JSXIdentifier' || n.name.name !== 'data-ls-param') return;\n                const name = n.value ? attributeText(n) : undefined;\n                if (name) out.add(name.trim());\n            });\n        }\n        return out;\n    };\n\n    /** Whether a host element is already a value marker, holding its value (VAR-3). */\n    const marks = (opening: t.JSXOpeningElement): boolean =>\n        opening.attributes.some(\n            (a) => a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'data-ls-param',\n        );\n\n    /** An attribute's value as the DOM reads it: `''` when bare, undefined when it is an expression. */\n    const attributeText = (a: t.JSXAttribute): string | undefined => {\n        const v = a.value;\n        if (!v) return '';\n        if (v.type === 'StringLiteral') return v.value;\n        if (v.type === 'JSXExpressionContainer' && v.expression.type === 'StringLiteral') return v.expression.value;\n        return undefined;\n    };\n\n    /** The value marker (VAR-3) around an expression: `<span data-ls-param=\"name\">{expression}</span>`. */\n    const marker = (name: string, expression: t.Expression): t.JSXElement =>\n        T.jsxElement(\n            T.jsxOpeningElement(T.jsxIdentifier('span'), [\n                T.jsxAttribute(T.jsxIdentifier('data-ls-param'), T.stringLiteral(name)),\n            ]),\n            T.jsxClosingElement(T.jsxIdentifier('span')),\n            [T.jsxExpressionContainer(expression)],\n        );\n\n    /** A JSX text as a JSX compiler hands it to React: its lines trimmed and joined (React's JSX whitespace rule). */\n    const asRendered = (text: t.JSXText): string => {\n        const [s] = T.react.buildChildren(\n            T.jsxElement(T.jsxOpeningElement(T.jsxIdentifier('x'), []), T.jsxClosingElement(T.jsxIdentifier('x')), [text]),\n        );\n        return s?.type === 'StringLiteral' ? s.value : '';\n    };\n\n    /**\n     * A run of text written so every JSX compiler hands React exactly `value`, in its own Babel pass\n     * (the node's value) and from the generated code (its raw form): JSX text, with the characters\n     * JSX gives a meaning to as entities, or a string literal where a line break, a tab or a line or\n     * paragraph separator would be trimmed or read differently by another compiler.\n     */\n    /**\n     * A placeholder as the core reads it after `before`: `%name%`, unless `before` ends in a `%` and a\n     * name the core has not closed, which the placeholder's own `%` would close (`%s` then `%x%` reads\n     * as `%s%`); there it is written in the stored form, `{name}`, which the core reads the same way.\n     * The core reads a unit's text as it registers it, with C0 control characters dropped, and as it\n     * renders it, with them kept, so `{name}` is written where either reading would close an open name.\n     */\n    const placeholderAfter = (before: string, name: string): string => {\n        const open = (text: string) => /%[A-Za-z_][A-Za-z0-9_]*$/.test(text.replace(EXPLICIT, '\\0'));\n        return open(before) || open(stripC0Controls(before)) ? `{${name}}` : `%${name}%`;\n    };\n\n    const textNode = (value: string): t.JSXText | t.JSXExpressionContainer => {\n        if (/[\\r\\n\\t\\u2028\\u2029]/.test(value)) return T.jsxExpressionContainer(T.stringLiteral(value));\n        const node = T.jsxText(value);\n        node.extra = { raw: value.replace(/[&<>{}]/g, (c) => `&#${c.charCodeAt(0)};`), rawValue: value };\n        return node;\n    };\n\n    /**\n     * One param per placeholder. Every expression is named by the core in order (VAR-2), and its\n     * names decide what repeats: a self-naming expression written twice is one placeholder, so its\n     * later occurrences share the first's name and param; an unnameable one is its own placeholder\n     * every time, even when its source text repeats, since `{a + b}` twice cannot be told from\n     * `{i++}` twice. Source text is never compared.\n     */\n    const placeholders = (named: Named[]): Named[] => {\n        const seen = new Set<string>();\n        return named.filter((n) => !seen.has(n.name) && seen.add(n.name));\n    };\n\n    const mergeParams = (existing: t.Expression | null, named: Named[]): t.Expression => {\n        const props = named.map((n) => T.objectProperty(T.identifier(n.name), n.expression));\n        if (!existing) return T.objectExpression(props);\n        if (existing.type === 'ObjectExpression') return T.objectExpression([...existing.properties, ...props]);\n        return T.objectExpression([T.spreadElement(existing), ...props]);\n    };\n\n    // ---- JSX: <Translate> / <Phrase> children --------------------------------------------------\n\n    function rewriteTarget(path: NodePath<t.JSXElement>, state: State) {\n        const found: Array<{\n            source: string;\n            expression: t.Expression;\n            /** Whether it travels as a param: in translated text, or under an opt-out only the page knows. */\n            param: boolean;\n            /** Text in translated text where no marker element can stand. */\n            bare: boolean;\n            /** In an attribute's text, the value as JavaScript writes it into the string. */\n            text?: t.Expression;\n            replace: (name: string) => void;\n        }> = [];\n        const tag = path.node.openingElement.name;\n        const isPhrase = tag.type === 'JSXIdentifier' && state.phrases.has(tag.name);\n        let unnamed = false;\n        /**\n         * A phrase holding a marker in its text is served as its source until a translation exists\n         * (the core keeps its markers), so its other values are marked too, and passed as params.\n         */\n        let markAll = false;\n        /** Text this transform wrote (a literal, a placeholder), which React shows as it is. */\n        const asWritten = new WeakSet<t.JSXText>();\n        /** The placeholders it wrote, by name: settled into their run's text as the core reads them there. */\n        const placeholderNames = new WeakMap<t.JSXText, string>();\n        const written = (value: string): t.JSXText => {\n            const node = T.jsxText(value);\n            asWritten.add(node);\n            return node;\n        };\n        /** The children lists this transform changed, each settled into one string per run of text. */\n        const touched = new Set<t.JSXElement['children']>();\n        /**\n         * A changed list as React receives it from the source: each run of text (JSX text, written\n         * text) one string, and a comment between two texts gone, as a JSX compiler drops it. A\n         * value split from its sentence in separate strings is how the runtime tells a value the\n         * transform did not name (VAR-7), so text the transform wrote never arrives split.\n         */\n        const settle = (children: t.JSXElement['children']) => {\n            const out: t.JSXElement['children'] = [];\n            let run = '';\n            for (const c of children) {\n                if (c.type === 'JSXText') {\n                    const name = placeholderNames.get(c);\n                    run += name !== undefined ? placeholderAfter(run, name) : asWritten.has(c) ? c.value : asRendered(c);\n                }\n                else if (c.type === 'JSXExpressionContainer' && c.expression.type === 'JSXEmptyExpression') continue;\n                else {\n                    if (run) out.push(textNode(run));\n                    run = '';\n                    out.push(c);\n                }\n            }\n            if (run) out.push(textNode(run));\n            children.splice(0, children.length, ...out);\n        };\n\n        /**\n         * A fragment's children in its place: React passes them on to the parent's, so its text joins\n         * the run around it.\n         */\n        const unwrap = (children: t.JSXElement['children']) => {\n            for (let i = 0; i < children.length; i++) {\n                const c = children[i];\n                if (c.type === 'JSXFragment' || (c.type === 'JSXElement' && isFragment(state, c.openingElement.name))) {\n                    children.splice(i--, 1, ...c.children);\n                    touched.add(children);\n                }\n            }\n        };\n\n        /**\n         * Whether the child at `i` is all the text of its run (what React renders between two\n         * elements): `{children}` there is content to translate, and beside text a value.\n         */\n        const aloneInRun = (children: t.JSXElement['children'], i: number): boolean => {\n            for (const step of [-1, 1]) {\n                for (let j = i + step; j >= 0 && j < children.length; j += step) {\n                    const d = children[j];\n                    if (d.type === 'JSXElement' || d.type === 'JSXFragment') break;\n                    if (d.type === 'JSXText') {\n                        if ((asWritten.has(d) ? d.value : asRendered(d)).trim()) return false;\n                        continue;\n                    }\n                    if (d.type === 'JSXSpreadChild') return false;\n                    const x = d.expression;\n                    if (x.type === 'JSXEmptyExpression') continue;\n                    const literal = literalOf(x);\n                    if (literal !== undefined) {\n                        if (literal.trim()) return false;\n                        continue;\n                    }\n                    if (holdsJsx(x)) break;\n                    return false;\n                }\n            }\n            return true;\n        };\n\n        /**\n         * A block's tokens begin with each element's attributes a translator reads (TOK-3), so a\n         * value in one is a placeholder, as in the text, and a value in its text travels as\n         * JavaScript writes it there. A phrase keys none of its elements' attributes. Under an\n         * opt-out only the page knows, or on an input whose type only the page knows, the value is\n         * left as written and the block, which might key it, registers nothing.\n         */\n        const attributes = (opening: t.JSXOpeningElement, tag: string, mode: Mode) => {\n            if (mode === 'shown') return;\n            for (const a of opening.attributes) {\n                if (a.type !== 'JSXAttribute' || a.name.type !== 'JSXIdentifier' || a.value?.type !== 'JSXExpressionContainer') continue;\n                const e = a.value.expression;\n                if (e.type === 'JSXEmptyExpression' || literalOf(e) !== undefined) continue;\n                if (e.type === 'LogicalExpression' || e.type === 'ConditionalExpression' || holdsJsx(e)) continue;\n                const reads = readsAsText(tag, opening, a.name.name);\n                if (reads === false) continue;\n                if (reads === undefined || mode === 'unknown') {\n                    unnamed = true;\n                    continue;\n                }\n                const parts = pieces(e) ?? [e];\n                const inTemplate = new WeakSet<t.Node>();\n                T.traverseFast(e, (n) => {\n                    if (n.type === 'TemplateLiteral') n.expressions.forEach((x) => inTemplate.add(x));\n                });\n                const names: string[] = [];\n                const attr = a;\n                parts.forEach((p, k) => {\n                    if (typeof p === 'string') return;\n                    found.push({\n                        source: sourceOf(state, p),\n                        expression: p,\n                        param: true,\n                        bare: false,\n                        text:\n                            p === e\n                                ? undefined\n                                : inTemplate.has(p)\n                                  ? T.templateLiteral([T.templateElement({ raw: '' }), T.templateElement({ raw: '' }, true)], [p])\n                                  : T.binaryExpression('+', T.stringLiteral(''), p),\n                        replace: (name) => {\n                            names[k] = name;\n                            const value = parts.reduce<string>((out, q, j) => out + (typeof q === 'string' ? q : placeholderAfter(out, names[j] ?? '')), '');\n                            attr.value = T.jsxExpressionContainer(T.stringLiteral(value));\n                        },\n                    });\n                });\n            }\n        };\n\n        const walk = (children: t.JSXElement['children'], where: Where) => {\n            unwrap(children);\n            children.forEach((c, i) => {\n                if (c.type === 'JSXExpressionContainer') {\n                    const e = c.expression;\n                    if (e.type === 'JSXEmptyExpression') {\n                        touched.add(children);\n                        return;\n                    }\n                    const literal = literalOf(e);\n                    if (literal !== undefined) {\n                        children[i] = written(literal);\n                        touched.add(children);\n                        return;\n                    }\n                    if (\n                        e.type === 'JSXElement' ||\n                        e.type === 'JSXFragment' ||\n                        e.type === 'LogicalExpression' ||\n                        e.type === 'ConditionalExpression' ||\n                        holdsJsx(e) ||\n                        (where.mode === 'text' && isChildren(e) && aloneInRun(children, i))\n                    ) {\n                        if (isPhrase && where.mode === 'text' && holdsMarker(e)) markAll = true;\n                        return;\n                    }\n                    if (where.mode !== 'text' && where.markerless) {\n                        // A marker element inside MathML or SVG draws nothing, and an element that\n                        // holds text only cannot take one, so the value is left as written. A block\n                        // would store it in its content; a phrase keys code, notation and an\n                        // exclusion as one empty pair.\n                        if (!isPhrase) unnamed = true;\n                        return;\n                    }\n                    touched.add(children);\n                    found.push({\n                        source: sourceOf(state, e),\n                        expression: e,\n                        param: where.mode !== 'shown',\n                        bare: where.mode === 'text' && where.markerless,\n                        replace: (name) => {\n                            if (where.mode !== 'text' || markAll) {\n                                children[i] = marker(name, e);\n                                return;\n                            }\n                            const text = written(`%${name}%`);\n                            placeholderNames.set(text, name);\n                            children[i] = text;\n                        },\n                    });\n                } else if (c.type === 'JSXElement') {\n                    const n = c.openingElement.name;\n                    if (n.type !== 'JSXIdentifier' || (/^[A-Z]/.test(n.name) && !state.verbatim.has(n.name))) {\n                        // Another component's content is its own; a marker of the phrase's in it still counts.\n                        if (isPhrase && where.mode === 'text' && holdsMarker(c)) markAll = true;\n                        return;\n                    }\n                    if (/^[a-z]/.test(n.name)) {\n                        if (RAW_TEXT.has(n.name)) {\n                            // Raw text takes no marker. A block stores it as written, so a value there\n                            // registers nothing; a phrase keys it as one empty pair.\n                            const value = (d: t.JSXElement['children'][number]) =>\n                                d.type === 'JSXExpressionContainer' &&\n                                d.expression.type !== 'JSXEmptyExpression' &&\n                                literalOf(d.expression) === undefined;\n                            if (!isPhrase && c.children.some(value)) unnamed = true;\n                            return;\n                        }\n                        if (marks(c.openingElement)) {\n                            if (isPhrase && where.mode === 'text') markAll = true;\n                            return;\n                        }\n                        const opt = optOut(n.name, c.openingElement);\n                        // In a phrase, a value under an opt-out only the page knows is a placeholder:\n                        // translated, the phrase fills it; excluded, the core fills the caller's\n                        // params into an author's exclusion, and keys it as one empty pair.\n                        const mode: Mode =\n                            where.mode === 'shown' || opt === 'shown'\n                                ? 'shown'\n                                : !isPhrase && (where.mode === 'unknown' || opt === 'unknown')\n                                  ? 'unknown'\n                                  : 'text';\n                        const foreign =\n                            n.name === 'math' || n.name === 'svg'\n                                ? n.name\n                                : where.foreign === 'svg' && n.name === 'foreignObject'\n                                  ? null\n                                  : where.foreign;\n                        if (!isPhrase) attributes(c.openingElement, n.name, mode);\n                        walk(c.children, { mode, foreign, markerless: foreign !== null || TEXT_ONLY.has(n.name) });\n                    } else if (state.verbatim.has(n.name)) walk(c.children, { ...where, mode: 'shown' });\n                }\n            });\n        };\n        walk(path.node.children, { mode: 'text', foreign: null, markerless: false });\n        if (markAll && found.some((f) => f.bare)) {\n            // Every value in the phrase is marked, and one where no marker can stand would show its\n            // placeholder until a translation exists: it is left as written, and the phrase, which\n            // would key it, registers nothing.\n            unnamed = true;\n            for (let i = found.length - 1; i >= 0; i--) if (found[i].bare) found.splice(i, 1);\n        }\n        const attrs = path.node.openingElement.attributes;\n        if (unnamed && !attrs.some((a) => a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === UNNAMED)) {\n            attrs.push(T.jsxAttribute(T.jsxIdentifier(UNNAMED), T.stringLiteral('')));\n        }\n        if (!found.length) {\n            touched.forEach(settle);\n            if (unnamed || touched.size) state.meta.rewritten++;\n            return;\n        }\n\n        const existing = attrs.find(\n            (a): a is t.JSXAttribute => a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'params',\n        );\n        const existingExpr =\n            existing?.value?.type === 'JSXExpressionContainer' && existing.value.expression.type !== 'JSXEmptyExpression'\n                ? existing.value.expression\n                : null;\n\n        const named = nameAll(found, new Set([...explicitNames(staticTexts(path.node), existingExpr), ...markedNames(path.node)]));\n        found.forEach((f, i) => f.replace(named[i].name));\n        placeholders(named).forEach((n) => warn(state, n));\n        // A marked value carries itself; a replaced one, or one under an opt-out only the page\n        // knows, travels as a param.\n        const params = placeholders(named.filter((_, i) => found[i].param)).map((n) => {\n            // A value only in attributes' text travels as JavaScript writes it there; one that is\n            // also content, or a whole attribute, travels as given.\n            const uses = found.filter((f, i) => f.param && named[i].name === n.name);\n            const given = uses.find((f) => !f.text);\n            return { ...n, expression: given ? given.expression : uses[0].text! };\n        });\n        touched.forEach(settle);\n\n        if (params.length) {\n            const value = T.jsxExpressionContainer(mergeParams(existingExpr, params));\n            if (existing) existing.value = value;\n            else attrs.push(T.jsxAttribute(T.jsxIdentifier('params'), value));\n        }\n        state.meta.rewritten++;\n    }\n\n    // ---- t() calls -----------------------------------------------------------------------------\n\n    /**\n     * The pieces of a template literal, or of a `+` chain holding at least one string, in order, as\n     * JavaScript joins them: `+` adds left to right, so what stands before the first string adds as\n     * it would (`a + b + ' total'`) and a sum in parentheses is its own operand; both are one value.\n     */\n    function pieces(node: t.Node): Array<string | t.Expression> | null {\n        if (node.type === 'TemplateLiteral') {\n            const out: Array<string | t.Expression> = [];\n            node.quasis.forEach((q, i) => {\n                if (q.value.cooked) out.push(q.value.cooked);\n                if (i < node.expressions.length) out.push(node.expressions[i] as t.Expression);\n            });\n            return node.expressions.length ? out : null;\n        }\n        if (node.type !== 'BinaryExpression' || node.operator !== '+') return null;\n        // The left spine, outermost first: each `+` adds its right operand to everything on its left.\n        const spine: t.BinaryExpression[] = [];\n        for (let n: t.Node = node; n.type === 'BinaryExpression' && n.operator === '+'; n = n.left) spine.push(n);\n        const operands = [spine[spine.length - 1].left, ...spine.map((s) => s.right).reverse()] as t.Expression[];\n        const first = operands.findIndex((o) => o.type === 'StringLiteral' || o.type === 'TemplateLiteral');\n        if (first < 0) return null;\n        const flat: Array<string | t.Expression> = [];\n        if (first === 1) flat.push(operands[0]);\n        else if (first > 1) flat.push(spine[spine.length - (first - 1)]);\n        for (const o of operands.slice(first)) {\n            if (o.type === 'StringLiteral') flat.push(o.value);\n            else if (o.type === 'TemplateLiteral') flat.push(...(pieces(o) ?? [o.quasis[0].value.cooked ?? '']));\n            else flat.push(o);\n        }\n        return flat.some((p) => typeof p !== 'string') ? flat : null;\n    }\n\n    /** A key built in the call (`errors.${code}`, `status_${status}`, `'common:' + id`): its text holds only a key's characters. */\n    const isKeyShaped = (parts: Array<string | t.Expression>): boolean =>\n        parts.every((p) => typeof p !== 'string' || /^[A-Za-z0-9_.:-]*$/.test(p));\n\n    /**\n     * What the core reads `t()`'s second argument as (MOVE-1's position rule): a category when it\n     * is a string, `undefined` or an `inCategory()` ref, and params when it is any other object,\n     * `null` included, in which case the third is ignored. `unknown` when the build cannot tell\n     * (a variable, a member, a call), unless a third argument stands, which only a category before\n     * it makes sense of.\n     */\n    const secondArgument = (second: t.Node | undefined, third: t.Node | undefined): 'category' | 'params' | 'unknown' => {\n        if (!second) return 'category';\n        if (second.type === 'ObjectExpression' || second.type === 'NullLiteral') return 'params';\n        if (second.type === 'StringLiteral' || second.type === 'TemplateLiteral') return 'category';\n        if (second.type === 'Identifier' && second.name === 'undefined') return 'category';\n        if (second.type === 'CallExpression' && second.callee.type === 'Identifier' && second.callee.name === 'inCategory') return 'category';\n        return third ? 'category' : 'unknown';\n    };\n\n    /**\n     * `...((p, a) => …)(params, second)`: hands the core `[a, p]` when `a` is a category and\n     * `[{ ...a, ...p }]` when the core would read `a` as params, by the core's own rule, the ref's\n     * registry brand included (`Symbol.for('langsys.category')`, public for this). The values are\n     * evaluated before the argument, as they were written.\n     */\n    const decidedAtRuntime = (params: t.Expression, second: t.Expression): t.SpreadElement => {\n        const a = T.identifier('a');\n        const p = T.identifier('p');\n        const isRef = T.logicalExpression(\n            '&&',\n            T.binaryExpression('!==', a, T.nullLiteral()),\n            T.binaryExpression(\n                '===',\n                T.memberExpression(a, T.callExpression(T.memberExpression(T.identifier('Symbol'), T.identifier('for')), [T.stringLiteral('langsys.category')]), true),\n                T.booleanLiteral(true),\n            ),\n        );\n        const isParams = T.logicalExpression('&&', T.binaryExpression('===', T.unaryExpression('typeof', a), T.stringLiteral('object')), T.unaryExpression('!', isRef));\n        const pick = T.arrowFunctionExpression(\n            [p, a],\n            T.conditionalExpression(isParams, T.arrayExpression([T.objectExpression([T.spreadElement(a), T.spreadElement(p)])]), T.arrayExpression([a, p])),\n        );\n        return T.spreadElement(T.callExpression(pick, [params, second]));\n    };\n\n    function rewriteCall(path: NodePath<t.CallExpression>, state: State) {\n        const [phrase, second, third] = path.node.arguments;\n        if (!phrase || phrase.type === 'SpreadElement' || phrase.type === 'ArgumentPlaceholder') return;\n        const parts = pieces(phrase);\n        // A key is looked up as it is built (legacy-key mode), not a sentence with a value in it.\n        if (!parts || isKeyShaped(parts)) return;\n        if (second?.type === 'SpreadElement' || second?.type === 'ArgumentPlaceholder') return;\n        if (third?.type === 'SpreadElement' || third?.type === 'ArgumentPlaceholder') return;\n\n        const values = parts\n            .filter((p): p is t.Expression => typeof p !== 'string')\n            .map((e) => ({ source: sourceOf(state, e), expression: e }));\n        const kind = secondArgument(second, third);\n        // Where the core reads the params from; for `unknown`, the argument that may hold them.\n        const paramsExpr =\n            kind === 'category'\n                ? ((third as t.Expression | undefined) ?? null)\n                : second!.type === 'NullLiteral'\n                  ? null\n                  : (second as t.Expression);\n        // A `{name}` the text writes is the developer's when the call passes params that can fill it.\n        // A params literal names each key it passes (taken below), so only params the build cannot\n        // read into (a variable, a spread, a computed key) may hold any name; otherwise a written\n        // `{name}` can only be the value's own (an ICU argument on it, `{count, plural, …}`).\n        const unread =\n            !!paramsExpr &&\n            (paramsExpr.type !== 'ObjectExpression' || paramsExpr.properties.some((p) => p.type !== 'ObjectProperty' || p.computed));\n        const written = unread ? parts.filter((p): p is string => typeof p === 'string') : [];\n        const named = nameAll(values, explicitNames(written, paramsExpr, BRACED));\n        let next = 0;\n        const text = parts.map((p) => (typeof p === 'string' ? p : `{${named[next++].name}}`)).join('');\n        const unique = placeholders(named);\n        unique.forEach((n) => warn(state, n));\n\n        const rest = path.node.arguments.slice(kind === 'category' ? 3 : 2);\n        path.node.arguments = [\n            T.stringLiteral(text),\n            ...(kind === 'category'\n                ? [(second as t.Expression | undefined) ?? T.identifier('undefined'), mergeParams(paramsExpr, unique)]\n                : kind === 'params'\n                  ? [mergeParams(paramsExpr, unique)]\n                  : [decidedAtRuntime(mergeParams(null, unique), second as t.Expression)]),\n            ...rest,\n        ];\n        state.meta.rewritten++;\n    }\n\n    /** Whether a name, where it is used, refers to one of these bindings. */\n    const isBound = (path: NodePath, name: string, bindings: Set<t.Identifier>): boolean => {\n        const b = path.scope.getBinding(name);\n        return !!b && bindings.has(b.identifier);\n    };\n\n    return {\n        name: 'langsys-placeholders',\n        pre(file) {\n            this.meta = { warnings: [], rewritten: 0 };\n            (file.metadata as unknown as { langsys: LangsysTransformMetadata }).langsys = this.meta;\n            this.targets = new Set();\n            this.phrases = new Set();\n            this.hooks = new Set();\n            this.targetBindings = new Set();\n            this.hookBindings = new Set();\n            this.tBindings = new Set();\n            this.verbatim = new Set();\n            this.fragments = new Set();\n            this.reactModules = new Set();\n        },\n        visitor: {\n            Program(program, state) {\n                for (const stmt of program.node.body) {\n                    if (stmt.type === 'ImportDeclaration' && stmt.source.value === 'react') {\n                        for (const s of stmt.specifiers) {\n                            if (s.type !== 'ImportSpecifier') state.reactModules.add(s.local.name);\n                            else if ((s.imported.type === 'Identifier' ? s.imported.name : s.imported.value) === 'Fragment') {\n                                state.fragments.add(s.local.name);\n                            }\n                        }\n                    }\n                    if (stmt.type !== 'ImportDeclaration' || stmt.source.value !== SOURCE) continue;\n                    for (const s of stmt.specifiers) {\n                        if (s.type !== 'ImportSpecifier') continue;\n                        const imported = s.imported.type === 'Identifier' ? s.imported.name : s.imported.value;\n                        if (TARGETS.has(imported)) state.targets.add(s.local.name);\n                        if (imported === 'Phrase') state.phrases.add(s.local.name);\n                        if (imported === 'useT') state.hooks.add(s.local.name);\n                        if (imported === VERBATIM) state.verbatim.add(s.local.name);\n                    }\n                }\n                if (!state.targets.size && !state.hooks.size) return;\n                // Names are matched by binding, so a local of the same name is never taken for them.\n                const bind = (names: Set<string>, into: Set<t.Identifier>) =>\n                    names.forEach((name) => {\n                        const b = program.scope.getBinding(name);\n                        if (b) into.add(b.identifier);\n                    });\n                bind(state.targets, state.targetBindings);\n                bind(state.hooks, state.hookBindings);\n                // `const t = useT()` binds a translation function.\n                program.traverse({\n                    VariableDeclarator(d) {\n                        const init = d.node.init;\n                        if (\n                            d.node.id.type === 'Identifier' &&\n                            init?.type === 'CallExpression' &&\n                            init.callee.type === 'Identifier' &&\n                            isBound(d, init.callee.name, state.hookBindings)\n                        ) {\n                            const b = d.scope.getBinding(d.node.id.name);\n                            if (b) state.tBindings.add(b.identifier);\n                        }\n                    },\n                });\n            },\n            JSXElement(path, state) {\n                const n = path.node.openingElement.name;\n                if (n.type === 'JSXIdentifier' && isBound(path, n.name, state.targetBindings)) rewriteTarget(path, state);\n            },\n            CallExpression(path, state) {\n                const callee = path.node.callee;\n                const isT =\n                    (callee.type === 'Identifier' && isBound(path, callee.name, state.tBindings)) ||\n                    (callee.type === 'CallExpression' &&\n                        callee.callee.type === 'Identifier' &&\n                        isBound(path, callee.callee.name, state.hookBindings));\n                if (isT) rewriteCall(path, state);\n            },\n        },\n    };\n}\n"]}