@arsedizioni/ars-utils 22.6.86 → 22.6.89

package/fesm2022/arsedizioni-ars-utils-core.validators.mjs

@@ -1,1525 +1,1335 @@
-import * as i0 from '@angular/core';
-import { input, Directive, forwardRef, effect, inject, DestroyRef } from '@angular/core';
-import { NG_VALIDATORS } from '@angular/forms';
-import { SystemUtils } from '@arsedizioni/ars-utils/core';
-import { endOfDay, startOfDay } from 'date-fns';
-import { validate } from '@angular/forms/signals';
-
-/**
- * Directive that delegates validation to an externally provided validator function.
- * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
- */
-class ValidatorDirective {
-    constructor() {
-        /** The custom validator function to apply. */
-        this.validator = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []));
-    }
-    /**
-     * Invokes the provided validator function against the given control.
-     * Returns `null` (valid) when no function is bound.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const fn = this.validator();
-        return fn ? fn(control) : null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: ValidatorDirective, isStandalone: true, selector: "[validator]", inputs: { validator: { classPropertyName: "validator", publicName: "validator", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[validator]',
-                    providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }],
-                    standalone: true,
-                }]
-        }], propDecorators: { validator: [{ type: i0.Input, args: [{ isSignal: true, alias: "validator", required: false }] }] } });
-
-/**
- * Directive that validates a control using the host object's `isValid()` method
- * or a boolean expression passed via `[validIf]`.
- */
-class ValidIfDirective {
-    constructor() {
-        /** When `true`, the control is considered valid regardless of the bound value. */
-        this.validIf = input(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "validIf" }] : /* istanbul ignore next */ []));
-    }
-    /**
-     * Validates the control value against a boolean flag or the value's own `isValid()` method.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        let isValid = false;
-        const c = control.value ? control.value : null;
-        if (!c) {
-            isValid = this.validIf() === true;
-        }
-        else {
-            try {
-                isValid = c.isValid();
-            }
-            catch { }
-        }
-        return isValid ? null : { validIf: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ValidIfDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: ValidIfDirective, isStandalone: true, selector: "[validIf]", inputs: { validIf: { classPropertyName: "validIf", publicName: "validIf", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => ValidIfDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ValidIfDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[validIf]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => ValidIfDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], propDecorators: { validIf: [{ type: i0.Input, args: [{ isSignal: true, alias: "validIf", required: false }] }] } });
-
-/**
- * Directive that validates that the host control's value equals the value of another control.
- * Bind `[equals]="otherControl"`.
- *
- * The host control is re-validated whenever the OTHER control's value changes:
- * without this, typing a new password AFTER the confirmation field was filled
- * left the form incorrectly valid (the classic password/confirm bug).
- *
- * IMPORTANT (reciprocal-binding safety): the re-validation triggered from the
- * other control's `valueChanges` runs with `{ emitEvent: false }`. Calling
- * Angular's `onValidatorChange` instead would re-emit valueChanges, so a
- * reciprocal setup (A [equals]=B and B [equals]=A) would overflow the stack.
- */
-class EqualsValidatorDirective {
-    constructor() {
-        /** The control whose value must match the host control's value. */
-        this.equals = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []));
-        // Re-subscribe whenever the [equals] binding points to a different control,
-        // and re-validate the host on every change of the other control.
-        effect(() => {
-            const other = this.equals();
-            this.subscription?.unsubscribe();
-            this.subscription = other?.valueChanges.subscribe(() => 
-            // emitEvent:false breaks the reciprocal valueChanges loop (see class doc).
-            this.hostControl?.updateValueAndValidity({ emitEvent: false }));
-            // Re-validate the host when the bound control itself is swapped.
-            this.hostControl?.updateValueAndValidity({ emitEvent: false });
-        });
-        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
-    }
-    /**
-     * Validates that the host control value equals the bound control's value.
-     * Returns `null` (valid) when no control is bound.
-     * @param control - The form control to validate.
-     * @returns `null` when valid, `{ equals: ... }` otherwise.
-     */
-    validate(control) {
-        this.hostControl = control;
-        const eq = this.equals();
-        if (!eq)
-            return null;
-        return eq.value === control.value ? null : { equals: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: EqualsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: EqualsValidatorDirective, isStandalone: true, selector: "[equals]", inputs: { equals: { classPropertyName: "equals", publicName: "equals", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => EqualsValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: EqualsValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[equals]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => EqualsValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [], propDecorators: { equals: [{ type: i0.Input, args: [{ isSignal: true, alias: "equals", required: false }] }] } });
-
-/**
- * Directive that validates that the host control's value is different from another control's value.
- * Bind `[notEqual]="otherControl"`.
- *
- * The host control is re-validated whenever the OTHER control's value changes,
- * so editing either field keeps both error states consistent.
- *
- * IMPORTANT (reciprocal-binding safety): the re-validation triggered from the
- * other control's `valueChanges` is run with `{ emitEvent: false }`. Using
- * Angular's `onValidatorChange` here instead would call `host.updateValueAndValidity()`
- * WITH events, so a reciprocal setup (A [notEqual]=B and B [notEqual]=A) would
- * ping-pong valueChanges between the two controls and overflow the stack.
- */
-class NotEqualValidatorDirective {
-    constructor() {
-        /** The control whose value must differ from the host control's value. */
-        this.notEqual = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []));
-        effect(() => {
-            const other = this.notEqual();
-            this.subscription?.unsubscribe();
-            this.subscription = other?.valueChanges.subscribe(() => 
-            // Re-validate the host WITHOUT emitting valueChanges, otherwise a
-            // reciprocal binding would loop forever (see class doc).
-            this.hostControl?.updateValueAndValidity({ emitEvent: false }));
-            // Re-validate the host when the bound control itself is swapped.
-            this.hostControl?.updateValueAndValidity({ emitEvent: false });
-        });
-        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
-    }
-    /**
-     * Validates that the host control value is not equal to the bound control's value.
-     * Also clears the `notequal` error on the other control when the host becomes valid.
-     * Returns `null` (valid) when no control is bound.
-     * @param control - The form control to validate.
-     * @returns `null` when valid, `{ notequal: true }` otherwise.
-     */
-    validate(control) {
-        this.hostControl = control;
-        const notEqual = this.notEqual();
-        if (!notEqual)
-            return null;
-        const isValid = (!notEqual.value && !control.value) || (notEqual.value !== control.value);
-        const errors = isValid ? null : { notequal: true };
-        if (errors) {
-            control.markAsTouched();
-        }
-        else if (notEqual.hasError('notequal')) {
-            const { notequal: _removed, ...rest } = notEqual.errors ?? {};
-            // emitEvent:false on both: clearing the partner's error must not feed
-            // back through valueChanges/statusChanges into this validator.
-            notEqual.setErrors(Object.keys(rest).length > 0 ? rest : null, { emitEvent: false });
-            notEqual.updateValueAndValidity({ onlySelf: true, emitEvent: false });
-            notEqual.markAsTouched();
-            notEqual.markAsDirty();
-        }
-        return errors;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotEqualValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: NotEqualValidatorDirective, isStandalone: true, selector: "[notEqual]", inputs: { notEqual: { classPropertyName: "notEqual", publicName: "notEqual", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => NotEqualValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotEqualValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[notEqual]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => NotEqualValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [], propDecorators: { notEqual: [{ type: i0.Input, args: [{ isSignal: true, alias: "notEqual", required: false }] }] } });
-
-/**
- * Directive that validates a semicolon-separated list of email addresses.
- * Apply `emails` to a text input containing one or more addresses separated by `;`.
- */
-class EmailsValidatorDirective {
-    /**
-     * Validates each address in a semicolon-separated email list.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        const parts = input.replaceAll(/\r\n/g, '').split(';');
-        const isValid = parts.every(part => part.length === 0 || !!SystemUtils.parseEmail(part));
-        return isValid ? null : { emails: "Elenco non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: EmailsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: EmailsValidatorDirective, isStandalone: true, selector: "[emails]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => EmailsValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: EmailsValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[emails]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => EmailsValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates a control value as a GUID / UUID string.
- * Apply `guid` to a text input that expects a valid UUID.
- */
-class GuidValidatorDirective {
-    /**
-     * Validates that the control value is a well-formed GUID / UUID.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        return SystemUtils.parseUUID(input) ? null : { guid: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: GuidValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: GuidValidatorDirective, isStandalone: true, selector: "[guid]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => GuidValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: GuidValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[guid]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => GuidValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates a control value as a parseable SQL-compatible date string.
- * Apply `sqlDate` to a text input that expects a date after year 1750.
- */
-class SqlDateValidatorDirective {
-    /**
-     * Validates that the control value can be parsed as a date after 1750.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        const parsed = SystemUtils.parseDate(input);
-        if (!parsed)
-            return { sqlDate: "Non valido." };
-        const d = endOfDay(parsed);
-        return d.getFullYear() > 1750 ? null : { sqlDate: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: SqlDateValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: SqlDateValidatorDirective, isStandalone: true, selector: "[sqlDate]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => SqlDateValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: SqlDateValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[sqlDate]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => SqlDateValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates that a control value is not a future date.
- * Apply `notFuture` to a text input that expects a date on or before today.
- */
-class NotFutureValidatorDirective {
-    /**
-     * Validates that the control value represents a date that is not in the future.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        const parsed = SystemUtils.parseDate(input);
-        if (!parsed)
-            return { notFuture: "Non valido." };
-        const today = endOfDay(new Date());
-        const d = endOfDay(parsed);
-        return d <= today ? null : { notFuture: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotFutureValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: NotFutureValidatorDirective, isStandalone: true, selector: "[notFuture]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => NotFutureValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotFutureValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[notFuture]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => NotFutureValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates a control value as a well-formed URL.
- * Apply `url` to a text input that expects a URL.
- */
-class UrlValidatorDirective {
-    /**
-     * Validates that the control value is a well-formed URL.
-     * Returns `null` (valid) when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        return SystemUtils.parseUrl(input) ? null : { url: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: UrlValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: UrlValidatorDirective, isStandalone: true, selector: "[url]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => UrlValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: UrlValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[url]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => UrlValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates a file size against configurable minimum and maximum bounds.
- * Bind `[fileSize]` together with `[size]="fileSizeInMb"`, `[maxSizeMb]`, and `[minSizeMb]`.
- */
-class FileSizeValidatorDirective {
-    constructor() {
-        /** Maximum allowed file size in megabytes. Defaults to 5. */
-        this.maxSizeMb = input(5, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "maxSizeMb" }] : /* istanbul ignore next */ []));
-        /** Minimum required file size in megabytes. Defaults to 0. */
-        this.minSizeMb = input(0, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "minSizeMb" }] : /* istanbul ignore next */ []));
-        /** The actual file size in megabytes to validate against the bounds. */
-        this.size = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "size" }] : /* istanbul ignore next */ []));
-    }
-    /**
-     * Validates that the bound file size falls within the configured min/max range.
-     * Returns `null` when no control value is present.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input)
-            return null;
-        const s = this.size() ?? 0;
-        const isValid = s <= this.maxSizeMb() && s >= this.minSizeMb();
-        return isValid ? null : { fileSize: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: FileSizeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: FileSizeValidatorDirective, isStandalone: true, selector: "[fileSize]", inputs: { maxSizeMb: { classPropertyName: "maxSizeMb", publicName: "maxSizeMb", isSignal: true, isRequired: false, transformFunction: null }, minSizeMb: { classPropertyName: "minSizeMb", publicName: "minSizeMb", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => FileSizeValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: FileSizeValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[fileSize]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => FileSizeValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], propDecorators: { maxSizeMb: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxSizeMb", required: false }] }], minSizeMb: [{ type: i0.Input, args: [{ isSignal: true, alias: "minSizeMb", required: false }] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "size", required: false }] }] } });
-
-/**
- * Directive that validates that a control value does not exceed a maximum word count.
- * Bind `[maxTerms]="10"` to allow at most 10 whitespace-separated terms.
- */
-class MaxTermsValidatorDirective {
-    constructor() {
-        /** The maximum number of whitespace-separated terms allowed. */
-        this.maxTerms = input(0, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "maxTerms" }] : /* istanbul ignore next */ []));
-    }
-    /**
-     * Validates that the control value contains no more than the configured number of terms.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input)
-            return null;
-        const terms = input.match(/\S+/g)?.length ?? 0;
-        return terms <= this.maxTerms() ? null : { maxTerms: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: MaxTermsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: MaxTermsValidatorDirective, isStandalone: true, selector: "[maxTerms]", inputs: { maxTerms: { classPropertyName: "maxTerms", publicName: "maxTerms", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => MaxTermsValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: MaxTermsValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[maxTerms]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => MaxTermsValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], propDecorators: { maxTerms: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxTerms", required: false }] }] } });
-
-/**
- * Directive that validates a control value as a sufficiently strong password.
- * Apply `password` to a password input.
- */
-class PasswordValidatorDirective {
-    /**
-     * Validates that the control value meets the minimum password-strength requirements.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value ?? '';
-        const strength = SystemUtils.calculatePasswordStrength(input);
-        return strength.isValid ? null : { password: "Non valido." };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: PasswordValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: PasswordValidatorDirective, isStandalone: true, selector: "[password]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => PasswordValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: PasswordValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[password]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => PasswordValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Directive that validates a time string against optional allowed time slot ranges.
- * Bind `[time]` and optionally `[slots]="'08:00-12:00|14:00-18:00'"` (pipe-separated ranges).
- */
-class TimeValidatorDirective {
-    constructor() {
-        /** Optional pipe-separated list of allowed time ranges, e.g. `"08:00-12:00|14:00-18:00"`. */
-        this.slots = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []));
-    }
-    /**
-     * Parses a `"HH:MM"` time string into a comparable integer (e.g. `"09:30"` -> `930`).
-     * Returns `-1` when the string is not a valid time.
-     * @param value - The time string to parse.
-     */
-    getTime(value) {
-        const p = value.split(':');
-        if (p.length !== 2)
-            return -1;
-        const hh = parseInt(p[0], 10);
-        if (isNaN(hh) || hh < 0 || hh > 23)
-            return -1;
-        const mm = parseInt(p[1], 10);
-        if (isNaN(mm) || mm < 0 || mm > 59)
-            return -1;
-        return hh * 100 + mm;
-    }
-    /**
-     * Validates that the control value is a valid time string and, when slots are configured,
-     * that it falls within at least one of the allowed ranges.
-     * Returns `null` when the control is empty.
-     * @param control - The form control to validate.
-     */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        const t = this.getTime(input);
-        if (t === -1)
-            return { time: "Non valido." };
-        const slotsValue = this.slots();
-        if (slotsValue) {
-            const isValid = slotsValue.split('|').some(s => {
-                const t1 = this.getTime(s.substring(0, 5));
-                const t2 = this.getTime(s.substring(6));
-                return t1 !== -1 && t2 !== -1 && t1 <= t && t2 >= t;
-            });
-            return isValid ? null : { time: "Non valido." };
-        }
-        return null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: TimeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.7", type: TimeValidatorDirective, isStandalone: true, selector: "[time]", inputs: { slots: { classPropertyName: "slots", publicName: "slots", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => TimeValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: TimeValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[time]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => TimeValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }], propDecorators: { slots: [{ type: i0.Input, args: [{ isSignal: true, alias: "slots", required: false }] }] } });
-
-/**
- * @file emptiness.ts
- *
- * The single definition of "empty" behind the `notEmpty` rule, in both its flavours: the
- * template-driven directive and the signal-form validator. It lives apart from either of them so
- * that the two faces of the same rule cannot drift, and it pulls in nothing — not
- * `@angular/forms`, not `@angular/core`.
- */
-/**
- * Tells whether a value is what the `notEmpty` rule rejects: a string made of whitespace alone,
- * or an array with no elements.
- *
- * An absent value and an empty string are deliberately NOT rejected: declaring a field mandatory
- * is the job of `required()`, and a blank field would otherwise raise two errors saying the same
- * thing. The empty array is the one exception, because there it IS the only shape emptiness can
- * take — a multi-select never holds `''`, and Angular's own `required()` does not see `[]` as
- * empty, so nothing else would catch it.
- *
- * @param value - The value to inspect.
- * @returns `true` when the value is a whitespace-only string or an empty array.
- */
+import * as i0 from "@angular/core";
+import { DestroyRef, Directive, effect, forwardRef, inject, input } from "@angular/core";
+import { NG_VALIDATORS } from "@angular/forms";
+import { SystemUtils } from "@arsedizioni/ars-utils/core";
+import { endOfDay, startOfDay } from "date-fns";
+import { validate } from "@angular/forms/signals";
+var ValidatorDirective = class ValidatorDirective {
+	constructor() {
+		this.validator = input(void 0, ...ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []);
+	}
+	validate(control) {
+		const fn = this.validator();
+		return fn ? fn(control) : null;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: ValidatorDirective,
+			isStandalone: true,
+			selector: "[validator]",
+			inputs: { validator: {
+				classPropertyName: "validator",
+				publicName: "validator",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: ValidatorDirective,
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[validator]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: ValidatorDirective,
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	propDecorators: { validator: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "validator",
+			required: false
+		}]
+	}] }
+});
+var ValidIfDirective = class ValidIfDirective {
+	constructor() {
+		this.validIf = input(false, ...ngDevMode ? [{ debugName: "validIf" }] : /* istanbul ignore next */ []);
+	}
+	validate(control) {
+		let isValid = false;
+		const c = control.value ? control.value : null;
+		if (!c) isValid = this.validIf() === true;
+		else try {
+			isValid = c.isValid();
+		} catch {}
+		return isValid ? null : { validIf: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ValidIfDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: ValidIfDirective,
+			isStandalone: true,
+			selector: "[validIf]",
+			inputs: { validIf: {
+				classPropertyName: "validIf",
+				publicName: "validIf",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => ValidIfDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ValidIfDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[validIf]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => ValidIfDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	propDecorators: { validIf: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "validIf",
+			required: false
+		}]
+	}] }
+});
+var EqualsValidatorDirective = class EqualsValidatorDirective {
+	constructor() {
+		this.equals = input(void 0, ...ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []);
+		effect(() => {
+			const other = this.equals();
+			this.subscription?.unsubscribe();
+			this.subscription = other?.valueChanges.subscribe(() => this.hostControl?.updateValueAndValidity({ emitEvent: false }));
+			this.hostControl?.updateValueAndValidity({ emitEvent: false });
+		});
+		inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+	}
+	validate(control) {
+		this.hostControl = control;
+		const eq = this.equals();
+		if (!eq) return null;
+		return eq.value === control.value ? null : { equals: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: EqualsValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: EqualsValidatorDirective,
+			isStandalone: true,
+			selector: "[equals]",
+			inputs: { equals: {
+				classPropertyName: "equals",
+				publicName: "equals",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => EqualsValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: EqualsValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[equals]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => EqualsValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { equals: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "equals",
+			required: false
+		}]
+	}] }
+});
+var NotEqualValidatorDirective = class NotEqualValidatorDirective {
+	constructor() {
+		this.notEqual = input(void 0, ...ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []);
+		effect(() => {
+			const other = this.notEqual();
+			this.subscription?.unsubscribe();
+			this.subscription = other?.valueChanges.subscribe(() => this.hostControl?.updateValueAndValidity({ emitEvent: false }));
+			this.hostControl?.updateValueAndValidity({ emitEvent: false });
+		});
+		inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+	}
+	validate(control) {
+		this.hostControl = control;
+		const notEqual = this.notEqual();
+		if (!notEqual) return null;
+		const errors = !notEqual.value && !control.value || notEqual.value !== control.value ? null : { notequal: true };
+		if (errors) control.markAsTouched();
+		else if (notEqual.hasError("notequal")) {
+			const { notequal: _removed, ...rest } = notEqual.errors ?? {};
+			notEqual.setErrors(Object.keys(rest).length > 0 ? rest : null, { emitEvent: false });
+			notEqual.updateValueAndValidity({
+				onlySelf: true,
+				emitEvent: false
+			});
+			notEqual.markAsTouched();
+			notEqual.markAsDirty();
+		}
+		return errors;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotEqualValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: NotEqualValidatorDirective,
+			isStandalone: true,
+			selector: "[notEqual]",
+			inputs: { notEqual: {
+				classPropertyName: "notEqual",
+				publicName: "notEqual",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotEqualValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: NotEqualValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[notEqual]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotEqualValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { notEqual: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "notEqual",
+			required: false
+		}]
+	}] }
+});
+var EmailsValidatorDirective = class EmailsValidatorDirective {
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		return input.replaceAll(/\r\n/g, "").split(";").every((part) => part.length === 0 || !!SystemUtils.parseEmail(part)) ? null : { emails: "Elenco non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: EmailsValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: EmailsValidatorDirective,
+			isStandalone: true,
+			selector: "[emails]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => EmailsValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: EmailsValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[emails]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => EmailsValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var GuidValidatorDirective = class GuidValidatorDirective {
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		return SystemUtils.parseUUID(input) ? null : { guid: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: GuidValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: GuidValidatorDirective,
+			isStandalone: true,
+			selector: "[guid]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => GuidValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: GuidValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[guid]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => GuidValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var SqlDateValidatorDirective = class SqlDateValidatorDirective {
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		const parsed = SystemUtils.parseDate(input);
+		if (!parsed) return { sqlDate: "Non valido." };
+		return endOfDay(parsed).getFullYear() > 1750 ? null : { sqlDate: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: SqlDateValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: SqlDateValidatorDirective,
+			isStandalone: true,
+			selector: "[sqlDate]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => SqlDateValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: SqlDateValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[sqlDate]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => SqlDateValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var NotFutureValidatorDirective = class NotFutureValidatorDirective {
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		const parsed = SystemUtils.parseDate(input);
+		if (!parsed) return { notFuture: "Non valido." };
+		const today = endOfDay(/* @__PURE__ */ new Date());
+		return endOfDay(parsed) <= today ? null : { notFuture: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotFutureValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: NotFutureValidatorDirective,
+			isStandalone: true,
+			selector: "[notFuture]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotFutureValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: NotFutureValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[notFuture]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotFutureValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var UrlValidatorDirective = class UrlValidatorDirective {
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		return SystemUtils.parseUrl(input) ? null : { url: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: UrlValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: UrlValidatorDirective,
+			isStandalone: true,
+			selector: "[url]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => UrlValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: UrlValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[url]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => UrlValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var FileSizeValidatorDirective = class FileSizeValidatorDirective {
+	constructor() {
+		this.maxSizeMb = input(5, ...ngDevMode ? [{ debugName: "maxSizeMb" }] : /* istanbul ignore next */ []);
+		this.minSizeMb = input(0, ...ngDevMode ? [{ debugName: "minSizeMb" }] : /* istanbul ignore next */ []);
+		this.size = input(void 0, ...ngDevMode ? [{ debugName: "size" }] : /* istanbul ignore next */ []);
+	}
+	validate(control) {
+		if (!control.value) return null;
+		const s = this.size() ?? 0;
+		return s <= this.maxSizeMb() && s >= this.minSizeMb() ? null : { fileSize: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: FileSizeValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: FileSizeValidatorDirective,
+			isStandalone: true,
+			selector: "[fileSize]",
+			inputs: {
+				maxSizeMb: {
+					classPropertyName: "maxSizeMb",
+					publicName: "maxSizeMb",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				minSizeMb: {
+					classPropertyName: "minSizeMb",
+					publicName: "minSizeMb",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				},
+				size: {
+					classPropertyName: "size",
+					publicName: "size",
+					isSignal: true,
+					isRequired: false,
+					transformFunction: null
+				}
+			},
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => FileSizeValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: FileSizeValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[fileSize]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => FileSizeValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	propDecorators: {
+		maxSizeMb: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "maxSizeMb",
+				required: false
+			}]
+		}],
+		minSizeMb: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "minSizeMb",
+				required: false
+			}]
+		}],
+		size: [{
+			type: i0.Input,
+			args: [{
+				isSignal: true,
+				alias: "size",
+				required: false
+			}]
+		}]
+	}
+});
+var MaxTermsValidatorDirective = class MaxTermsValidatorDirective {
+	constructor() {
+		this.maxTerms = input(0, ...ngDevMode ? [{ debugName: "maxTerms" }] : /* istanbul ignore next */ []);
+	}
+	validate(control) {
+		const input = control.value;
+		if (!input) return null;
+		return (input.match(/\S+/g)?.length ?? 0) <= this.maxTerms() ? null : { maxTerms: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: MaxTermsValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: MaxTermsValidatorDirective,
+			isStandalone: true,
+			selector: "[maxTerms]",
+			inputs: { maxTerms: {
+				classPropertyName: "maxTerms",
+				publicName: "maxTerms",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => MaxTermsValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: MaxTermsValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[maxTerms]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => MaxTermsValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	propDecorators: { maxTerms: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "maxTerms",
+			required: false
+		}]
+	}] }
+});
+var PasswordValidatorDirective = class PasswordValidatorDirective {
+	validate(control) {
+		const input = control.value ?? "";
+		return SystemUtils.calculatePasswordStrength(input).isValid ? null : { password: "Non valido." };
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: PasswordValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: PasswordValidatorDirective,
+			isStandalone: true,
+			selector: "[password]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => PasswordValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: PasswordValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[password]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => PasswordValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+var TimeValidatorDirective = class TimeValidatorDirective {
+	constructor() {
+		this.slots = input(void 0, ...ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []);
+	}
+	getTime(value) {
+		const p = value.split(":");
+		if (p.length !== 2) return -1;
+		const hh = parseInt(p[0], 10);
+		if (isNaN(hh) || hh < 0 || hh > 23) return -1;
+		const mm = parseInt(p[1], 10);
+		if (isNaN(mm) || mm < 0 || mm > 59) return -1;
+		return hh * 100 + mm;
+	}
+	validate(control) {
+		const input = control.value;
+		if (!input || input.length === 0) return null;
+		const t = this.getTime(input);
+		if (t === -1) return { time: "Non valido." };
+		const slotsValue = this.slots();
+		if (slotsValue) return slotsValue.split("|").some((s) => {
+			const t1 = this.getTime(s.substring(0, 5));
+			const t2 = this.getTime(s.substring(6));
+			return t1 !== -1 && t2 !== -1 && t1 <= t && t2 >= t;
+		}) ? null : { time: "Non valido." };
+		return null;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: TimeValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "22.2.1",
+			type: TimeValidatorDirective,
+			isStandalone: true,
+			selector: "[time]",
+			inputs: { slots: {
+				classPropertyName: "slots",
+				publicName: "slots",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => TimeValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: TimeValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[time]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => TimeValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}],
+	propDecorators: { slots: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "slots",
+			required: false
+		}]
+	}] }
+});
 function isBlankValue(value) {
-    if (Array.isArray(value))
-        return value.length === 0;
-    if (typeof value !== 'string')
-        return false;
-    return value.length > 0 && value.trim().length === 0;
-}
-
-/**
- * Directive that validates that a control value is not blank: neither a whitespace-only string
- * nor an empty array. Apply `notEmpty` to a text input where non-blank content is required, or
- * to a multi-value control that must carry at least one entry.
- *
- * A value that is simply absent passes: saying "obbligatorio" is the job of `required`, which is
- * declared next to this one when both rules belong on the same control.
- */
-class NotEmptyValidatorDirective {
-    /**
-     * Validates that the control value carries content.
-     * Returns `null` when the control is absent or holds a type this rule says nothing about.
-     * @param control - The form control to validate.
-     * @returns `{ notEmpty: true }` when the value is a blank string or an empty array, `null` otherwise.
-     */
-    validate(control) {
-        return isBlankValue(control?.value) ? { notEmpty: true } : null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotEmptyValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.7", type: NotEmptyValidatorDirective, isStandalone: true, selector: "[notEmpty]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => NotEmptyValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
+	if (Array.isArray(value)) return value.length === 0;
+	if (typeof value !== "string") return false;
+	return value.length > 0 && value.trim().length === 0;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: NotEmptyValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[notEmpty]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => NotEmptyValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * @file italian.ts
- *
- * The two check algorithms behind the `italianVat` and `italianFiscalCode` rules, kept apart from
- * the validators that use them for the same reason `emptiness.ts` is: the rule must exist in one
- * place only, so that no second copy of it can drift. They pull in nothing — not `@angular/forms`,
- * not `@angular/core` — and they live here rather than in `SystemUtils` so that `core`, which sits
- * on the boot path of every application, does not carry code only a form needs.
- */
-/**
- * Digits an "omocodia" substitution replaces with a letter, in digit order: `0` becomes `L`, `1`
- * becomes `M`, and so on.
- *
- * The Agenzia delle Entrate applies it when two people would otherwise share the same fiscal code,
- * so a perfectly legitimate code can carry letters where the format expects numbers. Ignoring this
- * is the classic way a validator rejects a real person.
- */
-const OMOCODIA_CHARS = 'LMNPQRSTUV';
-/** Letters usable as month of birth, one per month from January (`A`) to December (`T`). */
-const MONTH_CHARS = 'ABCDEHLMPRST';
-/** Alphabet the control character of a fiscal code is drawn from. */
-const CONTROL_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-/** Weight of each character sitting in an ODD position (1-based) of the first 15 of a fiscal code. */
+var NotEmptyValidatorDirective = class NotEmptyValidatorDirective {
+	validate(control) {
+		return isBlankValue(control?.value) ? { notEmpty: true } : null;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotEmptyValidatorDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			type: NotEmptyValidatorDirective,
+			isStandalone: true,
+			selector: "[notEmpty]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotEmptyValidatorDirective),
+				multi: true
+			}],
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: NotEmptyValidatorDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[notEmpty]",
+			providers: [{
+				provide: NG_VALIDATORS,
+				useExisting: forwardRef(() => NotEmptyValidatorDirective),
+				multi: true
+			}],
+			standalone: true
+		}]
+	}]
+});
+const OMOCODIA_CHARS = "LMNPQRSTUV";
+const MONTH_CHARS = "ABCDEHLMPRST";
+const CONTROL_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const ODD_WEIGHTS = {
-    '0': 1, '1': 0, '2': 5, '3': 7, '4': 9, '5': 13, '6': 15, '7': 17, '8': 19, '9': 21,
-    A: 1, B: 0, C: 5, D: 7, E: 9, F: 13, G: 15, H: 17, I: 19, J: 21, K: 2, L: 4, M: 18,
-    N: 20, O: 11, P: 3, Q: 6, R: 8, S: 12, T: 14, U: 16, V: 10, W: 22, X: 25, Y: 24, Z: 23,
+	"0": 1,
+	"1": 0,
+	"2": 5,
+	"3": 7,
+	"4": 9,
+	"5": 13,
+	"6": 15,
+	"7": 17,
+	"8": 19,
+	"9": 21,
+	A: 1,
+	B: 0,
+	C: 5,
+	D: 7,
+	E: 9,
+	F: 13,
+	G: 15,
+	H: 17,
+	I: 19,
+	J: 21,
+	K: 2,
+	L: 4,
+	M: 18,
+	N: 20,
+	O: 11,
+	P: 3,
+	Q: 6,
+	R: 8,
+	S: 12,
+	T: 14,
+	U: 16,
+	V: 10,
+	W: 22,
+	X: 25,
+	Y: 24,
+	Z: 23
 };
