@tolgee/ngx 6.4.1-prerelease.43dd4fa5.0 → 6.5.0

package/esm2022/lib/loader.component.mjs

@@ -0,0 +1,24 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LoaderComponent {
+    html;
+    static ɵfac = function LoaderComponent_Factory(t) { return new (t || LoaderComponent)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LoaderComponent, selectors: [["ng-component"]], inputs: { html: "html" }, decls: 1, vars: 1, consts: [[1, "loader-template", 3, "innerHTML"]], template: function LoaderComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "div", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("innerHTML", ctx.html, i0.ɵɵsanitizeHtml);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoaderComponent, [{
+        type: Component,
+        args: [{
+                template: `
+    <div class="loader-template" [innerHTML]="html"></div>
+  `,
+                standalone: false,
+            }]
+    }], null, { html: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LoaderComponent, { className: "LoaderComponent", filePath: "lib/loader.component.ts", lineNumber: 9 }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC10b2xnZWUvc3JjL2xpYi9sb2FkZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVFqRCxNQUFNLE9BQU8sZUFBZTtJQUNqQixJQUFJLENBQXFCO3lFQUR2QixlQUFlOzZEQUFmLGVBQWU7WUFKeEIseUJBQXNEOztZQUF6Qix1REFBa0I7OztpRkFJdEMsZUFBZTtjQU4zQixTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFOztHQUVUO2dCQUNELFVBQVUsRUFBRSxLQUFLO2FBQ2xCO2dCQUVVLElBQUk7a0JBQVosS0FBSzs7a0ZBREssZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHRlbXBsYXRlOiBgXG4gICAgPGRpdiBjbGFzcz1cImxvYWRlci10ZW1wbGF0ZVwiIFtpbm5lckhUTUxdPVwiaHRtbFwiPjwvZGl2PlxuICBgLFxuICBzdGFuZGFsb25lOiBmYWxzZSxcbn0pXG5leHBvcnQgY2xhc3MgTG9hZGVyQ29tcG9uZW50IHtcbiAgQElucHV0KCkgaHRtbDogc3RyaW5nIHwgdW5kZWZpbmVkO1xufVxuIl19

package/esm2022/lib/namespace.resolver.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./translate.service";
+export class NamespaceResolver {
+    service;
+    constructor(service) {
+        this.service = service;
+    }
+    async resolve(route) {
+        const ns = this.getNamespace(route);
+        await this.service.tolgee.addActiveNs(ns, true);
+    }
+    getNamespace(route) {
+        const namespace = route?.data?.tolgeeNamespace;
+        if (namespace === undefined) {
+            console.warn('No namespace provided. Please add tolgeeNamespace to your route data. \n' +
+                'If you really want to lazy load default namespace set tolgeeNamespace to empty string');
+        }
+        return namespace;
+    }
+    static ɵfac = function NamespaceResolver_Factory(t) { return new (t || NamespaceResolver)(i0.ɵɵinject(i1.TranslateService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: NamespaceResolver, factory: NamespaceResolver.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NamespaceResolver, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [{ type: i1.TranslateService }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ngx-tolgee.module.mjs

@@ -0,0 +1,39 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { TranslatePipe } from './translate.pipe';
+import { TComponent } from './t.component';
+import { TranslateService } from './translate.service';
+import { LoaderComponent } from "./loader.component";
+import * as i0 from "@angular/core";
+export class NgxTolgeeModule {
+    static ɵfac = function NgxTolgeeModule_Factory(t) { return new (t || NgxTolgeeModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: NgxTolgeeModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+            {
+                provide: APP_INITIALIZER,
+                useFactory: (service) => {
+                    return async () => await service.start();
+                },
+                deps: [TranslateService],
+                multi: true,
+            },
+        ] });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NgxTolgeeModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [TranslatePipe, TComponent, LoaderComponent],
+                exports: [TranslatePipe, TComponent],
+                providers: [
+                    {
+                        provide: APP_INITIALIZER,
+                        useFactory: (service) => {
+                            return async () => await service.start();
+                        },
+                        deps: [TranslateService],
+                        multi: true,
+                    },
+                ],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(NgxTolgeeModule, { declarations: [TranslatePipe, TComponent, LoaderComponent], exports: [TranslatePipe, TComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/t.component.mjs

@@ -0,0 +1,103 @@
+import { Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./translate.service";
+const _c0 = ["t", ""];
+export class TComponent {
+    ref;
+    translateService;
+    key;
+    ns;
+    params;
+    default;
+    noWrap = false;
+    language;
+    /**
+     * When true, innerHTML property of element is set.
+     * Use only when you're sure the HTML is sanitized.
+     */
+    isHtml = false;
+    subscription;
+    initialized;
+    constructor(ref, translateService) {
+        this.ref = ref;
+        this.translateService = translateService;
+    }
+    ngOnInit() {
+        // noinspection JSIgnoredPromiseFromCall
+        this.subscribe();
+        this.renderInstantValue();
+    }
+    ngOnChanges() {
+        // noinspection JSIgnoredPromiseFromCall
+        this.subscribe();
+    }
+    ngOnDestroy() {
+        this.unsubscribe();
+    }
+    renderInstantValue() {
+        // get initial value first
+        const translated = this.translateService.instant({
+            ...this.getTranslateProps(),
+            orEmpty: true,
+        });
+        this.setElementContent(translated);
+    }
+    getTranslateProps() {
+        return {
+            key: this.key,
+            ns: this.ns,
+            params: this.params,
+            defaultValue: this.default,
+            noWrap: this.noWrap,
+            language: this.language,
+        };
+    }
+    unsubscribe() {
+        this.subscription?.unsubscribe();
+    }
+    async subscribe() {
+        this.unsubscribe();
+        this.subscription = this.translateService
+            .translate(this.getTranslateProps())
+            .subscribe((translated) => {
+            this.setElementContent(translated);
+            this.initialized = true;
+        });
+    }
+    setElementContent(translated) {
+        if (this.isHtml) {
+            this.getElement().innerHTML = translated;
+            return;
+        }
+        this.getElement().textContent = translated;
+    }
+    getElement() {
+        return this.ref.nativeElement;
+    }
+    static ɵfac = function TComponent_Factory(t) { return new (t || TComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.TranslateService)); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TComponent, selectors: [["", "t", ""]], inputs: { key: "key", ns: "ns", params: "params", default: "default", noWrap: "noWrap", language: "language", isHtml: "isHtml" }, features: [i0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 0, vars: 0, template: function TComponent_Template(rf, ctx) { }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TComponent, [{
+        type: Component,
+        args: [{
+                selector: '[t]',
+                template: ``,
+                standalone: false
+            }]
+    }], () => [{ type: i0.ElementRef }, { type: i1.TranslateService }], { key: [{
+            type: Input
+        }], ns: [{
+            type: Input
+        }], params: [{
+            type: Input
+        }], default: [{
+            type: Input
+        }], noWrap: [{
+            type: Input
+        }], language: [{
+            type: Input
+        }], isHtml: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(TComponent, { className: "TComponent", filePath: "lib/t.component.ts", lineNumber: 18 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tolgee-instance-token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const TOLGEE_INSTANCE = new InjectionToken('tolgee.instance');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9sZ2VlLWluc3RhbmNlLXRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRvbGdlZS9zcmMvbGliL3RvbGdlZS1pbnN0YW5jZS10b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxJQUFJLGNBQWMsQ0FDL0MsaUJBQWlCLENBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVG9sZ2VlSW5zdGFuY2UgfSBmcm9tICdAdG9sZ2VlL3dlYic7XG5cbmV4cG9ydCBjb25zdCBUT0xHRUVfSU5TVEFOQ0UgPSBuZXcgSW5qZWN0aW9uVG9rZW48VG9sZ2VlSW5zdGFuY2U+KFxuICAndG9sZ2VlLmluc3RhbmNlJ1xuKTtcbiJdfQ==

package/esm2022/lib/translate.pipe.mjs

@@ -0,0 +1,64 @@
+import { Pipe, } from '@angular/core';
+import { getTranslateProps, } from '@tolgee/web';
+import * as i0 from "@angular/core";
+import * as i1 from "./translate.service";
+export class TranslatePipe {
+    translateService;
+    _cdr;
+    value = '';
+    previousHash;
+    subscription;
+    constructor(translateService, _cdr) {
+        this.translateService = translateService;
+        this._cdr = _cdr;
+    }
+    ngOnDestroy() {
+        this.unsubscribe();
+    }
+    transform = (...args) => {
+        // @ts-ignore
+        const params = getTranslateProps(...args);
+        const { key } = params;
+        if (!key || key.length === 0) {
+            return key;
+        }
+        const newHash = this.hash(params);
+        if (this.previousHash === newHash) {
+            return this.value;
+        }
+        this.previousHash = newHash;
+        this.translate(params);
+        return this.value;
+    };
+    hash(props) {
+        return JSON.stringify([props, this.translateService.tolgee.getLanguage()]);
+    }
+    unsubscribe() {
+        this.subscription?.unsubscribe();
+        this.subscription = null;
+    }
+    translate(props) {
+        this.value = this.translateService.instant({ ...props, orEmpty: true });
+        this.subscribe(props);
+    }
+    subscribe(props) {
+        this.unsubscribe();
+        this.subscription = this.translateService
+            .translate(props)
+            .subscribe((r) => {
+            this.value = r;
+            this._cdr.detectChanges();
+        });
+    }
+    static ɵfac = function TranslatePipe_Factory(t) { return new (t || TranslatePipe)(i0.ɵɵdirectiveInject(i1.TranslateService, 16), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef, 16)); };
+    static ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "translate", type: TranslatePipe, pure: false });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslatePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'translate',
+                pure: false,
+                standalone: false,
+            }]
+    }], () => [{ type: i1.TranslateService }, { type: i0.ChangeDetectorRef }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/translate.service.mjs

@@ -0,0 +1,133 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { getTranslateProps, } from '@tolgee/web';
+import { TOLGEE_INSTANCE } from './tolgee-instance-token';
+import * as i0 from "@angular/core";
+export class TranslateService {
+    _tolgee;
+    _ngZone;
+    runPromise;
+    constructor(_tolgee, _ngZone) {
+        this._tolgee = _tolgee;
+        this._ngZone = _ngZone;
+    }
+    get tolgee() {
+        return this._tolgee;
+    }
+    /**
+     * Starts Tolgee if not started.
+     *
+     * The Tolgee is run outside NgZone. The triggered events, doesn't
+     * trigger the change detection, when listening directly via Tolgee.on.
+     *
+     * However, all the emitting methods (on, translate, languageAsync)
+     * in this class are emitting back in Angular's NgZone,
+     * so the change detection works fine.
+     */
+    async start() {
+        if (!this.isSSR()) {
+            await this.runIfNotRunning();
+        }
+    }
+    /**
+     * Returns translation asynchronously, this method always return
+     */
+    translate = (...args) => {
+        // @ts-ignore
+        const params = getTranslateProps(...args);
+        return new Observable((subscriber) => {
+            const loadPromise = this.tolgee.addActiveNs(params.ns);
+            const translate = async () => {
+                await loadPromise;
+                const translated = this.tolgee.t(params);
+                subscriber.next(translated);
+            };
+            // noinspection JSIgnoredPromiseFromCall
+            translate();
+            const subscription = this.tolgee.on('update', translate);
+            return () => {
+                this.tolgee.removeActiveNs(params.ns);
+                subscription.unsubscribe();
+            };
+        });
+    };
+    /**
+     * Instantly returns translated value. May return undefined or outdated value.
+     * Use only when you cannot use translate.
+     */
+    instant = (...args) => {
+        // @ts-ignore
+        const params = getTranslateProps(...args);
+        return this.tolgee.t(params);
+    };
+    /**
+     * Returns current language
+     */
+    get language() {
+        return this.tolgee.getLanguage();
+    }
+    /**
+     * Returns an observable emitting current language.
+     * It instantly emits current language
+     */
+    get languageAsync() {
+        return new Observable((subscriber) => {
+            subscriber.next(this.tolgee.getLanguage());
+            const subscription = this.on('language').subscribe((value) => {
+                subscriber.next(value.value);
+            });
+            return () => subscription.unsubscribe();
+        });
+    }
+    /**
+     * Changes the current language
+     * @param lang The new current language (e.g. en, en-US)
+     * @return Promise<void> Resolves when translations
+     * for given language are loaded
+     */
+    changeLanguage(lang) {
+        return this.tolgee.changeLanguage(lang);
+    }
+    /**
+     * Returns observable emitting when specified event is triggered.
+     *
+     * It's a wrapper of Tolgee.on method. The emmit is triggered inside ngZone,
+     * so change detection should work properly.
+     *
+     * @param event the event to listen
+     */
+    on(event) {
+        return new Observable((subscriber) => {
+            const subscription = this.tolgee.on(event, (value) => {
+                this._ngZone.run(() => {
+                    subscriber.next(value);
+                });
+            });
+            return () => subscription.unsubscribe();
+        });
+    }
+    ngOnDestroy() {
+        this.tolgee.stop();
+    }
+    async runIfNotRunning() {
+        if (!this.runPromise) {
+            this.runPromise = this._ngZone.runOutsideAngular(() => {
+                return this.tolgee.run();
+            });
+        }
+        await this.runPromise;
+    }
+    isSSR() {
+        return typeof window === 'undefined';
+    }
+    static ɵfac = function TranslateService_Factory(t) { return new (t || TranslateService)(i0.ɵɵinject(TOLGEE_INSTANCE), i0.ɵɵinject(i0.NgZone)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TranslateService, factory: TranslateService.ɵfac, providedIn: 'root' });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [TOLGEE_INSTANCE]
+            }] }, { type: i0.NgZone }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.service.js","sourceRoot":"","sources":["../../../../projects/ngx-tolgee/src/lib/translate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, OnDestroy, NgZone } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport {\n  DefaultParamType,\n  EventType,\n  getTranslateProps,\n  ListenerEvent,\n  TFnType,\n  TolgeeInstance,\n  TranslationKey,\n} from '@tolgee/web';\nimport { TOLGEE_INSTANCE } from './tolgee-instance-token';\n\n@Injectable({ providedIn: 'root' })\nexport class TranslateService implements OnDestroy {\n  private runPromise: Promise<void>;\n\n  constructor(\n    @Inject(TOLGEE_INSTANCE) private _tolgee: TolgeeInstance,\n    private _ngZone: NgZone\n  ) {}\n\n  get tolgee() {\n    return this._tolgee;\n  }\n\n  /**\n   * Starts Tolgee if not started.\n   *\n   * The Tolgee is run outside NgZone. The triggered events, doesn't\n   * trigger the change detection, when listening directly via Tolgee.on.\n   *\n   * However, all the emitting methods (on, translate, languageAsync)\n   * in this class are emitting back in Angular's NgZone,\n   * so the change detection works fine.\n   */\n  public async start(): Promise<void> {\n    if (!this.isSSR()) {\n      await this.runIfNotRunning();\n    }\n  }\n\n  /**\n   * Returns translation asynchronously, this method always return\n   */\n  readonly translate: TFnType<DefaultParamType, Observable<string>, TranslationKey> = (\n    ...args\n  ) => {\n    // @ts-ignore\n    const params = getTranslateProps(...args);\n    return new Observable<string>((subscriber) => {\n      const loadPromise = this.tolgee.addActiveNs(params.ns);\n      const translate = async () => {\n        await loadPromise;\n        const translated = this.tolgee.t(params);\n        subscriber.next(translated);\n      };\n\n      // noinspection JSIgnoredPromiseFromCall\n      translate();\n\n      const subscription = this.tolgee.on('update', translate)\n\n      return () => {\n        this.tolgee.removeActiveNs(params.ns);\n        subscription.unsubscribe();\n      };\n    });\n  };\n\n  /**\n   * Instantly returns translated value. May return undefined or outdated value.\n   * Use only when you cannot use translate.\n   */\n  public readonly instant: TFnType<DefaultParamType, string, TranslationKey> = (...args) => {\n    // @ts-ignore\n    const params = getTranslateProps(...args);\n    return this.tolgee.t(params);\n  };\n\n  /**\n   * Returns current language\n   */\n  get language(): string {\n    return this.tolgee.getLanguage();\n  }\n\n  /**\n   * Returns an observable emitting current language.\n   * It instantly emits current language\n   */\n  get languageAsync(): Observable<string> {\n    return new Observable((subscriber) => {\n      subscriber.next(this.tolgee.getLanguage());\n      const subscription = this.on('language').subscribe((value) => {\n        subscriber.next(value.value);\n      });\n\n      return () => subscription.unsubscribe();\n    });\n  }\n\n  /**\n   * Changes the current language\n   * @param lang The new current language (e.g. en, en-US)\n   * @return Promise<void> Resolves when translations\n   * for given language are loaded\n   */\n  public changeLanguage(lang: string) {\n    return this.tolgee.changeLanguage(lang);\n  }\n\n  /**\n   * Returns observable emitting when specified event is triggered.\n   *\n   * It's a wrapper of Tolgee.on method. The emmit is triggered inside ngZone,\n   * so change detection should work properly.\n   *\n   * @param event the event to listen\n   */\n  on<Event extends keyof EventType>(event: Event) {\n    return new Observable<ListenerEvent<Event, EventType[Event]>>((subscriber) => {\n      const subscription = this.tolgee.on(event, (value) => {\n        this._ngZone.run(() => {\n          subscriber.next(value as any);\n        });\n      });\n      return () => subscription.unsubscribe();\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.tolgee.stop();\n  }\n\n  private async runIfNotRunning() {\n    if (!this.runPromise) {\n      this.runPromise = this._ngZone.runOutsideAngular(() => {\n        return this.tolgee.run();\n      });\n    }\n    await this.runPromise;\n  }\n\n  private isSSR() {\n    return typeof window === 'undefined';\n  }\n}\n"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,11 @@
+/*
+ * Public API Surface of ngx-tolgee
+ */
+export * from './lib/translate.service';
+export * from './lib/translate.pipe';
+export * from './lib/t.component';
+export * from './lib/ngx-tolgee.module';
+export * from './lib/tolgee-instance-token';
+export * from '@tolgee/web';
+export * from './lib/namespace.resolver';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC10b2xnZWUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LXRvbGdlZVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi90cmFuc2xhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90cmFuc2xhdGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi90LmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL25neC10b2xnZWUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3RvbGdlZS1pbnN0YW5jZS10b2tlbic7XG5cbmV4cG9ydCAqIGZyb20gJ0B0b2xnZWUvd2ViJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL25hbWVzcGFjZS5yZXNvbHZlcic7XG4iXX0=

package/esm2022/tolgee-ngx.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9sZ2VlLW5neC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC10b2xnZWUvc3JjL3RvbGdlZS1uZ3gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==