@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/directives/line-clamp/line-clamp.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { LineClampTargetDirective, LineClampDirective, DeprecatedLineClampDirective, DeprecatedLineClampTargetDirective } from './line-clamp.directive';
+import * as i0 from "@angular/core";
+export class LineClampModule {
+}
+LineClampModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: LineClampModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LineClampModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: LineClampModule, imports: [LineClampTargetDirective,
+        LineClampDirective,
+        DeprecatedLineClampDirective,
+        DeprecatedLineClampTargetDirective], exports: [LineClampTargetDirective,
+        LineClampDirective,
+        DeprecatedLineClampDirective,
+        DeprecatedLineClampTargetDirective] });
+LineClampModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: LineClampModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: LineClampModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        LineClampTargetDirective,
+                        LineClampDirective,
+                        DeprecatedLineClampDirective,
+                        DeprecatedLineClampTargetDirective
+                    ],
+                    exports: [
+                        LineClampTargetDirective,
+                        LineClampDirective,
+                        DeprecatedLineClampDirective,
+                        DeprecatedLineClampTargetDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluZS1jbGFtcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvbGluZS1jbGFtcC9saW5lLWNsYW1wLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFDSCx3QkFBd0IsRUFDeEIsa0JBQWtCLEVBQ2xCLDRCQUE0QixFQUM1QixrQ0FBa0MsRUFDckMsTUFBTSx3QkFBd0IsQ0FBQzs7QUFnQmhDLE1BQU0sT0FBTyxlQUFlOzs0R0FBZixlQUFlOzZHQUFmLGVBQWUsWUFacEIsd0JBQXdCO1FBQ3hCLGtCQUFrQjtRQUNsQiw0QkFBNEI7UUFDNUIsa0NBQWtDLGFBR2xDLHdCQUF3QjtRQUN4QixrQkFBa0I7UUFDbEIsNEJBQTRCO1FBQzVCLGtDQUFrQzs2R0FHN0IsZUFBZTsyRkFBZixlQUFlO2tCQWQzQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRTt3QkFDTCx3QkFBd0I7d0JBQ3hCLGtCQUFrQjt3QkFDbEIsNEJBQTRCO3dCQUM1QixrQ0FBa0M7cUJBQ3JDO29CQUNELE9BQU8sRUFBRTt3QkFDTCx3QkFBd0I7d0JBQ3hCLGtCQUFrQjt3QkFDbEIsNEJBQTRCO3dCQUM1QixrQ0FBa0M7cUJBQ3JDO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHtcbiAgICBMaW5lQ2xhbXBUYXJnZXREaXJlY3RpdmUsXG4gICAgTGluZUNsYW1wRGlyZWN0aXZlLFxuICAgIERlcHJlY2F0ZWRMaW5lQ2xhbXBEaXJlY3RpdmUsXG4gICAgRGVwcmVjYXRlZExpbmVDbGFtcFRhcmdldERpcmVjdGl2ZVxufSBmcm9tICcuL2xpbmUtY2xhbXAuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIExpbmVDbGFtcFRhcmdldERpcmVjdGl2ZSxcbiAgICAgICAgTGluZUNsYW1wRGlyZWN0aXZlLFxuICAgICAgICBEZXByZWNhdGVkTGluZUNsYW1wRGlyZWN0aXZlLFxuICAgICAgICBEZXByZWNhdGVkTGluZUNsYW1wVGFyZ2V0RGlyZWN0aXZlXG4gICAgXSxcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIExpbmVDbGFtcFRhcmdldERpcmVjdGl2ZSxcbiAgICAgICAgTGluZUNsYW1wRGlyZWN0aXZlLFxuICAgICAgICBEZXByZWNhdGVkTGluZUNsYW1wRGlyZWN0aXZlLFxuICAgICAgICBEZXByZWNhdGVkTGluZUNsYW1wVGFyZ2V0RGlyZWN0aXZlXG4gICAgXVxufSlcbmV4cG9ydCBjbGFzcyBMaW5lQ2xhbXBNb2R1bGUge31cbiJdfQ==

package/esm2020/utils/directives/only-digits/only-digits.directive.mjs

@@ -0,0 +1,218 @@
+import { A, BACKSPACE, C, DASH, DELETE, END, ENTER, ESCAPE, HOME, LEFT_ARROW, NUMPAD_MINUS, RIGHT_ARROW, TAB, V, X } from '@angular/cdk/keycodes';
+import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import { KeyUtil } from '../../functions';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export class DeprecatedOnlyDigitsDirective extends DeprecatedSelector {
+}
+DeprecatedOnlyDigitsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOnlyDigitsDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedOnlyDigitsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedOnlyDigitsDirective, isStandalone: true, selector: "[fdOnlyDigits], [fd-only-digits]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkOnlyDigits]', '[fdOnlyDigits], [fd-only-digits]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOnlyDigitsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fdOnlyDigits], [fd-only-digits]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkOnlyDigits]', '[fdOnlyDigits], [fd-only-digits]')
+                        }
+                    ]
+                }]
+        }] });
+export class OnlyDigitsDirective {
+    /** @hidden */
+    constructor(_el) {
+        this._el = _el;
+        /** Allow using decimal */
+        this.decimal = false;
+        /** Define decimal separator
+         * Default: .(dot)
+         */
+        this.decimalSeparator = '.';
+        /** @hidden */
+        this._hasDecimalPoint = false;
+        this._inputElement = this._el.nativeElement;
+    }
+    /** @hidden */
+    onKeyDown(e) {
+        if (
+        // Allow: Delete, Backspace, Tab, Escape, Enter, End, Home, Arrow Left, Arrow Right
+        KeyUtil.isKeyCode(e, [DELETE, BACKSPACE, TAB, ESCAPE, ENTER, END, HOME, LEFT_ARROW, RIGHT_ARROW]) ||
+            // Allow: Ctrl+(A/C/V/X) and Cmd+(A/C/V/X) (Mac)
+            (KeyUtil.isKeyCode(e, [A, C, V, X]) && (e.ctrlKey || e.metaKey))) {
+            return; // let it happen, don't do anything
+        }
+        if (KeyUtil.isKeyCode(e, [DASH, NUMPAD_MINUS])) {
+            const newValue = this._forecastValue(e.key);
+            if (this._inputElement.value[0] === '-' || newValue[0] !== '-') {
+                e.preventDefault();
+                return; // has DASH point
+            }
+            else {
+                return; // Allow: only one DASH point
+            }
+        }
+        if (this.decimal && e.key === this.decimalSeparator) {
+            const newValue = this._forecastValue(e.key);
+            if (newValue.split(this.decimalSeparator).length > 2) {
+                // has two or more decimal points
+                e.preventDefault();
+                return;
+            }
+            else {
+                this._hasDecimalPoint = newValue.indexOf(this.decimalSeparator) > -1;
+                return; // Allow: only one decimal point
+            }
+        }
+        // Ensure that it is a number and stop the keypress
+        if (e.key === ' ' || isNaN(Number(e.key))) {
+            e.preventDefault();
+            return;
+        }
+    }
+    /** @hidden */
+    onPaste(event) {
+        if (window['clipboardData']) {
+            // Browser is IE
+            this._pasteData(window['clipboardData'].getData('text'));
+        }
+        else if (event.clipboardData && event.clipboardData.getData) {
+            // Other browsers
+            this._pasteData(event.clipboardData.getData('text/plain'));
+        }
+        event.preventDefault();
+    }
+    /** @hidden */
+    onDrop(event) {
+        const textData = event.dataTransfer?.getData('text') ?? '';
+        this._inputElement.focus();
+        this._pasteData(textData);
+        event.preventDefault();
+    }
+    /** @hidden */
+    _pasteData(pastedContent) {
+        const sanitizedContent = this._sanitizeInput(pastedContent);
+        const pasted = document.execCommand('insertText', false, sanitizedContent);
+        if (!pasted) {
+            if (this._inputElement.setRangeText) {
+                const { selectionStart: start, selectionEnd: end } = this._inputElement;
+                this._inputElement.setRangeText(sanitizedContent, start ?? 0, end ?? 0, 'end');
+                // Angular's Reactive Form relies on "input" event, but on Firefox, the setRangeText method doesn't trigger it
+                // so we have to trigger it ourself.
+                if (typeof window['InstallTrigger'] !== 'undefined') {
+                    this._inputElement.dispatchEvent(new Event('input', { cancelable: true }));
+                }
+            }
+            else {
+                // Browser does not support setRangeText, e.g. IE
+                this._insertAtCursor(this._inputElement, sanitizedContent);
+            }
+        }
+        if (this.decimal) {
+            this._hasDecimalPoint = this._inputElement.value.indexOf(this.decimalSeparator) > -1;
+        }
+    }
+    // The following 2 methods were added from the below article for browsers that do not support setRangeText
+    // https://stackoverflow.com/questions/11076975/how-to-insert-text-into-the-textarea-at-the-current-cursor-position
+    /** @hidden */
+    _insertAtCursor(myField, myValue) {
+        const startPos = myField.selectionStart ?? 0;
+        const endPos = myField.selectionEnd ?? 0;
+        myField.value =
+            myField.value.substring(0, startPos) + myValue + myField.value.substring(endPos, myField.value.length);
+        const pos = startPos + myValue.length;
+        myField.focus();
+        myField.setSelectionRange(pos, pos);
+        this._triggerEvent(myField, 'input');
+    }
+    /** @hidden */
+    _triggerEvent(el, type) {
+        if ('createEvent' in document) {
+            // modern browsers, IE9+
+            const e = document.createEvent('HTMLEvents');
+            e.initEvent(type, false, true);
+            el.dispatchEvent(e);
+        }
+    }
+    // end stack overflow code
+    /** @hidden */
+    _sanitizeInput(input) {
+        let result = '';
+        if (this.decimal && this._isValidDecimal(input)) {
+            const regex = new RegExp(`[^0-9${this.decimalSeparator}]`, 'g');
+            result = input.replace(regex, '');
+        }
+        else {
+            result = input.replace(/[^0-9]/g, '');
+        }
+        if (input[0] === '-') {
+            result = `-${result}`;
+        }
+        const maxLength = this._inputElement.maxLength;
+        if (maxLength > 0) {
+            // the input element has maxLength limit
+            const allowedLength = maxLength - this._inputElement.value.length;
+            result = allowedLength > 0 ? result.substring(0, allowedLength) : '';
+        }
+        return result;
+    }
+    /** @hidden */
+    _isValidDecimal(string) {
+        if (!this._hasDecimalPoint) {
+            return string.split(this.decimalSeparator).length <= 2;
+        }
+        else {
+            // the input element already has a decimal separator
+            const selectedText = this._getSelection;
+            if (selectedText && selectedText.indexOf(this.decimalSeparator) > -1) {
+                return string.split(this.decimalSeparator).length <= 2;
+            }
+            else {
+                return string.indexOf(this.decimalSeparator) < 0;
+            }
+        }
+    }
+    /** @hidden */
+    get _getSelection() {
+        const { selectionStart, selectionEnd } = this._inputElement;
+        return this._inputElement.value.substring(selectionStart ?? 0, selectionEnd ?? 0);
+    }
+    /** @hidden */
+    _forecastValue(key) {
+        const { selectionStart, selectionEnd, value: oldValue } = this._inputElement;
+        const selection = oldValue.substring(selectionStart ?? 0, selectionEnd ?? 0);
+        return selection
+            ? oldValue.replace(selection, key)
+            : oldValue.substring(0, selectionStart ?? 0) + key + oldValue.substring(selectionStart ?? 0);
+    }
+}
+OnlyDigitsDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+OnlyDigitsDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: OnlyDigitsDirective, isStandalone: true, selector: "[fdkOnlyDigits], [fdOnlyDigits], [fd-only-digits]", inputs: { decimal: "decimal", decimalSeparator: "decimalSeparator" }, host: { listeners: { "keydown": "onKeyDown($event)", "paste": "onPaste($event)", "drop": "onDrop($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkOnlyDigits], [fdOnlyDigits], [fd-only-digits]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { decimal: [{
+                type: Input
+            }], decimalSeparator: [{
+                type: Input
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"only-digits.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/only-digits/only-digits.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    A,\n    BACKSPACE,\n    C,\n    DASH,\n    DELETE,\n    END,\n    ENTER,\n    ESCAPE,\n    HOME,\n    LEFT_ARROW,\n    NUMPAD_MINUS,\n    RIGHT_ARROW,\n    TAB,\n    V,\n    X\n} from '@angular/cdk/keycodes';\nimport { Directive, ElementRef, HostListener, Input } from '@angular/core';\nimport { KeyUtil } from '../../functions';\nimport {\n    DeprecatedSelector,\n    FD_DEPRECATED_DIRECTIVE_SELECTOR,\n    getDeprecatedModel\n} from '../../deprecated-selector.class';\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[fdOnlyDigits], [fd-only-digits]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel('[fdkOnlyDigits]', '[fdOnlyDigits], [fd-only-digits]')\n        }\n    ]\n})\nexport class DeprecatedOnlyDigitsDirective extends DeprecatedSelector {}\n\n@Directive({\n    selector: '[fdkOnlyDigits], [fdOnlyDigits], [fd-only-digits]',\n    standalone: true\n})\nexport class OnlyDigitsDirective {\n    /** Allow using decimal */\n    @Input() decimal = false;\n    /** Define decimal separator\n     * Default: .(dot)\n     */\n    @Input() decimalSeparator = '.';\n\n    /** @hidden */\n    private _inputElement: HTMLInputElement;\n    /** @hidden */\n    private _hasDecimalPoint = false;\n\n    /** @hidden */\n    constructor(private readonly _el: ElementRef) {\n        this._inputElement = this._el.nativeElement;\n    }\n\n    /** @hidden */\n    @HostListener('keydown', ['$event'])\n    onKeyDown(e: KeyboardEvent): void {\n        if (\n            // Allow: Delete, Backspace, Tab, Escape, Enter, End, Home, Arrow Left, Arrow Right\n            KeyUtil.isKeyCode(e, [DELETE, BACKSPACE, TAB, ESCAPE, ENTER, END, HOME, LEFT_ARROW, RIGHT_ARROW]) ||\n            // Allow: Ctrl+(A/C/V/X) and Cmd+(A/C/V/X) (Mac)\n            (KeyUtil.isKeyCode(e, [A, C, V, X]) && (e.ctrlKey || e.metaKey))\n        ) {\n            return; // let it happen, don't do anything\n        }\n\n        if (KeyUtil.isKeyCode(e, [DASH, NUMPAD_MINUS])) {\n            const newValue = this._forecastValue(e.key);\n\n            if (this._inputElement.value[0] === '-' || newValue[0] !== '-') {\n                e.preventDefault();\n\n                return; // has DASH point\n            } else {\n                return; // Allow: only one DASH point\n            }\n        }\n\n        if (this.decimal && e.key === this.decimalSeparator) {\n            const newValue = this._forecastValue(e.key);\n            if (newValue.split(this.decimalSeparator).length > 2) {\n                // has two or more decimal points\n                e.preventDefault();\n                return;\n            } else {\n                this._hasDecimalPoint = newValue.indexOf(this.decimalSeparator) > -1;\n                return; // Allow: only one decimal point\n            }\n        }\n\n        // Ensure that it is a number and stop the keypress\n        if (e.key === ' ' || isNaN(Number(e.key))) {\n            e.preventDefault();\n            return;\n        }\n    }\n\n    /** @hidden */\n    @HostListener('paste', ['$event'])\n    onPaste(event: any): void {\n        if (window['clipboardData']) {\n            // Browser is IE\n            this._pasteData(window['clipboardData'].getData('text'));\n        } else if (event.clipboardData && event.clipboardData.getData) {\n            // Other browsers\n            this._pasteData(event.clipboardData.getData('text/plain'));\n        }\n\n        event.preventDefault();\n    }\n\n    /** @hidden */\n    @HostListener('drop', ['$event'])\n    onDrop(event: DragEvent): void {\n        const textData = event.dataTransfer?.getData('text') ?? '';\n        this._inputElement.focus();\n        this._pasteData(textData);\n\n        event.preventDefault();\n    }\n\n    /** @hidden */\n    private _pasteData(pastedContent: string): void {\n        const sanitizedContent = this._sanitizeInput(pastedContent);\n        const pasted = document.execCommand('insertText', false, sanitizedContent);\n        if (!pasted) {\n            if (this._inputElement.setRangeText) {\n                const { selectionStart: start, selectionEnd: end } = this._inputElement;\n                this._inputElement.setRangeText(sanitizedContent, start ?? 0, end ?? 0, 'end');\n                // Angular's Reactive Form relies on \"input\" event, but on Firefox, the setRangeText method doesn't trigger it\n                // so we have to trigger it ourself.\n                if (typeof window['InstallTrigger'] !== 'undefined') {\n                    this._inputElement.dispatchEvent(new Event('input', { cancelable: true }));\n                }\n            } else {\n                // Browser does not support setRangeText, e.g. IE\n                this._insertAtCursor(this._inputElement, sanitizedContent);\n            }\n        }\n\n        if (this.decimal) {\n            this._hasDecimalPoint = this._inputElement.value.indexOf(this.decimalSeparator) > -1;\n        }\n    }\n\n    // The following 2 methods were added from the below article for browsers that do not support setRangeText\n    // https://stackoverflow.com/questions/11076975/how-to-insert-text-into-the-textarea-at-the-current-cursor-position\n    /** @hidden */\n    private _insertAtCursor(myField: HTMLInputElement, myValue: string): void {\n        const startPos = myField.selectionStart ?? 0;\n        const endPos = myField.selectionEnd ?? 0;\n\n        myField.value =\n            myField.value.substring(0, startPos) + myValue + myField.value.substring(endPos, myField.value.length);\n\n        const pos = startPos + myValue.length;\n        myField.focus();\n        myField.setSelectionRange(pos, pos);\n\n        this._triggerEvent(myField, 'input');\n    }\n\n    /** @hidden */\n    private _triggerEvent(el: HTMLInputElement, type: string): void {\n        if ('createEvent' in document) {\n            // modern browsers, IE9+\n            const e = document.createEvent('HTMLEvents');\n            e.initEvent(type, false, true);\n            el.dispatchEvent(e);\n        }\n    }\n    // end stack overflow code\n\n    /** @hidden */\n    private _sanitizeInput(input: string): string {\n        let result = '';\n        if (this.decimal && this._isValidDecimal(input)) {\n            const regex = new RegExp(`[^0-9${this.decimalSeparator}]`, 'g');\n            result = input.replace(regex, '');\n        } else {\n            result = input.replace(/[^0-9]/g, '');\n        }\n\n        if (input[0] === '-') {\n            result = `-${result}`;\n        }\n\n        const maxLength = this._inputElement.maxLength;\n        if (maxLength > 0) {\n            // the input element has maxLength limit\n            const allowedLength = maxLength - this._inputElement.value.length;\n            result = allowedLength > 0 ? result.substring(0, allowedLength) : '';\n        }\n\n        return result;\n    }\n\n    /** @hidden */\n    private _isValidDecimal(string: string): boolean {\n        if (!this._hasDecimalPoint) {\n            return string.split(this.decimalSeparator).length <= 2;\n        } else {\n            // the input element already has a decimal separator\n            const selectedText = this._getSelection;\n            if (selectedText && selectedText.indexOf(this.decimalSeparator) > -1) {\n                return string.split(this.decimalSeparator).length <= 2;\n            } else {\n                return string.indexOf(this.decimalSeparator) < 0;\n            }\n        }\n    }\n\n    /** @hidden */\n    private get _getSelection(): string {\n        const { selectionStart, selectionEnd } = this._inputElement;\n\n        return this._inputElement.value.substring(selectionStart ?? 0, selectionEnd ?? 0);\n    }\n\n    /** @hidden */\n    private _forecastValue(key: string): string {\n        const { selectionStart, selectionEnd, value: oldValue } = this._inputElement;\n        const selection = oldValue.substring(selectionStart ?? 0, selectionEnd ?? 0);\n\n        return selection\n            ? oldValue.replace(selection, key)\n            : oldValue.substring(0, selectionStart ?? 0) + key + oldValue.substring(selectionStart ?? 0);\n    }\n}\n"]}

