@onemrvapublic/design-system 1.0.0-beta.4 → 1.0.0-develop.1

package/fesm2022/onemrvapublic-design-system-shared.mjs

@@ -0,0 +1,2188 @@
+import * as i0 from '@angular/core';
+import { inject, ElementRef, Component, InjectionToken, Injectable, HostListener, Directive, HostBinding, Input, EventEmitter, Output, TemplateRef, ViewContainerRef, Renderer2, ComponentFactoryResolver, input, Pipe, RendererFactory2, NgModule, ErrorHandler } from '@angular/core';
+import * as i1 from '@angular/material/icon';
+import { MatIconModule } from '@angular/material/icon';
+import * as i2 from '@angular/material/tooltip';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { DOCUMENT } from '@angular/common';
+import { Platform, _isTestEnvironment } from '@angular/cdk/platform';
+import { Subject, merge, NEVER, take, tap, catchError, startWith, switchMap, shareReplay, filter, finalize, of, forkJoin, ReplaySubject, skip, distinctUntilChanged, map as map$1, combineLatestWith, from, takeUntil } from 'rxjs';
+import { OnemrvaMatColor, OnemrvaMatSize } from '@onemrvapublic/design-system/utils';
+import { BreakpointObserver } from '@angular/cdk/layout';
+import { catchError as catchError$1, map, startWith as startWith$1 } from 'rxjs/operators';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { __decorate } from 'tslib';
+import { TranslateService } from '@ngx-translate/core';
+import { countrySpecs, validateIBAN, electronicFormatIBAN, ValidationErrorsIBAN } from 'ibantools';
+import { NativeDateAdapter, DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';
+import { DateTime, Info } from 'luxon';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { MAT_FORM_FIELD_DEFAULT_OPTIONS } from '@angular/material/form-field';
+import { OverlayContainer } from '@angular/cdk/overlay';
+
+class ClipboardIconComponent {
+    constructor() {
+        this._elementRef = inject(ElementRef);
+        this.clipboardService = inject(Clipboard);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: ClipboardIconComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.7", type: ClipboardIconComponent, isStandalone: true, selector: "lib-clipboard-icon", ngImport: i0, template: "<mat-icon [matTooltip]=\"'TEST'\">content_copy</mat-icon>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: ClipboardIconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-clipboard-icon', standalone: true, imports: [MatIconModule, MatTooltipModule], template: "<mat-icon [matTooltip]=\"'TEST'\">content_copy</mat-icon>\n" }]
+        }] });
+
+var CDNUrlModeOptions;
+(function (CDNUrlModeOptions) {
+    CDNUrlModeOptions["PROD"] = "production";
+    CDNUrlModeOptions["VAL"] = "validation";
+})(CDNUrlModeOptions || (CDNUrlModeOptions = {}));
+
+const CDN_URLS = {
+    prod: 'https://cdn.services.rvaonem.fgov.be',
+    val: 'https://cdn.servicesval.rvaonem.fgov.be',
+};
+const NISS_MASK = '000000/000-00';
+const LOOKUP_COUNTRY_URL = 'http://services/lookupwpptservice/rest/lookup/getLookups?class=be.fgov.onerva.lookup.wppt.persistence.model.common.Country';
+const ONEMRVA_THEME = 'onemrva-theme';
+// export const LOOKUP_POSTAL_CODE_URL =
+//   'https://services/lookupwpptservice/rest/lookup/getBelgianCommunityByPostalCode?postalCode=';
+
+const parseNativeDateFormats = [
+    'ddMMyyyy',
+    'dd/MM/yyyy',
+    'd/M/yyyy',
+    'dd/M/yyyy',
+    'd/MM/yyyy',
+    'd.M.yyyy',
+    'dd.M.yyyy',
+    'd.MM.yyyy',
+    'd/M/yy',
+    'dd/M/yy',
+    'd/MM/yy',
+    'd.M.yy',
+    'dd.M.yy',
+    'd.MM.yy',
+];
+const parseNativeYearMonthFormats = [
+    'MMyyyy',
+    'M/yyyy',
+    'M/yy',
+    'MM/yyyy',
+    'MM/yy',
+    'M.yyyy',
+    'MM.yyyy',
+];
+const parseLuxonYearMonthFormats = [
+    'LLyyyy',
+    'L/yyyy',
+    'L/yy',
+    'LL/yyyy',
+    'LL/yy',
+    'L.yyyy',
+    'LL.yyyy',
+];
+const parseLuxonDateFormat = [
+    'ddLLyyyy',
+    'd/LL/yyyy',
+    'd/L/yyyy',
+    'dd/L/yyyy',
+    'd/LL/yyyy',
+    'd.L.yyyy',
+    'dd.L.yyyy',
+    'd.LL.yyyy',
+    'd/L/yy',
+    'dd/L/yy',
+    'd/LL/yy',
+    'd.L.yy',
+    'dd.L.yy',
+    'd.LL.yy',
+];
+const ONEMRVA_MAT_NATIVE_DATE_FORMAT = {
+    parse: {
+        dateInput: parseNativeDateFormats,
+    },
+    display: {
+        dateInput: 'dd/MM/yyyy',
+        monthYearLabel: 'LL / yyyy',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMMM yyyy',
+    },
+};
+const ONEMRVA_MAT_NATIVE_YEAR_MONTH_FORMAT = {
+    parse: {
+        dateInput: parseNativeYearMonthFormats,
+    },
+    display: {
+        dateInput: 'dd/MM/yyyy',
+        monthYearLabel: 'LL / yyyy',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMM yyyy',
+    },
+};
+const ONEMRVA_MAT_LUXON_YEAR_MONTH_FORMATS = {
+    parse: {
+        dateInput: parseLuxonYearMonthFormats,
+    },
+    display: {
+        dateInput: 'LL/yyyy',
+        monthYearLabel: 'LLL yyyy',
+        dateA11yLabel: 'DDD',
+        monthYearA11yLabel: 'LLLL yyyy',
+    },
+};
+const ONEMRVA_MAT_LUXON_DATE_FORMATS = {
+    parse: {
+        dateInput: parseLuxonDateFormat,
+    },
+    display: {
+        dateInput: 'dd/LL/yyyy',
+        monthYearLabel: 'LLL yyyy',
+        dateA11yLabel: 'DDD',
+        monthYearA11yLabel: 'LLL yyyy',
+    },
+};
+
+const CDN_URL_MODE = new InjectionToken('This is cdn url that will be used (val/prod)');
+
+const LOOKUP_COUNTRY_SERVICE_URL = new InjectionToken('LOOKUP_COUNTRY_SERVICE_URL', {
+    providedIn: 'root',
+    factory: () => LOOKUP_COUNTRY_URL,
+});
+const ONEMRVA_THEME_CLASS = new InjectionToken('ONEMRVA_THEME_CLASS', {
+    providedIn: 'root',
+    factory: () => ONEMRVA_THEME,
+});
+
+/**
+ * @license
+ * Copyright 2025 OneMRVA
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Container inside which all overlays will render. */
+class WebComponentOverlayContainer {
+    constructor() {
+        this._containerElement = null;
+        this._themeObserver = null;
+        this.platform = inject(Platform);
+        this._document = inject(DOCUMENT);
+        this.themeClass = inject(ONEMRVA_THEME_CLASS);
+    }
+    ngOnDestroy() {
+        this._containerElement?.remove();
+        this._themeObserver?.disconnect();
+    }
+    /**
+     * This method returns the overlay container element. It will lazily
+     * create the element the first time it is called to facilitate using
+     * the container in non-browser environments.
+     * @returns the container element
+     */
+    getContainerElement() {
+        if (this._containerElement === null) {
+            this._createContainer();
+        }
+        return this._containerElement;
+    }
+    /**
+     * Create the overlay container element, which is simply a div
+     * with the 'cdk-overlay-container' class on the document body.
+     */
+    _createContainer() {
+        const containerClass = 'cdk-overlay-container';
+        if (this.platform.isBrowser || _isTestEnvironment()) {
+            const oppositePlatformContainers = this._document.querySelectorAll(`.${containerClass}[platform="server"], ` +
+                `.${containerClass}[platform="test"]`);
+            oppositePlatformContainers.forEach(platform => {
+                platform.remove();
+            });
+        }
+        const containerwrap = this._document.createElement('div');
+        containerwrap.classList.add(this.themeClass);
+        const themeElements = this._document.querySelectorAll(`.${this.themeClass}`);
+        const existingThemeElement = Array.from(themeElements).find(el => el !== containerwrap);
+        if (existingThemeElement) {
+            if (existingThemeElement.classList.contains('dark-theme')) {
+                containerwrap.classList.add('dark-theme');
+            }
+            else if (existingThemeElement.classList.contains('light-theme')) {
+                containerwrap.classList.add('light-theme');
+            }
+        }
+        this._themeObserver = new MutationObserver(mutations => {
+            mutations.forEach(mutation => {
+                if (mutation.type === 'attributes' &&
+                    mutation.attributeName === 'class') {
+                    const target = mutation.target;
+                    if (target.classList.contains(this.themeClass) &&
+                        target !== containerwrap) {
+                        containerwrap.classList.remove('dark-theme', 'light-theme');
+                        if (target.classList.contains('dark-theme')) {
+                            containerwrap.classList.add('dark-theme');
+                        }
+                        else if (target.classList.contains('light-theme')) {
+                            containerwrap.classList.add('light-theme');
+                        }
+                    }
+                }
+            });
+        });
+        if (existingThemeElement) {
+            this._themeObserver.observe(existingThemeElement, {
+                attributes: true,
+                attributeFilter: ['class'],
+            });
+        }
+        const container = this._document.createElement('div');
+        container.classList.add(containerClass);
+        if (_isTestEnvironment()) {
+            container.setAttribute('platform', 'test');
+        }
+        else if (!this.platform.isBrowser) {
+            container.setAttribute('platform', 'server');
+        }
+        containerwrap.appendChild(container);
+        this._document.body.appendChild(containerwrap);
+        this._containerElement = container;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: WebComponentOverlayContainer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: WebComponentOverlayContainer, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: WebComponentOverlayContainer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class DefaultStorage {
+    constructor() {
+        this.storage = new Map();
+    }
+    getItem(key) {
+        return this.storage.get(key);
+    }
+    setItem(key, item) {
+        this.storage.set(key, item);
+    }
+    deleteItem(key) {
+        this.storage.delete(key);
+    }
+}
+class RequestTimes {
+    constructor() {
+        this.storage = new Map();
+    }
+    getItem(key) {
+        return this.storage.get(key);
+    }
+    setItem(key, item) {
+        this.storage.set(key, item);
+    }
+    deleteItem(key) {
+        this.storage.delete(key);
+    }
+}
+const HttpRequestCache = (optionsHandler) => {
+    return (target, methodName, descriptor) => {
+        if (!(descriptor?.value instanceof Function)) {
+            throw Error(`'@HttpRequestCache' can be applied only to the class method which returns an Observable`);
+        }
+        const cacheKeyPrefix = `${target.constructor.name}_${methodName}`;
+        const originalMethod = descriptor.value;
+        const working = {};
+        let subscribers = 0;
+        descriptor.value = function (...args) {
+            const options = optionsHandler?.call(this, this, ...args);
+            if (!options?.storage && !target._____storage_____) {
+                target._____storage_____ = new DefaultStorage();
+            }
+            if (options?.ttl && !target._____ttl_storage_____) {
+                target._____ttl_storage_____ = new RequestTimes();
+            }
+            const storage = options?.storage ?? target._____storage_____;
+            const key = `${cacheKeyPrefix}_${JSON.stringify(args)}`;
+            let ttl = undefined;
+            if (options?.ttl) {
+                ttl = target._____ttl_storage_____.getItem(key);
+                if (!ttl) {
+                    ttl = {
+                        requestTime: Date.now(),
+                        subject: new Subject(),
+                    };
+                }
+                else if (ttl.requestTime + options.ttl <= Date.now()) {
+                    working[key] = true;
+                    ttl.requestTime = Date.now();
+                    ttl.subject.next();
+                }
+                target._____ttl_storage_____.setItem(key, ttl);
+            }
+            const refreshOn = merge(options?.refreshOn ?? NEVER, ttl?.subject ?? NEVER);
+            return storage.getItem(key).pipe(take(1), tap(value => {
+                subscribers++;
+                if (value === null)
+                    throw '';
+            }), catchError(() => {
+                const observable = refreshOn.pipe(startWith(true), switchMap(() => originalMethod.apply(this, [...args])), tap(() => {
+                    delete working[key];
+                }), shareReplay({
+                    bufferSize: 1,
+                    refCount: options?.refCount ?? false,
+                    windowTime: options?.windowTime ?? Infinity,
+                }), filter(() => {
+                    return !working[key];
+                }), finalize(() => {
+                    subscribers--;
+                    if (subscribers === 0 && options?.refCount) {
+                        storage.deleteItem(key);
+                        target._____ttl_storage_____?.deleteItem(key);
+                    }
+                }));
+                storage.setItem(key, observable);
+                return observable;
+            }));
+            // let observable = storage.getItem(key);
+            //
+            // if (!observable) {
+            //
+            //   observable = refreshOn.pipe(
+            //     startWith(true),
+            //     switchMap(() => originalMethod.apply(this, [...args])),
+            //     tap(() => {
+            //       delete working[key];
+            //     }),
+            //     shareReplay({
+            //       bufferSize: 1,
+            //       refCount: options?.refCount ?? false,
+            //       windowTime: options?.windowTime ?? Infinity,
+            //     }),
+            //     filter(() => {
+            //       return !working[key];
+            //     }),
+            //     finalize(() => {
+            //       subscribers--;
+            //       if (subscribers === 0 && options?.refCount) {
+            //         storage.deleteItem(key);
+            //         (target as any)._____ttl_storage_____?.deleteItem(key);
+            //       }
+            //     })
+            //   );
+            //   storage.setItem(key, observable);
+            // }
+            //      subscribers++;
+            //      return observable;
+        };
+        return descriptor;
+    };
+};
+
+class DigitOnlyDirective {
+    onKeyDown(event) {
+        const e = event;
+        const allowedKey = [
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            '.',
+            ',',
+            ' ',
+            'Backspace',
+            'Delete',
+            'Tab',
+            '-',
+            'Enter',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'ArrowDown',
+            'Home',
+            'End',
+        ];
+        if (allowedKey.indexOf(e.key) >= 0)
+            return;
+        // HWKTODO manage ctrl Z and ctrl U
+        const allowedCtrlShortcuts = ['a', 'c', 'x', 'v'];
+        if (e.ctrlKey && allowedCtrlShortcuts.indexOf(e.key) >= 0)
+            return;
+        e.preventDefault();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: DigitOnlyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: DigitOnlyDirective, isStandalone: true, selector: "[digitOnly]", host: { listeners: { "keydown": "onKeyDown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: DigitOnlyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[digitOnly]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+
+/**
+ * Conditionally adds component to the tree if screen width matches at least one size in input
+ */
+class OnemRvaColorDirective {
+    constructor() {
+        this.color = '';
+    }
+    /** @hidden @internal */
+    get _isPrimary() {
+        return this.color === OnemrvaMatColor.PRIMARY;
+    }
+    /** @hidden @internal */
+    get _isAccent() {
+        return this.color === OnemrvaMatColor.ACCENT;
+    }
+    /** @hidden @internal */
+    get _isError() {
+        return this.color === OnemrvaMatColor.ERROR;
+    }
+    /** @hidden @internal */
+    get _isWarn() {
+        return this.color === OnemrvaMatColor.WARN;
+    }
+    /** @hidden @internal */
+    get _isSuccess() {
+        return this.color === OnemrvaMatColor.SUCCESS;
+    }
+    /** @hidden @internal */
+    get _isInfo() {
+        return this.color === OnemrvaMatColor.INFO;
+    }
+    /** @hidden @internal */
+    get _isNeutral() {
+        return this.color === OnemrvaMatColor.NEUTRAL;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaColorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemRvaColorDirective, isStandalone: true, selector: "onemrva-mat-selectable-box[color],div[color],onemrva-mat-avatar[color],mat-card[color],mat-toolbar[color],onemrva-mat-spinner[color],onemrva-mat-notification[color],onemrva-mat-task-list[color],onemrva-mat-sticker[color],onemrva-mat-panel[color],onemrva-mat-task[color],onemrva-mat-choice-chip[color],mat-form-field[color],button[color],mat-icon[color],mat-chip[color],mat-chip-option[color]", inputs: { color: "color" }, host: { properties: { "class.mat-primary": "this._isPrimary", "class.mat-accent": "this._isAccent", "class.mat-error": "this._isError", "class.mat-warn": "this._isWarn", "class.mat-success": "this._isSuccess", "class.mat-info": "this._isInfo", "class.mat-neutral": "this._isNeutral" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaColorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'onemrva-mat-selectable-box[color],' +
+                        'div[color],' +
+                        'onemrva-mat-avatar[color],' +
+                        'mat-card[color],' +
+                        'mat-toolbar[color],' +
+                        'onemrva-mat-spinner[color],' +
+                        'onemrva-mat-notification[color],' +
+                        'onemrva-mat-task-list[color],' +
+                        'onemrva-mat-sticker[color],' +
+                        'onemrva-mat-panel[color],' +
+                        'onemrva-mat-task[color],' +
+                        'onemrva-mat-choice-chip[color],' +
+                        'mat-form-field[color],' +
+                        'button[color],' +
+                        'mat-icon[color],' +
+                        'mat-chip[color],' +
+                        'mat-chip-option[color]',
+                    standalone: true,
+                }]
+        }], propDecorators: { color: [{
+                type: Input
+            }], _isPrimary: [{
+                type: HostBinding,
+                args: ['class.mat-primary']
+            }], _isAccent: [{
+                type: HostBinding,
+                args: ['class.mat-accent']
+            }], _isError: [{
+                type: HostBinding,
+                args: ['class.mat-error']
+            }], _isWarn: [{
+                type: HostBinding,
+                args: ['class.mat-warn']
+            }], _isSuccess: [{
+                type: HostBinding,
+                args: ['class.mat-success']
+            }], _isInfo: [{
+                type: HostBinding,
+                args: ['class.mat-info']
+            }], _isNeutral: [{
+                type: HostBinding,
+                args: ['class.mat-neutral']
+            }] } });
+
+class MatRowClickableDirective extends OnemRvaColorDirective {
+    constructor() {
+        super(...arguments);
+        this.matRowClickable = new EventEmitter();
+        this.cssClass = true;
+    }
+    click() {
+        this.matRowClickable.emit();
+    }
+    /** @hidden @internal */
+    get _isClickable() {
+        return this.matRowClickable.observed;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MatRowClickableDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: MatRowClickableDirective, isStandalone: true, selector: "tr[matRowClickable]", outputs: { matRowClickable: "matRowClickable" }, host: { listeners: { "click": "click($event)" }, properties: { "class.clickable": "this._isClickable", "class.onemrva-clickable-row": "this.cssClass" } }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MatRowClickableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'tr[matRowClickable]',
+                    standalone: true,
+                }]
+        }], propDecorators: { matRowClickable: [{
+                type: Output
+            }], click: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], _isClickable: [{
+                type: HostBinding,
+                args: ['class.clickable']
+            }], cssClass: [{
+                type: HostBinding,
+                args: ['class.onemrva-clickable-row']
+            }] } });
+
+/**
+ * Conditionally adds component to the tree if screen width matches at least one size in input
+ */
+class IfWidthIsDirective {
+    constructor() {
+        this.breakpointObserver = inject(BreakpointObserver);
+        this._templateRef = inject(TemplateRef);
+        this._viewContainer = inject(ViewContainerRef);
+    }
+    ngOnInit() {
+        this.breakpointObserver
+            .observe([...this.ifWidthIs])
+            .subscribe((state) => {
+            this._viewContainer.clear();
+            if (state.matches) {
+                this._viewContainer.createEmbeddedView(this._templateRef);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: IfWidthIsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: IfWidthIsDirective, isStandalone: true, selector: "[ifWidthIs]", inputs: { ifWidthIs: "ifWidthIs" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: IfWidthIsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ifWidthIs]',
+                    standalone: true,
+                }]
+        }], propDecorators: { ifWidthIs: [{
+                type: Input
+            }] } });
+
+const UNDO_STACK_MAX_LENGTH = 50;
+/**
+ * 0: digits
+ * A: letters (uppercase or lowercase) and digits
+ * S: only letters (uppercase or lowercase)
+ * U: only letters uppercase
+ * L: only letters lowercase
+ */
+class OnemrvaMaskDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        this.inputStack = ['']; // Stack for undo/redo
+        this.stackIdx = 0; // Current index in undo/redo stack
+        this.markForDelete = false;
+    }
+    onKeyDown(event) {
+        // Allow functional keystrokes
+        const e = event;
+        let specialKeys = [
+            'Tab',
+            'Enter',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'ArrowDown',
+            'Home',
+            'End',
+        ];
+        if (specialKeys.indexOf(e.key) >= 0)
+            return;
+        specialKeys = ['Backspace', 'Delete'];
+        if (specialKeys.indexOf(e.key) >= 0) {
+            this.markForDelete = true;
+            return;
+        }
+        // Undo
+        if (e.ctrlKey && 'z' === e.key && this.stackIdx > 0) {
+            this.stackIdx--;
+            this.el.nativeElement.value = this.inputStack[this.stackIdx];
+            event.preventDefault();
+        }
+        // Redo
+        if (e.ctrlKey &&
+            'u' === e.key &&
+            this.stackIdx < this.inputStack.length - 1) {
+            this.stackIdx++;
+            this.el.nativeElement.value = this.inputStack[this.stackIdx];
+            event.preventDefault();
+        }
+        const allowedCtrlShortcuts = ['a', 'c', 'x', 'v'];
+        if (e.ctrlKey && allowedCtrlShortcuts.indexOf(e.key) >= 0)
+            return;
+    }
+    onInput(event) {
+        const selectionStart = event.target?.selectionStart;
+        /*
+         * Step 1
+         * This block lets a delete execution if the new value is compliant.
+         * There are 2 deletion cases, after which the new value is not compliant
+         *  - dd/MX/yyyy: X is deleted, then the date becomes dd/M/yyyy
+         *                This case is resolved by step 2 and the date will become: dd/My/yyy
+         *  - dd/MMXyyyy: the last '/' is deleted, then the date becomes dd/MMyyyy
+         *                In this particular case, step 2 will automatically add the missing slash, so the date will remain dd/MM/yyyy
+         *                The issue is that the caret position will remain stuck where it was, so if the user keeps hitting the delete key, nothing will change at all. This is resolved in step 4 by moving the caret to the left
+         */
+        if (this.markForDelete) {
+            const isCompliantAfterDeletion = [...this.el.nativeElement.value].findIndex((char, idx) => {
+                const rule = this.onemrvamask[idx];
+                if (rule === null || rule === undefined)
+                    return true;
+                if (isNaN(char) && char.toLowerCase() === char.toUpperCase())
+                    return char !== rule;
+                return !isAllowed(rule, char);
+            }) < 0;
+            if (isCompliantAfterDeletion) {
+                this.markForDelete = false;
+                return;
+            }
+        }
+        // Step 2
+        const compliantValue = [...this.el.nativeElement.value]
+            .filter(char => isAllowed('A', char)) // Necessary when several special char in a row
+            .reduce((newValue, char) => {
+            let idx = newValue.length;
+            const rule = this.onemrvamask[idx];
+            if (rule === null || rule === undefined)
+                return newValue;
+            newValue = !isAllowed(rule, char) ? newValue : newValue + char;
+            // Add all trailing special characters
+            let nextRule = this.onemrvamask[++idx];
+            let i = 0;
+            while (nextRule !== null &&
+                nextRule !== undefined &&
+                ['0', 'A', 'S', 'U', 'L'].indexOf(nextRule) < 0) {
+                i++;
+                newValue += nextRule;
+                nextRule = this.onemrvamask[++idx];
+                if (i > 50)
+                    break;
+            }
+            return newValue;
+        }, '');
+        this.el.nativeElement.value = compliantValue;
+        // Step 3 - Find the new cursor position. If the last new character is just before special character, move the caret after
+        let idx = selectionStart;
+        let nextRule = this.onemrvamask[idx];
+        while (nextRule !== null &&
+            nextRule !== undefined &&
+            ['0', 'A', 'S', 'U', 'L'].indexOf(nextRule) < 0) {
+            idx++;
+            nextRule = this.onemrvamask[idx];
+            if (nextRule !== null &&
+                nextRule &&
+                ['0', 'A', 'S', 'U', 'L'].indexOf(nextRule) < 0) {
+                /* empty */
+            }
+            else
+                break;
+        }
+        // Step 4 - Update inputStack only when all characters are processed
+        if (compliantValue !== this.inputStack[this.stackIdx]) {
+            this.stackIdx++;
+            const stack = this.stackIdx > UNDO_STACK_MAX_LENGTH - 1
+                ? this.inputStack.slice(1)
+                : this.inputStack.splice(0, this.stackIdx);
+            this.stackIdx =
+                this.stackIdx > UNDO_STACK_MAX_LENGTH - 1
+                    ? UNDO_STACK_MAX_LENGTH - 1
+                    : this.stackIdx;
+            this.inputStack = [...stack, compliantValue];
+            this.el.nativeElement.setSelectionRange(idx, idx);
+        }
+        else {
+            if (this.markForDelete) {
+                let i = idx - 1;
+                /* Finds the last rule character before the special character.
+                 *    e.g: (nnn)/nnnn
+                 *         If the user tries to delete '/', the caret will move just before ')'
+                 */
+                while (i > 0) {
+                    const previousRule = this.onemrvamask[i - 1];
+                    if (['0', 'A', 'S', 'U', 'L'].indexOf(previousRule) < 0) {
+                        i--;
+                    }
+                    else
+                        break;
+                }
+                this.el.nativeElement.setSelectionRange(i, i);
+            }
+        }
+        this.markForDelete = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemrvaMaskDirective, isStandalone: true, selector: "[onemrvamask]", inputs: { onemrvamask: "onemrvamask" }, host: { listeners: { "keydown": "onKeyDown($event)", "input": "onInput($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[onemrvamask]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onemrvamask: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+function isAllowed(rule, character) {
+    switch (rule) {
+        // Any digit
+        case '0':
+            if (character === ' ')
+                return false;
+            return !isNaN(+character);
+        // A: letters (uppercase or lowercase) and digits
+        case 'A':
+            if (character === ' ')
+                return false;
+            return (!isNaN(+character) || character.toLowerCase() != character.toUpperCase());
+        // only letters (uppercase or lowercase)
+        case 'S':
+            return character.toLowerCase() != character.toUpperCase();
+        //  only uppercase letters
+        case 'U':
+            return (character.toLowerCase() != character.toUpperCase() &&
+                character === character.toUpperCase());
+        //  only lowercase letters
+        case 'L':
+            return (character.toLowerCase() != character.toUpperCase() &&
+                character === character.toLowerCase());
+    }
+    return false;
+}
+
+/**
+ * Conditionally adds component to the tree if screen width matches at least one size in input
+ */
+class OnemRvaClipboardDirective {
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        this.renderer = inject(Renderer2);
+        this.factory = inject(ComponentFactoryResolver);
+        this.vcRef = inject(ViewContainerRef);
+        this.clipboardService = inject(Clipboard);
+        this.class = '';
+        this.clipboard = '';
+        const miFactory = this.factory.resolveComponentFactory(ClipboardIconComponent);
+        this.icon = this.vcRef.createComponent(miFactory);
+        this.iconEl = this.icon.injector.get(ClipboardIconComponent)._elementRef.nativeElement;
+    }
+    ngOnInit() {
+        this.vcRef.clear();
+        this.renderer.appendChild(this.elementRef.nativeElement, this.iconEl);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaClipboardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemRvaClipboardDirective, isStandalone: true, selector: "span[clipboard]", inputs: { clipboard: "clipboard" }, host: { properties: { "class": "this.class" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaClipboardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'span[clipboard]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class']
+            }], clipboard: [{
+                type: Input
+            }] } });
+
+/**
+ * Conditionally adds component to the tree if screen width matches at least one size in input
+ */
+class OnemRvaIconRightDirective {
+    constructor() {
+        this.class = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaIconRightDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemRvaIconRightDirective, isStandalone: true, selector: "button[iconRight]", host: { properties: { "class.onemrva-icon-right": "this.class" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaIconRightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[iconRight]',
+                    standalone: true,
+                }]
+        }], propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class.onemrva-icon-right']
+            }] } });
+
+class OnemrvaDateFormatDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        this.template = '__/__/____';
+    }
+    onPaste(event) {
+        const input = this.el.nativeElement;
+        // Get pasted content
+        const pasted = event.clipboardData?.getData('text/plain') || '';
+        const digitsOnly = pasted.replace(/\D/g, '');
+        if (!digitsOnly) {
+            event.preventDefault(); // Ignore invalid paste
+            return;
+        }
+        event.preventDefault(); // Stop default paste
+        // Start at current caret position
+        let pos = input.selectionStart ?? 0;
+        const chars = input.value.split('');
+        let digitIndex = 0;
+        while (pos < this.template.length && digitIndex < digitsOnly.length) {
+            if (this.template[pos] === '/') {
+                pos++;
+                continue;
+            }
+            chars[pos] = digitsOnly[digitIndex++];
+            pos++;
+        }
+        input.value = chars.join('');
+        this.emitInputEvent(input);
+        // Set caret after the last replaced character
+        this.setCaretToNextEditable(pos);
+    }
+    onCut(event) {
+        const input = this.el.nativeElement;
+        const start = input.selectionStart ?? 0;
+        const end = input.selectionEnd ?? 0;
+        // Capture the selected value (optional: log or store it)
+        const cutText = input.value.substring(start, end);
+        // Replace the selected portion with underscores (skip slashes)
+        const chars = input.value.split('');
+        for (let i = start; i < end; i++) {
+            if (this.template[i] !== '/') {
+                chars[i] = '_';
+            }
+        }
+        // Update input value
+        input.value = chars.join('');
+        this.emitInputEvent(input);
+        // Move caret to next editable position
+        this.setCaretToNextEditable(start);
+        // Prevent default cut behavior from modifying content further
+        event.preventDefault();
+        // ✅ Optionally copy to clipboard manually (optional)
+        if (event.clipboardData) {
+            event.clipboardData.setData('text/plain', cutText.replace(/\//g, ''));
+        }
+    }
+    onFocus() {
+        const input = this.el.nativeElement;
+        if (!input.value || input.value === this.template) {
+            input.value = this.template;
+        }
+        this.setCaretToNextEditable(0);
+    }
+    onClick() {
+        const input = this.el.nativeElement;
+        // Only reposition the caret if there's no selection (start === end)
+        const selectionStart = input.selectionStart ?? 0;
+        const selectionEnd = input.selectionEnd ?? 0;
+        if (selectionStart === selectionEnd) {
+            if (input.value === this.template) {
+                this.setCaretToNextEditable(0);
+            }
+            else {
+                this.setCaretToNextEditable(selectionStart);
+            }
+        }
+    }
+    onKeyDown(event) {
+        const input = this.el.nativeElement;
+        let pos = input.selectionStart ?? 0;
+        const allowedCtrlShortcuts = ['a', 'c', 'x', 'v'];
+        if (event.ctrlKey && allowedCtrlShortcuts.indexOf(event.key) >= 0) {
+            if (event.key === 'x' && input.value === '') {
+                input.value = this.template;
+                this.emitInputEvent(input);
+            }
+            return;
+        }
+        // Allow navigation
+        if (['ArrowLeft', 'ArrowRight', 'Tab'].includes(event.key))
+            return;
+        // Handle Backspace or Delete with selection
+        if (event.key === 'Backspace' || event.key === 'Delete') {
+            event.preventDefault();
+            const start = input.selectionStart ?? 0;
+            const end = input.selectionEnd ?? start;
+            // If there's a selection
+            if (end > start) {
+                const chars = input.value.split('');
+                for (let i = start; i < end; i++) {
+                    if (this.template[i] !== '/') {
+                        chars[i] = '_';
+                    }
+                }
+                input.value = chars.join('');
+                this.emitInputEvent(input);
+                this.setCaretToNextEditable(start);
+                return;
+            }
+            // If no selection, handle as usual (delete previous or next char)
+            let pos = start;
+            if (event.key === 'Backspace' && pos > 0) {
+                do {
+                    pos--;
+                } while (this.template[pos] === '/' && pos > 0);
+                this.replaceCharAt(input, pos, '_');
+                this.emitInputEvent(input);
+                this.setCaretToNextEditable(pos);
+                return;
+            }
+            if (event.key === 'Delete' && pos < this.template.length) {
+                while (this.template[pos] === '/' && pos < this.template.length) {
+                    pos++;
+                }
+                this.replaceCharAt(input, pos, '_');
+                this.emitInputEvent(input);
+                this.setCaretToNextEditable(pos);
+                return;
+            }
+        }
+        // Handle Slash `/` key
+        if (event.key === '/' ||
+            event.key === '.' ||
+            event.key === '-' ||
+            event.key === ' ') {
+            event.preventDefault();
+            if (pos === 1 || pos === 4) {
+                // Typing `/` at end of day field
+                const currentVal = input.value.substring(pos - 1, pos);
+                if (!currentVal.includes('_')) {
+                    this.replaceCharAt(input, pos - 1, '0');
+                    this.replaceCharAt(input, pos, currentVal);
+                    this.setCaretToNextEditable(pos + 2);
+                    return;
+                }
+            }
+            // Default: just skip to next editable section if allowed
+            this.setCaretToNextEditable(pos + 1);
+            return;
+        }
+        // Handle Backspace
+        if (event.key === 'Backspace') {
+            event.preventDefault();
+            if (pos === 0)
+                return;
+            do {
+                pos--;
+            } while (this.template[pos] === '/' && pos > 0);
+            this.replaceCharAt(input, pos, '_');
+            this.setCaretToNextEditable(pos);
+            this.emitInputEvent(input);
+            return;
+        }
+        // Allow only digits
+        if (!/^\d$/.test(event.key)) {
+            event.preventDefault();
+            return;
+        }
+        // Prevent typing beyond mask
+        if (pos >= this.template.length) {
+            event.preventDefault();
+            return;
+        }
+        // Skip slashes forward
+        while (this.template[pos] === '/' && pos < this.template.length) {
+            pos++;
+        }
+        this.replaceCharAt(input, pos, event.key);
+        event.preventDefault();
+        this.setCaretToNextEditable(pos + 1);
+        this.emitInputEvent(input);
+    }
+    emitInputEvent(input) {
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+    onBlur() {
+        // Optionally keep the mask visible on blur — do nothing
+    }
+    replaceCharAt(input, index, char) {
+        const value = input.value.split('');
+        value[index] = char;
+        input.value = value.join('');
+    }
+    setCaretToNextEditable(pos) {
+        const input = this.el.nativeElement;
+        while (this.template[pos] === '/' && pos < this.template.length) {
+            pos++;
+        }
+        input.setSelectionRange(pos, pos);
+    }
+    sanitizeDateInput(input) {
+        if (typeof input !== 'string')
+            return '';
+        return input
+            .replace(/[.\s-]/g, '/') // Replace dot, space, dash with slash
+            .replace(/[^0-9/]/g, '')
+            .replace('//', ''); // Remove everything except digits and slash
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaDateFormatDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemrvaDateFormatDirective, isStandalone: true, selector: "[onemrvaDateFormat]", host: { listeners: { "paste": "onPaste($event)", "cut": "onCut($event)", "focus": "onFocus()", "click": "onClick()", "keydown": "onKeyDown($event)", "blur": "onBlur()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaDateFormatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[onemrvaDateFormat]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }], onCut: [{
+                type: HostListener,
+                args: ['cut', ['$event']]
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+
+class OnemRvaReadonlyDirective {
+    constructor() {
+        this.readonly = input(true, ...(ngDevMode ? [{ debugName: "readonly" }] : []));
+    }
+    /** @hidden @internal */
+    get isReadOnly() {
+        return this.readonly();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaReadonlyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.1.7", type: OnemRvaReadonlyDirective, isStandalone: true, selector: "form[readonly], mat-checkbox[readonly], mat-radio-group[readonly], mat-form-field[readonly], onemrva-mat-input-phone[readonly],onemrva-mat-task-list[readonly],onemrva-mat-selectable-box[readonly],onemrva-mat-choice-chip[readonly],onemrva-mat-input-birthplace[readonly],onemrva-mat-input-country[readonly],onemrva-mat-input-enterprise-number[readonly]", inputs: { readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.onemrva-readonly": "this.isReadOnly" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaReadonlyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'form[readonly], ' +
+                        'mat-checkbox[readonly], ' +
+                        'mat-radio-group[readonly], ' +
+                        'mat-form-field[readonly], ' +
+                        'onemrva-mat-input-phone[readonly],' +
+                        'onemrva-mat-task-list[readonly],' +
+                        'onemrva-mat-selectable-box[readonly],' +
+                        'onemrva-mat-choice-chip[readonly],' +
+                        'onemrva-mat-input-birthplace[readonly],' +
+                        'onemrva-mat-input-country[readonly],' +
+                        'onemrva-mat-input-enterprise-number[readonly]',
+                    standalone: true,
+                }]
+        }], propDecorators: { isReadOnly: [{
+                type: HostBinding,
+                args: ['class.onemrva-readonly']
+            }] } });
+
+/**
+ * Conditionally adds component to the tree if screen width matches at least one size in input
+ */
+class OnemRvaSizeDirective {
+    constructor() {
+        this.size = '';
+    }
+    /** @hidden @internal */
+    get _isXSmall() {
+        return this.size === OnemrvaMatSize.XSMALL;
+    }
+    /** @hidden @internal */
+    get _isSmall() {
+        return this.size === OnemrvaMatSize.SMALL;
+    }
+    /** @hidden @internal */
+    get _isLarge() {
+        return this.size === OnemrvaMatSize.LARGE;
+    }
+    /** @hidden @internal */
+    get _isXLarge() {
+        return this.size === OnemrvaMatSize.XLARGE;
+    }
+    /** @hidden @internal */
+    get _isXXLarge() {
+        return this.size === OnemrvaMatSize.XXLARGE;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaSizeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: OnemRvaSizeDirective, isStandalone: true, selector: "mat-icon[size], onemrva-mat-skeleton[size], onemrva-mat-avatar[size], button[size]", inputs: { size: "size" }, host: { properties: { "class.xsmall": "this._isXSmall", "class.small": "this._isSmall", "class.large": "this._isLarge", "class.xlarge": "this._isXLarge", "class.xxlarge": "this._isXXLarge" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaSizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mat-icon[size], onemrva-mat-skeleton[size], onemrva-mat-avatar[size], button[size]',
+                    standalone: true,
+                }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], _isXSmall: [{
+                type: HostBinding,
+                args: ['class.xsmall']
+            }], _isSmall: [{
+                type: HostBinding,
+                args: ['class.small']
+            }], _isLarge: [{
+                type: HostBinding,
+                args: ['class.large']
+            }], _isXLarge: [{
+                type: HostBinding,
+                args: ['class.xlarge']
+            }], _isXXLarge: [{
+                type: HostBinding,
+                args: ['class.xxlarge']
+            }] } });
+
+const directives = [
+    DigitOnlyDirective,
+    MatRowClickableDirective,
+    OnemRvaClipboardDirective,
+    OnemRvaIconRightDirective,
+    IfWidthIsDirective,
+    OnemRvaColorDirective,
+    OnemrvaMaskDirective,
+    OnemrvaDateFormatDirective,
+    OnemRvaReadonlyDirective,
+];
+
+/**
+ * Get language from local storage or browser.ééééééééééééé
+ * é
+ * @param translateService
+ * @param languages
+ * @param default_language
+ */
+function setTranslationLanguage(translateService, languages = ['en', 'fr', 'nl', 'de'], default_language = 'en') {
+    return async () => {
+        translateService.onLangChange.subscribe(value => {
+            localStorage.setItem('language', value.lang);
+        });
+        translateService.addLangs(languages);
+        let language = localStorage.getItem('language');
+        if (language === null || languages.indexOf(language) < 0) {
+            // getting language from browser
+            if (languages.indexOf(navigator.language) >= 0) {
+                language = navigator.language;
+            }
+            else {
+                // getting language from one of the browser's languages
+                for (const lng of navigator.languages) {
+                    if (languages.indexOf(lng) >= 0) {
+                        language = lng;
+                        break;
+                    }
+                }
+                // getting default language
+                if (language === null || languages.indexOf(language) < 0) {
+                    language = default_language;
+                }
+            }
+        }
+        await translateService.use(language).toPromise();
+    };
+}
+/**
+ * Get language from WO
+ *
+ * @param translateService
+ * @param languages
+ * @param default_language
+ */
+function setTranslationLanguageFromWO(translateService, languages = ['fr', 'nl'], default_language = 'fr') {
+    return async () => {
+        translateService.addLangs(languages);
+        let language = localStorage.getItem('be_social_security_workenv_language');
+        if (language !== null) {
+            language = language.toLowerCase();
+            if (languages.indexOf(language) >= 0) {
+                await translateService.use(language).toPromise();
+                return;
+            }
+        }
+        await translateService.use(default_language).toPromise();
+    };
+}
+
+class OnemrvaTranslateCDNLoader {
+    constructor(cdn, projects = [], prefix = '/i18n/', suffix = '.json') {
+        this.cdn = cdn;
+        this.projects = projects;
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+    /**
+     * Gets the translations from the server
+     */
+    getTranslation(lang) {
+        return this.cdn.getTranslations(this.projects, lang, this.prefix, this.suffix);
+    }
+}
+
+class OnemrvaTranslateHttpLoader {
+    constructor(http, prefix = '/assets/i18n/', suffix = '.json', modules = []) {
+        this.http = http;
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.modules = modules;
+    }
+    /**
+     * Gets the translations from the server
+     */
+    getTranslation(lang) {
+        const observables = [
+            this.http
+                .get(`${this.prefix}${lang}${this.suffix}`)
+                .pipe(catchError$1(() => of(null))),
+            ...this.modules.map(m => {
+                this.http
+                    .get(`${this.prefix}${m}/${lang}${this.suffix}`)
+                    .pipe(catchError$1(() => of(null)));
+                //console.log(`${this.prefix}${m}/${lang}${this.suffix}`);
+            }),
+        ];
+        return forkJoin(observables).pipe(map(all => {
+            return all.filter(v => !!v).reduce((s, c) => ({ ...s, ...c }), {});
+        }));
+    }
+}
+
+class OnemrvaBcePipe {
+    transform(value) {
+        const strOut = value.trim().replace(/\/|\.|-/g, '');
+        if (strOut.length !== 10)
+            return '?01?.???.???';
+        return `${strOut.substring(0, 4)}.${strOut.substring(4, 7)}.${strOut.substring(7, 10)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaBcePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaBcePipe, isStandalone: true, name: "onemrvaBce" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaBcePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'onemrvaBce',
+                    standalone: true,
+                }]
+        }] });
+
+class OnemrvaNissPipe {
+    transform(value) {
+        const strOut = value.trim().replace(/\/|\.|-/g, '');
+        if (strOut.length !== 11)
+            return '??01??/???-??';
+        return `${strOut.substring(0, 6)}/${strOut.substring(6, 9)}-${strOut.substring(9, 11)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNissPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNissPipe, isStandalone: true, name: "onemrvaNiss" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNissPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'onemrvaNiss',
+                    standalone: true,
+                }]
+        }] });
+
+class CommonCountryLookupService {
+    constructor() {
+        this._countries$ = new ReplaySubject(1);
+        this._customersInitialized = false;
+        this.http = inject(HttpClient);
+        this.commonCountryServiceURL = inject(LOOKUP_COUNTRY_SERVICE_URL);
+    }
+    getCountries(refresh = false) {
+        if (refresh || !this._customersInitialized) {
+            this._customersInitialized = true;
+            this.http
+                .get(this.commonCountryServiceURL)
+                .subscribe(countries => {
+                this._countries$.next(countries);
+            });
+        }
+        return this._countries$.pipe(skip(+refresh), distinctUntilChanged());
+    }
+    getCountryByCode(code) {
+        return this._countries$.pipe(map$1(countries => {
+            const country = countries.find(country => country.code === code);
+            return country || null;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CommonCountryLookupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CommonCountryLookupService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CommonCountryLookupService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class CacheService {
+    setItem(key, item) {
+        //console.log("SET " + key);
+        item.subscribe(value => {
+            localStorage.setItem(key, JSON.stringify(value));
+        });
+    }
+    getItem(key) {
+        const r = localStorage.getItem(key);
+        if (r === null) {
+            return of(null);
+        }
+        return of(JSON.parse(r));
+    }
+    deleteItem(key) {
+        //console.log("DELETE " + key);
+        localStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CacheService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CacheService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class OnemRvaCDNService {
+    constructor() {
+        this.rendererFactory = inject(RendererFactory2);
+        this.cacheService = inject(CacheService);
+        this.http = inject(HttpClient);
+        this.refresh$ = new Subject();
+        const cdnUrlMode = inject(CDN_URL_MODE, {
+            optional: true,
+        });
+        this.renderer = this.rendererFactory.createRenderer(null, null);
+        switch (cdnUrlMode) {
+            case CDNUrlModeOptions.PROD:
+                this.cdnUrl = CDN_URLS.prod;
+                break;
+            case CDNUrlModeOptions.VAL:
+                this.cdnUrl = CDN_URLS.val;
+                break;
+            default:
+                this.cdnUrl = CDN_URLS.prod;
+        }
+        const linkElement = this.renderer.createElement('link');
+        // Set the attributes
+        this.renderer.setAttribute(linkElement, 'rel', 'preconnect');
+        this.renderer.setAttribute(linkElement, 'href', this.cdnUrl);
+        // Append the <link> element to the <head>
+        this.renderer.appendChild(document.head, linkElement);
+    }
+    getUrl(path = '') {
+        return this.cdnUrl + path;
+    }
+    getImg(path = '') {
+        return this.getUrl('/img/' + path);
+    }
+    getOri(path = '') {
+        return this.getImg('ori/' + path);
+    }
+    fetch(endpoint) {
+        return this.http.get(this.cdnUrl + endpoint);
+    }
+    fetchNoCache(endpoint) {
+        return this.http.get(this.cdnUrl + endpoint);
+    }
+    getTranslations(projects, lang, prefix = '', suffix = '') {
+        const observables = [
+            this.http
+                .get(`${this.cdnUrl}${prefix}design-system/design-system/${lang}${suffix}`)
+                .pipe(catchError$1(() => of({}))),
+            ...projects.map(m => {
+                return this.http
+                    .get(`${this.cdnUrl}${prefix}${m}/${lang}${suffix}`)
+                    .pipe(catchError$1(() => {
+                    return of({});
+                }));
+            }),
+        ];
+        return forkJoin(observables).pipe(map(all => {
+            return all.filter(v => !!v).reduce((s, c) => ({ ...s, ...c }), {});
+        }));
+    }
+    /**
+     * Loads a CSS file dynamically into the document head.
+     * @param href The URL of the CSS file.
+     * @returns A promise that resolves when the CSS file is loaded.
+     * //
+     */
+    loadCss(href) {
+        return new Promise((resolve, reject) => {
+            const existingLink = document.querySelector(`link[href="${href}"]`);
+            if (existingLink) {
+                resolve(); // CSS is already loaded
+                return;
+            }
+            const link = this.renderer.createElement('link');
+            this.renderer.setAttribute(link, 'rel', 'stylesheet');
+            this.renderer.setAttribute(link, 'type', 'text/css');
+            this.renderer.setAttribute(link, 'href', href);
+            link.onload = () => resolve();
+            link.onerror = () => reject(new Error(`Failed to load CSS: ${href}`));
+            this.renderer.appendChild(document.head, link);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNService, providedIn: 'root' }); }
+}
+__decorate([
+    HttpRequestCache(cdnService => ({
+        refreshOn: cdnService.refresh$,
+        storage: cdnService.cacheService,
+        ttl: 3600000,
+    }))
+], OnemRvaCDNService.prototype, "fetch", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [], propDecorators: { fetch: [] } });
+
+class OnemRvaCDNCountryService {
+    constructor() {
+        this.cdnService = inject(OnemRvaCDNService);
+        this.translateService = inject(TranslateService);
+    }
+    getCountries() {
+        return this.cdnService.fetch('/json/countries.json').pipe(map(response => response), // ✅ Explicitly cast response
+        combineLatestWith(from(this.translateService.onLangChange).pipe(startWith$1(this.translateService.currentLang ?? 'fr'), map(event => {
+            return typeof event === 'string' ? event : event.lang;
+        }))), map(([response, currentLang]) => {
+            // ✅ Explicit type definition
+            return response
+                .map((country) => ({
+                ...country,
+                name: this.getTranslatedCountryName(country, currentLang),
+            }))
+                .sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+        }));
+    }
+    getCountriesByZone(zone) {
+        return this.getCountries().pipe(map(countries => {
+            return countries.filter(country => country.zone === zone);
+        }));
+    }
+    getTranslatedCountryName(country, languageCode = this.translateService.currentLang) {
+        if (languageCode === 'fr' ||
+            languageCode === 'nl' ||
+            languageCode === 'de') {
+            if (country.translations[languageCode] !== undefined)
+                return country.translations[languageCode];
+        }
+        return country.name;
+    }
+    findCountryFromCode(code) {
+        return this.getCountries().pipe(map(countries => {
+            return countries.find((country) => country.code.toLowerCase() === code.toLowerCase());
+        }));
+    }
+    findCountryFromVIESCode(code) {
+        return this.getCountriesByZone('EU').pipe(map(countries => {
+            return countries.find((country) => country.pattern.substring(0, 2) === code.substring(0, 2));
+        }));
+    }
+    findCountryFromPrefix(number) {
+        return this.getCountries().pipe(map(countries => {
+            return countries.find((country) => {
+                return (country.dial_code === number.substring(0, country.dial_code.length));
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNCountryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNCountryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNCountryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class OnemRvaCDNMimeService {
+    constructor() {
+        this.cdnService = inject(OnemRvaCDNService);
+    }
+    static { this.mimetypeFile = '/json/mimetypes.json'; }
+    getMimesForExtension(extensions) {
+        return this.cdnService.fetch(OnemRvaCDNMimeService.mimetypeFile).pipe(catchError(() => {
+            return [];
+        }), map$1(response => {
+            return response
+                .filter(mime => {
+                return extensions.includes(mime.extension);
+            })
+                .map(mime => {
+                return mime.mimeType;
+            });
+        }));
+    }
+    getExtensionsForMime(mimTypes) {
+        return this.cdnService.fetch(OnemRvaCDNMimeService.mimetypeFile).pipe(catchError(() => {
+            return [];
+        }), map$1(response => {
+            return response
+                .filter(mime => {
+                return mimTypes.includes(mime.mimeType);
+            })
+                .map(mime => {
+                return mime.extension;
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNMimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNMimeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaCDNMimeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class OnemRvaOSMService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.nominatimUrl = 'https://nominatim.openstreetmap.org/search';
+    }
+    searchAddress(query, countryCodes = ['be'], format = 'json', addressdetails = 1, limit = 10) {
+        const params = new HttpParams()
+            .set('q', query)
+            .set('format', format)
+            // .set('accept-language', 'fr') // TODO how do we manage multiple languages ??
+            .set('countrycodes', countryCodes.join(','))
+            .set('addressdetails', addressdetails)
+            .set('limit', limit);
+        return this.http.get(this.nominatimUrl, { params });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaOSMService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaOSMService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemRvaOSMService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class OnemrvaErrorHandler {
+    handleError(error) {
+        console.error(error);
+        //alert("Error: " + error.message);
+        // this._snackBar.open(`Error: ${error.message}`, '', {
+        //   duration: 5000,
+        //   panelClass: 'mat-primary',
+        //   horizontalPosition: this.horizontalPosition,
+        //   verticalPosition: this.verticalPosition,
+        // });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+
+class OnemrvaMissingTranslationHandler {
+    handle(params) {
+        return `???${params.key}???`;
+    }
+}
+
+class OnemrvaValidators {
+    static bceValidator(required = false, control) {
+        if (control.value === null || control.value.trim() === '') {
+            return !required ? null : { bceNull: true };
+        }
+        const bceCandidate = control.value.trim().replace(/\/|\.|-/g, '');
+        if (bceCandidate.length !== 10)
+            return { bceLengthError: { value: bceCandidate } };
+        if (Number.isNaN(+bceCandidate))
+            return { bceNan: { value: bceCandidate } };
+        return null;
+    }
+    static bce(required = false) {
+        return (control) => {
+            return this.bceValidator(required, control);
+        };
+    }
+    static nissValidator(required = false, control) {
+        if (control.value === null || control.value.trim() === '') {
+            return !required ? null : { nissNull: true };
+        }
+        const nissCandidate = control.value.trim().replace(/\/|\.|-/g, '');
+        if (nissCandidate.length !== 11) {
+            return { nissLengthError: { value: nissCandidate } };
+        }
+        if (Number.isNaN(+nissCandidate)) {
+            return { nissNan: { value: nissCandidate } };
+        }
+        // Niss day and year are actual values, the month can be different according to the logic below
+        // [20-32] & [40-52] => foreigners & temporary NISS values
+        // it is not necessary to check for the actual date to be valid
+        const checksumValue = nissCandidate.substring(9);
+        const nissNumbersToCheck = nissCandidate.substring(0, 9);
+        const isValidChecksumYear1900 = 97 - (+nissNumbersToCheck % 97) === +checksumValue;
+        const isValidChecksumYear2000 = 97 - (+`2${nissNumbersToCheck}` % 97) === +checksumValue;
+        if (!isValidChecksumYear1900 && !isValidChecksumYear2000) {
+            return { nissCheckDigitError: { value: nissCandidate } };
+        }
+        /*
+          Below checks aren't really necessary but are here to exclude even more potential errors
+          We could still improve this to include february days & 30 day months + the real potential ranges
+        */
+        const monthString = nissCandidate.substring(2, 4);
+        const month = parseInt(monthString) - 1;
+        const real_month = (parseInt(monthString) % 20) - 1;
+        if (real_month > 11 || month > 51) {
+            return { nissInvalidMonth: { value: nissCandidate } };
+        }
+        const day = +nissCandidate.substring(4, 6);
+        if (day > 31) {
+            return { nissInvalidDate: { value: nissCandidate } };
+        }
+        return null;
+    }
+    static niss(required = false) {
+        return (control) => {
+            return this.nissValidator(required, control);
+        };
+    }
+    static nissOrBce(required = false) {
+        return (control) => {
+            if (control.value === null || control.value.trim() === '')
+                return !required ? null : { nissNull: true };
+            const nissCandidate = control.value.trim().replace(/\/|\.|-/g, '');
+            if (control.value.length === 11) {
+                return this.nissValidator(required, control);
+            }
+            else if (control.value.length === 10) {
+                return this.bceValidator(required, control);
+            }
+            return { lengthError: { value: nissCandidate } };
+        };
+    }
+}
+
+const IBAN_SUPPORTED_COUNTRIES = Object.entries(countrySpecs)
+    .filter(value => {
+    return value[1].IBANRegistry;
+})
+    .map(value => {
+    return value[0];
+});
+const SEPA_ONLY_SUPPORTED_COUNTRIES = Object.entries(countrySpecs)
+    .filter(value => {
+    return value[1].SEPA;
+})
+    .map(value => {
+    return value[0];
+});
+const internValidateIban = (iban = '') => {
+    return validateIBAN(electronicFormatIBAN(iban) || undefined);
+};
+// const getMappedCodes = (errorCodes: ValidationErrorsIBAN[], value?: any) => {
+//   const mappedCodes = errorCodes.map(code => ValidationErrorsIBAN[code]);
+//
+//   if (mappedCodes.length > 0) {
+//     const listCodes: Record<string, any> = {};
+//
+//     mappedCodes.forEach((code: string) => {
+//       listCodes[code] = { value };
+//     });
+//
+//     return listCodes as ValidationErrors;
+//   }
+//
+//   return null;
+// };
+const bankAccountValidator = (allowEmptyCountry = true) => {
+    return (control) => {
+        let finalErrorCodes = [];
+        if (typeof control.getRawValue() === 'string') {
+            const regex = /^[a-zA-Z]{2}/;
+            if (regex.test(control.getRawValue().substring(0, 2))) {
+                const { valid: _valid, errorCodes } = internValidateIban(control.value);
+                finalErrorCodes = errorCodes;
+            }
+            else if (!allowEmptyCountry) {
+                finalErrorCodes.push(ValidationErrorsIBAN.NoIBANCountry);
+            }
+        }
+        else {
+            const countryCodeValue = control.value !== null ? control.value['countryCode'] : '';
+            const bankNumber = control.value !== null ? control.value['bban'] : '';
+            if (countryCodeValue !== '') {
+                const { valid: _valid, errorCodes } = internValidateIban(`${countryCodeValue}${bankNumber}`);
+                finalErrorCodes = errorCodes;
+            }
+            else if (!allowEmptyCountry) {
+                //
+            }
+        }
+        if (finalErrorCodes.length === 0) {
+            return null;
+        }
+        const validationErrors = {};
+        finalErrorCodes.forEach(errCode => {
+            const key = ValidationErrorsIBAN[errCode];
+            validationErrors[key] = { value: control.getRawValue() };
+        });
+        return validationErrors;
+    };
+};
+
+class OnemrvaSharedModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaSharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaSharedModule, imports: [DigitOnlyDirective, MatRowClickableDirective, OnemRvaClipboardDirective, OnemRvaIconRightDirective, IfWidthIsDirective, OnemRvaColorDirective, OnemrvaMaskDirective, OnemrvaDateFormatDirective, OnemRvaReadonlyDirective], exports: [DigitOnlyDirective, MatRowClickableDirective, OnemRvaClipboardDirective, OnemRvaIconRightDirective, IfWidthIsDirective, OnemRvaColorDirective, OnemrvaMaskDirective, OnemrvaDateFormatDirective, OnemRvaReadonlyDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaSharedModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaSharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...directives],
+                    exports: [...directives],
+                }]
+        }] });
+
+class OnemrvaNativeDateAdapter extends NativeDateAdapter {
+    constructor() {
+        super();
+        this.translateService = inject(TranslateService);
+        this.destroyNotifier$ = new Subject();
+        this.localeChanges = new Subject();
+        this.setLocale(this.translateService.currentLang);
+        this.localeChanges.next(this);
+        if (this.translateService !== undefined) {
+            this.translateService.onLangChange
+                .pipe(takeUntil(this.destroyNotifier$))
+                .subscribe(({ lang }) => {
+                this.setLocale(lang);
+                this.localeChanges.next(this);
+            });
+        }
+    }
+    format(date, formats) {
+        const dt = DateTime.fromJSDate(date);
+        return dt.toFormat(formats);
+    }
+    parse(value) {
+        const formats = ONEMRVA_MAT_NATIVE_DATE_FORMAT;
+        if (value && typeof value === 'string') {
+            value = value.replace(/\D/g, '/');
+        }
+        if (value === null || value === '') {
+            return null;
+        }
+        const dt = DateTime.fromFormat(value, formats.display.dateInput, {
+            locale: this.locale,
+        });
+        if (dt.isValid) {
+            return dt.toJSDate();
+        }
+        for (const format of formats.parse.dateInput) {
+            const parsed = DateTime.fromFormat(value, format, {
+                locale: this.locale,
+            });
+            if (parsed.isValid) {
+                return parsed.toJSDate();
+            }
+        }
+        return this.invalid();
+    }
+    getFirstDayOfWeek() {
+        return 1;
+    }
+    ngOnDestroy() {
+        this.destroyNotifier$.next();
+        this.destroyNotifier$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNativeDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNativeDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaNativeDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+/** InjectionToken for LuxonDateAdapter to configure options. */
+const MAT_LUXON_DATE_ADAPTER_OPTIONS = new InjectionToken('MAT_LUXON_DATE_ADAPTER_OPTIONS', {
+    providedIn: 'root',
+    factory: MAT_LUXON_DATE_ADAPTER_OPTIONS_FACTORY,
+});
+/** @docs-private */
+function MAT_LUXON_DATE_ADAPTER_OPTIONS_FACTORY() {
+    return {
+        useUtc: false,
+        firstDayOfWeek: 0,
+        defaultOutputCalendar: 'gregory',
+    };
+}
+/** Creates an array and fills it with values. */
+function luxonRange(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/** Adapts Luxon Dates for use with Angular Material. */
+class OnemrvaLuxonDateAdapter extends DateAdapter {
+    constructor() {
+        super();
+        this.translateService = inject(TranslateService);
+        const dateLocale = inject(MAT_DATE_LOCALE, { optional: true });
+        const options = inject(MAT_LUXON_DATE_ADAPTER_OPTIONS, {
+            optional: true,
+        });
+        this._useUTC = !!options?.useUtc;
+        this._firstDayOfWeek = options?.firstDayOfWeek || 0;
+        this._defaultOutputCalendar = options?.defaultOutputCalendar || 'gregory';
+        this.setLocale(dateLocale || DateTime.local().locale);
+        this.setLocale(this.translateService.currentLang);
+        if (this.translateService !== undefined) {
+            this.translateService.onLangChange
+                .pipe(takeUntilDestroyed())
+                .subscribe(({ lang }) => {
+                this.setLocale(lang);
+            });
+        }
+    }
+    getYear(date) {
+        return date.year;
+    }
+    getMonth(date) {
+        // Luxon works with 1-indexed months whereas our code expects 0-indexed.
+        return date.month - 1;
+    }
+    getDate(date) {
+        return date.day;
+    }
+    getDayOfWeek(date) {
+        return date.weekday;
+    }
+    getMonthNames(style) {
+        // Adding outputCalendar option, because LuxonInfo doesn't get effected by LuxonSettings
+        return Info.months(style, {
+            locale: this.locale,
+            outputCalendar: this._defaultOutputCalendar,
+        });
+    }
+    getDateNames() {
+        // At the time of writing, Luxon doesn't offer similar
+        // functionality so we have to fall back to the Intl API.
+        const dtf = new Intl.DateTimeFormat(this.locale, {
+            day: 'numeric',
+            timeZone: 'utc',
+        });
+        // Format a UTC date in order to avoid DST issues.
+        return luxonRange(31, i => dtf.format(DateTime.utc(2017, 1, i + 1).toJSDate()));
+    }
+    getDayOfWeekNames(style) {
+        // Note that we shift the array once, because Luxon returns Monday as the
+        // first day of the week, whereas our logic assumes that it's Sunday. See:
+        // https://moment.github.io/luxon/api-docs/index.html#infoweekdays
+        const days = Info.weekdays(style, { locale: this.locale });
+        days.unshift(days.pop());
+        return days;
+    }
+    getYearName(date) {
+        return date.toFormat('yyyy', this._getOptions());
+    }
+    getFirstDayOfWeek() {
+        return this._firstDayOfWeek;
+    }
+    getNumDaysInMonth(date) {
+        return date.daysInMonth;
+    }
+    clone(date) {
+        return DateTime.fromObject(date.toObject(), this._getOptions());
+    }
+    createDate(year, month, date) {
+        const options = this._getOptions();
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+        }
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+        }
+        // Luxon uses 1-indexed months so we need to add one to the month.
+        const result = this._useUTC
+            ? DateTime.utc(year, month + 1, date, options)
+            : DateTime.local(year, month + 1, date, options);
+        if (!this.isValid(result)) {
+            throw Error(`Invalid date "${date}". Reason: "${result.invalidReason}".`);
+        }
+        return result;
+    }
+    today() {
+        const options = this._getOptions();
+        return this._useUTC
+            ? DateTime.utc(options)
+            : DateTime.local(options);
+    }
+    parse(value, parseFormat) {
+        const options = this._getOptions();
+        if (typeof value == 'string' && value.length > 0) {
+            // This is screwing things up as 062005 would become 05 0602
+            // const iso8601Date = LuxonDateTime.fromISO(value, options);
+            //
+            // if (this.isValid(iso8601Date)) {
+            //   console.log(iso8601Date);
+            //   return iso8601Date;
+            // }
+            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+            if (!parseFormat.length) {
+                throw Error('Formats array must not be empty.');
+            }
+            for (const format of formats) {
+                const fromFormat = DateTime.fromFormat(value, format, options);
+                if (this.isValid(fromFormat)) {
+                    return fromFormat;
+                }
+            }
+            return this.invalid();
+        }
+        else if (typeof value === 'number') {
+            return DateTime.fromMillis(value, options);
+        }
+        else if (value instanceof Date) {
+            return DateTime.fromJSDate(value, options);
+        }
+        else if (value instanceof DateTime) {
+            return DateTime.fromMillis(value.toMillis(), options);
+        }
+        return null;
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('LuxonDateAdapter: Cannot format invalid date.');
+        }
+        if (this._useUTC) {
+            return date.setLocale(this.locale).setZone('utc').toFormat(displayFormat);
+        }
+        else {
+            return date.setLocale(this.locale).toFormat(displayFormat);
+        }
+    }
+    addCalendarYears(date, years) {
+        return date.reconfigure(this._getOptions()).plus({ years });
+    }
+    addCalendarMonths(date, months) {
+        return date.reconfigure(this._getOptions()).plus({ months });
+    }
+    addCalendarDays(date, days) {
+        return date.reconfigure(this._getOptions()).plus({ days });
+    }
+    toIso8601(date) {
+        return date.toISO();
+    }
+    /**
+     * Returns the given value if given a valid Luxon or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) and valid Date objects into valid DateTime and empty
+     * string into null. Returns an invalid date for all other values.
+     */
+    deserialize(value) {
+        const options = this._getOptions();
+        let date;
+        if (value instanceof Date) {
+            date = DateTime.fromJSDate(value, options);
+        }
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            date = DateTime.fromISO(value, options);
+        }
+        if (date && this.isValid(date)) {
+            return date;
+        }
+        return super.deserialize(value);
+    }
+    isDateInstance(obj) {
+        return obj instanceof DateTime;
+    }
+    isValid(date) {
+        return date.isValid;
+    }
+    invalid() {
+        return DateTime.invalid('Invalid Luxon DateTime object.');
+    }
+    setTime(target, hours, minutes, seconds) {
+        //if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        if (hours < 0 || hours > 23) {
+            throw Error(`Invalid hours "${hours}". Hours value must be between 0 and 23.`);
+        }
+        if (minutes < 0 || minutes > 59) {
+            throw Error(`Invalid minutes "${minutes}". Minutes value must be between 0 and 59.`);
+        }
+        if (seconds < 0 || seconds > 59) {
+            throw Error(`Invalid seconds "${seconds}". Seconds value must be between 0 and 59.`);
+        }
+        //}
+        return this.clone(target).set({
+            hour: hours,
+            minute: minutes,
+            second: seconds,
+            millisecond: 0,
+        });
+    }
+    getHours(date) {
+        return date.hour;
+    }
+    getMinutes(date) {
+        return date.minute;
+    }
+    getSeconds(date) {
+        return date.second;
+    }
+    parseTime(value, parseFormat) {
+        const result = this.parse(value, parseFormat);
+        if ((!result || !this.isValid(result)) && typeof value === 'string') {
+            // It seems like Luxon doesn't work well cross-browser for strings that have
+            // additional characters around the time. Try parsing without those characters.
+            return (this.parse(value.replace(/[^0-9:(AM|PM)]/gi, ''), parseFormat) || result);
+        }
+        return result;
+    }
+    addSeconds(date, amount) {
+        return date.reconfigure(this._getOptions()).plus({ seconds: amount });
+    }
+    /** Gets the options that should be used when constructing a new `DateTime` object. */
+    _getOptions() {
+        return {
+            zone: this._useUTC ? 'utc' : undefined,
+            locale: this.locale,
+            outputCalendar: this._defaultOutputCalendar,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaLuxonDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaLuxonDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OnemrvaLuxonDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+function onemrvaDateNativeYearMonthProvider() {
+    return [
+        {
+            provide: MAT_DATE_FORMATS,
+            useValue: ONEMRVA_MAT_NATIVE_YEAR_MONTH_FORMAT,
+        },
+        {
+            provide: DateAdapter,
+            useClass: OnemrvaNativeDateAdapter,
+        },
+    ];
+}
+
+function onemrvaDateNativeProvider() {
+    return [
+        {
+            provide: MAT_DATE_FORMATS,
+            useValue: ONEMRVA_MAT_NATIVE_DATE_FORMAT,
+        },
+        {
+            provide: DateAdapter,
+            useClass: OnemrvaNativeDateAdapter,
+        },
+    ];
+}
+
+function onemrvaDateLuxonProvider() {
+    return [
+        {
+            provide: MAT_DATE_FORMATS,
+            useValue: ONEMRVA_MAT_LUXON_DATE_FORMATS,
+        },
+        {
+            provide: DateAdapter,
+            useClass: OnemrvaLuxonDateAdapter,
+        },
+    ];
+}
+
+function onemrvaDateLuxonYearMonthProvider() {
+    return [
+        {
+            provide: MAT_DATE_FORMATS,
+            useValue: ONEMRVA_MAT_LUXON_YEAR_MONTH_FORMATS,
+        },
+        {
+            provide: DateAdapter,
+            useClass: OnemrvaLuxonDateAdapter,
+        },
+    ];
+}
+
+// import { MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
+// import { ONEMRVA_THEME_CLASS } from '@onemrvapublic/design-system/shared';
+function onemrvaThemeProvider() {
+    return [
+        {
+            provide: ErrorHandler,
+            useClass: OnemrvaErrorHandler,
+        },
+        {
+            provide: MAT_FORM_FIELD_DEFAULT_OPTIONS,
+            useValue: {
+                appearance: 'outline',
+                floatLabel: 'always',
+                subscriptSizing: 'dynamic',
+            },
+        },
+        {
+            provide: OverlayContainer,
+            useClass: WebComponentOverlayContainer,
+        },
+    ];
+}
+
+/*
+ * Public API Surface of shared
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CDNUrlModeOptions, CDN_URLS, CDN_URL_MODE, CacheService, ClipboardIconComponent, CommonCountryLookupService, DefaultStorage, DigitOnlyDirective, HttpRequestCache, IBAN_SUPPORTED_COUNTRIES, IfWidthIsDirective, LOOKUP_COUNTRY_SERVICE_URL, LOOKUP_COUNTRY_URL, MatRowClickableDirective, NISS_MASK, ONEMRVA_MAT_LUXON_DATE_FORMATS, ONEMRVA_MAT_LUXON_YEAR_MONTH_FORMATS, ONEMRVA_MAT_NATIVE_DATE_FORMAT, ONEMRVA_MAT_NATIVE_YEAR_MONTH_FORMAT, ONEMRVA_THEME, ONEMRVA_THEME_CLASS, OnemRvaCDNCountryService, OnemRvaCDNMimeService, OnemRvaCDNService, OnemRvaClipboardDirective, OnemRvaColorDirective, OnemRvaIconRightDirective, OnemRvaOSMService, OnemRvaReadonlyDirective, OnemRvaSizeDirective, OnemrvaBcePipe, OnemrvaDateFormatDirective, OnemrvaErrorHandler, OnemrvaLuxonDateAdapter, OnemrvaMaskDirective, OnemrvaMissingTranslationHandler, OnemrvaNativeDateAdapter, OnemrvaNissPipe, OnemrvaSharedModule, OnemrvaTranslateCDNLoader, OnemrvaTranslateHttpLoader, OnemrvaValidators, RequestTimes, SEPA_ONLY_SUPPORTED_COUNTRIES, WebComponentOverlayContainer, bankAccountValidator, directives, onemrvaDateLuxonProvider, onemrvaDateLuxonYearMonthProvider, onemrvaDateNativeProvider, onemrvaDateNativeYearMonthProvider, onemrvaThemeProvider, setTranslationLanguage, setTranslationLanguageFromWO };
+//# sourceMappingURL=onemrvapublic-design-system-shared.mjs.map