-/** Weight of each character sitting in an EVEN position (1-based) of the first 15 of a fiscal code. */
 const EVEN_WEIGHTS = {
-    '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
-    A: 0, B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12,
-    N: 13, O: 14, P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23, Y: 24, Z: 25,
+	"0": 0,
+	"1": 1,
+	"2": 2,
+	"3": 3,
+	"4": 4,
+	"5": 5,
+	"6": 6,
+	"7": 7,
+	"8": 8,
+	"9": 9,
+	A: 0,
+	B: 1,
+	C: 2,
+	D: 3,
+	E: 4,
+	F: 5,
+	G: 6,
+	H: 7,
+	I: 8,
+	J: 9,
+	K: 10,
+	L: 11,
+	M: 12,
+	N: 13,
+	O: 14,
+	P: 15,
+	Q: 16,
+	R: 17,
+	S: 18,
+	T: 19,
+	U: 20,
+	V: 21,
+	W: 22,
+	X: 23,
+	Y: 24,
+	Z: 25
 };
-/**
- * Shape of a fiscal code of a natural person, omocodia included: every group that is normally
- * numeric also admits the ten letters that stand in for a digit.
- */
 const FISCAL_CODE_REGEX = /^[A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]$/;
-/**
- * Strips what a user types around a code without changing the code itself: surrounding and inner
- * spaces, dots and dashes, and the letter case.
- *
- * Accepting a pasted `"IT 123 456 789 01"` is not indulgence — the value arrives from an invoice,
- * a registry export or a colleague's e-mail far more often than it is typed character by
- * character, and rejecting it teaches nothing to the person who pasted it.
- *
- * @param value - The raw value as the user entered it.
- * @returns The value in upper case with spaces, dots and dashes removed.
- */
 function normalize(value) {
-    return (value ?? '').toUpperCase().replace(/[\s.\-/]/g, '');
+	return (value ?? "").toUpperCase().replace(/[\s.\-/]/g, "");
 }
