@ptsecurity/mosaic 15.6.0 → 16.0.0

package/esm2022/input/input.mjs

@@ -0,0 +1,297 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { getSupportedInputTypes } from '@angular/cdk/platform';
+import { Directive, ElementRef, Inject, Input, Optional, Self } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { ErrorStateMatcher, mixinErrorState } from '@ptsecurity/mosaic/core';
+import { McFormFieldControl } from '@ptsecurity/mosaic/form-field';
+import { Subject } from 'rxjs';
+import { getMcInputUnsupportedTypeError } from './input-errors';
+import { McNumberInput } from './input-number';
+import { MC_INPUT_VALUE_ACCESSOR } from './input-value-accessor';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./input-number";
+import * as i3 from "@ptsecurity/mosaic/core";
+const MC_INPUT_INVALID_TYPES = [
+    'button',
+    'checkbox',
+    'file',
+    'hidden',
+    'image',
+    'radio',
+    'range',
+    'reset',
+    'submit'
+];
+let nextUniqueId = 0;
+/** @docs-private */
+export class McInputBase {
+    constructor(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl) {
+        this.defaultErrorStateMatcher = defaultErrorStateMatcher;
+        this.parentForm = parentForm;
+        this.parentFormGroup = parentFormGroup;
+        this.ngControl = ngControl;
+        /**
+         * Emits whenever the component state changes and should cause the parent
+         * form-field to update. Implemented as part of `McFormFieldControl`.
+         * @docs-private
+         */
+        this.stateChanges = new Subject();
+    }
+}
+/** @docs-private */
+export const McInputMixinBase = mixinErrorState(McInputBase);
+export class McInput extends McInputMixinBase {
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get disabled() {
+        if (this.ngControl && this.ngControl.disabled !== null) {
+            return this.ngControl.disabled;
+        }
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        // Browsers may not fire the blur event if the input is disabled too quickly.
+        // Reset from here to ensure that the element doesn't become stuck.
+        if (this.focused) {
+            this.focused = false;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this.uid;
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    // tslint:disable no-reserved-keywords
+    /** Input type of the element. */
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value || 'text';
+        this.validateType();
+        // When using Angular inputs, developers are no longer able to set the properties on the native
+        // input element. To ensure that bindings for `type` work, we need to sync the setter
+        // with the native property. Textarea elements don't support the type property or attribute.
+        if (getSupportedInputTypes().has(this._type)) {
+            this.elementRef.nativeElement.type = this._type;
+        }
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get value() {
+        return this.inputValueAccessor.value;
+    }
+    set value(value) {
+        if (value !== this.value) {
+            this.inputValueAccessor.value = value;
+            this.stateChanges.next();
+        }
+    }
+    // tslint:disable-next-line: naming-convention
+    constructor(elementRef, ngControl, numberInput, parentForm, parentFormGroup, defaultErrorStateMatcher, inputValueAccessor) {
+        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);
+        this.elementRef = elementRef;
+        this.numberInput = numberInput;
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.focused = false;
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.stateChanges = new Subject();
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.controlType = 'input';
+        this.uid = `mc-input-${nextUniqueId++}`;
+        this.neverEmptyInputTypes = [
+            'date',
+            'datetime',
+            'datetime-local',
+            'month',
+            'time',
+            'week'
+        ].filter((t) => getSupportedInputTypes().has(t));
+        this._disabled = false;
+        this._required = false;
+        // tslint:enable no-reserved-keywords
+        this._type = 'text';
+        // If no input value accessor was explicitly specified, use the element as the input value accessor.
+        this.inputValueAccessor = inputValueAccessor || this.elementRef.nativeElement;
+        this.previousNativeValue = this.value;
+        // Force setter to be called in case id was not specified.
+        this.id = this.id;
+    }
+    ngOnChanges() {
+        this.stateChanges.next();
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    ngDoCheck() {
+        if (this.ngControl) {
+            // We need to re-evaluate this on every change detection cycle, because there are some
+            // error triggers that we can't subscribe to (e.g. parent form submissions). This means
+            // that whatever logic is in here has to be super lean or we risk destroying the performance.
+            this.updateErrorState();
+        }
+        // We need to dirty-check the native element's value, because there are some cases where
+        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're
+        // updating the value using `emitEvent: false`).
+        this.dirtyCheckNativeValue();
+    }
+    /** Focuses the input. */
+    focus() {
+        this.elementRef.nativeElement.focus();
+    }
+    onBlur() {
+        this.focusChanged(false);
+        if (this.ngControl?.control) {
+            const control = this.ngControl.control;
+            control.updateValueAndValidity({ emitEvent: false });
+            control.statusChanges.emit(control.status);
+        }
+    }
+    /** Callback for the cases where the focused state of the input changes. */
+    focusChanged(isFocused) {
+        if (this.focused !== isFocused) {
+            this.focused = isFocused;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get empty() {
+        return !this.isNeverEmpty() && !this.elementRef.nativeElement.value && !this.isBadInput();
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    onContainerClick() {
+        this.focus();
+    }
+    /** Does some manual dirty checking on the native input `value` property. */
+    dirtyCheckNativeValue() {
+        const newValue = this.value;
+        if (this.previousNativeValue !== newValue) {
+            this.previousNativeValue = newValue;
+            this.stateChanges.next();
+        }
+    }
+    /** Make sure the input is a supported type. */
+    validateType() {
+        if (MC_INPUT_INVALID_TYPES.indexOf(this._type) > -1) {
+            throw getMcInputUnsupportedTypeError(this._type);
+        }
+    }
+    /** Checks whether the input type is one of the types that are never empty. */
+    isNeverEmpty() {
+        return this.neverEmptyInputTypes.indexOf(this._type) > -1;
+    }
+    /** Checks whether the input is invalid based on the native validation. */
+    isBadInput() {
+        // The `validity` property won't be present on platform-server.
+        const validity = this.elementRef.nativeElement.validity;
+        return validity?.badInput;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInput, deps: [{ token: i0.ElementRef }, { token: i1.NgControl, optional: true, self: true }, { token: i2.McNumberInput, optional: true, self: true }, { token: i1.NgForm, optional: true }, { token: i1.FormGroupDirective, optional: true }, { token: i3.ErrorStateMatcher }, { token: MC_INPUT_VALUE_ACCESSOR, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: McInput, selector: "input[mcInput]", inputs: { errorStateMatcher: "errorStateMatcher", placeholder: "placeholder", disabled: "disabled", id: "id", required: "required", type: "type", value: "value" }, host: { listeners: { "blur": "onBlur()", "focus": "focusChanged(true)" }, properties: { "attr.id": "id", "attr.placeholder": "placeholder", "attr.disabled": "disabled || null", "required": "required" }, classAttribute: "mc-input" }, providers: [{
+                provide: McFormFieldControl, useExisting: McInput
+            }], exportAs: ["mcInput"], usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInput, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `input[mcInput]`,
+                    exportAs: 'mcInput',
+                    host: {
+                        class: 'mc-input',
+                        // Native input properties that are overwritten by Angular inputs need to be synced with
+                        // the native input element. Otherwise property bindings for those don't work.
+                        '[attr.id]': 'id',
+                        '[attr.placeholder]': 'placeholder',
+                        '[attr.disabled]': 'disabled || null',
+                        '[required]': 'required',
+                        '(blur)': 'onBlur()',
+                        '(focus)': 'focusChanged(true)'
+                    },
+                    providers: [{
+                            provide: McFormFieldControl, useExisting: McInput
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i2.McNumberInput, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i1.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i1.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i3.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [MC_INPUT_VALUE_ACCESSOR]
+                }] }]; }, propDecorators: { errorStateMatcher: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+export class McInputMono {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputMono, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: McInputMono, selector: "input[mcInputMonospace]", host: { classAttribute: "mc-input_monospace" }, exportAs: ["McInputMonospace"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputMono, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[mcInputMonospace]',
+                    exportAs: 'McInputMonospace',
+                    host: { class: 'mc-input_monospace' }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.js","sourceRoot":"","sources":["../../../../packages/mosaic/input/input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EACH,SAAS,EAET,UAAU,EAEV,MAAM,EACN,KAAK,EAGL,QAAQ,EACR,IAAI,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,kBAAkB,EAClB,SAAS,EACT,MAAM,EACT,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAGH,iBAAiB,EACjB,eAAe,EAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;;;;;AAGjE,MAAM,sBAAsB,GAAG;IAC3B,QAAQ;IACR,UAAU;IACV,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,OAAO;IACP,OAAO;IACP,QAAQ;CACX,CAAC;AAEF,IAAI,YAAY,GAAG,CAAC,CAAC;AAErB,oBAAoB;AACpB,MAAM,OAAO,WAAW;IAQpB,YACW,wBAA2C,EAC3C,UAAkB,EAClB,eAAmC,EACnC,SAAoB;QAHpB,6BAAwB,GAAxB,wBAAwB,CAAmB;QAC3C,eAAU,GAAV,UAAU,CAAQ;QAClB,oBAAe,GAAf,eAAe,CAAoB;QACnC,cAAS,GAAT,SAAS,CAAW;QAX/B;;;;WAIG;QACM,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;IAOzC,CAAC;CACP;AAED,oBAAoB;AACpB,MAAM,CAAC,MAAM,gBAAgB,GAAiD,eAAe,CAAC,WAAW,CAAC,CAAC;AAqB3G,MAAM,OAAO,OAAQ,SAAQ,gBAAgB;IAyCzC;;;OAGG;IACH,IACI,QAAQ;QACR,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,KAAK,IAAI,EAAE;YAAE,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;SAAE;QAE3F,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAI,QAAQ,CAAC,KAAc;QACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAE9C,6EAA6E;QAC7E,mEAAmE;QACnE,IAAI,IAAI,CAAC,OAAO,EAAE;YACd,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAID;;;OAGG;IACH,IACI,EAAE;QACF,OAAO,IAAI,CAAC,GAAG,CAAC;IACpB,CAAC;IAED,IAAI,EAAE,CAAC,KAAa;QAChB,IAAI,CAAC,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC;IACjC,CAAC;IAID;;;OAGG;IACH,IACI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,IAAI,QAAQ,CAAC,KAAc;QACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAID,sCAAsC;IACtC,iCAAiC;IACjC,IACI,IAAI;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAI,IAAI,CAAC,KAAa;QAClB,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,MAAM,CAAC;QAC7B,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,+FAA+F;QAC/F,qFAAqF;QACrF,4FAA4F;QAC5F,IAAI,sBAAsB,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC1C,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;SACnD;IACL,CAAC;IAKD;;;OAGG;IACH,IACI,KAAK;QACL,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC;IACzC,CAAC;IAED,IAAI,KAAK,CAAC,KAAa;QACnB,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE;YACtB,IAAI,CAAC,kBAAkB,CAAC,KAAK,GAAG,KAAK,CAAC;YACtC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAKD,8CAA8C;IAC9C,YACc,UAAsB,EACZ,SAAoB,EACb,WAA0B,EACzC,UAAkB,EAClB,eAAmC,EAC/C,wBAA2C,EACU,kBAAuB;QAE5E,KAAK,CAAC,wBAAwB,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;QAR9D,eAAU,GAAV,UAAU,CAAY;QAEL,gBAAW,GAAX,WAAW,CAAe;QAtIzD;;;WAGG;QACH,YAAO,GAAY,KAAK,CAAC;QAEzB;;;WAGG;QACM,iBAAY,GAAkB,IAAI,OAAO,EAAQ,CAAC;QAE3D;;;WAGG;QACH,gBAAW,GAAW,OAAO,CAAC;QAQpB,QAAG,GAAG,YAAY,YAAY,EAAE,EAAE,CAAC;QAEnC,yBAAoB,GAAG;YAC7B,MAAM;YACN,UAAU;YACV,gBAAgB;YAChB,OAAO;YACP,MAAM;YACN,MAAM;SACT,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,sBAAsB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAwBzC,cAAS,GAAG,KAAK,CAAC;QA8BlB,cAAS,GAAG,KAAK,CAAC;QAoB1B,qCAAqC;QAE7B,UAAK,GAAG,MAAM,CAAC;QAiCnB,oGAAoG;QACpG,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QAE9E,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC;QAEtC,0DAA0D;QAC1D,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;IACtB,CAAC;IAED,WAAW;QACP,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAED,WAAW;QACP,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IACjC,CAAC;IAED,SAAS;QACL,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,sFAAsF;YACtF,uFAAuF;YACvF,6FAA6F;YAC7F,IAAI,CAAC,gBAAgB,EAAE,CAAC;SAC3B;QAED,wFAAwF;QACxF,uFAAuF;QACvF,gDAAgD;QAChD,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAED,yBAAyB;IACzB,KAAK;QACD,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC1C,CAAC;IAED,MAAM;QACF,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;QAEzB,IAAI,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE;YACzB,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YAEvC,OAAO,CAAC,sBAAsB,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;YACpD,OAAO,CAAC,aAAsC,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;SACxE;IACL,CAAC;IAED,2EAA2E;IAC3E,YAAY,CAAC,SAAkB;QAC3B,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE;YAC5B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAED;;;OAGG;IACH,IAAI,KAAK;QACL,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;IAC9F,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACZ,IAAI,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;IAED,4EAA4E;IAClE,qBAAqB;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;QAE5B,IAAI,IAAI,CAAC,mBAAmB,KAAK,QAAQ,EAAE;YACvC,IAAI,CAAC,mBAAmB,GAAG,QAAQ,CAAC;YACpC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAED,+CAA+C;IACrC,YAAY;QAClB,IAAI,sBAAsB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE;YACjD,MAAM,8BAA8B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpD;IACL,CAAC;IAED,8EAA8E;IACpE,YAAY;QAClB,OAAO,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,0EAA0E;IAChE,UAAU;QAChB,+DAA+D;QAC/D,MAAM,QAAQ,GAAI,IAAI,CAAC,UAAU,CAAC,aAAkC,CAAC,QAAQ,CAAC;QAE9E,OAAO,QAAQ,EAAE,QAAQ,CAAC;IAC9B,CAAC;iIAvPQ,OAAO,mRAgJgB,uBAAuB;qHAhJ9C,OAAO,sbAJL,CAAC;gBACR,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,OAAO;aACpD,CAAC;;2FAEO,OAAO;kBAlBnB,SAAS;mBAAC;oBACP,QAAQ,EAAE,gBAAgB;oBAC1B,QAAQ,EAAE,SAAS;oBACnB,IAAI,EAAE;wBACF,KAAK,EAAE,UAAU;wBACjB,wFAAwF;wBACxF,8EAA8E;wBAC9E,WAAW,EAAE,IAAI;wBACjB,oBAAoB,EAAE,aAAa;wBACnC,iBAAiB,EAAE,kBAAkB;wBACrC,YAAY,EAAE,UAAU;wBACxB,QAAQ,EAAE,UAAU;wBACpB,SAAS,EAAE,oBAAoB;qBAClC;oBACD,SAAS,EAAE,CAAC;4BACR,OAAO,EAAE,kBAAkB,EAAE,WAAW,SAAS;yBACpD,CAAC;iBACL;;0BA4IQ,QAAQ;;0BAAI,IAAI;;0BAChB,QAAQ;;0BAAI,IAAI;;0BAChB,QAAQ;;0BACR,QAAQ;;0BAER,QAAQ;;0BAAI,IAAI;;0BAAI,MAAM;2BAAC,uBAAuB;4CA5I9C,iBAAiB;sBAAzB,KAAK;gBAwBG,WAAW;sBAAnB,KAAK;gBAkBF,QAAQ;sBADX,KAAK;gBAyBF,EAAE;sBADL,KAAK;gBAgBF,QAAQ;sBADX,KAAK;gBAcF,IAAI;sBADP,KAAK;gBAyBF,KAAK;sBADR,KAAK;;AAsIV,MAAM,OAAO,WAAW;iIAAX,WAAW;qHAAX,WAAW;;2FAAX,WAAW;kBALvB,SAAS;mBAAC;oBACP,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ,EAAE,kBAAkB;oBAC5B,IAAI,EAAE,EAAE,KAAK,EAAE,oBAAoB,EAAE;iBACxC","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { getSupportedInputTypes } from '@angular/cdk/platform';\nimport {\n    Directive,\n    DoCheck,\n    ElementRef,\n    EventEmitter,\n    Inject,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    Self\n} from '@angular/core';\nimport {\n    FormGroupDirective,\n    NgControl,\n    NgForm\n} from '@angular/forms';\nimport {\n    CanUpdateErrorState,\n    CanUpdateErrorStateCtor,\n    ErrorStateMatcher,\n    mixinErrorState\n} from '@ptsecurity/mosaic/core';\nimport { McFormFieldControl } from '@ptsecurity/mosaic/form-field';\nimport { Subject } from 'rxjs';\n\nimport { getMcInputUnsupportedTypeError } from './input-errors';\nimport { McNumberInput } from './input-number';\nimport { MC_INPUT_VALUE_ACCESSOR } from './input-value-accessor';\n\n\nconst MC_INPUT_INVALID_TYPES = [\n    'button',\n    'checkbox',\n    'file',\n    'hidden',\n    'image',\n    'radio',\n    'range',\n    'reset',\n    'submit'\n];\n\nlet nextUniqueId = 0;\n\n/** @docs-private */\nexport class McInputBase {\n    /**\n     * Emits whenever the component state changes and should cause the parent\n     * form-field to update. Implemented as part of `McFormFieldControl`.\n     * @docs-private\n     */\n    readonly stateChanges = new Subject<void>();\n\n    constructor(\n        public defaultErrorStateMatcher: ErrorStateMatcher,\n        public parentForm: NgForm,\n        public parentFormGroup: FormGroupDirective,\n        public ngControl: NgControl\n    ) {}\n}\n\n/** @docs-private */\nexport const McInputMixinBase: CanUpdateErrorStateCtor & typeof McInputBase = mixinErrorState(McInputBase);\n\n\n@Directive({\n    selector: `input[mcInput]`,\n    exportAs: 'mcInput',\n    host: {\n        class: 'mc-input',\n        // Native input properties that are overwritten by Angular inputs need to be synced with\n        // the native input element. Otherwise property bindings for those don't work.\n        '[attr.id]': 'id',\n        '[attr.placeholder]': 'placeholder',\n        '[attr.disabled]': 'disabled || null',\n        '[required]': 'required',\n        '(blur)': 'onBlur()',\n        '(focus)': 'focusChanged(true)'\n    },\n    providers: [{\n        provide: McFormFieldControl, useExisting: McInput\n    }]\n})\nexport class McInput extends McInputMixinBase implements McFormFieldControl<any>, OnChanges, OnDestroy, DoCheck,\n    CanUpdateErrorState, OnChanges {\n\n    /** An object used to control when error messages are shown. */\n    @Input() errorStateMatcher: ErrorStateMatcher;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    focused: boolean = false;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    readonly stateChanges: Subject<void> = new Subject<void>();\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    controlType: string = 'input';\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input() placeholder: string;\n\n    protected uid = `mc-input-${nextUniqueId++}`;\n    protected previousNativeValue: any;\n    protected neverEmptyInputTypes = [\n        'date',\n        'datetime',\n        'datetime-local',\n        'month',\n        'time',\n        'week'\n    ].filter((t) => getSupportedInputTypes().has(t));\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get disabled(): boolean {\n        if (this.ngControl && this.ngControl.disabled !== null) { return this.ngControl.disabled; }\n\n        return this._disabled;\n    }\n\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n\n        // Browsers may not fire the blur event if the input is disabled too quickly.\n        // Reset from here to ensure that the element doesn't become stuck.\n        if (this.focused) {\n            this.focused = false;\n            this.stateChanges.next();\n        }\n    }\n\n    private _disabled = false;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get id(): string {\n        return this._id;\n    }\n\n    set id(value: string) {\n        this._id = value || this.uid;\n    }\n\n    private _id: string;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get required(): boolean {\n        return this._required;\n    }\n\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n\n    private _required = false;\n\n    // tslint:disable no-reserved-keywords\n    /** Input type of the element. */\n    @Input()\n    get type(): string {\n        return this._type;\n    }\n\n    set type(value: string) {\n        this._type = value || 'text';\n        this.validateType();\n\n        // When using Angular inputs, developers are no longer able to set the properties on the native\n        // input element. To ensure that bindings for `type` work, we need to sync the setter\n        // with the native property. Textarea elements don't support the type property or attribute.\n        if (getSupportedInputTypes().has(this._type)) {\n            this.elementRef.nativeElement.type = this._type;\n        }\n    }\n    // tslint:enable no-reserved-keywords\n\n    private _type = 'text';\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get value(): string {\n        return this.inputValueAccessor.value;\n    }\n\n    set value(value: string) {\n        if (value !== this.value) {\n            this.inputValueAccessor.value = value;\n            this.stateChanges.next();\n        }\n    }\n\n    // tslint:disable-next-line: orthodox-getter-and-setter\n    private inputValueAccessor: { value: any };\n\n    // tslint:disable-next-line: naming-convention\n    constructor(\n        protected elementRef: ElementRef,\n        @Optional() @Self() ngControl: NgControl,\n        @Optional() @Self() public numberInput: McNumberInput,\n        @Optional() parentForm: NgForm,\n        @Optional() parentFormGroup: FormGroupDirective,\n        defaultErrorStateMatcher: ErrorStateMatcher,\n        @Optional() @Self() @Inject(MC_INPUT_VALUE_ACCESSOR) inputValueAccessor: any\n    ) {\n        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);\n\n        // If no input value accessor was explicitly specified, use the element as the input value accessor.\n        this.inputValueAccessor = inputValueAccessor || this.elementRef.nativeElement;\n\n        this.previousNativeValue = this.value;\n\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n    }\n\n    ngOnChanges() {\n        this.stateChanges.next();\n    }\n\n    ngOnDestroy() {\n        this.stateChanges.complete();\n    }\n\n    ngDoCheck() {\n        if (this.ngControl) {\n            // We need to re-evaluate this on every change detection cycle, because there are some\n            // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n            // that whatever logic is in here has to be super lean or we risk destroying the performance.\n            this.updateErrorState();\n        }\n\n        // We need to dirty-check the native element's value, because there are some cases where\n        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're\n        // updating the value using `emitEvent: false`).\n        this.dirtyCheckNativeValue();\n    }\n\n    /** Focuses the input. */\n    focus(): void {\n        this.elementRef.nativeElement.focus();\n    }\n\n    onBlur(): void {\n        this.focusChanged(false);\n\n        if (this.ngControl?.control) {\n            const control = this.ngControl.control;\n\n            control.updateValueAndValidity({ emitEvent: false });\n            (control.statusChanges as EventEmitter<string>).emit(control.status);\n        }\n    }\n\n    /** Callback for the cases where the focused state of the input changes. */\n    focusChanged(isFocused: boolean) {\n        if (this.focused !== isFocused) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\n    }\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    get empty(): boolean {\n        return !this.isNeverEmpty() && !this.elementRef.nativeElement.value && !this.isBadInput();\n    }\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        this.focus();\n    }\n\n    /** Does some manual dirty checking on the native input `value` property. */\n    protected dirtyCheckNativeValue() {\n        const newValue = this.value;\n\n        if (this.previousNativeValue !== newValue) {\n            this.previousNativeValue = newValue;\n            this.stateChanges.next();\n        }\n    }\n\n    /** Make sure the input is a supported type. */\n    protected validateType() {\n        if (MC_INPUT_INVALID_TYPES.indexOf(this._type) > -1) {\n            throw getMcInputUnsupportedTypeError(this._type);\n        }\n    }\n\n    /** Checks whether the input type is one of the types that are never empty. */\n    protected isNeverEmpty() {\n        return this.neverEmptyInputTypes.indexOf(this._type) > -1;\n    }\n\n    /** Checks whether the input is invalid based on the native validation. */\n    protected isBadInput() {\n        // The `validity` property won't be present on platform-server.\n        const validity = (this.elementRef.nativeElement as HTMLInputElement).validity;\n\n        return validity?.badInput;\n    }\n}\n\n@Directive({\n    selector: 'input[mcInputMonospace]',\n    exportAs: 'McInputMonospace',\n    host: { class: 'mc-input_monospace' }\n})\nexport class McInputMono {}\n"]}

package/{esm2020 → esm2022}/input/input.module.mjs

@@ -9,29 +9,29 @@ import { MaxValidator, MinValidator } from './input-number-validators';
 import { McInputPassword, McPasswordToggle } from './input-password';
 import * as i0 from "@angular/core";
 export class McInputModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.5", ngImport: i0, type: McInputModule, declarations: [McInput,
+            McNumberInput,
+            McInputPassword,
+            McPasswordToggle,
+            McInputMono,
+            MinValidator,
+            MaxValidator], imports: [CommonModule,
+            A11yModule,
+            McCommonModule,
+            FormsModule], exports: [McInput,
+            McNumberInput,
+            McInputPassword,
+            McPasswordToggle,
+            McInputMono,
+            MinValidator,
+            MaxValidator] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputModule, imports: [CommonModule,
+            A11yModule,
+            McCommonModule,
+            FormsModule] }); }
 }
-/** @nocollapse */ McInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ McInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: McInputModule, declarations: [McInput,
-        McNumberInput,
-        McInputPassword,
-        McPasswordToggle,
-        McInputMono,
-        MinValidator,
-        MaxValidator], imports: [CommonModule,
-        A11yModule,
-        McCommonModule,
-        FormsModule], exports: [McInput,
-        McNumberInput,
-        McInputPassword,
-        McPasswordToggle,
-        McInputMono,
-        MinValidator,
-        MaxValidator] });
-/** @nocollapse */ McInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McInputModule, imports: [CommonModule,
-        A11yModule,
-        McCommonModule,
-        FormsModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McInputModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -60,4 +60,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/link/link.component.mjs

@@ -0,0 +1,122 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Input, ElementRef, ChangeDetectorRef, Directive, ContentChild } from '@angular/core';
+import { mixinDisabled, mixinTabIndex, toBoolean } from '@ptsecurity/mosaic/core';
+import { McIcon } from '@ptsecurity/mosaic/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+/** @docs-private */
+export class McLinkBase {
+}
+/** @docs-private */
+export const McLinkMixinBase = mixinTabIndex(mixinDisabled(McLinkBase));
+export const baseURLRegex = /^http(s)?:\/\//;
+export class McLink extends McLinkMixinBase {
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        const newValue = toBoolean(value);
+        if (newValue !== this._disabled) {
+            this._disabled = newValue;
+            this.changeDetector.markForCheck();
+        }
+    }
+    get pseudo() {
+        return this._pseudo;
+    }
+    set pseudo(value) {
+        this._pseudo = toBoolean(value);
+    }
+    get noUnderline() {
+        return this._noUnderline;
+    }
+    set noUnderline(value) {
+        this._noUnderline = toBoolean(value);
+    }
+    get caption() {
+        return this._caption;
+    }
+    set caption(value) {
+        this._caption = toBoolean(value);
+    }
+    get useVisited() {
+        return this._useVisited;
+    }
+    set useVisited(value) {
+        this._useVisited = toBoolean(value);
+    }
+    get hasIcon() {
+        return !!this.icon;
+    }
+    set print(value) {
+        this.printMode = value !== null;
+        this._print = value;
+        this.updatePrintUrl();
+    }
+    constructor(elementRef, focusMonitor, changeDetector) {
+        super();
+        this.elementRef = elementRef;
+        this.focusMonitor = focusMonitor;
+        this.changeDetector = changeDetector;
+        this._disabled = false;
+        this._pseudo = false;
+        this._noUnderline = false;
+        this._caption = false;
+        this._useVisited = false;
+        this.focusMonitor.monitor(elementRef.nativeElement, true);
+        this.updatePrintUrl();
+    }
+    ngOnDestroy() {
+        this.focusMonitor.stopMonitoring(this.elementRef.nativeElement);
+    }
+    focus() {
+        this.getHostElement().focus();
+    }
+    getHostElement() {
+        return this.elementRef.nativeElement;
+    }
+    updatePrintUrl() {
+        Promise.resolve().then(() => {
+            this.printUrl = this._print || this.getHostElement().href?.replace(baseURLRegex, '');
+        });
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McLink, deps: [{ token: i0.ElementRef }, { token: i1.FocusMonitor }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: McLink, selector: "[mc-link]", inputs: { tabIndex: "tabIndex", disabled: "disabled", pseudo: "pseudo", noUnderline: "noUnderline", caption: "caption", useVisited: "useVisited", print: "print" }, host: { properties: { "class.mc-link_no-underline": "noUnderline", "class.mc-link_use-visited": "useVisited", "class.mc-link_caption": "caption", "class.mc-link_pseudo": "pseudo", "class.mc-link_print": "printMode", "class.mc-text-only": "!hasIcon", "class.mc-text-with-icon": "hasIcon", "attr.disabled": "disabled || null", "attr.tabindex": "tabIndex", "attr.print": "printUrl" }, classAttribute: "mc-link" }, queries: [{ propertyName: "icon", first: true, predicate: McIcon, descendants: true }], exportAs: ["mcLink"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McLink, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mc-link]',
+                    exportAs: 'mcLink',
+                    inputs: ['tabIndex'],
+                    host: {
+                        class: 'mc-link',
+                        '[class.mc-link_no-underline]': 'noUnderline',
+                        '[class.mc-link_use-visited]': 'useVisited',
+                        '[class.mc-link_caption]': 'caption',
+                        '[class.mc-link_pseudo]': 'pseudo',
+                        '[class.mc-link_print]': 'printMode',
+                        '[class.mc-text-only]': '!hasIcon',
+                        '[class.mc-text-with-icon]': 'hasIcon',
+                        '[attr.disabled]': 'disabled || null',
+                        '[attr.tabindex]': 'tabIndex',
+                        '[attr.print]': 'printUrl'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FocusMonitor }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], pseudo: [{
+                type: Input
+            }], noUnderline: [{
+                type: Input
+            }], caption: [{
+                type: Input
+            }], useVisited: [{
+                type: Input
+            }], print: [{
+                type: Input
+            }], icon: [{
+                type: ContentChild,
+                args: [McIcon]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link.component.js","sourceRoot":"","sources":["../../../../packages/mosaic/link/link.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\nimport {\n    Input,\n    ElementRef,\n    OnDestroy,\n    ChangeDetectorRef,\n    Directive,\n    ContentChild\n} from '@angular/core';\nimport {\n    CanDisable,\n    CanDisableCtor,\n    HasTabIndex,\n    HasTabIndexCtor,\n    mixinDisabled,\n    mixinTabIndex,\n    toBoolean\n} from '@ptsecurity/mosaic/core';\nimport { McIcon } from '@ptsecurity/mosaic/icon';\n\n\n/** @docs-private */\nexport class McLinkBase {}\n\n/** @docs-private */\nexport const McLinkMixinBase: HasTabIndexCtor & CanDisableCtor &\n    typeof McLinkBase = mixinTabIndex(mixinDisabled(McLinkBase));\n\nexport const baseURLRegex = /^http(s)?:\\/\\//;\n\n@Directive({\n    selector: '[mc-link]',\n    exportAs: 'mcLink',\n    inputs: ['tabIndex'],\n    host: {\n        class: 'mc-link',\n        '[class.mc-link_no-underline]': 'noUnderline',\n        '[class.mc-link_use-visited]': 'useVisited',\n        '[class.mc-link_caption]': 'caption',\n        '[class.mc-link_pseudo]': 'pseudo',\n        '[class.mc-link_print]': 'printMode',\n        '[class.mc-text-only]': '!hasIcon',\n        '[class.mc-text-with-icon]': 'hasIcon',\n        '[attr.disabled]': 'disabled || null',\n        '[attr.tabindex]': 'tabIndex',\n        '[attr.print]': 'printUrl'\n    }\n})\n\nexport class McLink extends McLinkMixinBase implements OnDestroy, HasTabIndex, CanDisable {\n    @Input()\n    get disabled() {\n        return this._disabled;\n    }\n\n    set disabled(value: any) {\n        const newValue = toBoolean(value);\n\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this.changeDetector.markForCheck();\n        }\n    }\n\n    private _disabled = false;\n\n    @Input()\n    get pseudo() {\n        return this._pseudo;\n    }\n\n    set pseudo(value: any) {\n        this._pseudo = toBoolean(value);\n    }\n\n    private _pseudo = false;\n\n    @Input()\n    get noUnderline() {\n        return this._noUnderline;\n    }\n\n    set noUnderline(value: any) {\n        this._noUnderline = toBoolean(value);\n    }\n\n    private _noUnderline = false;\n\n    @Input()\n    get caption() {\n        return this._caption;\n    }\n\n    set caption(value: any) {\n        this._caption = toBoolean(value);\n    }\n\n    private _caption = false;\n\n    @Input()\n    get useVisited() {\n        return this._useVisited;\n    }\n\n    set useVisited(value: any) {\n        this._useVisited = toBoolean(value);\n    }\n\n    private _useVisited = false;\n\n    get hasIcon(): boolean {\n        return !!this.icon;\n    }\n\n    @Input()\n    set print(value: any) {\n        this.printMode = value !== null;\n\n        this._print = value;\n\n        this.updatePrintUrl();\n    }\n\n    private _print: string;\n\n    printMode: boolean;\n\n    printUrl: string;\n\n    @ContentChild(McIcon) icon: McIcon;\n\n    constructor(\n        private elementRef: ElementRef,\n        private focusMonitor: FocusMonitor,\n        private changeDetector: ChangeDetectorRef\n    ) {\n        super();\n\n        this.focusMonitor.monitor(elementRef.nativeElement, true);\n\n        this.updatePrintUrl();\n    }\n\n    ngOnDestroy() {\n        this.focusMonitor.stopMonitoring(this.elementRef.nativeElement);\n    }\n\n    focus(): void {\n        this.getHostElement().focus();\n    }\n\n    getHostElement() {\n        return this.elementRef.nativeElement;\n    }\n\n    private updatePrintUrl() {\n        Promise.resolve().then(() => {\n            this.printUrl = this._print || this.getHostElement().href?.replace(baseURLRegex, '');\n        });\n    }\n}\n"]}

package/{esm2020 → esm2022}/link/link.module.mjs

@@ -4,13 +4,13 @@ import { NgModule } from '@angular/core';
 import { McLink } from './link.component';
 import * as i0 from "@angular/core";
 export class McLinkModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McLinkModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.5", ngImport: i0, type: McLinkModule, declarations: [McLink], imports: [CommonModule,
+            A11yModule], exports: [McLink] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McLinkModule, imports: [CommonModule,
+            A11yModule] }); }
 }
-/** @nocollapse */ McLinkModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McLinkModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ McLinkModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: McLinkModule, declarations: [McLink], imports: [CommonModule,
-        A11yModule], exports: [McLink] });
-/** @nocollapse */ McLinkModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McLinkModule, imports: [CommonModule,
-        A11yModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: McLinkModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McLinkModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -21,4 +21,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     exports: [McLink]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluay5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9tb3NhaWMvbGluay9saW5rLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDL0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQVcxQyxNQUFNLE9BQU8sWUFBWTs7NEhBQVosWUFBWTs2SEFBWixZQUFZLGlCQUhOLE1BQU0sYUFIakIsWUFBWTtRQUNaLFVBQVUsYUFHSixNQUFNOzZIQUVQLFlBQVksWUFOakIsWUFBWTtRQUNaLFVBQVU7MkZBS0wsWUFBWTtrQkFSeEIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUU7d0JBQ0wsWUFBWTt3QkFDWixVQUFVO3FCQUNiO29CQUNELFlBQVksRUFBRSxDQUFDLE1BQU0sQ0FBQztvQkFDdEIsT0FBTyxFQUFFLENBQUMsTUFBTSxDQUFDO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEExMXlNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvYTExeSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgTWNMaW5rIH0gZnJvbSAnLi9saW5rLmNvbXBvbmVudCc7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIENvbW1vbk1vZHVsZSxcbiAgICAgICAgQTExeU1vZHVsZVxuICAgIF0sXG4gICAgZGVjbGFyYXRpb25zOiBbTWNMaW5rXSxcbiAgICBleHBvcnRzOiBbTWNMaW5rXVxufSlcbmV4cG9ydCBjbGFzcyBNY0xpbmtNb2R1bGUge31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluay5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9tb3NhaWMvbGluay9saW5rLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDL0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQVcxQyxNQUFNLE9BQU8sWUFBWTtpSUFBWixZQUFZO2tJQUFaLFlBQVksaUJBSE4sTUFBTSxhQUhqQixZQUFZO1lBQ1osVUFBVSxhQUdKLE1BQU07a0lBRVAsWUFBWSxZQU5qQixZQUFZO1lBQ1osVUFBVTs7MkZBS0wsWUFBWTtrQkFSeEIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUU7d0JBQ0wsWUFBWTt3QkFDWixVQUFVO3FCQUNiO29CQUNELFlBQVksRUFBRSxDQUFDLE1BQU0sQ0FBQztvQkFDdEIsT0FBTyxFQUFFLENBQUMsTUFBTSxDQUFDO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEExMXlNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvYTExeSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgTWNMaW5rIH0gZnJvbSAnLi9saW5rLmNvbXBvbmVudCc7XG5cblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIENvbW1vbk1vZHVsZSxcbiAgICAgICAgQTExeU1vZHVsZVxuICAgIF0sXG4gICAgZGVjbGFyYXRpb25zOiBbTWNMaW5rXSxcbiAgICBleHBvcnRzOiBbTWNMaW5rXVxufSlcbmV4cG9ydCBjbGFzcyBNY0xpbmtNb2R1bGUge31cbiJdfQ==