@fagon/ngx-intellitoolx 16.0.1

package/fesm2022/fagon-ngx-intellitoolx.mjs

@@ -0,0 +1,576 @@
+import * as i1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { NgModule, Pipe, Component, Input, InjectionToken, inject, Directive, Injectable } from '@angular/core';
+import * as i1$1 from '@angular/forms';
+import { FormGroup, FormArray, FormControl, Validators } from '@angular/forms';
+import { merge } from 'rxjs';
+
+class NgxIntellitoolxModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [CommonModule],
+                    exports: [],
+                }]
+        }] });
+
+class IntelliToolxHelper {
+    static captureInitialValue(form) {
+        const initialValue = form.getRawValue?.() ?? form.value;
+        form.markAsPristine();
+        return this.clone(initialValue);
+    }
+    static trimFormGroup(control) {
+        if (control instanceof FormGroup) {
+            Object.keys(control.controls).forEach((key) => this.trimFormGroup(control.controls[key]));
+            return;
+        }
+        if (control instanceof FormArray) {
+            control.controls.forEach((ctrl) => this.trimFormGroup(ctrl));
+            return;
+        }
+        if (control instanceof FormControl) {
+            const value = control.value;
+            if (typeof value === 'string') {
+                control.setValue(value.trim(), { emitEvent: false });
+            }
+        }
+    }
+    static deepEqual(obj1, obj2) {
+        // treat null, undefined, and empty string as equal
+        if (this.isEmpty(obj1) && this.isEmpty(obj2)) {
+            return true;
+        }
+        // normalize numeric values
+        if (typeof obj1 === 'number' && typeof obj2 === 'number') {
+            return Number(obj1) === Number(obj2);
+        }
+        // strict equality shortcut
+        if (obj1 === obj2)
+            return true;
+        // File comparison
+        if (obj1 instanceof File && obj2 instanceof File) {
+            return (obj1.name === obj2.name &&
+                obj1.size === obj2.size &&
+                obj1.type === obj2.type &&
+                obj1.lastModified === obj2.lastModified);
+        }
+        // if not objects → not equal
+        if (typeof obj1 !== 'object' ||
+            typeof obj2 !== 'object' ||
+            obj1 === null ||
+            obj2 === null) {
+            return false;
+        }
+        // arrays
+        if (Array.isArray(obj1) && Array.isArray(obj2)) {
+            if (obj1.length !== obj2.length)
+                return false;
+            return obj1.every((v, i) => this.deepEqual(v, obj2[i]));
+        }
+        const keys1 = Object.keys(obj1);
+        const keys2 = Object.keys(obj2);
+        if (keys1.length !== keys2.length)
+            return false;
+        for (const key of keys1) {
+            if (!keys2.includes(key))
+                return false;
+            if (!this.deepEqual(obj1[key], obj2[key]))
+                return false;
+        }
+        return true;
+    }
+    static isEmpty(value) {
+        return (value === null ||
+            value === undefined ||
+            (typeof value === 'string' && value.trim() === ''));
+    }
+    static clone(value) {
+        return structuredClone(value); // Angular 14+ safe
+    }
+    static formHasChanges(initialValue, form) {
+        if (!form)
+            return false;
+        const current = form.getRawValue();
+        return !this.deepEqual(initialValue, current);
+    }
+    static async confirmIfChanged(hasChanges, confirmHandler) {
+        if (!hasChanges)
+            return true;
+        if (confirmHandler) {
+            const result = confirmHandler();
+            return typeof result === 'boolean' ? result : await result;
+        }
+        // fallback (only if handler not provided)
+        return confirm('You have unsaved changes. Continue?');
+    }
+    static registerBeforeUnload(shouldBlock, message) {
+        const handler = (event) => {
+            if (!shouldBlock())
+                return;
+            event.preventDefault();
+            event.returnValue = message || '';
+        };
+        window.addEventListener('beforeunload', handler);
+        return () => window.removeEventListener('beforeunload', handler);
+    }
+    static getFormControl(form, path) {
+        if (!form || !path)
+            return null;
+        const segments = path.split('.');
+        let current = form;
+        for (const segment of segments) {
+            if (!current)
+                return null;
+            // Treat numeric segment as FormArray index
+            const index = Number(segment);
+            if (!isNaN(index) && current instanceof FormArray) {
+                current = current.at(index);
+            }
+            else if (current instanceof FormGroup) {
+                current = current.get(segment);
+            }
+            else {
+                return null;
+            }
+        }
+        return current instanceof FormControl ? current : null;
+    }
+    static convertImageToBase64(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => {
+                const base64String = reader.result;
+                const base64StringArray = base64String.split(',');
+                resolve(base64StringArray[1]);
+            };
+            reader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    }
+    static replaceCharacter(text, replaceChar, replaceWithChar) {
+        return text?.replaceAll(replaceChar, replaceWithChar) || '';
+    }
+    static convertJsonStringToJson(value) {
+        if (!value) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return null;
+            }
+        }
+        return value;
+    }
+}
+
+class JsonParsePipe {
+    transform(value) {
+        return IntelliToolxHelper.convertJsonStringToJson(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: JsonParsePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: JsonParsePipe, isStandalone: true, name: "jsonParse" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: JsonParsePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'jsonParse',
+                    standalone: true,
+                }]
+        }] });
+
+class NgxIntellitoolxComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: NgxIntellitoolxComponent, isStandalone: true, selector: "lib-ngx-intellitoolx", ngImport: i0, template: ` <p>ngx-intellitoolx works!</p> `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgxIntellitoolxComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-ngx-intellitoolx', standalone: true, template: ` <p>ngx-intellitoolx works!</p> ` }]
+        }] });
+
+class IntellitoolxFormUpdateMessage {
+    constructor() {
+        this.defaultMessage = 'There are no changes to save. Please modify a field to continue.';
+    }
+    get containerStyles() {
+        return {
+            padding: this.itxFormUpdateMessageConfig?.padding || '1rem',
+            gap: this.itxFormUpdateMessageConfig?.iconAndMessageGap || '0.5rem',
+            color: this.itxFormUpdateMessageConfig?.textColor || '#963C00',
+            border: '1px solid ' +
+                (this.itxFormUpdateMessageConfig?.borderColor || '#f3cd5a'),
+            'background-color': this.itxFormUpdateMessageConfig?.backgroundColor || '#fff3cd',
+            'font-weight': String(this.itxFormUpdateMessageConfig?.fontWeight || 400),
+            'border-radius': this.itxFormUpdateMessageConfig?.borderRadius || '0.5rem',
+        };
+    }
+    get iconStyles() {
+        return {
+            'font-size': this.itxFormUpdateMessageConfig?.iconSize || '1rem',
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormUpdateMessage, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: IntellitoolxFormUpdateMessage, isStandalone: true, selector: "itx-form-update-message", inputs: { itxFormUpdateMessageConfig: "itxFormUpdateMessageConfig" }, ngImport: i0, template: `
+    <div class="form-update-message" role="alert" [ngStyle]="containerStyles">
+      <span class="form-update-icon" aria-hidden="true" [ngStyle]="iconStyles"
+        >⚠</span
+      >
+      <span>
+        {{ itxFormUpdateMessageConfig?.message || defaultMessage }}
+      </span>
+    </div>
+  `, isInline: true, styles: [".form-update-message{display:flex;margin-top:.5rem}.form-update-icon{flex-shrink:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormUpdateMessage, decorators: [{
+            type: Component,
+            args: [{ selector: 'itx-form-update-message', standalone: true, imports: [CommonModule], template: `
+    <div class="form-update-message" role="alert" [ngStyle]="containerStyles">
+      <span class="form-update-icon" aria-hidden="true" [ngStyle]="iconStyles"
+        >⚠</span
+      >
+      <span>
+        {{ itxFormUpdateMessageConfig?.message || defaultMessage }}
+      </span>
+    </div>
+  `, styles: [".form-update-message{display:flex;margin-top:.5rem}.form-update-icon{flex-shrink:0}\n"] }]
+        }], propDecorators: { itxFormUpdateMessageConfig: [{
+                type: Input
+            }] } });
+
+class IntellitoolxFormErrors {
+    constructor() {
+        this.control = null;
+        this.componentValidation = {};
+        this.controlLabel = null;
+        this.errorMessages = {
+            required: 'This field is required',
+            email: 'The email entered is invalid',
+            minlength: 'You must enter at least {length} characters',
+            maxlength: 'You must not enter more than {length} characters',
+            pattern: 'Your entry must match the required pattern',
+            passwordMismatch: 'Password and confirm password do not match.',
+            futureDate: 'Future date is not allowed.',
+            exceededAllowedDateDifference: 'Date difference can only be one month.',
+            exceededLeastDateAllowed: 'Start date cannot be greater than end date',
+            duplicateEmail: 'Each email must be unique.',
+            maxWords: 'Exceeded maximum number of words.',
+            maxMonthYear: 'Date is later than allowed.',
+            minMonthYear: 'Date is earlier than allowed.',
+        };
+    }
+    getErrorMessage(key, value) {
+        if (!this.control)
+            return '';
+        const customMessage = this.componentValidation?.[key]?.message;
+        if (typeof value === 'boolean') {
+            return customMessage || this.errorMessages[key] || '';
+        }
+        if (typeof value === 'string') {
+            return customMessage || value;
+        }
+        if (typeof value === 'object') {
+            switch (key) {
+                case 'pattern':
+                    return (customMessage ||
+                        `Please provide a valid ${this.controlLabel || 'data'}.`);
+                case 'min':
+                    return customMessage
+                        ? customMessage
+                        : this.controlLabel
+                            ? `${this.controlLabel} cannot be less than ${value.min}.`
+                            : `Number cannot be less than ${value.min}`;
+                case 'max':
+                    return customMessage
+                        ? customMessage
+                        : this.controlLabel
+                            ? `${this.controlLabel} cannot be greater than ${value.max}.`
+                            : `Number cannot be greater than ${value.max}`;
+                case 'minlength':
+                    return (customMessage ||
+                        this.errorMessages.minlength.replace('{length}', value?.requiredLength || ''));
+                case 'maxlength':
+                    return (customMessage ||
+                        this.errorMessages.maxlength.replace('{length}', value?.requiredLength || ''));
+                case 'customMinValue':
+                case 'customMaxValue':
+                    return customMessage || value?.message || '';
+                case 'ngbDate':
+                    return (customMessage ||
+                        (this.control.value ? 'Invalid date format provided' : ''));
+                case 'passwordMismatch':
+                case 'futureDate':
+                case 'duplicateEmail':
+                case 'maxWords':
+                case 'maxMonthYear':
+                case 'minMonthYear':
+                case 'exceededAllowedDateDifference':
+                case 'exceededLeastDateAllowed':
+                    return customMessage || this.errorMessages[key];
+                default:
+                    return customMessage || '';
+            }
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormErrors, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: IntellitoolxFormErrors, isStandalone: true, selector: "itx-form-errors", inputs: { control: "control", componentValidation: "componentValidation", controlLabel: "controlLabel" }, ngImport: i0, template: `
+    <ng-container *ngIf="control?.touched && control?.invalid">
+      <ng-container *ngFor="let error of control?.errors | keyvalue">
+        {{ getErrorMessage(error?.key ?? '', error?.value) }}
+      </ng-container>
+    </ng-container>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.KeyValuePipe, name: "keyvalue" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IntellitoolxFormErrors, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'itx-form-errors',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <ng-container *ngIf="control?.touched && control?.invalid">
+      <ng-container *ngFor="let error of control?.errors | keyvalue">
+        {{ getErrorMessage(error?.key ?? '', error?.value) }}
+      </ng-container>
+    </ng-container>
+  `,
+                }]
+        }], propDecorators: { control: [{
+                type: Input
+            }], componentValidation: [{
+                type: Input
+            }], controlLabel: [{
+                type: Input
+            }] } });
+
+function customMaxAmountValidator(maxValue) {
+    return (control) => {
+        if (control.value !== null && control.value > maxValue) {
+            control.setErrors({ exceededMaximumValue: true });
+            const maxValueToFloat = maxValue.toFixed(2);
+            return {
+                customMaxValue: {
+                    requiredMin: maxValue,
+                    actual: control.value,
+                    message: `The value must not exceed ${maxValueToFloat}`,
+                },
+            };
+        }
+        control.setErrors(null);
+        return null;
+    };
+}
+
+function MaxWordsValidator(maxWords) {
+    return (control) => {
+        if (!control.value)
+            return null;
+        const wordCount = control.value.trim().split(/\s+/).length;
+        return wordCount > maxWords
+            ? { maxWords: { actual: wordCount, max: maxWords } }
+            : null;
+    };
+}
+
+function customMinAmountValidator(minValue) {
+    return (control) => {
+        if (control.value !== null && control.value < minValue) {
+            control.setErrors({ exceededMinimumValue: true });
+            const minValueToFloat = minValue.toFixed(2);
+            return {
+                customMinValue: {
+                    requiredMin: minValue,
+                    actual: control.value,
+                    message: `The value must be at least ${minValueToFloat}`,
+                },
+            };
+        }
+        control.setErrors(null);
+        return null;
+    };
+}
+
+function PasswordMismatchValidator(controlName, matchingControlName) {
+    return (formGroup) => {
+        const control = formGroup.controls[controlName];
+        const matchingControl = formGroup.controls[matchingControlName];
+        if (matchingControl.errors && !matchingControl.errors['passwordMismatch']) {
+            return;
+        }
+        if (control.value !== matchingControl.value) {
+            matchingControl.setErrors({ passwordMismatch: true });
+        }
+        else {
+            matchingControl.setErrors(null);
+        }
+    };
+}
+
+function uniqueEmailsValidator() {
+    return (formArray) => {
+        if (!(formArray instanceof FormArray)) {
+            return null;
+        }
+        const controls = formArray.controls;
+        // Collect all email values safely
+        const emails = controls.map((control) => {
+            const value = control.get('email')?.value;
+            return typeof value === 'string' ? value.toLowerCase().trim() : '';
+        });
+        // Count occurrences
+        const emailCounts = {};
+        emails.forEach((email) => {
+            if (email) {
+                emailCounts[email] = (emailCounts[email] || 0) + 1;
+            }
+        });
+        // Update each control's errors
+        controls.forEach((control) => {
+            const emailControl = control.get('email');
+            const email = emailControl?.value?.toLowerCase()?.trim();
+            if (emailControl) {
+                const currentErrors = emailControl.errors || {};
+                if (email && emailCounts[email] > 1) {
+                    emailControl.setErrors({ ...currentErrors, duplicateEmail: true });
+                }
+                else if (currentErrors?.['duplicateEmail']) {
+                    delete currentErrors['duplicateEmail'];
+                    const hasOtherErrors = Object.keys(currentErrors)?.length > 0;
+                    emailControl.setErrors(hasOtherErrors ? currentErrors : null);
+                }
+            }
+        });
+        const hasDuplicates = Object.values(emailCounts)?.some((count) => count > 1);
+        return hasDuplicates ? { duplicateEmails: true } : null;
+    };
+}
+
+const IntellitoolxRegExps = {
+    EMAIL_REGEX: /^(?=.{1,50}$)[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[A-Za-z]{2,}$/,
+    NUMBER_REGEX: /^\d+$/,
+    AMOUNT_REGEX: /^\d+(\.\d{1,2})?$/,
+    DOMAIN_REGEX: /^(?=.{1,255}$)(https?|ftp):\/\/([\w.-]+)\.([a-z\.]{2,6})(:[0-9]{1,5})?(\/\S*)?$/,
+};
+
+const REQUIRED_MARKER_GLOBAL_CONFIG = new InjectionToken('Required Marker Global Config');
+
+const DEFAULT_REQUIRED_MARKER_CONFIG = {
+    sign: '*',
+    color: 'red',
+    position: 'after',
+    spacing: '2px',
+    className: '',
+    showIfOptional: false,
+};
+
+class RequiredMarkerDirective {
+    constructor(el, renderer, parentForm) {
+        this.el = el;
+        this.renderer = renderer;
+        this.parentForm = parentForm;
+        this.globalConfig = inject(REQUIRED_MARKER_GLOBAL_CONFIG, {
+            optional: true,
+        });
+    }
+    resolveConfig() {
+        return {
+            ...DEFAULT_REQUIRED_MARKER_CONFIG,
+            ...this.globalConfig,
+        };
+    }
+    ngAfterViewInit() {
+        const label = this.el.nativeElement;
+        const controlId = label.getAttribute('for');
+        if (!controlId)
+            return;
+        const control = this.parentForm.form.get(controlId);
+        if (!control)
+            return;
+        this.updateLabel(label, control);
+        this.subscription = merge(control.valueChanges, control.statusChanges).subscribe(() => this.updateLabel(label, control));
+    }
+    updateLabel(label, control) {
+        const config = this.resolveConfig();
+        const isRequired = control.hasValidator?.(Validators.required);
+        const original = label.getAttribute('data-original') || label.textContent || '';
+        if (!label.getAttribute('data-original')) {
+            label.setAttribute('data-original', original.trim());
+        }
+        const match = original.match(/^([^\(]+)(.*)$/);
+        const mainText = match ? match[1].trim() : original;
+        const extraText = match ? match[2] : '';
+        this.renderer.setProperty(label, 'textContent', '');
+        const main = this.renderer.createText(mainText);
+        const marker = this.renderer.createElement('span');
+        this.renderer.setStyle(marker, 'color', config.color);
+        this.renderer.setStyle(marker, 'margin-left', config.spacing);
+        this.renderer.appendChild(marker, this.renderer.createText(config.sign));
+        if (isRequired) {
+            if (config.position === 'before') {
+                this.renderer.appendChild(label, marker);
+                this.renderer.appendChild(label, main);
+            }
+            else {
+                this.renderer.appendChild(label, main);
+                this.renderer.appendChild(label, marker);
+            }
+        }
+        else {
+            this.renderer.appendChild(label, main);
+        }
+        const extra = this.renderer.createText(extraText);
+        this.renderer.appendChild(label, extra);
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RequiredMarkerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1$1.FormGroupDirective }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: RequiredMarkerDirective, isStandalone: true, selector: "label[itxRequired]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RequiredMarkerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'label[itxRequired]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1$1.FormGroupDirective }]; } });
+
+class UnsavedChangesGuard {
+    canDeactivate(component) {
+        if (!component.hasUnsavedChanges()) {
+            return true;
+        }
+        const message = component.getUnsavedMessage?.() ||
+            'You have unsaved changes. Leave without saving?';
+        return confirm(message);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UnsavedChangesGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/*
+ * Public API Surface of ngx-intellitoolx
+ */
+// Moddules
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_REQUIRED_MARKER_CONFIG, IntelliToolxHelper, IntellitoolxFormErrors, IntellitoolxFormUpdateMessage, IntellitoolxRegExps, JsonParsePipe, MaxWordsValidator, NgxIntellitoolxComponent, NgxIntellitoolxModule, PasswordMismatchValidator, REQUIRED_MARKER_GLOBAL_CONFIG, RequiredMarkerDirective, UnsavedChangesGuard, customMaxAmountValidator, customMinAmountValidator, uniqueEmailsValidator };
+//# sourceMappingURL=fagon-ngx-intellitoolx.mjs.map