-/**
- * Turns the letters an omocodia substitution left behind back into the digits they stand for.
- *
- * @param value - A group of characters of a fiscal code that is numeric in the plain form.
- * @returns The same group with every substitution letter replaced by its digit.
- */
 function decodeOmocodia(value) {
-    let decoded = '';
-    for (const char of value) {
-        const index = OMOCODIA_CHARS.indexOf(char);
-        decoded += index === -1 ? char : String(index);
-    }
-    return decoded;
+	let decoded = "";
+	for (const char of value) {
+		const index = OMOCODIA_CHARS.indexOf(char);
+		decoded += index === -1 ? char : String(index);
+	}
+	return decoded;
 }
-/**
- * Tells whether a value is a valid Italian VAT number (partita IVA).
- *
- * Eleven digits, of which the last one is the check digit of the Luhn-like algorithm of
- * D.P.R. 633/72: the digits in even position (1-based) are doubled and folded back under ten, the
- * sum is completed to the next multiple of ten, and what is missing is the check digit. An
- * optional `IT` prefix is accepted, because that is how the number travels on invoices and in
- * VIES exports.
- *
- * The seven digits of the sequential number are required not to be all zeros, which is the one
- * combination the checksum happily accepts and the Agenzia delle Entrate never issues. The office
- * code (positions 8 to 10) is deliberately NOT checked against the list of the provinces: that
- * list grows, and a validator that rejects a number issued last month is worse than one that lets
- * a fabricated office code through.
- *
- * @param value - The value to check, with or without the `IT` prefix and any spacing.
- * @returns `true` when the value is a well-formed VAT number.
- */
 function isValidItalianVat(value) {
-    const normalized = normalize(value);
-    const digits = normalized.startsWith('IT') ? normalized.slice(2) : normalized;
-    if (!/^\d{11}$/.test(digits))
-        return false;
-    if (digits.startsWith('0000000'))
-        return false;
-    let sum = 0;
-    for (let i = 0; i < 10; i++) {
-        let digit = digits.charCodeAt(i) - 48;
-        // Positions are 1-based in the norm, so the doubled ones are those at an even index here.
-        if (i % 2 === 1) {
-            digit *= 2;
-            if (digit > 9)
-                digit -= 9;
-        }
-        sum += digit;
-    }
-    const check = (10 - (sum % 10)) % 10;
-    return check === digits.charCodeAt(10) - 48;
+	const normalized = normalize(value);
+	const digits = normalized.startsWith("IT") ? normalized.slice(2) : normalized;
+	if (!/^\d{11}$/.test(digits)) return false;
+	if (digits.startsWith("0000000")) return false;
+	let sum = 0;
+	for (let i = 0; i < 10; i++) {
+		let digit = digits.charCodeAt(i) - 48;
+		if (i % 2 === 1) {
+			digit *= 2;
+			if (digit > 9) digit -= 9;
+		}
+		sum += digit;
+	}
+	return (10 - sum % 10) % 10 === digits.charCodeAt(10) - 48;
 }
