@seniorsistemas/angular-components 19.6.2 → 19.7.0

package/esm2022/inline-edit/lib/inline-edit/fields/inline-edit-number-field.mjs

@@ -34,4 +34,4 @@ export class InlineEditNumberField extends InlineEditField {
         this.placeholder = options.placeholder ?? "";
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/inline-edit/lib/inline-edit/inline-edit.module.mjs

@@ -2,7 +2,7 @@ import { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
 import { FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { TranslateModule } from '@ngx-translate/core';
-import { InputMaskModule } from 'primeng/inputmask';
+import { InputMaskDirective } from '@seniorsistemas/angular-components/input-mask';
 import { InputTextModule } from 'primeng/inputtext';
 import { KeyFilterModule } from 'primeng/keyfilter';
 import { TextareaModule } from 'primeng/textarea';
@@ -43,7 +43,7 @@ export class InlineEditModule {
             ContentGeneratorModule,
             TooltipModule,
             DatepickerComponent,
-            InputMaskModule,
+            InputMaskDirective,
             InputTextModule,
             TextareaModule,
             KeyFilterModule,
@@ -59,7 +59,6 @@ export class InlineEditModule {
             ContentGeneratorModule,
             TooltipModule,
             DatepickerComponent,
-            InputMaskModule,
             InputTextModule,
             TextareaModule,
             KeyFilterModule,
@@ -80,7 +79,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                         ContentGeneratorModule,
                         TooltipModule,
                         DatepickerComponent,
-                        InputMaskModule,
+                        InputMaskDirective,
                         InputTextModule,
                         TextareaModule,
                         KeyFilterModule,
@@ -99,4 +98,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     exports: [InlineEditComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/input-mask/lib/input-mask/input-mask.directive.mjs

@@ -0,0 +1,460 @@
+import { Directive, ElementRef, forwardRef, inject, input, output, Renderer2, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * @description Diretiva de máscara de entrada para campos de texto.
+ *
+ * Aplique `[sInputMask]` em qualquer `<input>` para aplicar uma máscara de formatação,
+ * guiando a entrada do usuário com um padrão definido. Implementa ControlValueAccessor
+ * e Validator para integração nativa com Angular Forms.
+ *
+ * **Slots de máscara:**
+ * - `9` — dígito (0-9)
+ * - `a` — letra (conforme `characterPattern`, padrão `[A-Za-z]`)
+ * - `*` — alfanumérico (letra ou dígito)
+ * - Outros caracteres são tratados como literais (ex: `.`, `-`, `/`, `(`, `)`)
+ * - `?` — tudo após esse ponto na máscara é opcional
+ *
+ * @example
+ * ```html
+ * <!-- CPF -->
+ * <input type="text" [sInputMask]="'999.999.999-99'" [(ngModel)]="cpf" />
+ *
+ * <!-- Telefone com unmask -->
+ * <input type="text" [sInputMask]="'(99) 99999-9999'" [unmask]="true" [(ngModel)]="telefone" />
+ * ```
+ * @category Input
+ */
+export class InputMaskDirective {
+    /**
+     * Padrão da máscara. Slots: `9` (dígito), `a` (letra), `*` (alfanumérico).
+     * Demais caracteres são literais. `?` torna o restante da máscara opcional.
+     */
+    mask = input(undefined, { alias: 'sInputMask' });
+    /**
+     * Caractere exibido nas posições ainda não preenchidas.
+     * @default '_'
+     */
+    slotChar = input('_');
+    /**
+     * Quando `true`, o modelo recebe apenas os caracteres digitados pelo usuário,
+     * sem os literais da máscara. Quando `false`, o modelo recebe o valor completo
+     * incluindo literais.
+     * @default false
+     */
+    unmask = input(false);
+    /**
+     * Expressão regular usada para validar o slot `a` (letra).
+     * @default '[A-Za-z]'
+     */
+    characterPattern = input('[A-Za-z]');
+    /**
+     * Quando `true`, limpa o campo ao perder o foco se a máscara estiver incompleta.
+     * @default true
+     */
+    autoClear = input(true);
+    /**
+     * Emitido quando todos os slots obrigatórios da máscara estão preenchidos.
+     * Emite o valor atual (mascarado ou não, conforme `unmask`).
+     */
+    maskComplete = output();
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    tokens = [];
+    buffer = [];
+    wasComplete = false;
+    lastValue = null;
+    onChange = () => { };
+    onTouched = () => { };
+    ngOnInit() {
+        this.buildMask();
+    }
+    ngOnChanges(changes) {
+        if (changes['mask'] || changes['slotChar'] || changes['characterPattern']) {
+            this.buildMask();
+            if (this.mask()) {
+                this.writeValue(this.lastValue);
+            }
+        }
+    }
+    buildMask() {
+        const maskStr = this.mask();
+        if (!maskStr) {
+            this.tokens = [];
+            this.buffer = [];
+            return;
+        }
+        this.tokens = this.parseMask(maskStr);
+        this.resetBuffer();
+    }
+    parseMask(mask) {
+        const tokens = [];
+        let optional = false;
+        for (let i = 0; i < mask.length; i++) {
+            const ch = mask[i];
+            if (ch === '?') {
+                optional = true;
+                continue;
+            }
+            switch (ch) {
+                case '9':
+                    tokens.push({ type: 'digit', optional });
+                    break;
+                case 'a':
+                    tokens.push({ type: 'alpha', optional });
+                    break;
+                case '*':
+                    tokens.push({ type: 'alphanumeric', optional });
+                    break;
+                default:
+                    tokens.push({ type: 'literal', char: ch, optional: false });
+                    break;
+            }
+        }
+        return tokens;
+    }
+    resetBuffer() {
+        this.buffer = this.tokens.map((t) => (t.type === 'literal' ? t.char : this.slotChar()));
+    }
+    isValidChar(char, token) {
+        switch (token.type) {
+            case 'digit':
+                return /[0-9]/.test(char);
+            case 'alpha':
+                return new RegExp(this.characterPattern()).test(char);
+            case 'alphanumeric':
+                return /[A-Za-z0-9]/.test(char);
+            default:
+                return false;
+        }
+    }
+    isEditable(token) {
+        return token.type !== 'literal';
+    }
+    nextEditablePos(from) {
+        for (let i = from; i < this.tokens.length; i++) {
+            if (this.isEditable(this.tokens[i])) {
+                return i;
+            }
+        }
+        return this.tokens.length;
+    }
+    prevEditablePos(from) {
+        for (let i = from; i >= 0; i--) {
+            if (this.tokens[i] && this.isEditable(this.tokens[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    setCursor(pos) {
+        const safePos = Math.min(pos, this.tokens.length);
+        this.el.nativeElement.setSelectionRange(safePos, safePos);
+    }
+    setInputValue(value) {
+        this.renderer.setProperty(this.el.nativeElement, 'value', value);
+    }
+    getDisplayValue() {
+        return this.buffer.join('');
+    }
+    getBlurDisplayValue() {
+        let lastFilledIndex = -1;
+        for (let i = 0; i < this.buffer.length; i++) {
+            if (this.tokens[i] && this.tokens[i].type !== 'literal' && this.buffer[i] !== this.slotChar()) {
+                lastFilledIndex = i;
+            }
+        }
+        if (lastFilledIndex === -1)
+            return '';
+        return this.buffer.slice(0, lastFilledIndex + 1).join('');
+    }
+    /**
+     * Returns the value that should be set on the model.
+     * Returns null when the user has not typed anything.
+     */
+    getModelValue() {
+        const hasInput = this.buffer.some((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar());
+        if (!hasInput) {
+            return null;
+        }
+        if (this.unmask()) {
+            return (this.buffer
+                .filter((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar())
+                .join('') || null);
+        }
+        return this.buffer.join('');
+    }
+    clearRange(startPos, endPos) {
+        for (let i = startPos; i < endPos; i++) {
+            if (this.tokens[i] && this.tokens[i].type !== 'literal') {
+                this.buffer[i] = this.slotChar();
+            }
+        }
+        this.setInputValue(this.getDisplayValue());
+    }
+    isMaskComplete() {
+        return this.tokens.every((token, i) => {
+            if (token.type === 'literal' || token.optional) {
+                return true;
+            }
+            return this.buffer[i] !== this.slotChar();
+        });
+    }
+    checkAndEmitComplete() {
+        const complete = this.isMaskComplete();
+        if (complete && !this.wasComplete) {
+            this.wasComplete = true;
+            this.maskComplete.emit(this.getModelValue() ?? '');
+        }
+        else if (!complete) {
+            this.wasComplete = false;
+        }
+    }
+    dispatchInputEvent() {
+        this.el.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+    onKeyDown(event) {
+        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return;
+        }
+        const key = event.key;
+        // Let the browser handle shortcuts (Ctrl/Cmd), Tab, and function keys
+        if (event.ctrlKey || event.metaKey || key === 'Tab' || key.startsWith('F')) {
+            return;
+        }
+        // Let the browser handle arrow navigation and Home/End natively
+        if (['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End'].includes(key)) {
+            return;
+        }
+        const input = this.el.nativeElement;
+        const startPos = input.selectionStart ?? 0;
+        const endPos = input.selectionEnd ?? 0;
+        if (key === 'Backspace') {
+            event.preventDefault();
+            if (startPos !== endPos) {
+                this.clearRange(startPos, endPos);
+                const nextPos = this.nextEditablePos(startPos);
+                this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);
+            }
+            else if (startPos > 0) {
+                const pos = this.prevEditablePos(startPos - 1);
+                if (pos >= 0) {
+                    this.buffer[pos] = this.slotChar();
+                    this.setInputValue(this.getDisplayValue());
+                    this.setCursor(pos);
+                }
+            }
+            this.onChange(this.getModelValue());
+            this.checkAndEmitComplete();
+            this.dispatchInputEvent();
+            return;
+        }
+        if (key === 'Delete') {
+            event.preventDefault();
+            if (startPos !== endPos) {
+                this.clearRange(startPos, endPos);
+                const nextPos = this.nextEditablePos(startPos);
+                this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);
+            }
+            else {
+                const pos = this.nextEditablePos(startPos);
+                if (pos < this.tokens.length) {
+                    this.buffer[pos] = this.slotChar();
+                    this.setInputValue(this.getDisplayValue());
+                    this.setCursor(pos);
+                }
+            }
+            this.onChange(this.getModelValue());
+            this.checkAndEmitComplete();
+            this.dispatchInputEvent();
+            return;
+        }
+        // Single printable character
+        if (key.length === 1) {
+            event.preventDefault();
+            let insertPos = startPos;
+            // Clear selection range if any
+            if (startPos !== endPos) {
+                this.clearRange(startPos, endPos);
+                insertPos = startPos;
+            }
+            const pos = this.nextEditablePos(insertPos);
+            if (pos >= this.tokens.length) {
+                return;
+            }
+            const token = this.tokens[pos];
+            if (!this.isValidChar(key, token)) {
+                return;
+            }
+            this.buffer[pos] = key;
+            this.setInputValue(this.getDisplayValue());
+            const next = this.nextEditablePos(pos + 1);
+            this.setCursor(next <= this.tokens.length ? next : this.tokens.length);
+            this.onChange(this.getModelValue());
+            this.checkAndEmitComplete();
+            this.dispatchInputEvent();
+        }
+    }
+    onFocus(_event) {
+        if (!this.mask()) {
+            return;
+        }
+        // Always restore full mask display on focus (slot chars become visible)
+        this.setInputValue(this.getDisplayValue());
+        // Move cursor to the first empty editable slot
+        const firstEmpty = this.buffer.findIndex((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch === this.slotChar());
+        this.setCursor(firstEmpty >= 0 ? firstEmpty : this.nextEditablePos(0));
+    }
+    onBlur(_event) {
+        if (!this.mask()) {
+            return;
+        }
+        this.onTouched();
+        if (!this.isMaskComplete()) {
+            if (this.autoClear()) {
+                this.resetBuffer();
+                this.onChange(null);
+            }
+            this.setInputValue(this.getBlurDisplayValue());
+        }
+    }
+    onPaste(event) {
+        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return;
+        }
+        event.preventDefault();
+        const pastedText = event.clipboardData?.getData('text') ?? '';
+        const input = this.el.nativeElement;
+        const startPos = input.selectionStart ?? 0;
+        const endPos = input.selectionEnd ?? 0;
+        if (startPos !== endPos) {
+            this.clearRange(startPos, endPos);
+        }
+        let pos = this.nextEditablePos(startPos);
+        for (const ch of pastedText) {
+            if (pos >= this.tokens.length) {
+                break;
+            }
+            const token = this.tokens[pos];
+            if (token.type === 'literal') {
+                // Skip matching literal in pasted text; skip the literal slot regardless
+                if (ch === token.char) {
+                    pos++;
+                }
+                pos = this.nextEditablePos(pos);
+                continue;
+            }
+            if (this.isValidChar(ch, token)) {
+                this.buffer[pos] = ch;
+                pos = this.nextEditablePos(pos + 1);
+            }
+        }
+        this.setInputValue(this.getDisplayValue());
+        this.setCursor(pos <= this.tokens.length ? pos : this.tokens.length);
+        this.onChange(this.getModelValue());
+        this.checkAndEmitComplete();
+        this.dispatchInputEvent();
+    }
+    onClick() {
+        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return;
+        }
+        const input = this.el.nativeElement;
+        const pos = input.selectionStart ?? 0;
+        // If cursor landed on a literal, nudge it to the nearest editable slot
+        if (this.tokens[pos] && this.tokens[pos].type === 'literal') {
+            this.setCursor(this.nextEditablePos(pos));
+        }
+    }
+    writeValue(value) {
+        this.lastValue = value;
+        if (!this.mask()) {
+            return;
+        }
+        this.resetBuffer();
+        if (!value) {
+            this.setInputValue('');
+            return;
+        }
+        let bufferIdx = 0;
+        let valueIdx = 0;
+        while (valueIdx < value.length && bufferIdx < this.tokens.length) {
+            const token = this.tokens[bufferIdx];
+            const char = value[valueIdx];
+            if (token.type === 'literal') {
+                // Consume the literal character from value if it matches; always advance buffer
+                if (char === token.char)
+                    valueIdx++;
+                bufferIdx++;
+            }
+            else if (this.isValidChar(char, token)) {
+                this.buffer[bufferIdx] = char;
+                bufferIdx++;
+                valueIdx++;
+            }
+            else {
+                // Skip characters from value that do not match the current slot
+                valueIdx++;
+            }
+        }
+        this.setInputValue(this.getDisplayValue());
+    }
+    registerOnChange(onChange) {
+        this.onChange = onChange;
+    }
+    registerOnTouched(onTouched) {
+        this.onTouched = onTouched;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);
+    }
+    validate(control) {
+        if (!this.mask() || !control.value) {
+            return null;
+        }
+        if (!this.isMaskComplete()) {
+            return { incompleteMask: { mask: this.mask() } };
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: InputMaskDirective, isStandalone: true, selector: "input[sInputMask]", inputs: { mask: { classPropertyName: "mask", publicName: "sInputMask", isSignal: true, isRequired: false, transformFunction: null }, slotChar: { classPropertyName: "slotChar", publicName: "slotChar", isSignal: true, isRequired: false, transformFunction: null }, unmask: { classPropertyName: "unmask", publicName: "unmask", isSignal: true, isRequired: false, transformFunction: null }, characterPattern: { classPropertyName: "characterPattern", publicName: "characterPattern", isSignal: true, isRequired: false, transformFunction: null }, autoClear: { classPropertyName: "autoClear", publicName: "autoClear", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { maskComplete: "maskComplete" }, host: { listeners: { "keydown": "onKeyDown($event)", "focus": "onFocus($event)", "blur": "onBlur($event)", "paste": "onPaste($event)", "click": "onClick()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputMaskDirective),
+                multi: true,
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => InputMaskDirective),
+                multi: true,
+            },
+        ], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[sInputMask]',
+                    standalone: true,
+                    host: {
+                        '(keydown)': 'onKeyDown($event)',
+                        '(focus)': 'onFocus($event)',
+                        '(blur)': 'onBlur($event)',
+                        '(paste)': 'onPaste($event)',
+                        '(click)': 'onClick()',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => InputMaskDirective),
+                            multi: true,
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => InputMaskDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-mask.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/input-mask/src/lib/input-mask/input-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    forwardRef,\n    inject,\n    input,\n    OnChanges,\n    OnInit,\n    output,\n    Renderer2,\n    SimpleChanges,\n} from '@angular/core';\nimport {\n    AbstractControl,\n    ControlValueAccessor,\n    NG_VALIDATORS,\n    NG_VALUE_ACCESSOR,\n    ValidationErrors,\n    Validator,\n} from '@angular/forms';\n\ninterface MaskToken {\n    type: 'literal' | 'digit' | 'alpha' | 'alphanumeric';\n    char?: string;\n    optional: boolean;\n}\n\n/**\n * @description Diretiva de máscara de entrada para campos de texto.\n *\n * Aplique `[sInputMask]` em qualquer `<input>` para aplicar uma máscara de formatação,\n * guiando a entrada do usuário com um padrão definido. Implementa ControlValueAccessor\n * e Validator para integração nativa com Angular Forms.\n *\n * **Slots de máscara:**\n * - `9` — dígito (0-9)\n * - `a` — letra (conforme `characterPattern`, padrão `[A-Za-z]`)\n * - `*` — alfanumérico (letra ou dígito)\n * - Outros caracteres são tratados como literais (ex: `.`, `-`, `/`, `(`, `)`)\n * - `?` — tudo após esse ponto na máscara é opcional\n *\n * @example\n * ```html\n * <!-- CPF -->\n * <input type=\"text\" [sInputMask]=\"'999.999.999-99'\" [(ngModel)]=\"cpf\" />\n *\n * <!-- Telefone com unmask -->\n * <input type=\"text\" [sInputMask]=\"'(99) 99999-9999'\" [unmask]=\"true\" [(ngModel)]=\"telefone\" />\n * ```\n * @category Input\n */\n@Directive({\n    selector: 'input[sInputMask]',\n    standalone: true,\n    host: {\n        '(keydown)': 'onKeyDown($event)',\n        '(focus)': 'onFocus($event)',\n        '(blur)': 'onBlur($event)',\n        '(paste)': 'onPaste($event)',\n        '(click)': 'onClick()',\n    },\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => InputMaskDirective),\n            multi: true,\n        },\n        {\n            provide: NG_VALIDATORS,\n            useExisting: forwardRef(() => InputMaskDirective),\n            multi: true,\n        },\n    ],\n})\nexport class InputMaskDirective implements OnInit, OnChanges, ControlValueAccessor, Validator {\n    /**\n     * Padrão da máscara. Slots: `9` (dígito), `a` (letra), `*` (alfanumérico).\n     * Demais caracteres são literais. `?` torna o restante da máscara opcional.\n     */\n    public mask = input<string | undefined>(undefined, { alias: 'sInputMask' });\n\n    /**\n     * Caractere exibido nas posições ainda não preenchidas.\n     * @default '_'\n     */\n    public slotChar = input<string>('_');\n\n    /**\n     * Quando `true`, o modelo recebe apenas os caracteres digitados pelo usuário,\n     * sem os literais da máscara. Quando `false`, o modelo recebe o valor completo\n     * incluindo literais.\n     * @default false\n     */\n    public unmask = input<boolean>(false);\n\n    /**\n     * Expressão regular usada para validar o slot `a` (letra).\n     * @default '[A-Za-z]'\n     */\n    public characterPattern = input<string>('[A-Za-z]');\n\n    /**\n     * Quando `true`, limpa o campo ao perder o foco se a máscara estiver incompleta.\n     * @default true\n     */\n    public autoClear = input<boolean>(true);\n\n    /**\n     * Emitido quando todos os slots obrigatórios da máscara estão preenchidos.\n     * Emite o valor atual (mascarado ou não, conforme `unmask`).\n     */\n    public maskComplete = output<string>();\n\n    private readonly el = inject(ElementRef<HTMLInputElement>);\n    private readonly renderer = inject(Renderer2);\n\n    private tokens: MaskToken[] = [];\n    private buffer: string[] = [];\n    private wasComplete = false;\n    private lastValue: string | null = null;\n\n    private onChange: (value: string | null) => void = () => {};\n    private onTouched: () => void = () => {};\n\n    public ngOnInit(): void {\n        this.buildMask();\n    }\n\n    public ngOnChanges(changes: SimpleChanges): void {\n        if (changes['mask'] || changes['slotChar'] || changes['characterPattern']) {\n            this.buildMask();\n            if (this.mask()) {\n                this.writeValue(this.lastValue);\n            }\n        }\n    }\n\n    private buildMask(): void {\n        const maskStr = this.mask();\n        if (!maskStr) {\n            this.tokens = [];\n            this.buffer = [];\n            return;\n        }\n        this.tokens = this.parseMask(maskStr);\n        this.resetBuffer();\n    }\n\n    private parseMask(mask: string): MaskToken[] {\n        const tokens: MaskToken[] = [];\n        let optional = false;\n\n        for (let i = 0; i < mask.length; i++) {\n            const ch = mask[i];\n\n            if (ch === '?') {\n                optional = true;\n                continue;\n            }\n\n            switch (ch) {\n                case '9':\n                    tokens.push({ type: 'digit', optional });\n                    break;\n                case 'a':\n                    tokens.push({ type: 'alpha', optional });\n                    break;\n                case '*':\n                    tokens.push({ type: 'alphanumeric', optional });\n                    break;\n                default:\n                    tokens.push({ type: 'literal', char: ch, optional: false });\n                    break;\n            }\n        }\n\n        return tokens;\n    }\n\n    private resetBuffer(): void {\n        this.buffer = this.tokens.map((t) => (t.type === 'literal' ? t.char! : this.slotChar()));\n    }\n\n    private isValidChar(char: string, token: MaskToken): boolean {\n        switch (token.type) {\n            case 'digit':\n                return /[0-9]/.test(char);\n            case 'alpha':\n                return new RegExp(this.characterPattern()).test(char);\n            case 'alphanumeric':\n                return /[A-Za-z0-9]/.test(char);\n            default:\n                return false;\n        }\n    }\n\n    private isEditable(token: MaskToken): boolean {\n        return token.type !== 'literal';\n    }\n\n    private nextEditablePos(from: number): number {\n        for (let i = from; i < this.tokens.length; i++) {\n            if (this.isEditable(this.tokens[i])) {\n                return i;\n            }\n        }\n        return this.tokens.length;\n    }\n\n    private prevEditablePos(from: number): number {\n        for (let i = from; i >= 0; i--) {\n            if (this.tokens[i] && this.isEditable(this.tokens[i])) {\n                return i;\n            }\n        }\n        return -1;\n    }\n\n    private setCursor(pos: number): void {\n        const safePos = Math.min(pos, this.tokens.length);\n        this.el.nativeElement.setSelectionRange(safePos, safePos);\n    }\n\n    private setInputValue(value: string): void {\n        this.renderer.setProperty(this.el.nativeElement, 'value', value);\n    }\n\n    private getDisplayValue(): string {\n        return this.buffer.join('');\n    }\n\n    private getBlurDisplayValue(): string {\n        let lastFilledIndex = -1;\n        for (let i = 0; i < this.buffer.length; i++) {\n            if (this.tokens[i] && this.tokens[i].type !== 'literal' && this.buffer[i] !== this.slotChar()) {\n                lastFilledIndex = i;\n            }\n        }\n        if (lastFilledIndex === -1) return '';\n        return this.buffer.slice(0, lastFilledIndex + 1).join('');\n    }\n\n    /**\n     * Returns the value that should be set on the model.\n     * Returns null when the user has not typed anything.\n     */\n    private getModelValue(): string | null {\n        const hasInput = this.buffer.some(\n            (ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar(),\n        );\n\n        if (!hasInput) {\n            return null;\n        }\n\n        if (this.unmask()) {\n            return (\n                this.buffer\n                    .filter((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar())\n                    .join('') || null\n            );\n        }\n\n        return this.buffer.join('');\n    }\n\n    private clearRange(startPos: number, endPos: number): void {\n        for (let i = startPos; i < endPos; i++) {\n            if (this.tokens[i] && this.tokens[i].type !== 'literal') {\n                this.buffer[i] = this.slotChar();\n            }\n        }\n        this.setInputValue(this.getDisplayValue());\n    }\n\n    private isMaskComplete(): boolean {\n        return this.tokens.every((token, i) => {\n            if (token.type === 'literal' || token.optional) {\n                return true;\n            }\n\n            return this.buffer[i] !== this.slotChar();\n        });\n    }\n\n    private checkAndEmitComplete(): void {\n        const complete = this.isMaskComplete();\n        if (complete && !this.wasComplete) {\n            this.wasComplete = true;\n            this.maskComplete.emit(this.getModelValue() ?? '');\n        } else if (!complete) {\n            this.wasComplete = false;\n        }\n    }\n\n    private dispatchInputEvent(): void {\n        this.el.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));\n    }\n\n    public onKeyDown(event: KeyboardEvent): void {\n        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n            return;\n        }\n\n        const key = event.key;\n\n        // Let the browser handle shortcuts (Ctrl/Cmd), Tab, and function keys\n        if (event.ctrlKey || event.metaKey || key === 'Tab' || key.startsWith('F')) {\n            return;\n        }\n\n        // Let the browser handle arrow navigation and Home/End natively\n        if (['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End'].includes(key)) {\n            return;\n        }\n\n        const input = this.el.nativeElement;\n        const startPos = input.selectionStart ?? 0;\n        const endPos = input.selectionEnd ?? 0;\n\n        if (key === 'Backspace') {\n            event.preventDefault();\n            if (startPos !== endPos) {\n                this.clearRange(startPos, endPos);\n                const nextPos = this.nextEditablePos(startPos);\n                this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);\n            } else if (startPos > 0) {\n                const pos = this.prevEditablePos(startPos - 1);\n                if (pos >= 0) {\n                    this.buffer[pos] = this.slotChar();\n                    this.setInputValue(this.getDisplayValue());\n                    this.setCursor(pos);\n                }\n            }\n            this.onChange(this.getModelValue());\n            this.checkAndEmitComplete();\n            this.dispatchInputEvent();\n            return;\n        }\n\n        if (key === 'Delete') {\n            event.preventDefault();\n            if (startPos !== endPos) {\n                this.clearRange(startPos, endPos);\n                const nextPos = this.nextEditablePos(startPos);\n                this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);\n            } else {\n                const pos = this.nextEditablePos(startPos);\n                if (pos < this.tokens.length) {\n                    this.buffer[pos] = this.slotChar();\n                    this.setInputValue(this.getDisplayValue());\n                    this.setCursor(pos);\n                }\n            }\n            this.onChange(this.getModelValue());\n            this.checkAndEmitComplete();\n            this.dispatchInputEvent();\n            return;\n        }\n\n        // Single printable character\n        if (key.length === 1) {\n            event.preventDefault();\n\n            let insertPos = startPos;\n\n            // Clear selection range if any\n            if (startPos !== endPos) {\n                this.clearRange(startPos, endPos);\n                insertPos = startPos;\n            }\n\n            const pos = this.nextEditablePos(insertPos);\n            if (pos >= this.tokens.length) {\n                return;\n            }\n\n            const token = this.tokens[pos];\n\n            if (!this.isValidChar(key, token)) {\n                return;\n            }\n\n            this.buffer[pos] = key;\n            this.setInputValue(this.getDisplayValue());\n\n            const next = this.nextEditablePos(pos + 1);\n            this.setCursor(next <= this.tokens.length ? next : this.tokens.length);\n\n            this.onChange(this.getModelValue());\n            this.checkAndEmitComplete();\n            this.dispatchInputEvent();\n        }\n    }\n\n    public onFocus(_event: FocusEvent): void {\n        if (!this.mask()) {\n            return;\n        }\n\n        // Always restore full mask display on focus (slot chars become visible)\n        this.setInputValue(this.getDisplayValue());\n\n        // Move cursor to the first empty editable slot\n        const firstEmpty = this.buffer.findIndex(\n            (ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch === this.slotChar(),\n        );\n\n        this.setCursor(firstEmpty >= 0 ? firstEmpty : this.nextEditablePos(0));\n    }\n\n    public onBlur(_event: Event): void {\n        if (!this.mask()) {\n            return;\n        }\n\n        this.onTouched();\n\n        if (!this.isMaskComplete()) {\n            if (this.autoClear()) {\n                this.resetBuffer();\n                this.onChange(null);\n            }\n            this.setInputValue(this.getBlurDisplayValue());\n        }\n    }\n\n    public onPaste(event: ClipboardEvent): void {\n        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n            return;\n        }\n\n        event.preventDefault();\n\n        const pastedText = event.clipboardData?.getData('text') ?? '';\n        const input = this.el.nativeElement;\n        const startPos = input.selectionStart ?? 0;\n        const endPos = input.selectionEnd ?? 0;\n\n        if (startPos !== endPos) {\n            this.clearRange(startPos, endPos);\n        }\n\n        let pos = this.nextEditablePos(startPos);\n\n        for (const ch of pastedText) {\n            if (pos >= this.tokens.length) {\n                break;\n            }\n\n            const token = this.tokens[pos];\n\n            if (token.type === 'literal') {\n                // Skip matching literal in pasted text; skip the literal slot regardless\n                if (ch === token.char) {\n                    pos++;\n                }\n                pos = this.nextEditablePos(pos);\n                continue;\n            }\n\n            if (this.isValidChar(ch, token)) {\n                this.buffer[pos] = ch;\n                pos = this.nextEditablePos(pos + 1);\n            }\n        }\n\n        this.setInputValue(this.getDisplayValue());\n        this.setCursor(pos <= this.tokens.length ? pos : this.tokens.length);\n        this.onChange(this.getModelValue());\n        this.checkAndEmitComplete();\n        this.dispatchInputEvent();\n    }\n\n    public onClick(): void {\n        if (!this.mask() || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n            return;\n        }\n\n        const input = this.el.nativeElement;\n        const pos = input.selectionStart ?? 0;\n\n        // If cursor landed on a literal, nudge it to the nearest editable slot\n        if (this.tokens[pos] && this.tokens[pos].type === 'literal') {\n            this.setCursor(this.nextEditablePos(pos));\n        }\n    }\n\n    public writeValue(value: string | null): void {\n        this.lastValue = value;\n\n        if (!this.mask()) {\n            return;\n        }\n\n        this.resetBuffer();\n\n        if (!value) {\n            this.setInputValue('');\n            return;\n        }\n\n        let bufferIdx = 0;\n        let valueIdx = 0;\n\n        while (valueIdx < value.length && bufferIdx < this.tokens.length) {\n            const token = this.tokens[bufferIdx];\n            const char = value[valueIdx];\n\n            if (token.type === 'literal') {\n                // Consume the literal character from value if it matches; always advance buffer\n                if (char === token.char) valueIdx++;\n                bufferIdx++;\n            } else if (this.isValidChar(char, token)) {\n                this.buffer[bufferIdx] = char;\n                bufferIdx++;\n                valueIdx++;\n            } else {\n                // Skip characters from value that do not match the current slot\n                valueIdx++;\n            }\n        }\n\n        this.setInputValue(this.getDisplayValue());\n    }\n\n    public registerOnChange(onChange: (value: string | null) => void): void {\n        this.onChange = onChange;\n    }\n\n    public registerOnTouched(onTouched: () => void): void {\n        this.onTouched = onTouched;\n    }\n\n    public setDisabledState(isDisabled: boolean): void {\n        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);\n    }\n\n    public validate(control: AbstractControl): ValidationErrors | null {\n        if (!this.mask() || !control.value) {\n            return null;\n        }\n\n        if (!this.isMaskComplete()) {\n            return { incompleteMask: { mask: this.mask() } };\n        }\n\n        return null;\n    }\n}\n\n"]}