@messaia/cdk 0.0.0-CDK

package/esm2020/lib/dialogs/services/dialog.service.mjs

@@ -0,0 +1,136 @@
+import { Injectable, Optional, SkipSelf } from '@angular/core';
+import { MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { VdAlertDialogComponent } from '../alert-dialog/alert-dialog.component';
+import { VdConfirmDialogComponent } from '../confirm-dialog/confirm-dialog.component';
+import { VdPromptDialogComponent } from '../prompt-dialog/prompt-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+export class VdDialogService {
+    /**
+     * Constructor
+     * @param dialogService
+     */
+    constructor(dialogService) {
+        this.dialogService = dialogService;
+    }
+    /**
+     * params:
+     * - component: ComponentType<T>
+     * - config: MdDialogConfig
+     * Wrapper function over the open() method in MdDialog.
+     * Opens a modal dialog containing the given component.
+     */
+    open(component, config) {
+        return this.dialogService.open(component, config);
+    }
+    /**
+     * Wrapper function over the closeAll() method in MdDialog.
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        this.dialogService.closeAll();
+    }
+    /**
+     * params:
+     * - config: IAlertConfig {
+     *     message: string;
+     *     title?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     closeButton?: string;
+     * }
+     *
+     * Opens an alert dialog with the provided config.
+     * Returns an MdDialogRef<VdAlertDialogComponent> object.
+     */
+    openAlert(config) {
+        let dialogConfig = this._createConfig(config);
+        let dialogRef = this.dialogService.open(VdAlertDialogComponent, dialogConfig);
+        dialogRef.componentInstance.title = config.title;
+        dialogRef.componentInstance.message = config.message;
+        if (config.closeButton) {
+            dialogRef.componentInstance.closeButton = config.closeButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * params:
+     * - config: IConfirmConfig {
+     *     message: string;
+     *     title?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     acceptButton?: string;
+     *     cancelButton?: string;
+     * }
+     *
+     * Opens a confirm dialog with the provided config.
+     * Returns an MdDialogRef<VdConfirmDialogComponent> object.
+     */
+    openConfirm(config) {
+        let dialogConfig = this._createConfig(config);
+        let dialogRef = this.dialogService.open(VdConfirmDialogComponent, dialogConfig);
+        dialogRef.componentInstance.title = config.title;
+        dialogRef.componentInstance.message = config.message;
+        if (config.acceptButton) {
+            dialogRef.componentInstance.acceptButton = config.acceptButton;
+        }
+        if (config.cancelButton) {
+            dialogRef.componentInstance.cancelButton = config.cancelButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * params:
+     * - config: IPromptConfig {
+     *     message: string;
+     *     title?: string;
+     *     value?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     acceptButton?: string;
+     *     cancelButton?: string;
+     * }
+     *
+     * Opens a prompt dialog with the provided config.
+     * Returns an MdDialogRef<VdPromptDialogComponent> object.
+     */
+    openPrompt(config) {
+        let dialogConfig = this._createConfig(config);
+        let dialogRef = this.dialogService.open(VdPromptDialogComponent, dialogConfig);
+        dialogRef.componentInstance.title = config.title;
+        dialogRef.componentInstance.message = config.message;
+        dialogRef.componentInstance.value = config.value;
+        if (config.acceptButton) {
+            dialogRef.componentInstance.acceptButton = config.acceptButton;
+        }
+        if (config.cancelButton) {
+            dialogRef.componentInstance.cancelButton = config.cancelButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * Creates configuration
+     * @param config
+     * @returns
+     */
+    _createConfig(config) {
+        let dialogConfig = new MatDialogConfig();
+        dialogConfig.viewContainerRef = config.viewContainerRef;
+        dialogConfig.disableClose = config.disableClose;
+        return dialogConfig;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ VdDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdDialogService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ VdDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdDialogService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdDialogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }]; } });
+export function DIALOG_PROVIDER_FACTORY(parent, dialog) {
+    return parent || new VdDialogService(dialog);
+}
+export const DIALOG_PROVIDER = {
+    // If there is already service available, use that. Otherwise, provide a new one.
+    provide: VdDialogService,
+    deps: [[new Optional(), new SkipSelf(), VdDialogService], MatDialog],
+    useFactory: DIALOG_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/dialogs/services/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from '@angular/cdk/portal';\r\nimport { Injectable, Optional, Provider, SkipSelf, ViewContainerRef } from '@angular/core';\r\nimport { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';\r\nimport { VdAlertDialogComponent } from '../alert-dialog/alert-dialog.component';\r\nimport { VdConfirmDialogComponent } from '../confirm-dialog/confirm-dialog.component';\r\nimport { VdPromptDialogComponent } from '../prompt-dialog/prompt-dialog.component';\r\n\r\nexport interface IDialogConfig {\r\n\ttitle?: string;\r\n\tmessage: string;\r\n\tviewContainerRef?: ViewContainerRef;\r\n\tdisableClose?: boolean;\r\n}\r\n\r\nexport interface IAlertConfig extends IDialogConfig {\r\n\tcloseButton?: string;\r\n}\r\n\r\nexport interface IConfirmConfig extends IDialogConfig {\r\n\tacceptButton?: string;\r\n\tcancelButton?: string;\r\n}\r\n\r\nexport interface IPromptConfig extends IConfirmConfig {\r\n\tvalue?: string;\r\n}\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class VdDialogService {\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param dialogService \r\n\t */\r\n\tconstructor(public dialogService: MatDialog) { }\r\n\r\n\t/**\r\n\t * params:\r\n\t * - component: ComponentType<T>\r\n\t * - config: MdDialogConfig\r\n\t * Wrapper function over the open() method in MdDialog.\r\n\t * Opens a modal dialog containing the given component.\r\n\t */\r\n\tpublic open<T>(component: ComponentType<T>, config?: MatDialogConfig): MatDialogRef<T> {\r\n\t\treturn this.dialogService.open(component, config);\r\n\t}\r\n\r\n\t/**\r\n\t * Wrapper function over the closeAll() method in MdDialog.\r\n\t * Closes all of the currently-open dialogs.\r\n\t */\r\n\tpublic closeAll(): void {\r\n\t\tthis.dialogService.closeAll();\r\n\t}\r\n\r\n\t/**\r\n\t * params:\r\n\t * - config: IAlertConfig {\r\n\t *     message: string;\r\n\t *     title?: string;\r\n\t *     viewContainerRef?: ViewContainerRef;\r\n\t *     closeButton?: string;\r\n\t * }\r\n\t *\r\n\t * Opens an alert dialog with the provided config.\r\n\t * Returns an MdDialogRef<VdAlertDialogComponent> object.\r\n\t */\r\n\tpublic openAlert(config: IAlertConfig): MatDialogRef<VdAlertDialogComponent> {\r\n\t\tlet dialogConfig: MatDialogConfig = this._createConfig(config);\r\n\t\tlet dialogRef: MatDialogRef<VdAlertDialogComponent> = this.dialogService.open(VdAlertDialogComponent, dialogConfig);\r\n\r\n\t\tdialogRef.componentInstance.title = config.title;\r\n\t\tdialogRef.componentInstance.message = config.message;\r\n\r\n\t\tif (config.closeButton) {\r\n\t\t\tdialogRef.componentInstance.closeButton = config.closeButton;\r\n\t\t}\r\n\r\n\t\treturn dialogRef;\r\n\t}\r\n\r\n\t/**\r\n\t * params:\r\n\t * - config: IConfirmConfig {\r\n\t *     message: string;\r\n\t *     title?: string;\r\n\t *     viewContainerRef?: ViewContainerRef;\r\n\t *     acceptButton?: string;\r\n\t *     cancelButton?: string;\r\n\t * }\r\n\t *\r\n\t * Opens a confirm dialog with the provided config.\r\n\t * Returns an MdDialogRef<VdConfirmDialogComponent> object.\r\n\t */\r\n\tpublic openConfirm(config: IConfirmConfig): MatDialogRef<VdConfirmDialogComponent> {\r\n\t\tlet dialogConfig: MatDialogConfig = this._createConfig(config);\r\n\t\tlet dialogRef: MatDialogRef<VdConfirmDialogComponent> = this.dialogService.open(VdConfirmDialogComponent, dialogConfig);\r\n\r\n\t\tdialogRef.componentInstance.title = config.title;\r\n\t\tdialogRef.componentInstance.message = config.message;\r\n\r\n\t\tif (config.acceptButton) {\r\n\t\t\tdialogRef.componentInstance.acceptButton = config.acceptButton;\r\n\t\t}\r\n\r\n\t\tif (config.cancelButton) {\r\n\t\t\tdialogRef.componentInstance.cancelButton = config.cancelButton;\r\n\t\t}\r\n\r\n\t\treturn dialogRef;\r\n\t}\r\n\r\n\t/**\r\n\t * params:\r\n\t * - config: IPromptConfig {\r\n\t *     message: string;\r\n\t *     title?: string;\r\n\t *     value?: string;\r\n\t *     viewContainerRef?: ViewContainerRef;\r\n\t *     acceptButton?: string;\r\n\t *     cancelButton?: string;\r\n\t * }\r\n\t *\r\n\t * Opens a prompt dialog with the provided config.\r\n\t * Returns an MdDialogRef<VdPromptDialogComponent> object.\r\n\t */\r\n\tpublic openPrompt(config: IPromptConfig): MatDialogRef<VdPromptDialogComponent> {\r\n\t\tlet dialogConfig: MatDialogConfig = this._createConfig(config);\r\n\t\tlet dialogRef: MatDialogRef<VdPromptDialogComponent> = this.dialogService.open(VdPromptDialogComponent, dialogConfig);\r\n\r\n\t\tdialogRef.componentInstance.title = config.title;\r\n\t\tdialogRef.componentInstance.message = config.message;\r\n\t\tdialogRef.componentInstance.value = config.value;\r\n\r\n\t\tif (config.acceptButton) {\r\n\t\t\tdialogRef.componentInstance.acceptButton = config.acceptButton;\r\n\t\t}\r\n\r\n\t\tif (config.cancelButton) {\r\n\t\t\tdialogRef.componentInstance.cancelButton = config.cancelButton;\r\n\t\t}\r\n\r\n\t\treturn dialogRef;\r\n\t}\r\n\r\n\t/**\r\n\t * Creates configuration\r\n\t * @param config \r\n\t * @returns \r\n\t */\r\n\tprivate _createConfig(config: MatDialogConfig): MatDialogConfig {\r\n\t\tlet dialogConfig: MatDialogConfig = new MatDialogConfig();\r\n\t\tdialogConfig.viewContainerRef = config.viewContainerRef;\r\n\t\tdialogConfig.disableClose = config.disableClose;\r\n\t\treturn dialogConfig;\r\n\t}\r\n\r\n}\r\n\r\nexport function DIALOG_PROVIDER_FACTORY(\r\n\tparent: VdDialogService, dialog: MatDialog): VdDialogService {\r\n\treturn parent || new VdDialogService(dialog);\r\n}\r\n\r\nexport const DIALOG_PROVIDER: Provider = {\r\n\t// If there is already service available, use that. Otherwise, provide a new one.\r\n\tprovide: VdDialogService,\r\n\tdeps: [[new Optional(), new SkipSelf(), VdDialogService], MatDialog],\r\n\tuseFactory: DIALOG_PROVIDER_FACTORY,\r\n};"]}

package/esm2020/lib/file/file-input.component.mjs

@@ -0,0 +1,327 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, HostBinding, Input, Output, Renderer2, ViewChild } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/cdk/a11y";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/input";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/material/form-field";
+const noop = () => { };
+let nextUniqueId = 0;
+export class VdFileInputComponent {
+    /**
+     * Constructor
+     * @param _merchantService
+     */
+    constructor(ngControl, fm, _elementRef, _renderer, _changeDetectorRef) {
+        this.ngControl = ngControl;
+        this.fm = fm;
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._changeDetectorRef = _changeDetectorRef;
+        /**
+         * A name for this control that can be used by `vd-file-input`.
+         */
+        this.controlType = 'vd-file-input';
+        /**
+         * Because the <mat-form-field> uses the OnPush change detection strategy, we need
+         * to let it know when something happens in the form field control that may require
+         * the form field to run change detection. We do this via the stateChanges property.
+         * So far the only thing the form field needs to know about is when the value changes.
+         * We'll need to emit on the stateChanges stream when that happens, and as we continue
+         * flushing out these properties we'll likely find more places we need to emit. We
+         * should also make sure to complete stateChanges when our component is destroyed.
+         */
+        this.stateChanges = new Subject();
+        /**
+         * This property is used to indicate whether the input is focused.
+         */
+        this._focused = false;
+        /**
+         * This property tells the form field when it should be in the disabled state.
+         */
+        this._disabled = false;
+        /**
+         * This property is used to indicate whether the input is required.
+         */
+        this._required = false;
+        /**
+         * This property is used to indicate whether the input support multiple files.
+         */
+        this._multiple = false;
+        /**
+         * select?: function
+         * Event emitted a file is selected
+         * Emits a [File | FileList] object.
+         */
+        this.onSelect = new EventEmitter();
+        /**
+        * clear?: function
+        * Event emitted a file is cleared
+        */
+        this.onClear = new EventEmitter();
+        /**
+         * This property should return the ID of an element in the component's template
+         * that we want the <mat-form-field> to associate all of its labels and hints with.
+         * In this case, we'll use the host element and just generate a unique ID for it.
+         */
+        this.id = `vd-file-input-${nextUniqueId++}`;
+        /**
+         * Placeholders for the callbacks which are later providesd
+         * by the Control Value Accessor
+         */
+        this.onChangeCallback = noop;
+        this.onTouchedCallback = noop;
+        /**
+         * This method is used by the <mat-form-field> to specify the IDs that
+         * should be used for the aria-describedby attribute of your component.
+         * The method has one parameter, the list of IDs, we just need to apply
+         *  the given IDs to our host element.
+         */
+        this.describedBy = '';
+        ngControl.valueAccessor = this;
+        fm.monitor(_elementRef.nativeElement, true).subscribe(origin => {
+            this._focused = !!origin;
+            this.stateChanges.next();
+        });
+    }
+    get inputElement() {
+        return this._inputElement.nativeElement;
+    }
+    get fileInputElement() {
+        return this._fileInputElement.nativeElement;
+    }
+    /**
+     * Setters and getters for the input value.
+     * Its type should be the same type we used for the type parameter when we
+     * implemented MatFormFieldControl. Since our component already has a value
+     * property, we don't need to do anything for this one.
+     */
+    get value() { return this._value; }
+    ;
+    set value(v) {
+        if (v !== this._value) {
+            this._value = v;
+            this.onChangeCallback(v);
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Whether the input is focused.
+     */
+    get focused() { return this._inputElement.nativeElement.focused; }
+    /**
+     * Whether the input has a value.
+     */
+    get empty() { return !this.value; }
+    /**
+     * Placeholder to be shown if no value has been selected.
+     * Since the value of the placeholder may change over time, we need to make sure to
+     * trigger change detection in the parent form field by emitting on the stateChanges
+     * stream when the placeholder changes.
+     */
+    get placeholder() { return this._placeholder; }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    /**
+     * Whether the input is required.
+     * Again, we'll want to make sure we run change detection if the required state changes.
+     */
+    get required() { return this._required; }
+    set required(req) {
+        this._required = coerceBooleanProperty(req);
+        this.stateChanges.next();
+    }
+    /**
+     * Whether the input is multiple.
+     * Again, we'll want to make sure we run change detection if the required state changes.
+     */
+    get multiple() { return this._multiple; }
+    set multiple(req) {
+        this._multiple = coerceBooleanProperty(req);
+        this.stateChanges.next();
+    }
+    /**
+     * In addition to reporting the right state to the form field, we need to
+     * set the disabled state on the individual inputs that make up our component.
+     */
+    get disabled() { return this._disabled; }
+    set disabled(dis) {
+        this._disabled = coerceBooleanProperty(dis);
+        this.stateChanges.next();
+    }
+    get errorState() {
+        return this.ngControl.errors !== null && this.ngControl.touched;
+    }
+    /**
+     * This property is used to indicate whether the label should be in the floating position.
+     * We'll use the same logic as matInput and float the placeholder when the input is focused
+     *  or non-empty. Since the placeholder will be overlapping our control when when it's not
+     * floating, we should hide the – characters when it's not floating.
+     */
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    /**
+    * Method executed when a file is selected.
+    */
+    handleSelect(files) {
+        let file = files[0];
+        if (file) {
+            this.writeValue(file.name);
+            this.onSelect.emit(file);
+        }
+        else {
+            this.writeValue(null);
+        }
+    }
+    /**
+    * Used to clear the selected files from the [VdFileInputComponent].
+    */
+    clear() {
+        this.writeValue(null);
+        this._renderer.setProperty(this.inputElement, 'value', null);
+        this.onClear.emit(null);
+    }
+    /** Method executed when the disabled value changes */
+    onDisabledChange(v) {
+        if (v) {
+            this.clear();
+        }
+    }
+    /**
+    * Implemented as part of ControlValueAccessor.
+    */
+    writeValue(value) {
+        this.value = value;
+        if (this.ngControl && this.ngControl.control) {
+            this.ngControl.control.markAsTouched();
+            this.ngControl.control.markAsDirty();
+        }
+        this._changeDetectorRef.markForCheck();
+        if (!value) {
+            this.fileInputElement.value = null;
+        }
+    }
+    /**
+     * From ControlValueAccessor interface
+     * @param fn
+     */
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    /**
+     * From ControlValueAccessor interface
+     * @param fn
+     */
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    setDescribedByIds(ids) {
+        this.describedBy = ids.join(' ');
+    }
+    /**
+     * This method will be called when the form field is clicked on.
+     * It allows the component to hook in and handle that click however it wants.
+     * The method has one parameter, the MouseEvent for the click. In our case we'll
+     * just focus the first <input> if the user isn't about to click an <input> anyways.
+     * @param event
+     */
+    onContainerClick(event) {
+        this.inputElement.focus();
+    }
+    /**
+     * Lifecycle hook that is called when a directive, pipe or service is destroyed.
+     */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+        this.fm.stopMonitoring(this._elementRef.nativeElement);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ VdFileInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileInputComponent, deps: [{ token: i1.NgControl }, { token: i2.FocusMonitor }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ VdFileInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: VdFileInputComponent, selector: "[vd-file-input]", inputs: { accept: "accept", placeholder: "placeholder", required: "required", multiple: "multiple", disabled: "disabled", errorState: "errorState" }, outputs: { onSelect: "select", onClear: "clear" }, host: { properties: { "id": "this.id", "class.floating": "this.shouldLabelFloat", "attr.aria-describedby": "this.describedBy" } }, providers: [
+        { provide: MatFormFieldControl, useExisting: VdFileInputComponent }
+    ], viewQueries: [{ propertyName: "_inputElement", first: true, predicate: ["fileElement"], descendants: true, static: true }, { propertyName: "_fileInputElement", first: true, predicate: ["fileInput"], descendants: true, static: true }], ngImport: i0, template: `
+		<div layout="row" flex>
+			<input matInput #fileElement [(ngModel)]="value" (click)="fileInput.click()" readonly="true" [placeholder]="placeholder" [disabled]="disabled" [required]="required">
+			<input hidden type="file" [accept]="accept" #fileInput (change)="handleSelect($event.target.files)" />
+			<div class="btn-suffix">
+				<button type="button" mat-button *ngIf="!value" matSuffix mat-icon-button (click)="fileInput.click()">
+					<mat-icon>file_upload</mat-icon>
+				</button>
+				<button type="button" mat-button *ngIf="value" matSuffix mat-icon-button (click)="clear()">
+					<mat-icon>close</mat-icon>
+				</button>
+			</div>
+		</div>`, isInline: true, styles: [".btn-suffix .mat-button{position:absolute;right:0;top:0}\n"], components: [{ type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], directives: [{ type: i5.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.MatSuffix, selector: "[matSuffix]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileInputComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[vd-file-input]',
+                    template: `
+		<div layout="row" flex>
+			<input matInput #fileElement [(ngModel)]="value" (click)="fileInput.click()" readonly="true" [placeholder]="placeholder" [disabled]="disabled" [required]="required">
+			<input hidden type="file" [accept]="accept" #fileInput (change)="handleSelect($event.target.files)" />
+			<div class="btn-suffix">
+				<button type="button" mat-button *ngIf="!value" matSuffix mat-icon-button (click)="fileInput.click()">
+					<mat-icon>file_upload</mat-icon>
+				</button>
+				<button type="button" mat-button *ngIf="value" matSuffix mat-icon-button (click)="clear()">
+					<mat-icon>close</mat-icon>
+				</button>
+			</div>
+		</div>`,
+                    styles: [`
+		.btn-suffix .mat-button {
+			position: absolute;
+			right: 0;
+			top: 0;
+		}`
+                    ],
+                    providers: [
+                        { provide: MatFormFieldControl, useExisting: VdFileInputComponent }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl }, { type: i2.FocusMonitor }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { accept: [{
+                type: Input,
+                args: ['accept']
+            }], onSelect: [{
+                type: Output,
+                args: ['select']
+            }], onClear: [{
+                type: Output,
+                args: ['clear']
+            }], _inputElement: [{
+                type: ViewChild,
+                args: ['fileElement', { static: true }]
+            }], _fileInputElement: [{
+                type: ViewChild,
+                args: ['fileInput', { static: true }]
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], errorState: [{
+                type: Input
+            }], id: [{
+                type: HostBinding
+            }], shouldLabelFloat: [{
+                type: HostBinding,
+                args: ['class.floating']
+            }], describedBy: [{
+                type: HostBinding,
+                args: ['attr.aria-describedby']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-input.component.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/file/file-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\r\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { ChangeDetectorRef, Component, ElementRef, EventEmitter, HostBinding, Input, OnDestroy, Output, Renderer2, ViewChild } from '@angular/core';\r\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\r\nimport { MatFormFieldControl } from '@angular/material/form-field';\r\nimport { Subject } from 'rxjs';\r\n\r\nconst noop = () => { };\r\nlet nextUniqueId = 0;\r\n\r\n@Component({\r\n\tselector: '[vd-file-input]',\r\n\ttemplate: `\r\n\t\t<div layout=\"row\" flex>\r\n\t\t\t<input matInput #fileElement [(ngModel)]=\"value\" (click)=\"fileInput.click()\" readonly=\"true\" [placeholder]=\"placeholder\" [disabled]=\"disabled\" [required]=\"required\">\r\n\t\t\t<input hidden type=\"file\" [accept]=\"accept\" #fileInput (change)=\"handleSelect($event.target.files)\" />\r\n\t\t\t<div class=\"btn-suffix\">\r\n\t\t\t\t<button type=\"button\" mat-button *ngIf=\"!value\" matSuffix mat-icon-button (click)=\"fileInput.click()\">\r\n\t\t\t\t\t<mat-icon>file_upload</mat-icon>\r\n\t\t\t\t</button>\r\n\t\t\t\t<button type=\"button\" mat-button *ngIf=\"value\" matSuffix mat-icon-button (click)=\"clear()\">\r\n\t\t\t\t\t<mat-icon>close</mat-icon>\r\n\t\t\t\t</button>\r\n\t\t\t</div>\r\n\t\t</div>`,\r\n\tstyles: [`\r\n\t\t.btn-suffix .mat-button {\r\n\t\t\tposition: absolute;\r\n\t\t\tright: 0;\r\n\t\t\ttop: 0;\r\n\t\t}`\r\n\t],\r\n\tproviders: [\r\n\t\t{ provide: MatFormFieldControl, useExisting: VdFileInputComponent }\r\n\t]\r\n})\r\nexport class VdFileInputComponent implements MatFormFieldControl<any>, ControlValueAccessor, OnDestroy {\r\n\r\n\t/** \r\n\t * A name for this control that can be used by `vd-file-input`.\r\n\t */\r\n\tpublic controlType = 'vd-file-input';\r\n\r\n\t/**\r\n\t * Because the <mat-form-field> uses the OnPush change detection strategy, we need \r\n\t * to let it know when something happens in the form field control that may require \r\n\t * the form field to run change detection. We do this via the stateChanges property. \r\n\t * So far the only thing the form field needs to know about is when the value changes. \r\n\t * We'll need to emit on the stateChanges stream when that happens, and as we continue \r\n\t * flushing out these properties we'll likely find more places we need to emit. We \r\n\t * should also make sure to complete stateChanges when our component is destroyed.\r\n\t */\r\n\tpublic stateChanges = new Subject<void>();\r\n\r\n\t/** \r\n\t * The placeholder displayed in the trigger of the select.\r\n\t */\r\n\tprivate _placeholder: string;\r\n\r\n\t/**\r\n\t * This property is used to indicate whether the input is focused.\r\n\t */\r\n\tpublic _focused: boolean = false;\r\n\r\n\t/**\r\n\t * This property tells the form field when it should be in the disabled state.\r\n\t */\r\n\tpublic _disabled: boolean = false;\r\n\r\n\t/**\r\n\t * This property is used to indicate whether the input is required.\r\n\t */\r\n\tpublic _required: boolean = false;\r\n\r\n\t/**\r\n\t * This property is used to indicate whether the input support multiple files.\r\n\t */\r\n\tpublic _multiple: boolean = false;\r\n\r\n\t/**\r\n\t * This property allows someone to set or get the value of our control.\r\n\t */\r\n\tpublic _value: string;\r\n\r\n\t/**\r\n\t * accept?: string\r\n\t * Sets files accepted when opening the file browser dialog.\r\n\t * Same as 'accept' attribute in <input/> element.\r\n\t */\r\n\t@Input('accept') accept: string;\r\n\r\n\t/**\r\n\t * select?: function\r\n\t * Event emitted a file is selected\r\n\t * Emits a [File | FileList] object.\r\n\t */\r\n\t@Output('select') onSelect: EventEmitter<File | FileList> = new EventEmitter<File | FileList>();\r\n\r\n\t/**\r\n\t* clear?: function\r\n\t* Event emitted a file is cleared\r\n\t*/\r\n\t@Output('clear') onClear: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n\t/** \r\n\t * The input element\r\n\t */\r\n\t@ViewChild('fileElement', { static: true }) _inputElement: ElementRef;\r\n\tget inputElement(): HTMLInputElement {\r\n\t\treturn this._inputElement.nativeElement;\r\n\t}\r\n\r\n\t/** \r\n\t * The native `<input type=\"file\"> element\r\n\t */\r\n\t@ViewChild('fileInput', { static: true }) _fileInputElement: ElementRef;\r\n\tget fileInputElement(): HTMLInputElement {\r\n\t\treturn this._fileInputElement.nativeElement;\r\n\t}\r\n\r\n\t/**\r\n\t * Setters and getters for the input value.\r\n\t * Its type should be the same type we used for the type parameter when we \r\n\t * implemented MatFormFieldControl. Since our component already has a value \r\n\t * property, we don't need to do anything for this one.\r\n\t */\r\n\tget value(): string { return this._value };\r\n\tset value(v: string) {\r\n\t\tif (v !== this._value) {\r\n\t\t\tthis._value = v;\r\n\t\t\tthis.onChangeCallback(v);\r\n\t\t\tthis.stateChanges.next();\r\n\t\t}\r\n\t}\r\n\r\n\t/** \r\n\t * Whether the input is focused.\r\n\t */\r\n\tget focused() { return this._inputElement.nativeElement.focused; }\r\n\r\n\t/** \r\n\t * Whether the input has a value.\r\n\t */\r\n\tget empty(): boolean { return !this.value; }\r\n\r\n\t/** \r\n\t * Placeholder to be shown if no value has been selected.\r\n\t * Since the value of the placeholder may change over time, we need to make sure to \r\n\t * trigger change detection in the parent form field by emitting on the stateChanges \r\n\t * stream when the placeholder changes.\r\n\t */\r\n\t@Input()\r\n\tget placeholder() { return this._placeholder; }\r\n\tset placeholder(value: string) {\r\n\t\tthis._placeholder = value;\r\n\t\tthis.stateChanges.next();\r\n\t}\r\n\r\n\t/**\r\n\t * Whether the input is required.\r\n\t * Again, we'll want to make sure we run change detection if the required state changes.\r\n\t */\r\n\t@Input()\r\n\tget required() { return this._required; }\r\n\tset required(req) {\r\n\t\tthis._required = coerceBooleanProperty(req);\r\n\t\tthis.stateChanges.next();\r\n\t}\r\n\r\n\t/**\r\n\t * Whether the input is multiple.\r\n\t * Again, we'll want to make sure we run change detection if the required state changes.\r\n\t */\r\n\t@Input()\r\n\tget multiple() { return this._multiple; }\r\n\tset multiple(req) {\r\n\t\tthis._multiple = coerceBooleanProperty(req);\r\n\t\tthis.stateChanges.next();\r\n\t}\r\n\r\n\t/**\r\n\t * In addition to reporting the right state to the form field, we need to \r\n\t * set the disabled state on the individual inputs that make up our component.\r\n\t */\r\n\t@Input()\r\n\tget disabled() { return this._disabled; }\r\n\tset disabled(dis) {\r\n\t\tthis._disabled = coerceBooleanProperty(dis);\r\n\t\tthis.stateChanges.next();\r\n\t}\r\n\r\n\t@Input() get errorState() {\r\n\t\treturn this.ngControl.errors !== null && this.ngControl.touched;\r\n\t}\r\n\r\n\t/**\r\n\t * This property should return the ID of an element in the component's template \r\n\t * that we want the <mat-form-field> to associate all of its labels and hints with. \r\n\t * In this case, we'll use the host element and just generate a unique ID for it.\r\n\t */\r\n\t@HostBinding() id = `vd-file-input-${nextUniqueId++}`;\r\n\r\n\t/**\r\n\t * This property is used to indicate whether the label should be in the floating position.\r\n\t * We'll use the same logic as matInput and float the placeholder when the input is focused\r\n\t *  or non-empty. Since the placeholder will be overlapping our control when when it's not \r\n\t * floating, we should hide the – characters when it's not floating.\r\n\t */\r\n\t@HostBinding('class.floating')\r\n\tget shouldLabelFloat() {\r\n\t\treturn this.focused || !this.empty;\r\n\t}\r\n\r\n\t/**\r\n\t * Constructor\r\n\t * @param _merchantService \r\n\t */\r\n\tconstructor(public ngControl: NgControl, private fm: FocusMonitor, private _elementRef: ElementRef, private _renderer: Renderer2, private _changeDetectorRef: ChangeDetectorRef) {\r\n\t\tngControl.valueAccessor = this;\r\n\t\tfm.monitor(_elementRef.nativeElement, true).subscribe(origin => {\r\n\t\t\tthis._focused = !!origin;\r\n\t\t\tthis.stateChanges.next();\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t* Method executed when a file is selected.\r\n\t*/\r\n\thandleSelect(files: FileList): void {\r\n\t\tlet file = files[0];\r\n\t\tif (file) {\r\n\t\t\tthis.writeValue(file.name);\r\n\t\t\tthis.onSelect.emit(file);\r\n\t\t} else {\r\n\t\t\tthis.writeValue(null);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t* Used to clear the selected files from the [VdFileInputComponent].\r\n\t*/\r\n\tclear(): void {\r\n\t\tthis.writeValue(null);\r\n\t\tthis._renderer.setProperty(this.inputElement, 'value', null);\r\n\t\tthis.onClear.emit(null);\r\n\t}\r\n\r\n\t/** Method executed when the disabled value changes */\r\n\tonDisabledChange(v: boolean): void {\r\n\t\tif (v) {\r\n\t\t\tthis.clear();\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t* Implemented as part of ControlValueAccessor.\r\n\t*/\r\n\twriteValue(value: any): void {\r\n\t\tthis.value = value;\r\n\r\n\t\tif (this.ngControl && this.ngControl.control) {\r\n\t\t\tthis.ngControl.control.markAsTouched();\r\n\t\t\tthis.ngControl.control.markAsDirty();\r\n\t\t}\r\n\r\n\t\tthis._changeDetectorRef.markForCheck();\r\n\r\n\t\tif (!value) {\r\n\t\t\tthis.fileInputElement.value = null;\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * From ControlValueAccessor interface\r\n\t * @param fn \r\n\t */\r\n\tregisterOnChange(fn: any) {\r\n\t\tthis.onChangeCallback = fn;\r\n\t}\r\n\r\n    /**\r\n\t * From ControlValueAccessor interface\r\n\t * @param fn \r\n\t */\r\n\tregisterOnTouched(fn: any) {\r\n\t\tthis.onTouchedCallback = fn;\r\n\t}\r\n\r\n\t/**\r\n\t * Placeholders for the callbacks which are later providesd \r\n\t * by the Control Value Accessor\r\n\t */\r\n\tprivate onChangeCallback: (_: any) => void = noop;\r\n\tprivate onTouchedCallback: () => void = noop;\r\n\r\n\t/**\r\n\t * This method is used by the <mat-form-field> to specify the IDs that \r\n\t * should be used for the aria-describedby attribute of your component. \r\n\t * The method has one parameter, the list of IDs, we just need to apply\r\n\t *  the given IDs to our host element.\r\n\t */\r\n\t@HostBinding('attr.aria-describedby') describedBy = '';\r\n\tsetDescribedByIds(ids: string[]) {\r\n\t\tthis.describedBy = ids.join(' ');\r\n\t}\r\n\r\n\t/**\r\n\t * This method will be called when the form field is clicked on. \r\n\t * It allows the component to hook in and handle that click however it wants. \r\n\t * The method has one parameter, the MouseEvent for the click. In our case we'll \r\n\t * just focus the first <input> if the user isn't about to click an <input> anyways.\r\n\t * @param event \r\n\t */\r\n\tonContainerClick(event: MouseEvent) {\r\n\t\tthis.inputElement.focus();\r\n\t}\r\n\r\n\t/**\r\n\t * Lifecycle hook that is called when a directive, pipe or service is destroyed.\r\n\t */\r\n\tngOnDestroy() {\r\n\t\tthis.stateChanges.complete();\r\n\t\tthis.fm.stopMonitoring(this._elementRef.nativeElement);\r\n\t}\r\n}"]}

package/esm2020/lib/file/file.module.mjs

@@ -0,0 +1,39 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { VdFileInputComponent } from './file-input.component';
+import * as i0 from "@angular/core";
+export { VdFileInputComponent } from './file-input.component';
+export class VdFileModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdFileModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdFileModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileModule, declarations: [VdFileInputComponent], imports: [CommonModule,
+        FormsModule,
+        MatInputModule,
+        MatIconModule,
+        MatButtonModule], exports: [VdFileInputComponent] });
+/** @nocollapse */ /** @nocollapse */ VdFileModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileModule, imports: [[
+            CommonModule,
+            FormsModule,
+            MatInputModule,
+            MatIconModule,
+            MatButtonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: VdFileModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        MatInputModule,
+                        MatIconModule,
+                        MatButtonModule
+                    ],
+                    declarations: [VdFileInputComponent],
+                    exports: [VdFileInputComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/file/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './file.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL2ZpbGUvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZmlsZS5tb2R1bGUnIl19

package/esm2020/lib/form-validators/abstract/typed-form.mjs

@@ -0,0 +1,3 @@
+export class TypedForm {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZWQtZm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL2Zvcm0tdmFsaWRhdG9ycy9hYnN0cmFjdC90eXBlZC1mb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBZ0IsU0FBUztDQUU5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElGb3JtR3JvdXAgfSBmcm9tICcuLi9tb2RlbHMvaW50ZXJmYWNlL2ktZm9ybS1ncm91cCdcclxuXHJcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBUeXBlZEZvcm08VD57XHJcbiAgICBmb3JtR3JvdXA6IElGb3JtR3JvdXA8VD5cclxufSJdfQ==

package/esm2020/lib/form-validators/algorithm/luhn-algorithm.mjs

@@ -0,0 +1,15 @@
+export function calculate(numbers) {
+    let numberSum = 0;
+    for (var i = 0; i < numbers.length; i++)
+        numberSum += parseInt(numbers.substring(i, i + 1));
+    let deltas = new Array(0, 1, 2, 3, 4, -4, -3, -2, -1, 0);
+    for (var i = numbers.length - 1; i >= 0; i -= 2) {
+        numberSum += deltas[parseInt(numbers.substring(i, i + 1))];
+    }
+    let mod = numberSum % 10;
+    mod = 10 - mod;
+    if (mod == 10)
+        mod = 0;
+    return mod;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVobi1hbGdvcml0aG0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvc3JjL2xpYi9mb3JtLXZhbGlkYXRvcnMvYWxnb3JpdGhtL2x1aG4tYWxnb3JpdGhtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxTQUFTLENBQUMsT0FBZTtJQUNyQyxJQUFJLFNBQVMsR0FBRyxDQUFDLENBQUM7SUFDbEIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFO1FBQUUsU0FBUyxJQUFJLFFBQVEsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUU1RixJQUFJLE1BQU0sR0FBRyxJQUFJLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ3pELEtBQUssSUFBSSxDQUFDLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxFQUFFO1FBQzdDLFNBQVMsSUFBSSxNQUFNLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7S0FDOUQ7SUFFRCxJQUFJLEdBQUcsR0FBRyxTQUFTLEdBQUcsRUFBRSxDQUFDO0lBQ3pCLEdBQUcsR0FBRyxFQUFFLEdBQUcsR0FBRyxDQUFDO0lBQ2YsSUFBSSxHQUFHLElBQUksRUFBRTtRQUNULEdBQUcsR0FBRyxDQUFDLENBQUM7SUFDWixPQUFPLEdBQUcsQ0FBQztBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gY2FsY3VsYXRlKG51bWJlcnM6IHN0cmluZykge1xyXG4gICAgbGV0IG51bWJlclN1bSA9IDA7XHJcbiAgICBmb3IgKHZhciBpID0gMDsgaSA8IG51bWJlcnMubGVuZ3RoOyBpKyspIG51bWJlclN1bSArPSBwYXJzZUludChudW1iZXJzLnN1YnN0cmluZyhpLCBpICsgMSkpO1xyXG5cclxuICAgIGxldCBkZWx0YXMgPSBuZXcgQXJyYXkoMCwgMSwgMiwgMywgNCwgLTQsIC0zLCAtMiwgLTEsIDApO1xyXG4gICAgZm9yICh2YXIgaSA9IG51bWJlcnMubGVuZ3RoIC0gMTsgaSA+PSAwOyBpIC09IDIpIHtcclxuICAgICAgICBudW1iZXJTdW0gKz0gZGVsdGFzW3BhcnNlSW50KG51bWJlcnMuc3Vic3RyaW5nKGksIGkgKyAxKSldO1xyXG4gICAgfVxyXG5cclxuICAgIGxldCBtb2QgPSBudW1iZXJTdW0gJSAxMDtcclxuICAgIG1vZCA9IDEwIC0gbW9kO1xyXG4gICAgaWYgKG1vZCA9PSAxMClcclxuICAgICAgICBtb2QgPSAwO1xyXG4gICAgcmV0dXJuIG1vZDtcclxufSJdfQ==