-/**
- * Tells whether a value is a valid Italian fiscal code (codice fiscale), in either of the two
- * shapes a form can receive.
- *
- * A natural person has the sixteen-character code of D.M. 23/12/1976: the shape is checked, the
- * month letter and the day of birth are checked (41 to 71 for a woman, which is the day plus
- * forty), and the sixteenth character is recomputed from the first fifteen and compared. Letters
- * left by an omocodia substitution are accepted and decoded before the date is judged, so a
- * legitimately altered code is not turned away.
- *
- * A company or a public body has no such code: its fiscal code IS its VAT number, eleven digits
- * checked by {@link isValidItalianVat}. Both are accepted here because a single "codice fiscale"
- * field in a registry form receives both, and asking the user which kind they are about to type is
- * a question the code can answer by itself.
- *
- * @param value - The value to check, in any case and with any spacing.
- * @returns `true` when the value is a well-formed fiscal code of either shape.
- */
 function isValidItalianFiscalCode(value) {
-    const code = normalize(value);
-    // A company or a public body: its fiscal code is the VAT number.
-    if (/^\d{11}$/.test(code))
-        return isValidItalianVat(code);
-    if (code.length !== 16 || !FISCAL_CODE_REGEX.test(code))
-        return false;
-    // The day carries the sex: 01-31 for a man, 41-71 for a woman (the day plus forty).
-    const day = parseInt(decodeOmocodia(code.substring(9, 11)), 10);
-    const isValidDay = (day >= 1 && day <= 31) || (day >= 41 && day <= 71);
-    if (!isValidDay)
-        return false;
-    // The month letter is already constrained by the regex; this keeps the two in step if it changes.
-    if (!MONTH_CHARS.includes(code[8]))
-        return false;
-    let sum = 0;
-    for (let i = 0; i < 15; i++) {
-        // Odd positions in the norm are the even indexes here. The character is weighted as it is
-        // written, substitution letters included: the control character is computed on the altered
-        // code, not on the original one.
-        sum += i % 2 === 0 ? ODD_WEIGHTS[code[i]] : EVEN_WEIGHTS[code[i]];
-    }
-    return CONTROL_CHARS[sum % 26] === code[15];
+	const code = normalize(value);
+	if (/^\d{11}$/.test(code)) return isValidItalianVat(code);
+	if (code.length !== 16 || !FISCAL_CODE_REGEX.test(code)) return false;
+	const day = parseInt(decodeOmocodia(code.substring(9, 11)), 10);
+	if (!(day >= 1 && day <= 31 || day >= 41 && day <= 71)) return false;
+	if (!MONTH_CHARS.includes(code[8])) return false;
+	let sum = 0;
+	for (let i = 0; i < 15; i++) sum += i % 2 === 0 ? ODD_WEIGHTS[code[i]] : EVEN_WEIGHTS[code[i]];
+	return CONTROL_CHARS[sum % 26] === code[15];
 }
