ngx-ode-sijil 4.6.0-dev.0 → 4.6.0

package/esm2020/lib/components/s5l.component.mjs

@@ -0,0 +1,52 @@
+import { Component, Input, ViewChild, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/bundles.service";
+export class S5lComponent {
+    constructor(bundlesService) {
+        this.bundlesService = bundlesService;
+    }
+    refreshTranslation() {
+        const newDisplayedValue = this.bundlesService.translate(this.value, this.parameters, this.fixedLanguage);
+        if (this.displayedValue !== newDisplayedValue) {
+            this.displayedValue = newDisplayedValue;
+            this.wrapperRef.nativeElement.innerHTML = this.displayedValue;
+        }
+    }
+    ngAfterViewInit() {
+        this.value = this.wrapperRef.nativeElement.innerHTML.trim();
+        this.loaded = true;
+        this.refreshTranslation();
+    }
+    ngDoCheck() {
+        if (!this.loaded) {
+            return;
+        }
+        this.refreshTranslation();
+    }
+}
+S5lComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: S5lComponent, deps: [{ token: i1.BundlesService }], target: i0.ɵɵFactoryTarget.Component });
+S5lComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: S5lComponent, selector: "s5l", inputs: { parameters: ["s5l-params", "parameters"], fixedLanguage: ["s5l-lang", "fixedLanguage"] }, viewQueries: [{ propertyName: "wrapperRef", first: true, predicate: ["wrapper"], descendants: true }], ngImport: i0, template: `
+    <span #wrapper>
+        <ng-content></ng-content>
+    </span>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: S5lComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 's5l',
+                    template: `
+    <span #wrapper>
+        <ng-content></ng-content>
+    </span>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BundlesService }]; }, propDecorators: { wrapperRef: [{
+                type: ViewChild,
+                args: ['wrapper']
+            }], parameters: [{
+                type: Input,
+                args: ["s5l-params"]
+            }], fixedLanguage: [{
+                type: Input,
+                args: ["s5l-lang"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/ngx-ode-sijil.module.mjs

@@ -0,0 +1,42 @@
+import { NgModule } from '@angular/core';
+import { S5lComponent } from './components/s5l.component';
+import { TranslatePipe } from './pipes/translate.pipe';
+import { HttpClientModule } from '@angular/common/http';
+import { RequireService } from './services/require/require.interface';
+import { Parser } from './services/parser/parser.interface';
+import { SijilOpts, defaultSijilOpts } from './services/sijil.opts';
+import { BundlesService } from './services/bundles.service';
+import { HttpRequireService } from './services/require/httprequire.service';
+import { FragmentsParser } from './services/parser/fragments.parser';
+import * as i0 from "@angular/core";
+export class NgxOdeSijilModule {
+    static forRoot(require, parser, options) {
+        return {
+            ngModule: NgxOdeSijilModule,
+            providers: [
+                { provide: BundlesService, useClass: BundlesService, deps: [RequireService, Parser, SijilOpts] },
+                { provide: RequireService, useClass: require || HttpRequireService },
+                { provide: Parser, useClass: parser || FragmentsParser },
+                { provide: SijilOpts, useValue: options || defaultSijilOpts }
+            ]
+        };
+    }
+    static forChild() {
+        return {
+            ngModule: NgxOdeSijilModule,
+            providers: []
+        };
+    }
+}
+NgxOdeSijilModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: NgxOdeSijilModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxOdeSijilModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.1", ngImport: i0, type: NgxOdeSijilModule, declarations: [S5lComponent, TranslatePipe], imports: [HttpClientModule], exports: [S5lComponent, TranslatePipe] });
+NgxOdeSijilModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: NgxOdeSijilModule, imports: [HttpClientModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: NgxOdeSijilModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [S5lComponent, TranslatePipe],
+                    imports: [HttpClientModule],
+                    exports: [S5lComponent, TranslatePipe]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LW9kZS1zaWppbC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtb2RlLXNpamlsL3NyYy9saWIvbmd4LW9kZS1zaWppbC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBNkIsTUFBTSxlQUFlLENBQUM7QUFDcEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQzFELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDdEUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDNUQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDNUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQU9yRSxNQUFNLE9BQU8saUJBQWlCO0lBQzVCLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBOEIsRUFBRSxNQUFxQixFQUFFLE9BQW1CO1FBQ3ZGLE9BQU87WUFDSCxRQUFRLEVBQUUsaUJBQWlCO1lBQzNCLFNBQVMsRUFBRTtnQkFDUCxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsUUFBUSxFQUFFLGNBQWMsRUFBRSxJQUFJLEVBQUUsQ0FBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLFNBQVMsQ0FBRSxFQUFFO2dCQUNsRyxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsUUFBUSxFQUFFLE9BQU8sSUFBSSxrQkFBa0IsRUFBRTtnQkFDcEUsRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxNQUFNLElBQUksZUFBZSxFQUFFO2dCQUN4RCxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLE9BQU8sSUFBSSxnQkFBZ0IsRUFBRTthQUNoRTtTQUNKLENBQUM7SUFDSixDQUFDO0lBRUQsTUFBTSxDQUFDLFFBQVE7UUFDYixPQUFPO1lBQ0gsUUFBUSxFQUFFLGlCQUFpQjtZQUMzQixTQUFTLEVBQUUsRUFBRTtTQUNoQixDQUFDO0lBQ0osQ0FBQzs7OEdBbEJVLGlCQUFpQjsrR0FBakIsaUJBQWlCLGlCQUpiLFlBQVksRUFBRSxhQUFhLGFBQ2hDLGdCQUFnQixhQUNoQixZQUFZLEVBQUUsYUFBYTsrR0FFMUIsaUJBQWlCLFlBSGxCLGdCQUFnQjsyRkFHZixpQkFBaUI7a0JBTDdCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztvQkFDM0MsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7b0JBQzNCLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7aUJBQ3ZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMsIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFM1bENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9zNWwuY29tcG9uZW50JztcbmltcG9ydCB7IFRyYW5zbGF0ZVBpcGUgfSBmcm9tICcuL3BpcGVzL3RyYW5zbGF0ZS5waXBlJztcbmltcG9ydCB7IEh0dHBDbGllbnRNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBSZXF1aXJlU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvcmVxdWlyZS9yZXF1aXJlLmludGVyZmFjZSc7XG5pbXBvcnQgeyBQYXJzZXIgfSBmcm9tICcuL3NlcnZpY2VzL3BhcnNlci9wYXJzZXIuaW50ZXJmYWNlJztcbmltcG9ydCB7IFNpamlsT3B0cywgZGVmYXVsdFNpamlsT3B0cyB9IGZyb20gJy4vc2VydmljZXMvc2lqaWwub3B0cyc7XG5pbXBvcnQgeyBCdW5kbGVzU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvYnVuZGxlcy5zZXJ2aWNlJztcbmltcG9ydCB7IEh0dHBSZXF1aXJlU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMvcmVxdWlyZS9odHRwcmVxdWlyZS5zZXJ2aWNlJztcbmltcG9ydCB7IEZyYWdtZW50c1BhcnNlciB9IGZyb20gJy4vc2VydmljZXMvcGFyc2VyL2ZyYWdtZW50cy5wYXJzZXInO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTNWxDb21wb25lbnQsIFRyYW5zbGF0ZVBpcGVdLFxuICBpbXBvcnRzOiBbSHR0cENsaWVudE1vZHVsZV0sXG4gIGV4cG9ydHM6IFtTNWxDb21wb25lbnQsIFRyYW5zbGF0ZVBpcGVdXG59KVxuZXhwb3J0IGNsYXNzIE5neE9kZVNpamlsTW9kdWxlIHtcbiAgc3RhdGljIGZvclJvb3QocmVxdWlyZT86IFR5cGU8UmVxdWlyZVNlcnZpY2U+LCBwYXJzZXI/OiBUeXBlPFBhcnNlcj4sIG9wdGlvbnM/OiBTaWppbE9wdHMpOiBNb2R1bGVXaXRoUHJvdmlkZXJzPE5neE9kZVNpamlsTW9kdWxlPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgICAgbmdNb2R1bGU6IE5neE9kZVNpamlsTW9kdWxlLFxuICAgICAgICBwcm92aWRlcnM6IFtcbiAgICAgICAgICAgIHsgcHJvdmlkZTogQnVuZGxlc1NlcnZpY2UsIHVzZUNsYXNzOiBCdW5kbGVzU2VydmljZSwgZGVwczogWyBSZXF1aXJlU2VydmljZSwgUGFyc2VyLCBTaWppbE9wdHMgXSB9LFxuICAgICAgICAgICAgeyBwcm92aWRlOiBSZXF1aXJlU2VydmljZSwgdXNlQ2xhc3M6IHJlcXVpcmUgfHwgSHR0cFJlcXVpcmVTZXJ2aWNlIH0sXG4gICAgICAgICAgICB7IHByb3ZpZGU6IFBhcnNlciwgdXNlQ2xhc3M6IHBhcnNlciB8fCBGcmFnbWVudHNQYXJzZXIgfSxcbiAgICAgICAgICAgIHsgcHJvdmlkZTogU2lqaWxPcHRzLCB1c2VWYWx1ZTogb3B0aW9ucyB8fCBkZWZhdWx0U2lqaWxPcHRzIH1cbiAgICAgICAgXVxuICAgIH07XG4gIH1cblxuICBzdGF0aWMgZm9yQ2hpbGQoKTogTW9kdWxlV2l0aFByb3ZpZGVyczxOZ3hPZGVTaWppbE1vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICAgIG5nTW9kdWxlOiBOZ3hPZGVTaWppbE1vZHVsZSxcbiAgICAgICAgcHJvdmlkZXJzOiBbXVxuICAgIH07XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/pipes/translate.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/bundles.service";
+export class TranslatePipe {
+    constructor(bundlesService) {
+        this.bundlesService = bundlesService;
+    }
+    transform(key, parameters, lang) {
+        return this.bundlesService.translate(key, parameters, lang);
+    }
+}
+TranslatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: TranslatePipe, deps: [{ token: i1.BundlesService }], target: i0.ɵɵFactoryTarget.Pipe });
+TranslatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.1.1", ngImport: i0, type: TranslatePipe, name: "translate", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: TranslatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'translate', pure: false }]
+        }], ctorParameters: function () { return [{ type: i1.BundlesService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtb2RlLXNpamlsL3NyYy9saWIvcGlwZXMvdHJhbnNsYXRlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQUdwRCxNQUFNLE9BQU8sYUFBYTtJQUV0QixZQUFvQixjQUE4QjtRQUE5QixtQkFBYyxHQUFkLGNBQWMsQ0FBZ0I7SUFBRyxDQUFDO0lBRXRELFNBQVMsQ0FBQyxHQUFXLEVBQUUsVUFBMkIsRUFBRSxJQUFhO1FBQzdELE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLFVBQVUsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNoRSxDQUFDOzswR0FOUSxhQUFhO3dHQUFiLGFBQWE7MkZBQWIsYUFBYTtrQkFEekIsSUFBSTttQkFBQyxFQUFDLElBQUksRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJ1bmRsZXNTZXJ2aWNlIH0gZnJvbSAnLi4vc2VydmljZXMvYnVuZGxlcy5zZXJ2aWNlJztcbmltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe25hbWU6ICd0cmFuc2xhdGUnLCBwdXJlOiBmYWxzZX0pXG5leHBvcnQgY2xhc3MgVHJhbnNsYXRlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBidW5kbGVzU2VydmljZTogQnVuZGxlc1NlcnZpY2UpIHt9XG5cbiAgICB0cmFuc2Zvcm0oa2V5OiBzdHJpbmcsIHBhcmFtZXRlcnM/OiBvYmplY3QgfCBhbnlbXSwgbGFuZz86IHN0cmluZyk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLmJ1bmRsZXNTZXJ2aWNlLnRyYW5zbGF0ZShrZXksIHBhcmFtZXRlcnMsIGxhbmcpO1xuICAgIH1cblxufVxuIl19

package/esm2020/lib/services/bundles.service.mjs

@@ -0,0 +1,98 @@
+/**
+ * Defines a BundlesService, whice is the main entry point for Sijil operations.
+ *
+ * A BundlesServices has three dependencies :
+ * - RequireService : Used to fetch bundles
+ * - Parser : Used to parse logic inside bundle values
+ * - SijilOpts : An object containing custom settings
+ */
+export class BundlesService {
+    constructor(requireService, parser, sijilOpts) {
+        this.requireService = requireService;
+        this.parser = parser;
+        this.bundles = {};
+        this.defaultLanguage = sijilOpts.defaultLanguage;
+        if (!this.defaultLanguage && typeof window !== 'undefined') {
+            this.defaultLanguage = window.navigator.language.split('-')[0];
+        }
+        this.currentLanguage = this.defaultLanguage;
+    }
+    /**
+     * Add keys/values to an existing bundle, or create it if missing.
+     *
+     * @param bundle An object containing translations as key / values.
+     * @param lang The language to map the bundle with, or the current langugage if omitted.
+     */
+    addToBundle(bundle, lang) {
+        const targetLanguage = lang || this.currentLanguage || this.defaultLanguage || 'en';
+        if (!this.bundles[targetLanguage]) {
+            this.bundles[targetLanguage] = {};
+        }
+        this.bundles[targetLanguage] = Object.assign({}, this.bundles[targetLanguage], bundle);
+        if (!this.currentLanguage) {
+            this.currentLanguage = lang;
+        }
+    }
+    /**
+     * Loads a bundle and associates it with a language.
+     * If the target language already contains key/values, then we mixin the new bundle and the existing one.
+     *
+     * @param where The path, or whatever the RequireService needs to fetch the bundle.
+     * @param lang The target language, or the current language if omitted.
+     * @returns A Promise, because the RequireService can be (is - by default) asynchronous.
+     */
+    loadBundle(where, lang) {
+        return this.requireService.load(where)
+            .then(bundle => {
+            this.addToBundle(bundle, lang);
+        });
+    }
+    /**
+     * Loads multiple bundles and associates then with a language.
+     *
+     * @see {@link loadBundle}
+     */
+    loadBundles(specs) {
+        return Promise.all(specs.map((spec) => {
+            return this.loadBundle(spec.where, spec.lang);
+        }));
+    }
+    /**
+     * Removes a bundle from the bundles list.
+     *
+     * @param lang Language to remove.
+     */
+    unloadBundle(lang) {
+        delete this.bundles[lang];
+    }
+    /**
+     * @returns Returns a list of all loaded languages.
+     */
+    getLoadedLanguages() {
+        return Object.keys(this.bundles);
+    }
+    /**
+     * Translates a single key into a target language, using the parameters provided if needed.
+     *
+     * @param key Key to translate
+     * @param parameters Parameters to use if the translation contains logic.
+     * @param lang Target language, of the current language if omitted.
+     * @returns The computed translation, or the key if no match was found in the bundles (including the fallback language bundle).
+     */
+    translate(key, parameters, lang) {
+        const targetLanguage = lang || this.currentLanguage;
+        const rawTranslation = this.bundles[targetLanguage] &&
+            this.bundles[targetLanguage][key] ||
+            this.defaultLanguage &&
+                this.bundles[this.defaultLanguage] &&
+                this.bundles[this.defaultLanguage][key] ||
+            key;
+        if (rawTranslation !== key && parameters) {
+            return this.parser.compile(rawTranslation, parameters, (e) => { console.error(e); return key; });
+        }
+        else {
+            return rawTranslation;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundles.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-ode-sijil/src/lib/services/bundles.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { RequireService } from './require/require.interface';\nimport { Parser } from './parser/parser.interface';\nimport { SijilOpts } from './sijil.opts';\n\n/**\n * Defines a BundlesService, whice is the main entry point for Sijil operations.\n *\n * A BundlesServices has three dependencies :\n * - RequireService : Used to fetch bundles\n * - Parser : Used to parse logic inside bundle values\n * - SijilOpts : An object containing custom settings\n */\nexport class BundlesService {\n\n    constructor(private requireService: RequireService, private parser: Parser, sijilOpts: SijilOpts) {\n        this.defaultLanguage = sijilOpts.defaultLanguage;\n        if(!this.defaultLanguage && typeof window !== 'undefined') {\n            this.defaultLanguage = window.navigator.language.split('-')[0];\n        }\n        this.currentLanguage = this.defaultLanguage;\n    }\n\n    private bundles: Object = {};\n    /**\n     * Fallback language.\n     */\n    defaultLanguage: string;\n    /**\n     * Current language.\n     */\n    currentLanguage: string;\n\n    /**\n     * Add keys/values to an existing bundle, or create it if missing.\n     *\n     * @param bundle An object containing translations as key / values.\n     * @param lang The language to map the bundle with, or the current langugage if omitted.\n     */\n    addToBundle(bundle: Object, lang?: string) : void {\n        const targetLanguage = lang || this.currentLanguage || this.defaultLanguage || 'en';\n\n        if(!this.bundles[targetLanguage]) {\n            this.bundles[targetLanguage] = {};\n        }\n\n        this.bundles[targetLanguage] = Object.assign({}, this.bundles[targetLanguage], bundle);\n\n        if(!this.currentLanguage) {\n            this.currentLanguage = lang;\n        }\n    }\n\n    /**\n     * Loads a bundle and associates it with a language.\n     * If the target language already contains key/values, then we mixin the new bundle and the existing one.\n     *\n     * @param where The path, or whatever the RequireService needs to fetch the bundle.\n     * @param lang The target language, or the current language if omitted.\n     * @returns A Promise, because the RequireService can be (is - by default) asynchronous.\n     */\n    loadBundle(where, lang?: string) : Promise<void> {\n        return this.requireService.load(where)\n            .then(bundle => {\n                this.addToBundle(bundle, lang);\n            })\n    }\n    /**\n     * Loads multiple bundles and associates then with a language.\n     *\n     * @see {@link loadBundle}\n     */\n    loadBundles(specs: { lang: string, where: any }[]): Promise<void[]> {\n        return Promise.all(specs.map((spec) => {\n            return this.loadBundle(spec.where, spec.lang);\n        }))\n    }\n\n    /**\n     * Removes a bundle from the bundles list.\n     *\n     * @param lang Language to remove.\n     */\n    unloadBundle(lang: string): void {\n        delete this.bundles[lang];\n    }\n\n    /**\n     * @returns Returns a list of all loaded languages.\n     */\n    getLoadedLanguages() : string[] {\n        return Object.keys(this.bundles);\n    }\n\n    /**\n     * Translates a single key into a target language, using the parameters provided if needed.\n     *\n     * @param key Key to translate\n     * @param parameters Parameters to use if the translation contains logic.\n     * @param lang Target language, of the current language if omitted.\n     * @returns The computed translation, or the key if no match was found in the bundles (including the fallback language bundle).\n     */\n    translate(key: string, parameters?: Object | any[], lang?: string) : string {\n        const targetLanguage = lang || this.currentLanguage;\n\n        const rawTranslation : string = this.bundles[targetLanguage] &&\n            this.bundles[targetLanguage][key] ||\n            this.defaultLanguage &&\n            this.bundles[this.defaultLanguage] &&\n            this.bundles[this.defaultLanguage][key] ||\n            key;\n\n        if(rawTranslation !== key && parameters) {\n            return this.parser.compile(rawTranslation, parameters, (e) => { console.error(e); return key; });\n        } else {\n            return rawTranslation;\n        }\n    }\n}\n"]}

package/esm2020/lib/services/parser/fragments.parser.mjs

@@ -0,0 +1,142 @@
+import { ParserError } from './parser.interface';
+/**
+ * The default Sijil parser.
+ *
+ * - Input : bundle value (translation) + parameters (Object or Array)
+ * - Output : compiled translation
+ *
+ * Logic is contained inside mustache blocks : {{ LOGIC BLOCK }}
+ *
+ * There are two variants :
+ *  - A single parameter key (when the params are contained inside an object) or index (params contained inside an array)
+ *
+ * Examples:
+ *
+ * {{ key }} + { "key" : "my key" } = my key
+ *
+ * {{ 1 }} + [1, 2] = 2
+ *
+ *  - A ternary-like condition
+ *
+ * {{ condition ? trueValue : falseValue }}
+ * Where condition may be : a single parameter key/index, or 2 clauses with the following operators : ==, >, =>, <=, <
+ *
+ * Examples:
+ *
+ * (the $ sign to refer to a variable is mandatory when a clause contains more than 1 word)
+ *
+ * {{ count > 1 ? $count cats : 1 cat }} + {"count": 10} = 10 cats
+ * {{ 1 < count ? $count cats : 1 cat }} + {"count": 1} = 1 cat
+ *
+ * @export
+ */
+// @dynamic
+export class FragmentsParser {
+    constructor() { }
+    getParameter(parameters, fragment, strict) {
+        const splittedFrag = fragment.split(/\s+/);
+        if (splittedFrag.length === 1) {
+            return fragment[0] === '$' ?
+                parameters[fragment.substr(1)] :
+                strict ?
+                    fragment :
+                    parameters[fragment] !== undefined ?
+                        parameters[fragment] :
+                        fragment;
+        }
+        return fragment.split(/\s+/).reduce((l, r) => {
+            l.push(r[0] === '$' ? parameters[r.substr(1)] : r);
+            return l;
+        }, []).join(' ');
+    }
+    compileFragment(fragment, parameters) {
+        fragment = fragment.replace(/{{|}}/g, '');
+        let interrogationIndex;
+        let dotsIndex;
+        if ((interrogationIndex = fragment.indexOf('?')) > 0 && (dotsIndex = fragment.lastIndexOf(':')) > 1) {
+            const condition = fragment.substring(0, interrogationIndex).trim();
+            const trueReturn = fragment.substring(interrogationIndex + 1, dotsIndex).trim();
+            const falseReturn = fragment.substring(dotsIndex + 1).trim();
+            const computedTrueReturn = this.getParameter(parameters, trueReturn);
+            const computedFalseReturn = this.getParameter(parameters, falseReturn);
+            const splittedCondition = condition.split(/\s+/);
+            if (splittedCondition.length === 1) {
+                // Single variable case
+                const variable = parameters[splittedCondition[0]];
+                return variable ?
+                    computedTrueReturn :
+                    computedFalseReturn;
+            }
+            else if (splittedCondition.length === 3) {
+                // Operator case
+                const leftHandParam = this.getParameter(parameters, splittedCondition[0], parameters instanceof Array);
+                const rightHand = this.getParameter(parameters, splittedCondition[2], parameters instanceof Array);
+                const comparisonOperator = splittedCondition[1];
+                switch (comparisonOperator) {
+                    case '==':
+                        return leftHandParam === rightHand ?
+                            computedTrueReturn :
+                            computedFalseReturn;
+                    case '>':
+                        return leftHandParam > rightHand ?
+                            computedTrueReturn :
+                            computedFalseReturn;
+                    case '>=':
+                        return leftHandParam >= rightHand ?
+                            computedTrueReturn :
+                            computedFalseReturn;
+                    case '<':
+                        return leftHandParam < rightHand ?
+                            computedTrueReturn :
+                            computedFalseReturn;
+                    case '<=':
+                        return leftHandParam <= rightHand ?
+                            computedTrueReturn :
+                            computedFalseReturn;
+                    default:
+                        throw new ParserError(`Invalid conditional operator for fragment : ${fragment}`, fragment);
+                }
+            }
+            else {
+                throw new ParserError(`Invalid condition for fragment : ${fragment}`, fragment);
+            }
+        }
+        else {
+            fragment = fragment.trim();
+            return parameters[fragment];
+        }
+    }
+    compile(rawTranslation, parameters, onError) {
+        const parts = rawTranslation.split(FragmentsParser.delimRegexp);
+        const fragments = rawTranslation.match(FragmentsParser.delimRegexp);
+        let compiledTranslation = '';
+        if (!onError) {
+            onError = FragmentsParser.defaultErrorCallback;
+        }
+        if (!fragments) {
+            compiledTranslation += rawTranslation;
+        }
+        else {
+            for (let i = 0; i < parts.length; i++) {
+                compiledTranslation += parts[i];
+                if (i > fragments.length - 1) {
+                    continue;
+                }
+                try {
+                    compiledTranslation += this.compileFragment(fragments[i], parameters);
+                }
+                catch (e) {
+                    compiledTranslation += onError(e);
+                }
+            }
+        }
+        return compiledTranslation;
+    }
+}
+FragmentsParser.delimiters = ['{{', '}}'];
+FragmentsParser.delimRegexp = new RegExp(`${FragmentsParser.delimiters[0]}[^}]+${FragmentsParser.delimiters[1]}`, 'gm');
+FragmentsParser.defaultErrorCallback = (e) => {
+    console.error(e);
+    return e.fragment;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fragments.parser.js","sourceRoot":"","sources":["../../../../../../projects/ngx-ode-sijil/src/lib/services/parser/fragments.parser.ts"],"names":[],"mappings":"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","sourcesContent":["import { Parser, ParserCallback, ParserError } from './parser.interface';\n\n/**\n * The default Sijil parser.\n *\n * - Input : bundle value (translation) + parameters (Object or Array)\n * - Output : compiled translation\n *\n * Logic is contained inside mustache blocks : {{ LOGIC BLOCK }}\n *\n * There are two variants :\n *  - A single parameter key (when the params are contained inside an object) or index (params contained inside an array)\n *\n * Examples:\n *\n * {{ key }} + { \"key\" : \"my key\" } = my key\n *\n * {{ 1 }} + [1, 2] = 2\n *\n *  - A ternary-like condition\n *\n * {{ condition ? trueValue : falseValue }}\n * Where condition may be : a single parameter key/index, or 2 clauses with the following operators : ==, >, =>, <=, <\n *\n * Examples:\n *\n * (the $ sign to refer to a variable is mandatory when a clause contains more than 1 word)\n *\n * {{ count > 1 ? $count cats : 1 cat }} + {\"count\": 10} = 10 cats\n * {{ 1 < count ? $count cats : 1 cat }} + {\"count\": 1} = 1 cat\n *\n * @export\n */\n// @dynamic\nexport class FragmentsParser implements Parser {\n\n    constructor(){}\n\n    private static delimiters: string[] = ['{{', '}}'];\n    private static delimRegexp = new RegExp(`${FragmentsParser.delimiters[0]}[^}]+${FragmentsParser.delimiters[1]}`, 'gm');\n\n    private static defaultErrorCallback: ParserCallback = (e: ParserError) => {\n        console.error(e);\n        return e.fragment;\n    }\n\n    private getParameter(parameters: Object | any[], fragment: string, strict?: boolean): string {\n        const splittedFrag = fragment.split(/\\s+/);\n        if(splittedFrag.length === 1) {\n            return fragment[0] === '$' ?\n                parameters[fragment.substr(1)] :\n                strict ?\n                    fragment :\n                    parameters[fragment] !== undefined ?\n                        parameters[fragment] :\n                        fragment;\n        }\n        return fragment.split(/\\s+/).reduce((l, r) => {\n            l.push(r[0] === '$' ? parameters[r.substr(1)] : r);\n            return l;\n        }, []).join(' ');\n    }\n\n    private compileFragment(fragment: string, parameters: Object | any[]): string {\n        fragment = fragment.replace(/{{|}}/g, '');\n\n        let interrogationIndex;\n        let dotsIndex;\n        if ((interrogationIndex = fragment.indexOf('?')) > 0 && (dotsIndex = fragment.lastIndexOf(':')) > 1) {\n            const condition = fragment.substring(0, interrogationIndex).trim();\n            const trueReturn = fragment.substring(interrogationIndex + 1, dotsIndex).trim();\n            const falseReturn = fragment.substring(dotsIndex + 1).trim();\n            const computedTrueReturn = this.getParameter(parameters, trueReturn);\n            const computedFalseReturn = this.getParameter(parameters, falseReturn);\n\n            const splittedCondition = condition.split(/\\s+/);\n\n            if (splittedCondition.length === 1) {\n\n                // Single variable case\n\n                const variable = parameters[splittedCondition[0]];\n\n                return variable ?\n                    computedTrueReturn :\n                    computedFalseReturn;\n\n            } else if (splittedCondition.length === 3) {\n\n                // Operator case\n\n                const leftHandParam = this.getParameter(parameters, splittedCondition[0], parameters instanceof Array);\n                const rightHand = this.getParameter(parameters, splittedCondition[2], parameters instanceof Array);\n                const comparisonOperator = splittedCondition[1];\n\n                switch (comparisonOperator) {\n                    case '==':\n                        return leftHandParam === rightHand ?\n                            computedTrueReturn :\n                            computedFalseReturn;\n                    case '>':\n                        return leftHandParam > rightHand ?\n                            computedTrueReturn :\n                            computedFalseReturn;\n                    case '>=':\n                        return leftHandParam >= rightHand ?\n                            computedTrueReturn :\n                            computedFalseReturn;\n                    case '<':\n                        return leftHandParam < rightHand ?\n                            computedTrueReturn :\n                            computedFalseReturn;\n                    case '<=':\n                        return leftHandParam <= rightHand ?\n                            computedTrueReturn :\n                            computedFalseReturn;\n                    default:\n                        throw new ParserError(`Invalid conditional operator for fragment : ${fragment}`, fragment);\n                }\n\n            } else {\n                throw new ParserError(`Invalid condition for fragment : ${fragment}`, fragment);\n            }\n        } else {\n            fragment = fragment.trim();\n            return parameters[fragment];\n        }\n    }\n\n    compile(rawTranslation: string, parameters: Object, onError?: ParserCallback): string {\n\n        const parts = rawTranslation.split(FragmentsParser.delimRegexp);\n        const fragments = rawTranslation.match(FragmentsParser.delimRegexp);\n\n        let compiledTranslation = '';\n\n        if (!onError) {\n            onError = FragmentsParser.defaultErrorCallback;\n        }\n\n        if (!fragments) {\n            compiledTranslation += rawTranslation;\n        } else {\n            for (let i = 0; i < parts.length; i++) {\n                compiledTranslation += parts[i];\n                if (i > fragments.length - 1) {\n                    continue;\n                }\n                try {\n                    compiledTranslation += this.compileFragment(fragments[i], parameters);\n                } catch (e) {\n                    compiledTranslation += onError(e);\n                }\n            }\n        }\n\n        return compiledTranslation;\n\n    }\n\n}\n"]}

package/esm2020/lib/services/parser/parser.interface.mjs

@@ -0,0 +1,15 @@
+export class ParserError extends Error {
+    constructor(message, fragment) {
+        super(message);
+        this.message = message;
+        this.fragment = fragment;
+    }
+}
+/**
+ * Parses logic inside translations.
+ *
+ * @export
+ */
+export class Parser {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VyLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1vZGUtc2lqaWwvc3JjL2xpYi9zZXJ2aWNlcy9wYXJzZXIvcGFyc2VyLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sV0FBWSxTQUFRLEtBQUs7SUFDbEMsWUFBbUIsT0FBZSxFQUFTLFFBQWdCO1FBQ3ZELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQURDLFlBQU8sR0FBUCxPQUFPLENBQVE7UUFBUyxhQUFRLEdBQVIsUUFBUSxDQUFRO0lBRTNELENBQUM7Q0FDSjtBQUdEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQWdCLE1BQU07Q0FPM0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgUGFyc2VyRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gICAgY29uc3RydWN0b3IocHVibGljIG1lc3NhZ2U6IHN0cmluZywgcHVibGljIGZyYWdtZW50OiBzdHJpbmcpIHtcbiAgICAgICAgc3VwZXIobWVzc2FnZSlcbiAgICB9XG59XG5cbmV4cG9ydCB0eXBlIFBhcnNlckNhbGxiYWNrID0gKF8gOiBQYXJzZXJFcnJvcikgPT4gc3RyaW5nO1xuLyoqXG4gKiBQYXJzZXMgbG9naWMgaW5zaWRlIHRyYW5zbGF0aW9ucy5cbiAqXG4gKiBAZXhwb3J0XG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBQYXJzZXIge1xuICAgIC8qKlxuICAgICAqIFByb2Nlc3NlcyBhIHN0cmluZywgaXNvbGF0aW5nIGxvZ2ljIGZyYWdtZW50cyBhbmQgY29tcGlsaW5nIHRoZW0uXG4gICAgICpcbiAgICAgKiBAbWVtYmVyT2YgUGFyc2VyXG4gICAgICovXG4gICAgY29tcGlsZTogKHRleHQ6IHN0cmluZywgcGFyYW1ldGVyczogYW55LCBlcnJvcj86IFBhcnNlckNhbGxiYWNrKSA9PiBzdHJpbmc7XG59XG4iXX0=

package/esm2020/lib/services/require/httprequire.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Fetches a bundle from a target url.
+ *
+ * @export
+ */
+export class HttpRequireService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    load(url) {
+        return this.httpClient.get(url).toPromise()
+            .then(data => data);
+    }
+}
+HttpRequireService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: HttpRequireService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpRequireService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: HttpRequireService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: HttpRequireService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cHJlcXVpcmUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1vZGUtc2lqaWwvc3JjL2xpYi9zZXJ2aWNlcy9yZXF1aXJlL2h0dHByZXF1aXJlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7O0FBRzFDOzs7O0dBSUc7QUFFSCxNQUFNLE9BQU8sa0JBQWtCO0lBRTNCLFlBQW9CLFVBQXNCO1FBQXRCLGVBQVUsR0FBVixVQUFVLENBQVk7SUFBRSxDQUFDO0lBRTdDLElBQUksQ0FBQyxHQUFHO1FBQ0osT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxTQUFTLEVBQUU7YUFDdEMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsQ0FBQzs7K0dBUFEsa0JBQWtCO21IQUFsQixrQkFBa0I7MkZBQWxCLGtCQUFrQjtrQkFEOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcXVpcmVTZXJ2aWNlIH0gZnJvbSAnLi9yZXF1aXJlLmludGVyZmFjZSdcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJ1xuXG4vKipcbiAqIEZldGNoZXMgYSBidW5kbGUgZnJvbSBhIHRhcmdldCB1cmwuXG4gKlxuICogQGV4cG9ydFxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgSHR0cFJlcXVpcmVTZXJ2aWNlIGltcGxlbWVudHMgUmVxdWlyZVNlcnZpY2Uge1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBodHRwQ2xpZW50OiBIdHRwQ2xpZW50KXt9XG5cbiAgICBsb2FkKHVybCkgOiBQcm9taXNlPE9iamVjdD4ge1xuICAgICAgICByZXR1cm4gdGhpcy5odHRwQ2xpZW50LmdldCh1cmwpLnRvUHJvbWlzZSgpXG4gICAgICAgICAgICAudGhlbihkYXRhID0+IGRhdGEpO1xuICAgIH1cblxufVxuIl19

package/esm2020/lib/services/require/require.interface.mjs

@@ -0,0 +1,8 @@
+/**
+ * Service used to fetch bundles.
+ *
+ * @export
+ */
+export class RequireService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtb2RlLXNpamlsL3NyYy9saWIvc2VydmljZXMvcmVxdWlyZS9yZXF1aXJlLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsTUFBTSxPQUFnQixjQUFjO0NBTW5DIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTZXJ2aWNlIHVzZWQgdG8gZmV0Y2ggYnVuZGxlcy5cbiAqXG4gKiBAZXhwb3J0XG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBSZXF1aXJlU2VydmljZSB7XG4gICAgLyoqXG4gICAgICogRmV0Y2ggYSBidW5kbGUuXG4gICAgICogQG1lbWJlck9mIFJlcXVpcmVTZXJ2aWNlXG4gICAgICovXG4gICAgbG9hZDogKGZyb206IGFueSkgPT4gUHJvbWlzZTxPYmplY3Q+O1xufVxuIl19

package/esm2020/lib/services/sijil.opts.mjs

@@ -0,0 +1,11 @@
+/**
+ * Contains Sijil options.
+ *
+ * @export
+ */
+export class SijilOpts {
+}
+export let defaultSijilOpts = {
+    defaultLanguage: window ? window.navigator.language.split('-')[0] : undefined
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lqaWwub3B0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1vZGUtc2lqaWwvc3JjL2xpYi9zZXJ2aWNlcy9zaWppbC5vcHRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQWdCLFNBQVM7Q0FHOUI7QUFFRCxNQUFNLENBQUMsSUFBSSxnQkFBZ0IsR0FBZTtJQUN0QyxlQUFlLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVM7Q0FDaEYsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29udGFpbnMgU2lqaWwgb3B0aW9ucy5cbiAqXG4gKiBAZXhwb3J0XG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBTaWppbE9wdHMge1xuICAgIC8qKiBGYWxsYmFjayBsYW5ndWFnZSB3aGVuIGEgdHJhbnNsYXRpb24gaXMgbm90IGF2YWlsYWJsZSBpbiB0aGUgY3VycmVudCBsYW5ndWFnZS4gKi9cbiAgICBkZWZhdWx0TGFuZ3VhZ2U6IHN0cmluZztcbn1cblxuZXhwb3J0IGxldCBkZWZhdWx0U2lqaWxPcHRzIDogU2lqaWxPcHRzID0ge1xuICAgIGRlZmF1bHRMYW5ndWFnZTogd2luZG93ID8gd2luZG93Lm5hdmlnYXRvci5sYW5ndWFnZS5zcGxpdCgnLScpWzBdIDogdW5kZWZpbmVkXG59O1xuIl19

package/esm2020/ngx-ode-sijil.mjs

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

package/esm2020/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of ngx-ode-sijil
+ */
+export * from './lib/services/bundles.service';
+export * from './lib/components/s5l.component';
+export * from './lib/pipes/translate.pipe';
+export * from './lib/ngx-ode-sijil.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1vZGUtc2lqaWwvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtb2RlLXNpamlsXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvYnVuZGxlcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvczVsLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9waXBlcy90cmFuc2xhdGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9uZ3gtb2RlLXNpamlsLm1vZHVsZSc7XG4iXX0=