package/esm2020/utils/directives/only-digits/only-digits.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { OnlyDigitsDirective, DeprecatedOnlyDigitsDirective } from './only-digits.directive';
+import * as i0 from "@angular/core";
+export class OnlyDigitsModule {
+}
+OnlyDigitsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OnlyDigitsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsModule, imports: [OnlyDigitsDirective, DeprecatedOnlyDigitsDirective], exports: [OnlyDigitsDirective, DeprecatedOnlyDigitsDirective] });
+OnlyDigitsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OnlyDigitsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OnlyDigitsDirective, DeprecatedOnlyDigitsDirective],
+                    exports: [OnlyDigitsDirective, DeprecatedOnlyDigitsDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25seS1kaWdpdHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL29ubHktZGlnaXRzL29ubHktZGlnaXRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQU03RixNQUFNLE9BQU8sZ0JBQWdCOzs2R0FBaEIsZ0JBQWdCOzhHQUFoQixnQkFBZ0IsWUFIZixtQkFBbUIsRUFBRSw2QkFBNkIsYUFDbEQsbUJBQW1CLEVBQUUsNkJBQTZCOzhHQUVuRCxnQkFBZ0I7MkZBQWhCLGdCQUFnQjtrQkFKNUIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsRUFBRSw2QkFBNkIsQ0FBQztvQkFDN0QsT0FBTyxFQUFFLENBQUMsbUJBQW1CLEVBQUUsNkJBQTZCLENBQUM7aUJBQ2hFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgT25seURpZ2l0c0RpcmVjdGl2ZSwgRGVwcmVjYXRlZE9ubHlEaWdpdHNEaXJlY3RpdmUgfSBmcm9tICcuL29ubHktZGlnaXRzLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW09ubHlEaWdpdHNEaXJlY3RpdmUsIERlcHJlY2F0ZWRPbmx5RGlnaXRzRGlyZWN0aXZlXSxcbiAgICBleHBvcnRzOiBbT25seURpZ2l0c0RpcmVjdGl2ZSwgRGVwcmVjYXRlZE9ubHlEaWdpdHNEaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIE9ubHlEaWdpdHNNb2R1bGUge31cbiJdfQ==

package/esm2020/utils/directives/overflow-list/overflow-list-item.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive, ElementRef } from '@angular/core';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+export class DeprecatedOverflowListItemDirective extends DeprecatedSelector {
+}
+DeprecatedOverflowListItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOverflowListItemDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedOverflowListItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedOverflowListItemDirective, isStandalone: true, selector: "[fdOverflowListItem], [fd-overflow-list-item]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkOverflowListItem]', '[fdOverflowListItem], [fd-overflow-list-item]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOverflowListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fdOverflowListItem], [fd-overflow-list-item]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkOverflowListItem]', '[fdOverflowListItem], [fd-overflow-list-item]')
+                        }
+                    ]
+                }]
+        }] });
+export class OverflowListItemDirective {
+    /** @hidden */
+    constructor(el) {
+        this.el = el;
+    }
+}
+OverflowListItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListItemDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+OverflowListItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: OverflowListItemDirective, isStandalone: true, selector: "[fdkOverflowListItem], [fdOverflowListItem], [fd-overflow-list-item]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkOverflowListItem], [fdOverflowListItem], [fd-overflow-list-item]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/directives/overflow-list/overflow-list.directive.mjs