-
-/**
- * Default texts of the rules declared here, in one place so that the validators and the fallback
- * map of `SignalsUtils.getFieldErrorMessage` cannot drift apart: a rule added below without a
- * message here would show "Errore", and one renamed here without touching the validator would
- * leave the map with a kind nobody produces.
- */
-/**
- * Earliest year {@link date} and {@link dateRange} accept: 1750.
- *
- * It is the floor of what the backend can store, and it is set that low on purpose: a birth date,
- * the date of an old norm or the commissioning of an old machine are real data well before 1970.
- * What it does catch is the 01/01/0001 or 01/01/0020 that a mistyped year produces, which SQL
- * Server would reject with an error nobody can read.
- */
 const MIN_VALID_YEAR = 1750;
 const ARS_VALIDATOR_MESSAGES = {
-    required: 'Obbligatorio',
-    guid: 'Ticket non riconosciuto',
-    password: 'Password non sufficientemente robusta',
-    notEmpty: 'Non può essere vuoto o contenere solo spazi.',
-    notEqual: 'Deve essere diverso dall\'altro valore',
-    // Emitted by `SqlDateValidatorDirective`, which a `[formField]` on a ControlValueAccessor still reads.
-    sqlDate: 'Data non valida',
-    date: 'Data non valida',
-    dateRange: 'Intervallo non valido',
-    notFuture: 'La data non può essere futura',
-    notPast: 'La data non può essere passata',
-    url: 'Indirizzo non valido',
-    maxTerms: 'Troppe parole',
-    fileSize: 'Dimensione del file non ammessa',
-    validIf: 'Non valido',
-    emails: 'Elenco non valido',
-    time: 'Orario non valido',
-    equals: 'I due valori non coincidono',
-    otp: 'Codice non valido',
-    italianVat: 'Partita IVA non valida',
-    italianFiscalCode: 'Codice fiscale non valido',
+	required: "Obbligatorio",
+	guid: "Ticket non riconosciuto",
+	password: "Password non sufficientemente robusta",
+	notEmpty: "Non può essere vuoto o contenere solo spazi.",
+	notEqual: "Deve essere diverso dall'altro valore",
+	sqlDate: "Data non valida",
+	date: "Data non valida",
+	dateRange: "Intervallo non valido",
+	notFuture: "La data non può essere futura",
+	notPast: "La data non può essere passata",
+	url: "Indirizzo non valido",
+	maxTerms: "Troppe parole",
+	fileSize: "Dimensione del file non ammessa",
+	validIf: "Non valido",
+	emails: "Elenco non valido",
+	time: "Orario non valido",
+	equals: "I due valori non coincidono",
+	otp: "Codice non valido",
+	italianVat: "Partita IVA non valida",
+	italianFiscalCode: "Codice fiscale non valido"
 };
-/**
- * Requires the value to be a well-formed GUID / UUID.
- *
- * The signal-form counterpart of `GuidValidatorDirective`, sharing its rule down to the empty
- * case: an empty value is NOT an error here, because saying "obbligatorio" is the job of
- * `required()` and two errors on one empty field only ever read as noise.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.serial); guid(p.serial); });
- */
 function guid(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        return SystemUtils.parseUUID(input)
-            ? null
-            : { kind: 'guid', message: config?.message ?? ARS_VALIDATOR_MESSAGES['guid'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		return SystemUtils.parseUUID(input) ? null : {
+			kind: "guid",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["guid"]
+		};
+	});
 }
