@ng-linguo/linguo 0.9.0

package/fesm2022/ng-linguo-linguo.mjs

@@ -0,0 +1,775 @@
+import { DOCUMENT } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, makeEnvironmentProviders, Pipe, input, TemplateRef, Directive, ElementRef, Renderer2, ViewContainerRef, contentChildren, effect } from '@angular/core';
+import { signalStore, withState, withMethods, patchState, withHooks } from '@ngrx/signals';
+
+function isSupported(lang, supported) {
+    return supported === undefined || supported.some((l) => l.toLowerCase() === lang.toLowerCase());
+}
+/** Match a BCP-47 tag (e.g. `pl-PL`) to a supported language: exact first, then
+ * its base subtag (`pl`). Returns the supported language in its original case. */
+function matchSupported(tag, supported) {
+    const lower = tag.toLowerCase();
+    const base = lower.split('-')[0] ?? lower;
+    return (supported.find((l) => l.toLowerCase() === lower) ??
+        supported.find((l) => l.toLowerCase() === base));
+}
+/**
+ * Resolve the language to load on startup, in priority order:
+ * **persisted → browser-preferred → default**.
+ *
+ * Pure: the store gathers the (SSR-safe) inputs and passes them in. A persisted
+ * value is honored only if it's supported; browser preferences are matched
+ * against `supportedLangs` (so an unshipped language is never selected), and if
+ * nothing matches the `defaultLang` is used.
+ */
+function resolveInitialLang(input) {
+    const { persisted, browserLangs, supportedLangs, defaultLang } = input;
+    if (persisted && persisted.trim() !== '' && isSupported(persisted, supportedLangs)) {
+        return persisted;
+    }
+    if (supportedLangs !== undefined) {
+        for (const tag of browserLangs) {
+            const match = matchSupported(tag, supportedLangs);
+            if (match !== undefined) {
+                return match;
+            }
+        }
+    }
+    return defaultLang;
+}
+
+/**
+ * Normalize a source message to its canonical translation key.
+ *
+ * Trims the message and collapses every internal whitespace run (including
+ * newlines from multi-line templates) to a single space. This MUST stay
+ * byte-for-byte identical to the extractor's normalizer
+ * (`@ng-linguo/extract`'s `normalizeMessage`) so that a key extracted at build
+ * time resolves at runtime — the parity contract in CLAUDE.md §5.2, verified by
+ * both packages against `tests/fixtures/normalization-cases.json`.
+ *
+ * Duplicated rather than imported because `core` must not depend on `extract`
+ * (CLAUDE.md §2.1).
+ */
+function normalizeKey(source) {
+    return source.trim().replace(/\s+/g, ' ');
+}
+/**
+ * Separator joining a context to a key in the compiled dictionary. This is the
+ * gettext `pgettext` convention — the EOT control character (U+0004) — chosen
+ * because it never occurs in real translator text, so contextual keys cannot
+ * collide with plain ones. MUST stay identical to the extractor's
+ * `compileEntries`, so a contextual key produced at build time resolves at
+ * runtime.
+ */
+const CONTEXT_GLUE = String.fromCharCode(4);
+/**
+ * Build the dictionary lookup key for a message, optionally disambiguated by a
+ * context label. With a context the key is `context<glue>normalizedKey`;
+ * without one it is just the normalized key — which is also the fallback the
+ * runtime tries when a contextual entry is absent.
+ */
+function contextKey(key, context) {
+    const normalizedKey = normalizeKey(key);
+    const normalizedContext = context?.trim() ?? '';
+    return normalizedContext === ''
+        ? normalizedKey
+        : `${normalizedContext}${CONTEXT_GLUE}${normalizedKey}`;
+}
+
+/**
+ * DI token carrying the {@link TranslateConfig} supplied via `provideTranslate`.
+ * Internal: consumers configure the runtime through `provideTranslate`, not by
+ * providing this token directly.
+ */
+const TRANSLATE_CONFIG = new InjectionToken('ng-linguo.config');
+/**
+ * DI token carrying the resolved {@link TranslationLoader}. `provideTranslate`
+ * registers it from the config's `loader` — either directly (a ready-made
+ * loader) or via a factory run inside the injection context (so loaders that
+ * inject Angular services, like `createHttpLoader`, can be used). Internal.
+ */
+const TRANSLATION_LOADER = new InjectionToken('ng-linguo.loader');
+const initialState = {
+    currentLang: '',
+    isReady: false,
+    translations: {},
+};
+/**
+ * The reactive translation runtime, implemented as an `@ngrx/signals`
+ * `signalStore`. Consumers inject it and read state through signals; there are
+ * no `Observable` getters on the public surface.
+ *
+ * State is not loaded implicitly. Call {@link TranslateStore.restoreLang} once
+ * at startup to pick the language (persisted → browser → default) and load it,
+ * or {@link TranslateStore.setLang} to switch to a specific one.
+ * {@link TranslateStore.isReady} stays `false` until a language has loaded, so
+ * UI can gate on it to avoid a flash of untranslated content.
+ *
+ * @example
+ * ```ts
+ * const store = inject(TranslateStore);
+ * store.currentLang(); // Signal<string>
+ * store.isReady();     // Signal<boolean>
+ * await store.restoreLang(); // startup: persisted ?? browser ?? default
+ * await store.setLang('pl'); // explicit switch
+ * store.translate('greeting');
+ * ```
+ */
+const TranslateStore = signalStore({ providedIn: 'root' }, withState(initialState), withMethods((store) => {
+    const config = inject(TRANSLATE_CONFIG);
+    const loader = inject(TRANSLATION_LOADER);
+    // `defaultView` is the Window in a browser, and null under SSR — so all
+    // localStorage/navigator access below is automatically a no-op on the server.
+    const win = inject(DOCUMENT).defaultView;
+    const persistEnabled = config.persistSelectedLanguage ?? true;
+    // Restore (read on startup) defaults to the persist setting, so disabling
+    // persistence alone still disables restore (the pre-decoupling behavior);
+    // set restoreSelectedLanguage explicitly to control the two independently.
+    const restoreEnabled = config.restoreSelectedLanguage ?? persistEnabled;
+    const detectEnabled = config.detectBrowserLanguage ?? true;
+    const persistKey = config.persistKey ?? 'ng-linguo.lang';
+    function readPersisted() {
+        if (!restoreEnabled || !win)
+            return null;
+        try {
+            return win.localStorage.getItem(persistKey);
+        }
+        catch {
+            return null; // storage disabled (private mode, blocked cookies, …)
+        }
+    }
+    function writePersisted(lang) {
+        if (!persistEnabled || !win)
+            return;
+        try {
+            win.localStorage.setItem(persistKey, lang);
+        }
+        catch {
+            // ignore — persistence is best-effort
+        }
+    }
+    function browserLangs() {
+        const nav = win?.navigator;
+        if (!detectEnabled || !nav)
+            return [];
+        return nav.languages?.length ? nav.languages : nav.language ? [nav.language] : [];
+    }
+    async function load(lang) {
+        const translations = await loader.load(lang);
+        patchState(store, { currentLang: lang, translations, isReady: true });
+        writePersisted(lang);
+    }
+    return {
+        /**
+         * Load the translations for `lang`, make them current, and (when
+         * `persistSelectedLanguage` is on) persist the choice. Resolves once the
+         * loader has returned and the store is ready.
+         */
+        setLang(lang) {
+            return load(lang);
+        },
+        /**
+         * Resolve the startup language — **persisted → browser-preferred →
+         * `defaultLang`** — and load it. Call this once at startup instead of
+         * `setLang(defaultLang)`. Persistence and browser detection are on by
+         * default and can be turned off via `provideTranslate` config; both are
+         * SSR-safe (they fall through to the default on the server).
+         */
+        restoreLang() {
+            return load(resolveInitialLang({
+                persisted: readPersisted(),
+                browserLangs: browserLangs(),
+                supportedLangs: config.supportedLangs,
+                defaultLang: config.defaultLang,
+            }));
+        },
+        /**
+         * Resolve a translation key against the currently loaded language.
+         *
+         * An optional `context` disambiguates keys that share the same source
+         * text (for example `Play` in a game versus a music player). Lookup tries
+         * the contextual key first, then falls back to the plain key, then to the
+         * key itself — so a missing translation is visible rather than blank, and
+         * omitting the context always resolves to the default entry.
+         */
+        translate(key, context) {
+            const normalized = normalizeKey(key);
+            const translations = store.translations();
+            if (context !== undefined && context.trim() !== '') {
+                const contextual = translations[contextKey(key, context)];
+                if (contextual !== undefined) {
+                    return contextual;
+                }
+            }
+            return translations[normalized] ?? normalized;
+        },
+    };
+}), withHooks({
+    onInit(store) {
+        // Report the configured default language immediately, without loading.
+        patchState(store, { currentLang: inject(TRANSLATE_CONFIG).defaultLang });
+    },
+}));
+
+/**
+ * Register the translation runtime for an application or a feature scope.
+ *
+ * Add the returned providers to `bootstrapApplication`'s `providers` (or a
+ * route's `providers`). This only wires up configuration — it never starts a
+ * load, so no HTTP is fired during DI initialization. Trigger the first load
+ * explicitly via `TranslateStore.setLang`.
+ *
+ * The `loader` may be a ready-made loader object, or a factory `() => loader`
+ * that is run inside the injection context — use the factory form for loaders
+ * that inject Angular services (e.g. `createHttpLoader()`, which needs
+ * `HttpClient`).
+ *
+ * @example
+ * ```ts
+ * // a static dictionary or fetch-based loader
+ * provideTranslate({ defaultLang: 'en', loader: myLoader });
+ *
+ * // an HttpClient-backed loader (factory form)
+ * provideTranslate({ defaultLang: 'en', loader: () => createHttpLoader() });
+ * ```
+ */
+function provideTranslate(config) {
+    const { loader } = config;
+    return makeEnvironmentProviders([
+        { provide: TRANSLATE_CONFIG, useValue: config },
+        typeof loader === 'function'
+            ? { provide: TRANSLATION_LOADER, useFactory: loader }
+            : { provide: TRANSLATION_LOADER, useValue: loader },
+    ]);
+}
+
+/**
+ * Matches a single slot tag at the start of a string: an optional leading slash
+ * (closing tag) followed by a name. The name grammar
+ * (`[a-zA-Z_][a-zA-Z0-9_-]*`) is part of the public contract — see CLAUDE.md
+ * §5.1. Changing it is a major version bump.
+ *
+ * A literal `[` is written as `[[`; that escape is handled in {@link tokenize}
+ * before this pattern is tried, so a tag is never matched across an escape.
+ */
+const TAG_PATTERN = /^\[(\/?)([a-zA-Z_][a-zA-Z0-9_-]*)\]/;
+function tokenize(input) {
+    const tokens = [];
+    let buffer = '';
+    const flush = () => {
+        if (buffer.length > 0) {
+            tokens.push({ kind: 'text', value: buffer });
+            buffer = '';
+        }
+    };
+    let index = 0;
+    while (index < input.length) {
+        if (input[index] === '[') {
+            // `[[` is an escaped literal `[` — the one way a translatable string can
+            // contain text that looks like a slot tag (e.g. `[note]`) without it being
+            // parsed as one. Checked before TAG_PATTERN so the escape always wins; a
+            // lone `]` needs no escape, since it is never significant on its own.
+            if (input[index + 1] === '[') {
+                buffer += '[';
+                index += 2;
+                continue;
+            }
+            const match = TAG_PATTERN.exec(input.slice(index));
+            if (match) {
+                // Defaults satisfy `noUncheckedIndexedAccess` without non-null `!`.
+                const [whole, slash = '', name = ''] = match;
+                flush();
+                tokens.push(slash === '/' ? { kind: 'close', name } : { kind: 'open', name });
+                index += whole.length;
+                continue;
+            }
+        }
+        // A `[` that does not start a valid tag is ordinary text — malformed input
+        // is tolerated rather than throwing, so a stray bracket never breaks a page.
+        buffer += input[index];
+        index += 1;
+    }
+    flush();
+    return tokens;
+}
+function appendText(into, value) {
+    const last = into[into.length - 1];
+    if (last && last.kind === 'text') {
+        into[into.length - 1] = { kind: 'text', value: last.value + value };
+    }
+    else {
+        into.push({ kind: 'text', value });
+    }
+}
+/**
+ * Parse a translator-authored string into a tree of {@link SlotNode}s.
+ *
+ * The parser is total: every input produces a tree, and any malformed
+ * construct (a stray `[`, an unclosed tag, a mismatched closing tag) degrades
+ * gracefully to literal text rather than throwing. Well-formed
+ * `[name]...[/name]` regions — including nested ones — become `slot` nodes. To
+ * include a literal `[` (so text such as `[note]` is not read as a tag), double
+ * it: `[[` parses to a single `[`.
+ *
+ * @example
+ * ```ts
+ * parseSlots('Hello [b]world[/b]!');
+ * // [
+ * //   { kind: 'text', value: 'Hello ' },
+ * //   { kind: 'slot', name: 'b', children: [{ kind: 'text', value: 'world' }] },
+ * //   { kind: 'text', value: '!' },
+ * // ]
+ *
+ * parseSlots('See [[b] for bold');
+ * // [{ kind: 'text', value: 'See [b] for bold' }]
+ * ```
+ */
+function parseSlots(input) {
+    const root = [];
+    const stack = [];
+    const current = () => {
+        const top = stack.at(-1);
+        return top ? top.children : root;
+    };
+    for (const token of tokenize(input)) {
+        if (token.kind === 'text') {
+            appendText(current(), token.value);
+            continue;
+        }
+        if (token.kind === 'open') {
+            stack.push({ name: token.name, children: [] });
+            continue;
+        }
+        // Closing tag.
+        const top = stack.at(-1);
+        if (top && top.name === token.name) {
+            stack.pop();
+            current().push({ kind: 'slot', name: top.name, children: top.children });
+        }
+        else {
+            // No matching open tag: treat the closing tag as literal text.
+            appendText(current(), `[/${token.name}]`);
+        }
+    }
+    // Unwind any tags left open at end of input, back into literal text so their
+    // contents are still rendered.
+    for (let frame = stack.pop(); frame !== undefined; frame = stack.pop()) {
+        const parent = current();
+        appendText(parent, `[${frame.name}]`);
+        for (const child of frame.children) {
+            if (child.kind === 'text') {
+                appendText(parent, child.value);
+            }
+            else {
+                parent.push(child);
+            }
+        }
+    }
+    return root;
+}
+function collectText$1(nodes) {
+    let text = '';
+    for (const node of nodes) {
+        text += node.kind === 'text' ? node.value : collectText$1(node.children);
+    }
+    return text;
+}
+/**
+ * Flatten a slot string to plain text: slot tags are dropped and their inner
+ * text is kept. This is how the `t` pipe and {@link injectTranslate} render a
+ * message containing `[name]...[/name]` slots — they return a string, so the
+ * markup degrades to text (the `[t]` directive renders the slots into templates
+ * instead).
+ *
+ * @example
+ * ```ts
+ * slotsToText('Read the [docs]documentation[/docs] now'); // 'Read the documentation now'
+ * slotsToText('Press [[Enter] to send'); // 'Press [Enter] to send'
+ * ```
+ */
+function slotsToText(input) {
+    return collectText$1(parseSlots(input));
+}
+
+/**
+ * DI token for an optional {@link MessageFormatter}. Provided by
+ * `@ng-linguo/linguo/icu`'s `provideIcu`; absent by default.
+ */
+const MESSAGE_FORMATTER = new InjectionToken('ng-linguo.message-formatter');
+
+/**
+ * Obtain a {@link TranslateFn} for use in component code — the TypeScript
+ * counterpart of the `t` pipe.
+ *
+ * Call it in an injection context (a field initializer or constructor); the
+ * returned `t` reads the store's signals each time it runs, so it stays reactive
+ * when used in a template binding or inside a `computed`.
+ *
+ * @example
+ * ```ts
+ * export class Greeting {
+ *   private readonly t = injectTranslate();
+ *   protected readonly name = signal('Ada');
+ *   protected readonly text = computed(() =>
+ *     this.t('Hello {$name}!', { params: { name: this.name() } }),
+ *   );
+ * }
+ * ```
+ */
+function injectTranslate() {
+    const store = inject(TranslateStore);
+    const formatter = inject(MESSAGE_FORMATTER, { optional: true });
+    return (key, options) => {
+        let message = store.translate(key, options?.context);
+        if (options?.params && formatter) {
+            message = formatter.format(message, options.params, store.currentLang() || 'en');
+        }
+        // Returns a string, so slot tags degrade to their inner text; the `[t]`
+        // directive renders them into templates instead.
+        return slotsToText(message);
+    };
+}
+
+/** Shallow value-equality for `params`: same keys, each value strictly equal. */
+function paramsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((k) => a[k] === b[k]);
+}
+/**
+ * Resolve a translation key to its string for the current language, with options
+ * passed as a single object: ICU `params` and a disambiguating `context`.
+ *
+ * @example
+ * ```html
+ * {{ 'Play' | t }}
+ * {{ 'Play' | t: { context: 'game' } }}
+ * {{ 'Hello {$name}!' | t: { params: { name } } }}
+ * ```
+ *
+ * The key is the source text; a missing key renders as itself. ICU `params` are
+ * applied by the formatter from `@ng-linguo/linguo/icu` (`provideIcu`); without
+ * it the message is returned unformatted.
+ *
+ * Impure so it re-evaluates against the store's signals each change detection,
+ * re-rendering when the language changes. To keep that cheap it **memoizes** by
+ * value: the lookup/format only re-runs when the key, `context`, `params`
+ * contents, or the active language actually change — so a fresh `{ params: … }`
+ * literal on every change-detection pass costs only an equality check. For hot
+ * or looped bindings, prefer `injectTranslate()` inside a `computed()`, which
+ * does zero work per change-detection pass.
+ */
+class TranslatePipe {
+    t = injectTranslate();
+    // The translations signal's value reference changes on every `setLang`, so it
+    // doubles as the "language version" for cache invalidation.
+    translations = inject(TranslateStore).translations;
+    cache;
+    transform(key, options) {
+        const version = this.translations();
+        const context = options?.context;
+        const params = options?.params;
+        const cached = this.cache;
+        if (cached !== undefined &&
+            cached.key === key &&
+            cached.context === context &&
+            cached.version === version &&
+            paramsEqual(cached.params, params)) {
+            return cached.result;
+        }
+        const result = this.t(key, options);
+        this.cache = { key, context, params, version, result };
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: TranslatePipe, isStandalone: true, name: "t", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 't', pure: false }]
+        }] });
+
+/**
+ * Mark a string as a translatable message so `@ng-linguo/extract` collects it,
+ * returning the string unchanged (it does not translate at runtime).
+ *
+ * Use it for messages that are not written inline at a `t` pipe or `[t]`
+ * directive — for example an ICU message kept in a component field (an MF2
+ * pattern contains `{{ … }}`, which collides with Angular's `{{ }}` binding).
+ * The marked string is still translated at render time by the pipe/directive
+ * that consumes it.
+ *
+ * Pass `context` to record a `msgctxt`/translator note for the entry. Because
+ * context is part of the key, the **same** `context` must be supplied where the
+ * marked string is rendered (`| t: { context }` or `tContext`), or the runtime
+ * lookup will not find the contextual entry.
+ *
+ * @example
+ * ```ts
+ * readonly fileCount = mark(
+ *   '.input {$count :number} .match $count one {{{$count} file}} * {{{$count} files}}',
+ *   { context: 'file = a document on disk' },
+ * );
+ * // template: {{ fileCount | t: { params: { count: count() }, context: 'file = a document on disk' } }}
+ * ```
+ */
+function mark(message, options) {
+    // `options` is read only by the extractor (statically); at runtime it is a
+    // no-op, so the parameter is intentionally unused here.
+    void options;
+    return message;
+}
+
+/** Flatten a slot subtree to its concatenated text, dropping the tags. */
+function collectText(nodes) {
+    let text = '';
+    for (const node of nodes) {
+        text += node.kind === 'text' ? node.value : collectText(node.children);
+    }
+    return text;
+}
+/**
+ * Renders a parsed slot tree into the DOM as text nodes and embedded
+ * `<ng-template>` views — never as HTML (CLAUDE.md §5.1).
+ *
+ * Owns the views and host-level text nodes it creates so a re-render (a language
+ * or params change) can tear them down. A single instance is shared by a `[t]`
+ * element and every `*tRender` outlet nested inside it: views are tracked flat
+ * and destroyed together, so a re-render is a clean teardown-then-rebuild
+ * regardless of nesting depth.
+ */
+class SlotRenderer {
+    renderer;
+    viewContainer;
+    views = [];
+    hostNodes = [];
+    constructor(renderer, viewContainer) {
+        this.renderer = renderer;
+        this.viewContainer = viewContainer;
+    }
+    /** Destroy every view and remove every host-level text node from the last render. */
+    clear() {
+        for (const view of this.views) {
+            view.destroy();
+        }
+        this.views = [];
+        for (const node of this.hostNodes) {
+            // Nodes placed inside an embedded view are gone with their view; only the
+            // ones appended straight onto the persistent host element remain here.
+            if (node.parentNode) {
+                this.renderer.removeChild(node.parentNode, node);
+            }
+        }
+        this.hostNodes = [];
+    }
+    /**
+     * Render `nodes` into `parent`, before `before` (or appended when `before` is
+     * `null`). `trackHost` is `true` only for nodes placed directly on the `[t]`
+     * host element — those text nodes outlive any single view and must be removed
+     * explicitly on the next render; nodes inside an embedded view ride along when
+     * that view is destroyed, so they are not tracked.
+     */
+    render(nodes, parent, before, templates, trackHost) {
+        for (const node of nodes) {
+            if (node.kind === 'text') {
+                const text = this.renderer.createText(node.value);
+                this.insert(parent, text, before);
+                if (trackHost) {
+                    this.hostNodes.push(text);
+                }
+                continue;
+            }
+            const template = templates.get(node.name);
+            if (!template) {
+                // No matching template: render the slot's children inline (transparent),
+                // so a nested *matched* slot still renders and text-only content reads
+                // the same as a plain flatten.
+                this.render(node.children, parent, before, templates, trackHost);
+                continue;
+            }
+            const view = this.viewContainer.createEmbeddedView(template, {
+                $implicit: collectText(node.children),
+                children: node.children,
+            });
+            this.views.push(view);
+            // Running the view's bindings instantiates any `*tRender` outlet inside it,
+            // which calls back to render this slot's children into that outlet — the
+            // nesting recursion happens here, on the call stack.
+            view.detectChanges();
+            for (const rootNode of view.rootNodes) {
+                this.insert(parent, rootNode, before);
+            }
+        }
+    }
+    insert(parent, node, before) {
+        if (before) {
+            this.renderer.insertBefore(parent, node, before);
+        }
+        else {
+            this.renderer.appendChild(parent, node);
+        }
+    }
+}
+
+/**
+ * Provides an `<ng-template>` as the renderer for a named slot of the enclosing
+ * `[t]` element. The `[name]...[/name]` bracket syntax resembles BBCode, but the
+ * name is arbitrary and author-chosen — it identifies a slot to fill, not a tag
+ * with predefined HTML. Declared as a child of the `[t]` element (it renders as
+ * an invisible anchor), so the name is scoped to that element. The template
+ * receives the slot's inner text (`let-text`) and parsed children
+ * (`let-kids="children"`, for nesting via `*tRender`) as its context.
+ *
+ * @example
+ * ```html
+ * <ng-template tFor="docs" let-text>
+ *   <a routerLink="/docs">{{ text }}</a>
+ * </ng-template>
+ * ```
+ */
+class TranslateSlot {
+    /** Slot name, matching `[name]...[/name]` in the translation. */
+    name = input.required({ ...(ngDevMode ? { debugName: "name" } : /* istanbul ignore next */ {}), alias: 'tFor' });
+    templateRef = inject(TemplateRef);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateSlot, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: TranslateSlot, isStandalone: true, selector: "ng-template[tFor]", inputs: { name: { classPropertyName: "name", publicName: "tFor", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateSlot, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ng-template[tFor]' }]
+        }], propDecorators: { name: [{ type: i0.Input, args: [{ isSignal: true, alias: "tFor", required: true }] }] } });
+/**
+ * Translate the `t` message and render it into the element, applying ICU `tParams`
+ * and binding any `[name]...[/name]` slot regions to `<ng-template tFor>`
+ * children.
+ *
+ * The message is the `t` attribute (a string expression), so it may contain both
+ * ICU (`{$name}`) and slot tags (`[name]`) safely. Rendered text is emitted as DOM
+ * text nodes, never HTML (CLAUDE.md §5.1); a slot with no matching template
+ * degrades to its inner text. Nested slots bind to their own templates when the
+ * parent template marks where they go with `*tRender` (see
+ * `TranslateSlotOutlet`); otherwise a nested slot renders as text. Re-renders
+ * when the language, params, or a slot template changes.
+ *
+ * @example
+ * ```html
+ * <p t="Hello {$name}!" [tParams]="{ name }"></p>
+ *
+ * <p t="Read the [docs]documentation[/docs] to get started">
+ *   <ng-template tFor="docs" let-text>
+ *     <a routerLink="/docs">{{ text }}</a>
+ *   </ng-template>
+ * </p>
+ * ```
+ */
+class TranslateDirective {
+    store = inject(TranslateStore);
+    host = inject(ElementRef).nativeElement;
+    renderer = inject(Renderer2);
+    formatter = inject(MESSAGE_FORMATTER, { optional: true });
+    slotRenderer = new SlotRenderer(this.renderer, inject(ViewContainerRef));
+    /** Source message (the translation key); may contain ICU and slot tags. */
+    message = input.required({ ...(ngDevMode ? { debugName: "message" } : /* istanbul ignore next */ {}), alias: 't' });
+    /** ICU arguments, formatted via `@ng-linguo/linguo/icu` when provided. */
+    tParams = input(undefined, ...(ngDevMode ? [{ debugName: "tParams" }] : /* istanbul ignore next */ []));
+    /** Optional disambiguating/contextual text (part of the key). */
+    tContext = input('', ...(ngDevMode ? [{ debugName: "tContext" }] : /* istanbul ignore next */ []));
+    slots = contentChildren(TranslateSlot, { ...(ngDevMode ? { debugName: "slots" } : /* istanbul ignore next */ {}), descendants: true });
+    templates = new Map();
+    constructor() {
+        effect(() => {
+            const templates = new Map();
+            for (const slot of this.slots()) {
+                templates.set(slot.name(), slot.templateRef);
+            }
+            this.templates = templates;
+            let text = this.store.translate(this.message(), this.tContext());
+            const params = this.tParams();
+            if (params && this.formatter) {
+                text = this.formatter.format(text, params, this.store.currentLang() || 'en');
+            }
+            this.slotRenderer.clear();
+            this.slotRenderer.render(parseSlots(text), this.host, null, templates, true);
+        });
+    }
+    ngOnInit() {
+        // Remove any authored whitespace text so the rendered translation is not
+        // preceded by stray spacing. Slot `<ng-template>` anchors (comments) are
+        // left intact for the content query.
+        for (const node of Array.from(this.host.childNodes)) {
+            if (node.nodeType === 3 /* text node */) {
+                this.renderer.removeChild(this.host, node);
+            }
+        }
+    }
+    /**
+     * Render a nested slot's `nodes` into `parent` before `before`, reusing the
+     * current templates and the shared renderer. Internal: called by
+     * `TranslateSlotOutlet` (`*tRender`); not part of the consumer-facing API.
+     */
+    renderChildren(parent, before, nodes) {
+        this.slotRenderer.render(nodes, parent, before, this.templates, false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "21.2.9", type: TranslateDirective, isStandalone: true, selector: "[t]", inputs: { message: { classPropertyName: "message", publicName: "t", isSignal: true, isRequired: true, transformFunction: null }, tParams: { classPropertyName: "tParams", publicName: "tParams", isSignal: true, isRequired: false, transformFunction: null }, tContext: { classPropertyName: "tContext", publicName: "tContext", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "slots", predicate: TranslateSlot, descendants: true, isSignal: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[t]' }]
+        }], ctorParameters: () => [], propDecorators: { message: [{ type: i0.Input, args: [{ isSignal: true, alias: "t", required: true }] }], tParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "tParams", required: false }] }], tContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "tContext", required: false }] }], slots: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => TranslateSlot), { ...{ descendants: true }, isSignal: true }] }] } });
+
+/**
+ * Renders the *children* of a slot at this position, so a nested slot binds to
+ * its own `<ng-template>` instead of flattening to text. Without it, a slot
+ * inside a templated slot renders as plain text (its `$implicit` value); with
+ * it, each nested slot finds its own `tFor` template.
+ *
+ * Bind the `children` from the enclosing slot's context and place the outlet
+ * where the nested content should appear:
+ *
+ * @example
+ * ```html
+ * <p t="Agree to our [link]Terms and [b]Conditions[/b][/link]">
+ *   <ng-template tFor="link" let-kids="children">
+ *     <a href="/terms"><ng-container *tRender="kids" /></a>
+ *   </ng-template>
+ *   <ng-template tFor="b" let-text><strong>{{ text }}</strong></ng-template>
+ * </p>
+ * ```
+ *
+ * Valid only inside a `[t]` element's slot template — it resolves the enclosing
+ * {@link TranslateDirective} and renders through its shared engine, so nested
+ * views are torn down with the rest on a language or params change.
+ */
+class TranslateSlotOutlet {
+    /** The nodes to render — the `children` value from the slot context. */
+    nodes = input.required({ ...(ngDevMode ? { debugName: "nodes" } : /* istanbul ignore next */ {}), alias: 'tRender' });
+    host = inject(TranslateDirective);
+    // The outlet sits on an `<ng-container>`, whose anchor is a comment node; its
+    // parent is the element the children belong in, and we render before it.
+    anchor = inject(ViewContainerRef).element.nativeElement;
+    ngOnInit() {
+        const parent = this.anchor.parentNode;
+        if (parent) {
+            this.host.renderChildren(parent, this.anchor, this.nodes());
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateSlotOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: TranslateSlotOutlet, isStandalone: true, selector: "[tRender]", inputs: { nodes: { classPropertyName: "nodes", publicName: "tRender", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TranslateSlotOutlet, decorators: [{
+            type: Directive,
+            args: [{ selector: '[tRender]' }]
+        }], propDecorators: { nodes: [{ type: i0.Input, args: [{ isSignal: true, alias: "tRender", required: true }] }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { MESSAGE_FORMATTER, TranslateDirective, TranslatePipe, TranslateSlot, TranslateSlotOutlet, TranslateStore, injectTranslate, mark, parseSlots, provideTranslate, slotsToText };
+//# sourceMappingURL=ng-linguo-linguo.mjs.map