@@ -0,0 +1,140 @@
+import { ContentChildren, Directive, ElementRef, EventEmitter, Input, NgZone, Output, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { OverflowListItemDirective } from './overflow-list-item.directive';
+import { ViewportRuler } from '@angular/cdk/overlay';
+import { DeprecatedSelector, FD_DEPRECATED_DIRECTIVE_SELECTOR, getDeprecatedModel } from '../../deprecated-selector.class';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class DeprecatedOverflowListDirective extends DeprecatedSelector {
+}
+DeprecatedOverflowListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOverflowListDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DeprecatedOverflowListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: DeprecatedOverflowListDirective, isStandalone: true, selector: "[fdOverflowList], [fd-overflow-list]", providers: [
+        {
+            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+            useValue: getDeprecatedModel('[fdkOverflowList]', '[fdOverflowList], [fd-overflow-list]')
+        }
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DeprecatedOverflowListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[fdOverflowList], [fd-overflow-list]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,
+                            useValue: getDeprecatedModel('[fdkOverflowList]', '[fdOverflowList], [fd-overflow-list]')
+                        }
+                    ]
+                }]
+        }] });
+export class OverflowListDirective {
+    /** @hidden */
+    constructor(_el, _viewportRuler, _ngZone) {
+        this._el = _el;
+        this._viewportRuler = _viewportRuler;
+        this._ngZone = _ngZone;
+        /**
+         * @description Offset to calculate correct position
+         */
+        this.overflowOffset = 0;
+        /**
+         * @description value of display property of existed list items
+         */
+        this.itemCssBlockValue = 'flex';
+        /**
+         * @description Emits when changed amount of extra items
+         */
+        this.overflowChanged = new EventEmitter();
+        /** @hidden */
+        this._onDestroy$ = new Subject();
+    }
+    /** @hidden */
+    ngAfterViewInit() {
+        this._viewportRuler
+            .change(50)
+            .pipe(takeUntil(this._onDestroy$))
+            // ViewportRuler invoked out of zone, that is why I need to invoke function in zone
+            .subscribe(() => this._ngZone.run(() => this._calculateAmountOfOverflowedItems()));
+        this._calculateAmountOfOverflowedItems();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /**
+     * @description Get amount of extra items in current list
+     * */
+    getAmountOfExtraItems() {
+        const elements = this.overflowItems.toArray().map((item) => item.el.nativeElement);
+        const computed = getComputedStyle(this._el.nativeElement);
+        const contentWidth = this._el.nativeElement.clientWidth - parseFloat(computed.paddingLeft) - parseFloat(computed.paddingRight);
+        return this._checkWidthWithOffset(elements, contentWidth);
+    }
+    /** @hidden */
+    _calculateAmountOfOverflowedItems() {
+        const extra = this.getAmountOfExtraItems();
+        this.overflowChanged.emit(extra);
+    }
+    /**
+     * @hidden
+     * @param arrItems
+     * @param containerWidth
+     * @param checkWithOffset
+     * */
+    _checkWidthWithOffset(arrItems, containerWidth, checkWithOffset = false) {
+        let itemsTotalWidth = 0;
+        const parentWidth = checkWithOffset ? containerWidth - this.overflowOffset : containerWidth;
+        arrItems.forEach((item) => {
+            item.hidden = true;
+            item.style.display = this.itemCssBlockValue;
+        });
+        for (let i = 0; i < arrItems.length; i++) {
+            const item = arrItems[i];
+            itemsTotalWidth += this.isRtl
+                ? containerWidth - item.offsetLeft - itemsTotalWidth
+                : item.offsetWidth + item.offsetLeft - itemsTotalWidth;
+            if (parentWidth < itemsTotalWidth) {
+                this._clearTempStyles(arrItems);
+                return checkWithOffset
+                    ? arrItems.length - i
+                    : this._checkWidthWithOffset(arrItems, containerWidth, true);
+            }
+        }
+        this._clearTempStyles(arrItems);
+        return 0;
+    }
+    /**
+     * @param arrItems
+     * @hidden
+     * */
+    _clearTempStyles(arrItems) {
+        arrItems.forEach((item) => {
+            item.hidden = false;
+            item.style.removeProperty('display');
+        });
+    }
+}
+OverflowListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListDirective, deps: [{ token: i0.ElementRef }, { token: i1.ViewportRuler }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+OverflowListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: OverflowListDirective, isStandalone: true, selector: "[fdkOverflowList], [fdOverflowList], [fd-overflow-list]", inputs: { overflowOffset: "overflowOffset", isRtl: "isRtl", itemCssBlockValue: "itemCssBlockValue" }, outputs: { overflowChanged: "overflowChanged" }, queries: [{ propertyName: "overflowItems", predicate: OverflowListItemDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fdkOverflowList], [fdOverflowList], [fd-overflow-list]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ViewportRuler }, { type: i0.NgZone }]; }, propDecorators: { overflowOffset: [{
+                type: Input
+            }], isRtl: [{
+                type: Input
+            }], itemCssBlockValue: [{
+                type: Input
+            }], overflowChanged: [{
+                type: Output
+            }], overflowItems: [{
+                type: ContentChildren,
+                args: [OverflowListItemDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overflow-list.directive.js","sourceRoot":"","sources":["../../../../../../../libs/cdk/src/lib/utils/directives/overflow-list/overflow-list.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    ContentChildren,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    Input,\n    NgZone,\n    OnDestroy,\n    Output,\n    QueryList\n} from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { OverflowListItemDirective } from './overflow-list-item.directive';\nimport { ViewportRuler } from '@angular/cdk/overlay';\nimport {\n    DeprecatedSelector,\n    FD_DEPRECATED_DIRECTIVE_SELECTOR,\n    getDeprecatedModel\n} from '../../deprecated-selector.class';\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: '[fdOverflowList], [fd-overflow-list]',\n    standalone: true,\n    providers: [\n        {\n            provide: FD_DEPRECATED_DIRECTIVE_SELECTOR,\n            useValue: getDeprecatedModel('[fdkOverflowList]', '[fdOverflowList], [fd-overflow-list]')\n        }\n    ]\n})\nexport class DeprecatedOverflowListDirective extends DeprecatedSelector {}\n\n@Directive({\n    selector: '[fdkOverflowList], [fdOverflowList], [fd-overflow-list]',\n    standalone: true\n})\nexport class OverflowListDirective implements AfterViewInit, OnDestroy {\n    /**\n     * @description Offset to calculate correct position\n     */\n    @Input()\n    overflowOffset = 0;\n\n    /**\n     * @description Flag representing rtl mode\n     */\n    @Input()\n    isRtl: boolean;\n\n    /**\n     * @description value of display property of existed list items\n     */\n    @Input()\n    itemCssBlockValue = 'flex';\n\n    /**\n     * @description Emits when changed amount of extra items\n     */\n    @Output()\n    overflowChanged: EventEmitter<number> = new EventEmitter<number>();\n\n    /**\n     * @description References to QueryList of OverflowListItemDirective\n     */\n    @ContentChildren(OverflowListItemDirective)\n    overflowItems: QueryList<OverflowListItemDirective>;\n\n    /** @hidden */\n    private _onDestroy$ = new Subject<void>();\n\n    /** @hidden */\n    constructor(private _el: ElementRef, private _viewportRuler: ViewportRuler, private _ngZone: NgZone) {}\n\n    /** @hidden */\n    ngAfterViewInit(): void {\n        this._viewportRuler\n            .change(50)\n            .pipe(takeUntil(this._onDestroy$))\n            // ViewportRuler invoked out of zone, that is why I need to invoke function in zone\n            .subscribe(() => this._ngZone.run(() => this._calculateAmountOfOverflowedItems()));\n\n        this._calculateAmountOfOverflowedItems();\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._onDestroy$.next();\n        this._onDestroy$.complete();\n    }\n\n    /**\n     * @description Get amount of extra items in current list\n     * */\n    getAmountOfExtraItems(): number {\n        const elements = this.overflowItems.toArray().map((item) => item.el.nativeElement);\n        const computed = getComputedStyle(this._el.nativeElement);\n        const contentWidth =\n            this._el.nativeElement.clientWidth - parseFloat(computed.paddingLeft) - parseFloat(computed.paddingRight);\n        return this._checkWidthWithOffset(elements, contentWidth);\n    }\n\n    /** @hidden */\n    private _calculateAmountOfOverflowedItems(): void {\n        const extra = this.getAmountOfExtraItems();\n        this.overflowChanged.emit(extra);\n    }\n\n    /**\n     * @hidden\n     * @param arrItems\n     * @param containerWidth\n     * @param checkWithOffset\n     * */\n    private _checkWidthWithOffset(\n        arrItems: HTMLElement[],\n        containerWidth: number,\n        checkWithOffset: boolean = false\n    ): number {\n        let itemsTotalWidth = 0;\n        const parentWidth = checkWithOffset ? containerWidth - this.overflowOffset : containerWidth;\n\n        arrItems.forEach((item) => {\n            item.hidden = true;\n            item.style.display = this.itemCssBlockValue;\n        });\n\n        for (let i = 0; i < arrItems.length; i++) {\n            const item = arrItems[i];\n\n            itemsTotalWidth += this.isRtl\n                ? containerWidth - item.offsetLeft - itemsTotalWidth\n                : item.offsetWidth + item.offsetLeft - itemsTotalWidth;\n\n            if (parentWidth < itemsTotalWidth) {\n                this._clearTempStyles(arrItems);\n                return checkWithOffset\n                    ? arrItems.length - i\n                    : this._checkWidthWithOffset(arrItems, containerWidth, true);\n            }\n        }\n\n        this._clearTempStyles(arrItems);\n        return 0;\n    }\n\n    /**\n     * @param arrItems\n     * @hidden\n     * */\n    private _clearTempStyles(arrItems: HTMLElement[]): void {\n        arrItems.forEach((item) => {\n            item.hidden = false;\n            item.style.removeProperty('display');\n        });\n    }\n}\n"]}

package/esm2020/utils/directives/overflow-list/overflow-list.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { OverflowListDirective, DeprecatedOverflowListDirective } from './overflow-list.directive';
+import { OverflowListItemDirective, DeprecatedOverflowListItemDirective } from './overflow-list-item.directive';
+import * as i0 from "@angular/core";
+export class OverflowListModule {
+}
+OverflowListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OverflowListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: OverflowListModule, imports: [OverflowListDirective,
+        OverflowListItemDirective,
+        DeprecatedOverflowListItemDirective,
+        DeprecatedOverflowListDirective], exports: [OverflowListDirective,
+        OverflowListItemDirective,
+        DeprecatedOverflowListItemDirective,
+        DeprecatedOverflowListDirective] });
+OverflowListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: OverflowListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        OverflowListDirective,
+                        OverflowListItemDirective,
+                        DeprecatedOverflowListItemDirective,
+                        DeprecatedOverflowListDirective
+                    ],
+                    exports: [
+                        OverflowListDirective,
+                        OverflowListItemDirective,
+                        DeprecatedOverflowListItemDirective,
+                        DeprecatedOverflowListDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmZsb3ctbGlzdC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2RpcmVjdGl2ZXMvb3ZlcmZsb3ctbGlzdC9vdmVyZmxvdy1saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSwrQkFBK0IsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ25HLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDOztBQWdCaEgsTUFBTSxPQUFPLGtCQUFrQjs7K0dBQWxCLGtCQUFrQjtnSEFBbEIsa0JBQWtCLFlBWnZCLHFCQUFxQjtRQUNyQix5QkFBeUI7UUFDekIsbUNBQW1DO1FBQ25DLCtCQUErQixhQUcvQixxQkFBcUI7UUFDckIseUJBQXlCO1FBQ3pCLG1DQUFtQztRQUNuQywrQkFBK0I7Z0hBRzFCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQWQ5QixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRTt3QkFDTCxxQkFBcUI7d0JBQ3JCLHlCQUF5Qjt3QkFDekIsbUNBQW1DO3dCQUNuQywrQkFBK0I7cUJBQ2xDO29CQUNELE9BQU8sRUFBRTt3QkFDTCxxQkFBcUI7d0JBQ3JCLHlCQUF5Qjt3QkFDekIsbUNBQW1DO3dCQUNuQywrQkFBK0I7cUJBQ2xDO2lCQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgT3ZlcmZsb3dMaXN0RGlyZWN0aXZlLCBEZXByZWNhdGVkT3ZlcmZsb3dMaXN0RGlyZWN0aXZlIH0gZnJvbSAnLi9vdmVyZmxvdy1saXN0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBPdmVyZmxvd0xpc3RJdGVtRGlyZWN0aXZlLCBEZXByZWNhdGVkT3ZlcmZsb3dMaXN0SXRlbURpcmVjdGl2ZSB9IGZyb20gJy4vb3ZlcmZsb3ctbGlzdC1pdGVtLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1xuICAgICAgICBPdmVyZmxvd0xpc3REaXJlY3RpdmUsXG4gICAgICAgIE92ZXJmbG93TGlzdEl0ZW1EaXJlY3RpdmUsXG4gICAgICAgIERlcHJlY2F0ZWRPdmVyZmxvd0xpc3RJdGVtRGlyZWN0aXZlLFxuICAgICAgICBEZXByZWNhdGVkT3ZlcmZsb3dMaXN0RGlyZWN0aXZlXG4gICAgXSxcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIE92ZXJmbG93TGlzdERpcmVjdGl2ZSxcbiAgICAgICAgT3ZlcmZsb3dMaXN0SXRlbURpcmVjdGl2ZSxcbiAgICAgICAgRGVwcmVjYXRlZE92ZXJmbG93TGlzdEl0ZW1EaXJlY3RpdmUsXG4gICAgICAgIERlcHJlY2F0ZWRPdmVyZmxvd0xpc3REaXJlY3RpdmVcbiAgICBdXG59KVxuZXhwb3J0IGNsYXNzIE92ZXJmbG93TGlzdE1vZHVsZSB7fVxuIl19

package/esm2020/utils/directives/readonly/default-readonly-view-modifier.mjs

@@ -0,0 +1,12 @@
+import { setReadonlyState } from './set-readonly-state';
+export class DefaultReadonlyViewModifier {
+    /** @hidden */
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        /** @hidden */
+        this.setReadonlyState = (isDisabled) => {
+            setReadonlyState(this.elementRef, isDisabled);
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1yZWFkb25seS12aWV3LW1vZGlmaWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzL3JlYWRvbmx5L2RlZmF1bHQtcmVhZG9ubHktdmlldy1tb2RpZmllci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxNQUFNLE9BQU8sMkJBQTJCO0lBQ3BDLGNBQWM7SUFDZCxZQUFvQixVQUErQjtRQUEvQixlQUFVLEdBQVYsVUFBVSxDQUFxQjtRQUVuRCxjQUFjO1FBQ2QscUJBQWdCLEdBQUcsQ0FBQyxVQUFtQixFQUFRLEVBQUU7WUFDN0MsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNsRCxDQUFDLENBQUM7SUFMb0QsQ0FBQztDQU0xRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJlYWRvbmx5Vmlld01vZGlmaWVyIH0gZnJvbSAnLi9yZWFkb25seS12aWV3LW1vZGlmaWVyLmludGVyZmFjZSc7XG5pbXBvcnQgeyBzZXRSZWFkb25seVN0YXRlIH0gZnJvbSAnLi9zZXQtcmVhZG9ubHktc3RhdGUnO1xuXG5leHBvcnQgY2xhc3MgRGVmYXVsdFJlYWRvbmx5Vmlld01vZGlmaWVyIGltcGxlbWVudHMgUmVhZG9ubHlWaWV3TW9kaWZpZXIge1xuICAgIC8qKiBAaGlkZGVuICovXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbGVtZW50UmVmOiBFbGVtZW50UmVmPEVsZW1lbnQ+KSB7fVxuXG4gICAgLyoqIEBoaWRkZW4gKi9cbiAgICBzZXRSZWFkb25seVN0YXRlID0gKGlzRGlzYWJsZWQ6IGJvb2xlYW4pOiB2b2lkID0+IHtcbiAgICAgICAgc2V0UmVhZG9ubHlTdGF0ZSh0aGlzLmVsZW1lbnRSZWYsIGlzRGlzYWJsZWQpO1xuICAgIH07XG59XG4iXX0=