-/**
- * Requires the value to be a password strong enough for {@link SystemUtils.calculatePasswordStrength}.
- *
- * The signal-form counterpart of `PasswordValidatorDirective`. Unlike {@link guid} it does judge
- * the empty value, because an empty password IS a weak one and the directive behaved the same way.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override.
- * @returns void
- */
 function password(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const strength = SystemUtils.calculatePasswordStrength(ctx.value() ?? '');
-        return strength.isValid
-            ? null
-            : { kind: 'password', message: config?.message ?? ARS_VALIDATOR_MESSAGES['password'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		return SystemUtils.calculatePasswordStrength(ctx.value() ?? "").isValid ? null : {
+			kind: "password",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["password"]
+		};
+	});
 }
-/**
- * Requires the value not to be made of whitespace alone, and a collection not to be empty.
- *
- * The signal-form counterpart of `NotEmptyValidatorDirective`, sharing its predicate through
- * {@link isBlankValue}: a blank string and an empty array are errors, an absent value is not.
- * That last part is not an oversight — saying "obbligatorio" belongs to `required()`, and a field
- * that is merely blank would otherwise raise two errors that mean the same thing. Declare the two
- * together when a field must be both present and non-blank.
- *
- * Replaces the `pattern(p.x, /\S/)` workaround: same rule, but the intent is in the name and the
- * error kind is `notEmpty` rather than `pattern`.
- *
- * On a multi-value field this rule is the ONLY one that sees an empty selection: Angular's
- * `required()` treats emptiness as `'' | false | null | undefined`, so an empty array walks past
- * it. Give it a message of its own there, because the default one talks about whitespace.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.city); notEmpty(p.city); });
- * @example
- * const f = form(this.model, p => { notEmpty(p.tags); });   // at least one tag
- */
 function notEmpty(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        return isBlankValue(ctx.value())
-            ? { kind: 'notEmpty', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notEmpty'] }
-            : null;
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		return isBlankValue(ctx.value()) ? {
+			kind: "notEmpty",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["notEmpty"]
+		} : null;
+	});
 }
-/**
- * Requires the value to differ from the value of another field of the same form.
- *
- * The signal-form counterpart of `NotEqualValidatorDirective`, with its exact rule: two empty
- * values are considered different, so an untouched pair of fields does not start out in error.
- * Reactive on both fields — editing either one re-validates this one, which is what the
- * directive needed a `valueChanges` subscription (and a re-entrancy guard) to achieve.
- *
- * @param path   - Path of the field to validate.
- * @param other  - Path of the field whose value must differ.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function notEqual(path, other, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const mine = ctx.value();
-        const theirs = ctx.valueOf(other);
-        const isValid = (!theirs && !mine) || theirs !== mine;
-        return isValid ? null : { kind: 'notEqual', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notEqual'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const mine = ctx.value();
+		const theirs = ctx.valueOf(other);
+		return !theirs && !mine || theirs !== mine ? null : {
+			kind: "notEqual",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["notEqual"]
+		};
+	});
 }
-/**
- * Requires the value to be a real date, as {@link SystemUtils.parseDate} understands one.
- *
- * This is the rule for anything a user picks or types as a date: it accepts both the `Date` a
- * Material datepicker or timepicker writes into the model and the text of a plain input, since
- * `parseDate` handles the shapes this codebase produces (ISO, `dd/MM/yyyy`, `yyyy-MM-dd`, and the
- * shorthand forms). Empty passes — saying "obbligatorio" is the job of `required()`.
- *
- * A date earlier than {@link MIN_VALID_YEAR} (1750) is rejected: it is what the backend can
- * store, so an earlier value is a mistyped year rather than data.
- *
- * It is also the signal-form counterpart of `SqlDateValidatorDirective`: one rule for every date,
- * whether it is typed or picked.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.expiry); date(p.expiry); });
- */
 function date(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (input === undefined || input === null || input === '')
-            return null;
-        const parsed = SystemUtils.parseDate(input);
-        return parsed && parsed.getFullYear() >= MIN_VALID_YEAR
-            ? null
-            : { kind: 'date', message: config?.message ?? ARS_VALIDATOR_MESSAGES['date'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (input === void 0 || input === null || input === "") return null;
+		const parsed = SystemUtils.parseDate(input);
+		return parsed && parsed.getFullYear() >= 1750 ? null : {
+			kind: "date",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["date"]
+		};
+	});
 }
-/**
- * Requires the two ends of a date range to be real dates and to be in order.
- *
- * Written for the two inputs of a `mat-date-range-input`, whose start and end live in two
- * separate fields of the model. Each end is checked with the same rule as {@link date}, and the
- * ordering is checked only when BOTH ends are filled in — a half-open range ("from today
- * onwards") is a legitimate filter, not an error. The {@link MIN_VALID_YEAR} floor of {@link date}
- * applies to both ends.
- *
- * The rule is bound to BOTH paths, so the error appears on whichever end the user is looking at
- * and a single `<mat-error>` under the range can read either one. Comparison is made on the end
- * of the day, so picking the same day for both ends is valid.
- *
- * @param from   - Path of the field holding the start of the range.
- * @param to     - Path of the field holding the end of the range.
- * @param config - Optional message override (used for the ordering error) and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { dateRange(p.sentFrom, p.sentTo); });
- */
 function dateRange(from, to, config) {
-    date(from, config);
-    date(to, config);
-    /**
-     * Compares the two ends of the range once both of them are filled in.
-     * @param startValue - Raw value of the start field.
-     * @param endValue   - Raw value of the end field.
-     * @returns The ordering error, or `null` when the pair is acceptable.
-     */
-    const checkOrder = (startValue, endValue) => {
-        const start = SystemUtils.parseDate(startValue ?? undefined);
-        const end = SystemUtils.parseDate(endValue ?? undefined);
-        // A half-open range is legitimate: nothing to compare until both ends are there. An end that
-        // is not a valid date is already reported by the `date` rule bound above, so it is skipped
-        // here rather than reported twice.
-        if (!start || !end)
-            return null;
-        if (start.getFullYear() < MIN_VALID_YEAR || end.getFullYear() < MIN_VALID_YEAR)
-            return null;
-        return endOfDay(start) <= endOfDay(end)
-            ? null
-            : { kind: 'dateRange', message: config?.message ?? ARS_VALIDATOR_MESSAGES['dateRange'] };
-    };
-    // Reading the opposite end through `valueOf` keeps each rule reactive on the other field, so
-    // filling in one end re-validates the other.
-    validate(from, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        return checkOrder(ctx.value(), ctx.valueOf(to));
-    });
-    validate(to, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        return checkOrder(ctx.valueOf(from), ctx.value());
-    });
+	date(from, config);
+	date(to, config);
+	const checkOrder = (startValue, endValue) => {
+		const start = SystemUtils.parseDate(startValue ?? void 0);
+		const end = SystemUtils.parseDate(endValue ?? void 0);
+		if (!start || !end) return null;
+		if (start.getFullYear() < 1750 || end.getFullYear() < 1750) return null;
+		return endOfDay(start) <= endOfDay(end) ? null : {
+			kind: "dateRange",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["dateRange"]
+		};
+	};
+	validate(from, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		return checkOrder(ctx.value(), ctx.valueOf(to));
+	});
+	validate(to, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		return checkOrder(ctx.valueOf(from), ctx.value());
+	});
 }
-/**
- * Requires the value to be a date that is not in the future.
- *
- * The signal-form counterpart of `NotFutureValidatorDirective`. Today counts as valid: the
- * comparison is made on the end of the day, so a date entered this morning does not become
- * invalid because the clock says 09:00.
- *
- * Like {@link notPast}, it accepts both the `Date` a Material datepicker writes into the model and
- * the text of a plain input. An empty value passes: saying "obbligatorio" is the job of
- * `required()`.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.executionDate); notFuture(p.executionDate); });
- */
 function notFuture(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (input === undefined || input === null || input === '')
-            return null;
-        const parsed = SystemUtils.parseDate(input);
-        const invalid = { kind: 'notFuture', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notFuture'] };
-        if (!parsed)
-            return invalid;
-        return endOfDay(parsed) <= endOfDay(new Date()) ? null : invalid;
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (input === void 0 || input === null || input === "") return null;
+		const parsed = SystemUtils.parseDate(input);
+		const invalid = {
+			kind: "notFuture",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["notFuture"]
+		};
+		if (!parsed) return invalid;
+		return endOfDay(parsed) <= endOfDay(/* @__PURE__ */ new Date()) ? null : invalid;
+	});
 }
-/**
- * Requires the value to be a date that is not in the past.
- *
- * The mirror image of {@link notFuture}, for the fields that can only look forward: an expiry, a
- * deadline, the date of a course still to be held. Today counts as valid — the comparison is made
- * on the start of the day, so a date picked this afternoon for today does not become invalid
- * because the clock has moved on.
- *
- * Like {@link date}, and unlike the older {@link notFuture}, it accepts both the `Date` a Material
- * datepicker writes into the model and the text of a plain input. An empty value passes: saying
- * "obbligatorio" is the job of `required()`.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.scadenza); notPast(p.scadenza); });
- */
 function notPast(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (input === undefined || input === null || input === '')
-            return null;
-        const parsed = SystemUtils.parseDate(input);
-        const invalid = { kind: 'notPast', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notPast'] };
-        if (!parsed)
-            return invalid;
-        return startOfDay(parsed) >= startOfDay(new Date()) ? null : invalid;
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (input === void 0 || input === null || input === "") return null;
+		const parsed = SystemUtils.parseDate(input);
+		const invalid = {
+			kind: "notPast",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["notPast"]
+		};
+		if (!parsed) return invalid;
+		return startOfDay(parsed) >= startOfDay(/* @__PURE__ */ new Date()) ? null : invalid;
+	});
 }
-/**
- * Requires the value to be a well-formed URL. An empty value passes, as everywhere else here.
- *
- * The signal-form counterpart of `UrlValidatorDirective`.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function url(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        return SystemUtils.parseUrl(input)
-            ? null
-            : { kind: 'url', message: config?.message ?? ARS_VALIDATOR_MESSAGES['url'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		return SystemUtils.parseUrl(input) ? null : {
+			kind: "url",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["url"]
+		};
+	});
 }
-/**
- * Requires the value to hold no more than `max` whitespace-separated terms.
- *
- * The signal-form counterpart of `MaxTermsValidatorDirective`, used on the search boxes where
- * the backend refuses a query past a certain number of words.
- *
- * @param path   - Path of the field to validate.
- * @param max    - The maximum number of terms, as a number or a reactive function.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function maxTerms(path, max, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input)
-            return null;
-        const terms = input.match(/\S+/g)?.length ?? 0;
-        return terms <= (typeof max === 'function' ? max() : max)
-            ? null
-            : { kind: 'maxTerms', message: config?.message ?? ARS_VALIDATOR_MESSAGES['maxTerms'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input) return null;
+		return (input.match(/\S+/g)?.length ?? 0) <= (typeof max === "function" ? max() : max) ? null : {
+			kind: "maxTerms",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["maxTerms"]
+		};
+	});
 }
-/**
- * Requires the size of the picked file to fall within the allowed range.
- *
- * The signal-form counterpart of `FileSizeValidatorDirective`, and it keeps its shape: the field
- * itself holds the file NAME, while the size arrives from outside — the control that picked the
- * file knows it, the form does not. An empty field passes, so "no file" is `required()`'s call
- * and not a size error.
- *
- * @param path      - Path of the field holding the file name.
- * @param sizeMb    - The size of the picked file in megabytes, as a reactive function.
- * @param maxSizeMb - The maximum allowed size in megabytes. Defaults to `5`.
- * @param minSizeMb - The minimum required size in megabytes. Defaults to `0`.
- * @param config    - Optional message override and `when` condition.
- * @returns void
- */
 function fileSize(path, sizeMb, maxSizeMb = 5, minSizeMb = 0, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        if (!ctx.value())
-            return null;
-        const size = sizeMb() ?? 0;
-        const max = typeof maxSizeMb === 'function' ? maxSizeMb() : maxSizeMb;
-        const min = typeof minSizeMb === 'function' ? minSizeMb() : minSizeMb;
-        return size <= max && size >= min
-            ? null
-            : { kind: 'fileSize', message: config?.message ?? ARS_VALIDATOR_MESSAGES['fileSize'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		if (!ctx.value()) return null;
+		const size = sizeMb() ?? 0;
+		const max = typeof maxSizeMb === "function" ? maxSizeMb() : maxSizeMb;
+		const min = typeof minSizeMb === "function" ? minSizeMb() : minSizeMb;
+		return size <= max && size >= min ? null : {
+			kind: "fileSize",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["fileSize"]
+		};
+	});
 }
-/**
- * Requires the value to declare itself valid.
- *
- * The signal-form counterpart of `ValidIfDirective`: when the field holds an object implementing
- * `Validated` the verdict is its own `isValid()`, and when the field is empty the verdict is the
- * `flag`. It is the escape hatch for the composite controls whose validity only they can judge.
- *
- * @param path   - Path of the field to validate.
- * @param flag   - Verdict used while the field is empty, as a boolean or a reactive function.
- *                 Defaults to `false`.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function validIf(path, flag = false, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const value = ctx.value();
-        let isValid;
-        if (!value) {
-            isValid = (typeof flag === 'function' ? flag() : flag) === true;
-        }
-        else {
-            try {
-                isValid = value.isValid?.() === true;
-            }
-            catch {
-                isValid = false;
-            }
-        }
-        return isValid ? null : { kind: 'validIf', message: config?.message ?? ARS_VALIDATOR_MESSAGES['validIf'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const value = ctx.value();
+		let isValid;
+		if (!value) isValid = (typeof flag === "function" ? flag() : flag) === true;
+		else try {
+			isValid = value.isValid?.() === true;
+		} catch {
+			isValid = false;
+		}
+		return isValid ? null : {
+			kind: "validIf",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["validIf"]
+		};
+	});
 }
-/**
- * Requires the value to be a semicolon-separated list of valid e-mail addresses.
- *
- * The signal-form counterpart of `EmailsValidatorDirective`. An empty value passes, and so does
- * an empty entry between two semicolons: the list is typed by hand and a trailing `;` is not a
- * mistake worth an error.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function emails(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        const parts = input.replaceAll(/\r\n/g, '').split(';');
-        const isValid = parts.every(part => part.length === 0 || !!SystemUtils.parseEmail(part));
-        return isValid ? null : { kind: 'emails', message: config?.message ?? ARS_VALIDATOR_MESSAGES['emails'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		return input.replaceAll(/\r\n/g, "").split(";").every((part) => part.length === 0 || !!SystemUtils.parseEmail(part)) ? null : {
+			kind: "emails",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["emails"]
+		};
+	});
 }
-/**
- * Requires the value to be a `"HH:MM"` time and, when slots are given, to fall inside one of them.
- *
- * The signal-form counterpart of `TimeValidatorDirective`. An empty value passes.
- *
- * @param path   - Path of the field to validate.
- * @param slots  - Optional reactive function returning the pipe-separated allowed ranges
- *                 (e.g. `"08:00-12:00|14:00-18:00"`), or `undefined` for no restriction.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function time(path, slots, config) {
-    /**
-     * Turns `"HH:MM"` into a comparable integer (`"09:30"` -> `930`).
-     * @param value - The time string to parse.
-     * @returns The comparable integer, or `-1` when the string is not a valid time.
-     */
-    const getTime = (value) => {
-        const p = value.split(':');
-        if (p.length !== 2)
-            return -1;
-        const hh = parseInt(p[0], 10);
-        if (isNaN(hh) || hh < 0 || hh > 23)
-            return -1;
-        const mm = parseInt(p[1], 10);
-        if (isNaN(mm) || mm < 0 || mm > 59)
-            return -1;
-        return hh * 100 + mm;
-    };
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        const invalid = { kind: 'time', message: config?.message ?? ARS_VALIDATOR_MESSAGES['time'] };
-        const t = getTime(input);
-        if (t === -1)
-            return invalid;
-        const slotsValue = slots?.();
-        if (slotsValue) {
-            const inSlot = slotsValue.split('|').some(s => {
-                const from = getTime(s.substring(0, 5));
-                const to = getTime(s.substring(6));
-                return from !== -1 && to !== -1 && from <= t && to >= t;
-            });
-            if (!inSlot)
-                return invalid;
-        }
-        return null;
-    });
+	const getTime = (value) => {
+		const p = value.split(":");
+		if (p.length !== 2) return -1;
+		const hh = parseInt(p[0], 10);
+		if (isNaN(hh) || hh < 0 || hh > 23) return -1;
+		const mm = parseInt(p[1], 10);
+		if (isNaN(mm) || mm < 0 || mm > 59) return -1;
+		return hh * 100 + mm;
+	};
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		const invalid = {
+			kind: "time",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["time"]
+		};
+		const t = getTime(input);
+		if (t === -1) return invalid;
+		const slotsValue = slots?.();
+		if (slotsValue) {
+			if (!slotsValue.split("|").some((s) => {
+				const from = getTime(s.substring(0, 5));
+				const to = getTime(s.substring(6));
+				return from !== -1 && to !== -1 && from <= t && to >= t;
+			})) return invalid;
+		}
+		return null;
+	});
 }
-/**
- * Requires the value to equal the value of another field of the same form.
- *
- * The signal-form counterpart of `EqualsValidatorDirective`. Reactive on both fields, which is
- * what the directive needed a `valueChanges` subscription to obtain: retyping the first password
- * re-validates the confirmation without anyone wiring the two together.
- *
- * @param path   - Path of the field to validate.
- * @param other  - Path of the field whose value must match.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function equals(path, other, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        return ctx.valueOf(other) === ctx.value()
-            ? null
-            : { kind: 'equals', message: config?.message ?? ARS_VALIDATOR_MESSAGES['equals'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		return ctx.valueOf(other) === ctx.value() ? null : {
+			kind: "equals",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["equals"]
+		};
+	});
 }
-/**
- * Requires the value to be either empty or a complete six-digit one-time code.
- *
- * The schema-level counterpart of the validator inside `OtpInputComponent`: a partial code is an
- * error, an empty one is `required()`'s business.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- */
 function otp(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value() ?? '';
-        if (input.length === 0)
-            return null;
-        return /^\d{6}$/.test(input)
-            ? null
-            : { kind: 'otp', message: config?.message ?? ARS_VALIDATOR_MESSAGES['otp'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value() ?? "";
+		if (input.length === 0) return null;
+		return /^\d{6}$/.test(input) ? null : {
+			kind: "otp",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["otp"]
+		};
+	});
 }
-/**
- * Requires the value to be a valid Italian VAT number (partita IVA).
- *
- * Eleven digits whose last one is the check digit of D.P.R. 633/72, so a mistyped or invented
- * number is caught here rather than by the backend that will refuse the invoice. An `IT` prefix
- * and the spacing of a pasted value are tolerated, because that is the shape the number arrives
- * in; what is stored is still whatever the user typed, since this rule only judges.
- *
- * An empty value passes, as everywhere else here: declaring the field mandatory is `required()`'s
- * job.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.partitaIva); italianVat(p.partitaIva); });
- */
 function italianVat(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        return isValidItalianVat(input)
-            ? null
-            : { kind: 'italianVat', message: config?.message ?? ARS_VALIDATOR_MESSAGES['italianVat'] };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		return isValidItalianVat(input) ? null : {
+			kind: "italianVat",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["italianVat"]
+		};
+	});
 }
-/**
- * Requires the value to be a valid Italian fiscal code (codice fiscale).
- *
- * Both shapes a registry form receives are accepted: the sixteen-character code of a natural
- * person, control character recomputed and compared, and the eleven digits of a company or a
- * public body, whose fiscal code IS its VAT number. Nothing has to tell the rule which one is
- * coming — the value says it by its own length.
- *
- * Codes altered by an "omocodia" substitution (digits replaced by letters when two people would
- * otherwise share a code) are accepted: they are issued by the Agenzia delle Entrate and rejecting
- * them is the classic way a form turns away a real person.
- *
- * An empty value passes. Pair with `required()` when the field is mandatory, and reach for
- * {@link italianVat} instead on a field that is specifically a VAT number.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override and `when` condition.
- * @returns void
- * @example
- * const f = form(this.model, p => { required(p.codiceFiscale); italianFiscalCode(p.codiceFiscale); });
- */
 function italianFiscalCode(path, config) {
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        if (!input || input.length === 0)
-            return null;
-        return isValidItalianFiscalCode(input)
-            ? null
-            : {
-                kind: 'italianFiscalCode',
-                message: config?.message ?? ARS_VALIDATOR_MESSAGES['italianFiscalCode'],
-            };
-    });
+	validate(path, (ctx) => {
+		if (config?.when && !config.when(ctx)) return null;
+		const input = ctx.value();
+		if (!input || input.length === 0) return null;
+		return isValidItalianFiscalCode(input) ? null : {
+			kind: "italianFiscalCode",
+			message: config?.message ?? ARS_VALIDATOR_MESSAGES["italianFiscalCode"]
+		};
+	});
 }
-/** Helpers around signal forms that are not validators themselves. */
-class SignalsUtils {
-    /**
-     * Builds the error text for a signal-forms field.
-     *
-     * Deliberately dumb: the wording lives in the schema, next to the rule that produces it
-     * (`required(p.x, { message: ... })`), so a field says what is wrong with it in one place
-     * instead of here in a switch that has to guess from the error kind. The map below is only
-     * the safety net for the rules declared without a message — the Angular built-ins, plus
-     * {@link ARS_VALIDATOR_MESSAGES} for the ones declared in this file.
-     * @param errors  - The errors currently on the field, from `f.x().errors()`.
-     * @param message - Optional override applied to every error of the field.
-     * @returns The first relevant error text, or `undefined` when the field has no errors.
-     */
-    static getFieldErrorMessage(errors, message) {
-        if (!errors || errors.length === 0)
-            return undefined;
-        const fallback = {
-            // Angular built-ins declared without a message of their own.
-            min: 'Valore troppo basso',
-            max: 'Valore troppo alto',
-            minLength: 'Testo troppo corto',
-            maxLength: 'Testo troppo lungo',
-            pattern: 'Formato non valido',
-            email: 'Indirizzo email non valido',
-            minDate: 'Data troppo indietro',
-            maxDate: 'Data troppo avanti',
-            parse: 'Valore non valido',
-            matDatepickerParse: 'Data non valida',
-            matDatepickerMin: 'Data troppo indietro',
-            matDatepickerMax: 'Data troppo avanti',
-            matDatepickerFilter: 'Data non selezionabile',
-            matStartDateInvalid: 'Intervallo non valido',
-            matEndDateInvalid: 'Intervallo non valido',
-            matTimepickerParse: 'Orario non valido',
-            matTimepickerMin: 'Orario troppo presto',
-            matTimepickerMax: 'Orario troppo tardi',
-            // The rules of this file, from the single table above: adding a validator there is enough,
-            // and this map can never fall behind it.
-            ...ARS_VALIDATOR_MESSAGES,
-        };
-        message = message ?? errors[0].message ?? fallback[errors[0].kind] ?? '';
-        return message.length > 0 ? message : 'Non valido';
-    }
-}
-
-/*
- * Public API Surface of @arsedizioni/ars-utils/core.validators
- *
- * Template-driven form validators. Kept OUT of `core` on purpose: every one of them pulls in
- * `@angular/forms` (53 KB), and `core` is on the boot path of every application through
- * `ThemeService`, `BroadcastService` and friends. Importing a validator now costs `@angular/forms`
- * only to the lazy chunk that actually uses one.
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+var SignalsUtils = class {
+	static getFieldErrorMessage(errors, message) {
+		if (!errors || errors.length === 0) return void 0;
+		const fallback = {
+			min: "Valore troppo basso",
+			max: "Valore troppo alto",
+			minLength: "Testo troppo corto",
+			maxLength: "Testo troppo lungo",
+			pattern: "Formato non valido",
+			email: "Indirizzo email non valido",
+			minDate: "Data troppo indietro",
+			maxDate: "Data troppo avanti",
+			parse: "Valore non valido",
+			matDatepickerParse: "Data non valida",
+			matDatepickerMin: "Data troppo indietro",
+			matDatepickerMax: "Data troppo avanti",
+			matDatepickerFilter: "Data non selezionabile",
+			matStartDateInvalid: "Intervallo non valido",
+			matEndDateInvalid: "Intervallo non valido",
+			matTimepickerParse: "Orario non valido",
+			matTimepickerMin: "Orario troppo presto",
+			matTimepickerMax: "Orario troppo tardi",
+			...ARS_VALIDATOR_MESSAGES
+		};
+		message = message ?? errors[0].message ?? fallback[errors[0].kind] ?? "";
+		return message.length > 0 ? message : "Non valido";
+	}
+};
 export { ARS_VALIDATOR_MESSAGES, EmailsValidatorDirective, EqualsValidatorDirective, FileSizeValidatorDirective, GuidValidatorDirective, MIN_VALID_YEAR, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, SignalsUtils, SqlDateValidatorDirective, TimeValidatorDirective, UrlValidatorDirective, ValidIfDirective, ValidatorDirective, date, dateRange, emails, equals, fileSize, guid, italianFiscalCode, italianVat, maxTerms, notEmpty, notEqual, notFuture, notPast, otp, password, time, url, validIf };
-//# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map
+
+//# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map