@bravura/ui 3.8.1 → 5.0.0

package/esm2022/currency-input/currency-input.directive.mjs

@@ -0,0 +1,276 @@
+import { DecimalPipe, getCurrencySymbol } from '@angular/common';
+import { DEFAULT_CURRENCY_CODE, Directive, forwardRef, HostBinding, HostListener, Inject, Input, LOCALE_ID, Optional, Self, ɵfindLocaleData } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MAT_FORM_FIELD } from '@angular/material/form-field';
+import { MatInput } from '@angular/material/input';
+import { noop } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+/* tslint:disable:no-empty */
+export const noop_consumer = (_) => { };
+/**
+ * This directive will enhance an input element to format the numbers entered to a currency amount.
+ */
+export class CurrencyInputDirective {
+    constructor(_el, _renderer, _locale, _defaultCurrencyCode, _field) {
+        this._el = _el;
+        this._renderer = _renderer;
+        this._locale = _locale;
+        this._defaultCurrencyCode = _defaultCurrencyCode;
+        this._field = _field;
+        /**
+         * true to allow negative input, otherwise false
+         * Default to false.
+         */
+        this.allowNegative = false;
+        /**
+         * Provide the currency code to format the entered amount.
+         * Uses angular token DEFAULT_CURRENCY_CODE by default.
+         */
+        this.currencyCode = '';
+        /**
+         * true if no decimal digits allowed, otherwise false.
+         * Default to false.
+         */
+        this.baseUnitOnly = false;
+        /**
+         * The format the of the amount either in wide or narrow.
+         */
+        this.format = 'wide';
+        this.placeholder = '';
+        this.autocomplete = 'off';
+        this.type = 'text';
+        this.inputMode = 'decimal';
+        this.change = noop_consumer;
+        this.onTouch = noop;
+        this._symbol = '$';
+        this._ds = '.'; // decimal separator
+        this._trailing = false;
+        const userAgent = navigator.userAgent;
+        this._safari = !userAgent.match(/Firefox/i) && !userAgent.match(/Chrome/i) && !!userAgent.match(/safari/i);
+        this._currencyUpdated();
+    }
+    ngOnInit() { }
+    ngOnChanges() {
+        this._currencyUpdated();
+        this.onInput();
+    }
+    onInput() {
+        this._formatCurrency(this._el, false, true);
+    }
+    onFocus() {
+        this._formatCurrency(this._el, false, true);
+    }
+    onblur() {
+        this.onTouch();
+        this._formatCurrency(this._el, true, false);
+    }
+    writeValue(value) {
+        value = this._decimalPipe.transform(value);
+        this._renderer.setProperty(this._el.nativeElement, 'value', value);
+        this._formatCurrency(this._el, true, false);
+    }
+    registerOnChange(fn) {
+        this.change = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    _updatePlaceholder() {
+        this.placeholder = this.placeholder || this._0Text;
+        if (this._field?._control instanceof MatInput) {
+            this._field._control.placeholder = this.placeholder;
+        }
+    }
+    _currencyUpdated() {
+        this.currencyCode = this.currencyCode || this._defaultCurrencyCode;
+        this._symbol = getCurrencySymbol(this.currencyCode, this.format, this._locale) || '$';
+        const localeData = ɵfindLocaleData(this._locale);
+        this._ds = localeData[13][0];
+        this._decimalPipe = new DecimalPipe(this._locale);
+        const curFormat = localeData[14][2];
+        this._trailing = curFormat.indexOf('¤') > 0;
+        this._updatePlaceholder();
+    }
+    _formatCurrency(input, blur, focus) {
+        // appends $ to value, validates decimal side
+        // and puts cursor back in right position.
+        // get input value
+        let input_val = input.nativeElement.value;
+        // don't validate empty input
+        if (input_val === '') {
+            this.change(null);
+            return;
+        }
+        const minus = this.allowNegative ? '-' : '';
+        // remove non digit values except currency symbol, decimal separator and hypen
+        const reg = new RegExp(`[^0-9${minus}${this._symbol}${this._ds}]`, 'g');
+        let sanitiseValue = input_val.replace(reg, '');
+        if (sanitiseValue === '' || sanitiseValue === this._symbol) {
+            this.change(null);
+            this._renderer.setProperty(input.nativeElement, 'value', '');
+            return;
+        }
+        else if ((this.allowNegative && sanitiseValue === `-${this._symbol}`) ||
+            sanitiseValue === '-' ||
+            sanitiseValue === '--') {
+            this.change(null);
+            this._renderer.setProperty(input.nativeElement, 'value', '-');
+            return;
+        }
+        const negative = this.allowNegative && input_val.indexOf('-') >= 0;
+        // original length
+        const original_len = input_val.length;
+        // initial caret position
+        let caret_pos = input.nativeElement.selectionStart;
+        input_val = input_val.replace(RegExp(`[^0-9${minus}${this._ds}]`, 'g'), '').replace(/^\.\./, '');
+        // check for decimal
+        if (input_val.indexOf(this._ds) >= 0) {
+            // get position of first decimal
+            // this prevents multiple decimals from
+            // being entered
+            let decimal_pos = input_val.indexOf(this._ds);
+            // split number by decimal point
+            let left_side = input_val.substring(0, decimal_pos);
+            let right_side = input_val.substring(decimal_pos);
+            // add commas to left side of number
+            left_side = this._formatNumber(left_side, blur) || '';
+            // no value append a zero for decimal values
+            if (!left_side.length) {
+                left_side = '0';
+            }
+            if (!this.baseUnitOnly) {
+                // validate right side
+                right_side = right_side.replace(/\D/g, '');
+                // Limit decimal to only 2 digits
+                let v = Number(`0.${right_side}`);
+                if (v) {
+                    const length = right_side.length > 1 ? 2 : 1;
+                    right_side = v.toFixed(length).substring(2, 4);
+                }
+                // On blur make sure 2 numbers after decimal
+                if (blur) {
+                    right_side += '00';
+                }
+                right_side = right_side.substring(0, 2);
+                // join number by .
+                input_val = left_side + this._ds + right_side;
+            }
+            else {
+                input_val = left_side;
+            }
+        }
+        else {
+            input_val = this._formatNumber(input_val, blur);
+            // final formatting
+            if (blur && !this.baseUnitOnly) {
+                input_val += `${this._ds}00`;
+            }
+        }
+        const numStr = input_val;
+        // append the currency symbol
+        if (!this._safari || !focus) {
+            if (this._trailing) {
+                input_val = input_val + ' ' + this._symbol;
+            }
+            else {
+                input_val = this._symbol + input_val;
+            }
+        }
+        if (negative) {
+            // append the hypen back to the value if a negative value was entered
+            input_val = `-${input_val}`;
+        }
+        const num = this._convert((negative ? '-' : '') + numStr);
+        // update control value first with the number
+        this.change(Number(num));
+        if (blur && num === 0) {
+            input_val = this._0Text;
+        }
+        // update dom with the formatted value
+        this._renderer.setProperty(input.nativeElement, 'value', input_val);
+        // put caret back in the right position
+        let updated_len = input_val.length;
+        if (caret_pos) {
+            caret_pos = updated_len - original_len + caret_pos;
+            if (input_val.substring(caret_pos - this._symbol.length) === this._symbol && this._trailing) {
+                caret_pos -= this._symbol.length + 1;
+            }
+        }
+        if (!this._safari) {
+            input.nativeElement.setSelectionRange(caret_pos, caret_pos);
+        }
+    }
+    // format the number into currency format
+    _formatNumber(n, blur = false) {
+        // format number 1000000 to 1,234,567
+        n = n.replace(/\D/g, '');
+        if (blur) {
+            n = n.replace(/^0+/, '');
+        }
+        return this._decimalPipe.transform(n, '1.0-0');
+    }
+    _convert(input) {
+        const val = input
+            .replace(this._ds, 'd')
+            .replace(/[^0-9d-]/g, '')
+            .replace('d', '.');
+        return parseFloat(val);
+    }
+    get _0Text() {
+        const decimalStr = this.baseUnitOnly ? '' : `${this._ds}00`;
+        return this._trailing ? `0${decimalStr} ${this._symbol}` : `${this._symbol}0${decimalStr}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputDirective, deps: [{ token: i0.ElementRef, self: true }, { token: i0.Renderer2 }, { token: LOCALE_ID }, { token: DEFAULT_CURRENCY_CODE }, { token: MAT_FORM_FIELD, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: CurrencyInputDirective, selector: "input[buiCurrencyInput],input[currencyCode],input[data-type=currency]", inputs: { allowNegative: "allowNegative", currencyCode: "currencyCode", baseUnitOnly: "baseUnitOnly", format: "format" }, host: { listeners: { "input": "onInput()", "focus": "onFocus()", "blur": "onblur()" }, properties: { "placeholder": "this.placeholder", "autocomplete": "this.autocomplete", "type": "this.type", "attr.inputmode": "this.inputMode" } }, providers: [{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => CurrencyInputDirective), multi: true }], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[buiCurrencyInput],input[currencyCode],input[data-type=currency]',
+                    providers: [{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => CurrencyInputDirective), multi: true }]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef, decorators: [{
+                    type: Self
+                }] }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DEFAULT_CURRENCY_CODE]
+                }] }, { type: i1.MatFormField, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_FORM_FIELD]
+                }] }], propDecorators: { allowNegative: [{
+                type: Input
+            }], currencyCode: [{
+                type: Input
+            }], baseUnitOnly: [{
+                type: Input
+            }], format: [{
+                type: Input
+            }], placeholder: [{
+                type: HostBinding,
+                args: ['placeholder']
+            }], autocomplete: [{
+                type: HostBinding,
+                args: ['autocomplete']
+            }], type: [{
+                type: HostBinding,
+                args: ['type']
+            }], inputMode: [{
+                type: HostBinding,
+                args: ['attr.inputmode']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input']
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], onblur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency-input.directive.js","sourceRoot":"","sources":["../../../../projects/ui/currency-input/currency-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DecimalPipe, getCurrencySymbol } from '@angular/common';\r\nimport {\r\n\tDEFAULT_CURRENCY_CODE,\r\n\tDirective,\r\n\tElementRef,\r\n\tforwardRef,\r\n\tHostBinding,\r\n\tHostListener,\r\n\tInject,\r\n\tInput,\r\n\tLOCALE_ID,\r\n\tOnChanges,\r\n\tOnInit,\r\n\tOptional,\r\n\tRenderer2,\r\n\tSelf,\r\n\tɵfindLocaleData\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { MatFormField, MAT_FORM_FIELD } from '@angular/material/form-field';\r\nimport { MatInput } from '@angular/material/input';\r\nimport { noop } from 'rxjs';\r\n\r\n/* tslint:disable:no-empty */\r\nexport const noop_consumer = (_: any) => {};\r\n\r\n/**\r\n * This directive will enhance an input element to format the numbers entered to a currency amount.\r\n */\r\n@Directive({\r\n\tselector: 'input[buiCurrencyInput],input[currencyCode],input[data-type=currency]',\r\n\tproviders: [{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => CurrencyInputDirective), multi: true }]\r\n})\r\nexport class CurrencyInputDirective implements OnInit, OnChanges, ControlValueAccessor {\r\n\t/**\r\n\t * true to allow negative input, otherwise false\r\n\t * Default to false.\r\n\t */\r\n\t@Input()\r\n\tallowNegative: boolean = false;\r\n\r\n\t/**\r\n\t * Provide the currency code to format the entered amount.\r\n\t * Uses angular token DEFAULT_CURRENCY_CODE by default.\r\n\t */\r\n\t@Input()\r\n\tcurrencyCode: string = '';\r\n\r\n\t/**\r\n\t * true if no decimal digits allowed, otherwise false.\r\n\t * Default to false.\r\n\t */\r\n\t@Input()\r\n\tbaseUnitOnly = false;\r\n\r\n\t/**\r\n\t * The format the of the amount either in wide or narrow.\r\n\t */\r\n\t@Input()\r\n\tformat: 'narrow' | 'wide' = 'wide';\r\n\r\n\t@HostBinding('placeholder')\r\n\tprivate placeholder: string = '';\r\n\r\n\t@HostBinding('autocomplete')\r\n\tprivate autocomplete = 'off';\r\n\r\n\t@HostBinding('type')\r\n\tprivate type = 'text';\r\n\r\n\t@HostBinding('attr.inputmode')\r\n\tprivate inputMode = 'decimal';\r\n\r\n\tprivate change = noop_consumer;\r\n\tprivate onTouch = noop;\r\n\tprivate _safari: boolean;\r\n\tprivate _symbol: string = '$';\r\n\tprivate _decimalPipe!: DecimalPipe;\r\n\r\n\tprivate _ds = '.'; // decimal separator\r\n\tprivate _trailing = false;\r\n\r\n\tconstructor(\r\n\t\t@Self() private _el: ElementRef<HTMLInputElement>,\r\n\t\tprivate _renderer: Renderer2,\r\n\t\t@Inject(LOCALE_ID) private _locale: string,\r\n\t\t@Inject(DEFAULT_CURRENCY_CODE) private _defaultCurrencyCode: string,\r\n\t\t@Optional() @Inject(MAT_FORM_FIELD) private _field?: MatFormField\r\n\t) {\r\n\t\tconst userAgent = navigator.userAgent;\r\n\t\tthis._safari = !userAgent.match(/Firefox/i) && !userAgent.match(/Chrome/i) && !!userAgent.match(/safari/i);\r\n\t\tthis._currencyUpdated();\r\n\t}\r\n\r\n\tngOnInit() {}\r\n\r\n\tngOnChanges(): void {\r\n\t\tthis._currencyUpdated();\r\n\t\tthis.onInput();\r\n\t}\r\n\r\n\t@HostListener('input')\r\n\tonInput() {\r\n\t\tthis._formatCurrency(this._el, false, true);\r\n\t}\r\n\r\n\t@HostListener('focus')\r\n\tonFocus() {\r\n\t\tthis._formatCurrency(this._el, false, true);\r\n\t}\r\n\r\n\t@HostListener('blur')\r\n\tonblur() {\r\n\t\tthis.onTouch();\r\n\t\tthis._formatCurrency(this._el, true, false);\r\n\t}\r\n\r\n\twriteValue(value: any) {\r\n\t\tvalue = this._decimalPipe.transform(value);\r\n\t\tthis._renderer.setProperty(this._el.nativeElement, 'value', value);\r\n\t\tthis._formatCurrency(this._el, true, false);\r\n\t}\r\n\r\n\tregisterOnChange(fn: any) {\r\n\t\tthis.change = fn;\r\n\t}\r\n\r\n\tregisterOnTouched(fn: any) {\r\n\t\tthis.onTouch = fn;\r\n\t}\r\n\r\n\tprivate _updatePlaceholder() {\r\n\t\tthis.placeholder = this.placeholder || this._0Text;\r\n\t\tif (this._field?._control instanceof MatInput) {\r\n\t\t\tthis._field._control.placeholder = this.placeholder;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate _currencyUpdated() {\r\n\t\tthis.currencyCode = this.currencyCode || this._defaultCurrencyCode;\r\n\t\tthis._symbol = getCurrencySymbol(this.currencyCode, this.format, this._locale) || '$';\r\n\t\tconst localeData = ɵfindLocaleData(this._locale);\r\n\t\tthis._ds = localeData[13][0];\r\n\t\tthis._decimalPipe = new DecimalPipe(this._locale);\r\n\t\tconst curFormat: string = localeData[14][2];\r\n\t\tthis._trailing = curFormat.indexOf('¤') > 0;\r\n\t\tthis._updatePlaceholder();\r\n\t}\r\n\r\n\tprivate _formatCurrency(input: ElementRef<HTMLInputElement>, blur: boolean, focus: boolean) {\r\n\t\t// appends $ to value, validates decimal side\r\n\t\t// and puts cursor back in right position.\r\n\t\t// get input value\r\n\t\tlet input_val = input.nativeElement.value;\r\n\r\n\t\t// don't validate empty input\r\n\t\tif (input_val === '') {\r\n\t\t\tthis.change(null);\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst minus = this.allowNegative ? '-' : '';\r\n\r\n\t\t// remove non digit values except currency symbol, decimal separator and hypen\r\n\t\tconst reg = new RegExp(`[^0-9${minus}${this._symbol}${this._ds}]`, 'g');\r\n\r\n\t\tlet sanitiseValue = input_val.replace(reg, '');\r\n\r\n\t\tif (sanitiseValue === '' || sanitiseValue === this._symbol) {\r\n\t\t\tthis.change(null);\r\n\t\t\tthis._renderer.setProperty(input.nativeElement, 'value', '');\r\n\t\t\treturn;\r\n\t\t} else if (\r\n\t\t\t(this.allowNegative && sanitiseValue === `-${this._symbol}`) ||\r\n\t\t\tsanitiseValue === '-' ||\r\n\t\t\tsanitiseValue === '--'\r\n\t\t) {\r\n\t\t\tthis.change(null);\r\n\t\t\tthis._renderer.setProperty(input.nativeElement, 'value', '-');\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst negative = this.allowNegative && input_val.indexOf('-') >= 0;\r\n\r\n\t\t// original length\r\n\t\tconst original_len = input_val.length;\r\n\r\n\t\t// initial caret position\r\n\t\tlet caret_pos = input.nativeElement.selectionStart;\r\n\r\n\t\tinput_val = input_val.replace(RegExp(`[^0-9${minus}${this._ds}]`, 'g'), '').replace(/^\\.\\./, '');\r\n\t\t// check for decimal\r\n\t\tif (input_val.indexOf(this._ds) >= 0) {\r\n\t\t\t// get position of first decimal\r\n\t\t\t// this prevents multiple decimals from\r\n\t\t\t// being entered\r\n\t\t\tlet decimal_pos = input_val.indexOf(this._ds);\r\n\r\n\t\t\t// split number by decimal point\r\n\t\t\tlet left_side = input_val.substring(0, decimal_pos);\r\n\t\t\tlet right_side = input_val.substring(decimal_pos);\r\n\r\n\t\t\t// add commas to left side of number\r\n\t\t\tleft_side = this._formatNumber(left_side, blur) || '';\r\n\r\n\t\t\t// no value append a zero for decimal values\r\n\t\t\tif (!left_side.length) {\r\n\t\t\t\tleft_side = '0';\r\n\t\t\t}\r\n\r\n\t\t\tif (!this.baseUnitOnly) {\r\n\t\t\t\t// validate right side\r\n\t\t\t\tright_side = right_side.replace(/\\D/g, '');\r\n\r\n\t\t\t\t// Limit decimal to only 2 digits\r\n\t\t\t\tlet v = Number(`0.${right_side}`);\r\n\t\t\t\tif (v) {\r\n\t\t\t\t\tconst length = right_side.length > 1 ? 2 : 1;\r\n\t\t\t\t\tright_side = v.toFixed(length).substring(2, 4);\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// On blur make sure 2 numbers after decimal\r\n\t\t\t\tif (blur) {\r\n\t\t\t\t\tright_side += '00';\r\n\t\t\t\t}\r\n\r\n\t\t\t\tright_side = right_side.substring(0, 2);\r\n\r\n\t\t\t\t// join number by .\r\n\t\t\t\tinput_val = left_side + this._ds + right_side;\r\n\t\t\t} else {\r\n\t\t\t\tinput_val = left_side;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tinput_val = this._formatNumber(input_val, blur);\r\n\r\n\t\t\t// final formatting\r\n\t\t\tif (blur && !this.baseUnitOnly) {\r\n\t\t\t\tinput_val += `${this._ds}00`;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst numStr = input_val;\r\n\t\t// append the currency symbol\r\n\t\tif (!this._safari || !focus) {\r\n\t\t\tif (this._trailing) {\r\n\t\t\t\tinput_val = input_val + ' ' + this._symbol;\r\n\t\t\t} else {\r\n\t\t\t\tinput_val = this._symbol + input_val;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (negative) {\r\n\t\t\t// append the hypen back to the value if a negative value was entered\r\n\t\t\tinput_val = `-${input_val}`;\r\n\t\t}\r\n\r\n\t\tconst num = this._convert((negative ? '-' : '') + numStr);\r\n\r\n\t\t// update control value first with the number\r\n\t\tthis.change(Number(num));\r\n\r\n\t\tif (blur && num === 0) {\r\n\t\t\tinput_val = this._0Text;\r\n\t\t}\r\n\r\n\t\t// update dom with the formatted value\r\n\t\tthis._renderer.setProperty(input.nativeElement, 'value', input_val);\r\n\t\t// put caret back in the right position\r\n\t\tlet updated_len = input_val.length;\r\n\t\tif (caret_pos) {\r\n\t\t\tcaret_pos = updated_len - original_len + caret_pos;\r\n\t\t\tif (input_val.substring(caret_pos - this._symbol.length) === this._symbol && this._trailing) {\r\n\t\t\t\tcaret_pos -= this._symbol.length + 1;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (!this._safari) {\r\n\t\t\tinput.nativeElement.setSelectionRange(caret_pos, caret_pos);\r\n\t\t}\r\n\t}\r\n\r\n\t// format the number into currency format\r\n\tprivate _formatNumber(n: string, blur: boolean = false) {\r\n\t\t// format number 1000000 to 1,234,567\r\n\t\tn = n.replace(/\\D/g, '');\r\n\t\tif (blur) {\r\n\t\t\tn = n.replace(/^0+/, '');\r\n\t\t}\r\n\t\treturn this._decimalPipe.transform(n, '1.0-0') as string;\r\n\t}\r\n\r\n\tprivate _convert(input: string): number {\r\n\t\tconst val = input\r\n\t\t\t.replace(this._ds, 'd')\r\n\t\t\t.replace(/[^0-9d-]/g, '')\r\n\t\t\t.replace('d', '.');\r\n\t\treturn parseFloat(val);\r\n\t}\r\n\r\n\tprivate get _0Text(): string {\r\n\t\tconst decimalStr = this.baseUnitOnly ? '' : `${this._ds}00`;\r\n\t\treturn this._trailing ? `0${decimalStr} ${this._symbol}` : `${this._symbol}0${decimalStr}`;\r\n\t}\r\n}\r\n"]}

package/esm2022/currency-input/currency-input.module.mjs

@@ -0,0 +1,19 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { CurrencyInputDirective } from './currency-input.directive';
+import * as i0 from "@angular/core";
+export class CurrencyInputModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputModule, declarations: [CurrencyInputDirective], imports: [CommonModule], exports: [CurrencyInputDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: CurrencyInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CurrencyInputDirective],
+                    imports: [CommonModule],
+                    exports: [CurrencyInputDirective]
+                }]
+        }] });
+export { CurrencyInputDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3ktaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvY3VycmVuY3ktaW5wdXQvY3VycmVuY3ktaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQU9wRSxNQUFNLE9BQU8sbUJBQW1COzhHQUFuQixtQkFBbUI7K0dBQW5CLG1CQUFtQixpQkFKaEIsc0JBQXNCLGFBQzNCLFlBQVksYUFDWixzQkFBc0I7K0dBRXBCLG1CQUFtQixZQUhyQixZQUFZOzsyRkFHVixtQkFBbUI7a0JBTC9CLFFBQVE7bUJBQUM7b0JBQ1QsWUFBWSxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ3RDLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7aUJBQ2pDOztBQUdELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ3VycmVuY3lJbnB1dERpcmVjdGl2ZSB9IGZyb20gJy4vY3VycmVuY3ktaW5wdXQuZGlyZWN0aXZlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcblx0ZGVjbGFyYXRpb25zOiBbQ3VycmVuY3lJbnB1dERpcmVjdGl2ZV0sXHJcblx0aW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXHJcblx0ZXhwb3J0czogW0N1cnJlbmN5SW5wdXREaXJlY3RpdmVdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDdXJyZW5jeUlucHV0TW9kdWxlIHt9XHJcblxyXG5leHBvcnQgeyBDdXJyZW5jeUlucHV0RGlyZWN0aXZlIH07XHJcbiJdfQ==

package/{esm2020 → esm2022}/currency-input/public-api.mjs

@@ -1,2 +1,2 @@
 export * from './currency-input.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL2N1cnJlbmN5LWlucHV0L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3VycmVuY3ktaW5wdXQubW9kdWxlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpL2N1cnJlbmN5LWlucHV0L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3VycmVuY3ktaW5wdXQubW9kdWxlJztcclxuIl19

package/esm2022/decimal-input/decimal-input.directive.mjs

@@ -0,0 +1,122 @@
+import { DecimalPipe } from '@angular/common';
+import { Directive, forwardRef, HostBinding, HostListener, Input, Self } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { noop } from 'rxjs';
+import * as i0 from "@angular/core";
+/* tslint:disable:no-empty */
+export const noop_consumer = (_) => { };
+/**
+ * This directive will enhance an input element to format the numbers entered to a decimal amount.
+ */
+export class DecimalInputDirective {
+    constructor(_el, _renderer) {
+        this._el = _el;
+        this._renderer = _renderer;
+        /**
+         * number of decimal places allowed
+         */
+        this.buiDecimalInput = 2;
+        this.placeholder = '';
+        this.autocomplete = 'off';
+        this.type = 'number';
+        this.inputMode = 'decimal';
+        this.change = noop_consumer;
+        this.onTouch = noop;
+    }
+    ngOnChanges() {
+        this.buiDecimalInput = this.buiDecimalInput || 2;
+        this.onInput();
+    }
+    onInput() {
+        const value = this._el.nativeElement.value;
+        const decimalPart = value.split('.')[1];
+        if (decimalPart && decimalPart.length > this.buiDecimalInput) {
+            const indexOfPeriod = value.indexOf('.');
+            const newValue = value.substring(0, indexOfPeriod + this.buiDecimalInput + 1);
+            this._renderer.setProperty(this._el.nativeElement, 'value', newValue);
+        }
+        const resolvedValue = this._el.nativeElement.value;
+        this.change(resolvedValue === '' || resolvedValue === null || resolvedValue === undefined ? null : Number(resolvedValue));
+    }
+    onKeypress(evt) {
+        const target = evt.target;
+        const value = target.value;
+        const isSpace = evt.key === ' ';
+        if (isSpace ||
+            (!['.', '-'].includes(evt.key) && isNaN(Number(evt.key))) ||
+            (evt.key === '.' && value.indexOf('.') > 0)) {
+            evt.preventDefault();
+        }
+    }
+    onblur() {
+        this.onTouch();
+        this._resetDecimalPlaces();
+    }
+    writeValue(value) {
+        this._renderer.setProperty(this._el.nativeElement, 'value', value);
+        this._resetDecimalPlaces();
+    }
+    registerOnChange(fn) {
+        this.change = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    _resetDecimalPlaces() {
+        const value = this._el.nativeElement.value;
+        if (value === '' || value === null || value === undefined) {
+            return;
+        }
+        const splitValues = value.split('.');
+        let newValue = '';
+        if (splitValues[1] && splitValues[1].length > this.buiDecimalInput) {
+            newValue = value.substring(0, splitValues[0].length + 1 + this.buiDecimalInput);
+        }
+        else {
+            this.buiDecimalInput = this.buiDecimalInput < 0 ? 0 : this.buiDecimalInput;
+            newValue = Number(value).toFixed(this.buiDecimalInput);
+        }
+        this._renderer.setProperty(this._el.nativeElement, 'value', newValue);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputDirective, deps: [{ token: i0.ElementRef, self: true }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.2", type: DecimalInputDirective, selector: "input[buiDecimalInput]", inputs: { buiDecimalInput: "buiDecimalInput" }, host: { listeners: { "input": "onInput()", "keypress": "onKeypress($event)", "blur": "onblur()" }, properties: { "placeholder": "this.placeholder", "autocomplete": "this.autocomplete", "type": "this.type", "attr.inputmode": "this.inputMode" } }, providers: [
+            DecimalPipe,
+            { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => DecimalInputDirective), multi: true }
+        ], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[buiDecimalInput]',
+                    providers: [
+                        DecimalPipe,
+                        { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => DecimalInputDirective), multi: true }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef, decorators: [{
+                    type: Self
+                }] }, { type: i0.Renderer2 }], propDecorators: { buiDecimalInput: [{
+                type: Input
+            }], placeholder: [{
+                type: HostBinding,
+                args: ['placeholder']
+            }], autocomplete: [{
+                type: HostBinding,
+                args: ['autocomplete']
+            }], type: [{
+                type: HostBinding,
+                args: ['type']
+            }], inputMode: [{
+                type: HostBinding,
+                args: ['attr.inputmode']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input']
+            }], onKeypress: [{
+                type: HostListener,
+                args: ['keypress', ['$event']]
+            }], onblur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decimal-input.directive.js","sourceRoot":"","sources":["../../../../projects/ui/decimal-input/decimal-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DecimalPipe } from '@angular/common';\r\nimport {\r\n\tDirective,\r\n\tElementRef,\r\n\tforwardRef,\r\n\tHostBinding,\r\n\tHostListener,\r\n\tInput,\r\n\tOnChanges,\r\n\tRenderer2,\r\n\tSelf\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { noop } from 'rxjs';\r\n\r\n/* tslint:disable:no-empty */\r\nexport const noop_consumer = (_: any) => {};\r\n\r\n/**\r\n * This directive will enhance an input element to format the numbers entered to a decimal amount.\r\n */\r\n@Directive({\r\n\tselector: 'input[buiDecimalInput]',\r\n\tproviders: [\r\n\t\tDecimalPipe,\r\n\t\t{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => DecimalInputDirective), multi: true }\r\n\t]\r\n})\r\nexport class DecimalInputDirective implements OnChanges, ControlValueAccessor {\r\n\t/**\r\n\t * number of decimal places allowed\r\n\t */\r\n\t@Input()\r\n\tbuiDecimalInput: number = 2;\r\n\r\n\t@HostBinding('placeholder')\r\n\tprivate placeholder: string = '';\r\n\r\n\t@HostBinding('autocomplete')\r\n\tprivate autocomplete = 'off';\r\n\r\n\t@HostBinding('type')\r\n\tprivate type = 'number';\r\n\r\n\t@HostBinding('attr.inputmode')\r\n\tprivate inputMode = 'decimal';\r\n\r\n\tprivate change = noop_consumer;\r\n\tprivate onTouch = noop;\r\n\r\n\tconstructor(@Self() private _el: ElementRef<HTMLInputElement>, private _renderer: Renderer2) {}\r\n\r\n\tngOnChanges(): void {\r\n\t\tthis.buiDecimalInput = this.buiDecimalInput || 2;\r\n\t\tthis.onInput();\r\n\t}\r\n\r\n\t@HostListener('input')\r\n\tonInput() {\r\n\t\tconst value = this._el.nativeElement.value;\r\n\r\n\t\tconst decimalPart = value.split('.')[1];\r\n\r\n\t\tif (decimalPart && decimalPart.length > this.buiDecimalInput) {\r\n\t\t\tconst indexOfPeriod = value.indexOf('.');\r\n\t\t\tconst newValue = value.substring(0, indexOfPeriod + this.buiDecimalInput + 1);\r\n\t\t\tthis._renderer.setProperty(this._el.nativeElement, 'value', newValue);\r\n\t\t}\r\n\t\tconst resolvedValue = this._el.nativeElement.value;\r\n\t\tthis.change(\r\n\t\t\tresolvedValue === '' || resolvedValue === null || resolvedValue === undefined ? null : Number(resolvedValue)\r\n\t\t);\r\n\t}\r\n\r\n\t@HostListener('keypress', ['$event'])\r\n\tonKeypress(evt: KeyboardEvent) {\r\n\t\tconst target = evt.target as HTMLInputElement;\r\n\t\tconst value = target.value;\r\n\t\tconst isSpace = evt.key === ' ';\r\n\r\n\t\tif (\r\n\t\t\tisSpace ||\r\n\t\t\t(!['.', '-'].includes(evt.key) && isNaN(Number(evt.key))) ||\r\n\t\t\t(evt.key === '.' && value.indexOf('.') > 0)\r\n\t\t) {\r\n\t\t\tevt.preventDefault();\r\n\t\t}\r\n\t}\r\n\r\n\t@HostListener('blur')\r\n\tonblur() {\r\n\t\tthis.onTouch();\r\n\t\tthis._resetDecimalPlaces();\r\n\t}\r\n\r\n\twriteValue(value: any) {\r\n\t\tthis._renderer.setProperty(this._el.nativeElement, 'value', value);\r\n\t\tthis._resetDecimalPlaces();\r\n\t}\r\n\r\n\tregisterOnChange(fn: any) {\r\n\t\tthis.change = fn;\r\n\t}\r\n\r\n\tregisterOnTouched(fn: any) {\r\n\t\tthis.onTouch = fn;\r\n\t}\r\n\r\n\tprivate _resetDecimalPlaces() {\r\n\t\tconst value = this._el.nativeElement.value;\r\n\t\tif (value === '' || value === null || value === undefined) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconst splitValues = value.split('.');\r\n\t\tlet newValue = '';\r\n\t\tif (splitValues[1] && splitValues[1].length > this.buiDecimalInput) {\r\n\t\t\tnewValue = value.substring(0, splitValues[0].length + 1 + this.buiDecimalInput);\r\n\t\t} else {\r\n\t\t\tthis.buiDecimalInput = this.buiDecimalInput < 0 ? 0 : this.buiDecimalInput;\r\n\t\t\tnewValue = Number(value).toFixed(this.buiDecimalInput);\r\n\t\t}\r\n\t\tthis._renderer.setProperty(this._el.nativeElement, 'value', newValue);\r\n\t}\r\n}\r\n"]}

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

@@ -3,11 +3,11 @@ import { NgModule } from '@angular/core';
 import { DecimalInputDirective } from './decimal-input.directive';
 import * as i0 from "@angular/core";
 export class DecimalInputModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputModule, declarations: [DecimalInputDirective], imports: [CommonModule], exports: [DecimalInputDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputModule, imports: [CommonModule] }); }
 }
-DecimalInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: DecimalInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DecimalInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.6", ngImport: i0, type: DecimalInputModule, declarations: [DecimalInputDirective], imports: [CommonModule], exports: [DecimalInputDirective] });
-DecimalInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: DecimalInputModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImport: i0, type: DecimalInputModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.2", ngImport: i0, type: DecimalInputModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [DecimalInputDirective],
@@ -16,4 +16,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.6", ngImpor
                 }]
         }] });
 export { DecimalInputDirective };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjaW1hbC1pbnB1dC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9kZWNpbWFsLWlucHV0L2RlY2ltYWwtaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU9sRSxNQUFNLE9BQU8sa0JBQWtCOzsrR0FBbEIsa0JBQWtCO2dIQUFsQixrQkFBa0IsaUJBSmYscUJBQXFCLGFBQzFCLFlBQVksYUFDWixxQkFBcUI7Z0hBRW5CLGtCQUFrQixZQUhwQixZQUFZOzJGQUdWLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDVCxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztpQkFDaEM7O0FBRUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERlY2ltYWxJbnB1dERpcmVjdGl2ZSB9IGZyb20gJy4vZGVjaW1hbC1pbnB1dC5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuXHRkZWNsYXJhdGlvbnM6IFtEZWNpbWFsSW5wdXREaXJlY3RpdmVdLFxuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcblx0ZXhwb3J0czogW0RlY2ltYWxJbnB1dERpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgRGVjaW1hbElucHV0TW9kdWxlIHt9XG5leHBvcnQgeyBEZWNpbWFsSW5wdXREaXJlY3RpdmUgfTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjaW1hbC1pbnB1dC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9kZWNpbWFsLWlucHV0L2RlY2ltYWwtaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU9sRSxNQUFNLE9BQU8sa0JBQWtCOzhHQUFsQixrQkFBa0I7K0dBQWxCLGtCQUFrQixpQkFKZixxQkFBcUIsYUFDMUIsWUFBWSxhQUNaLHFCQUFxQjsrR0FFbkIsa0JBQWtCLFlBSHBCLFlBQVk7OzJGQUdWLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDVCxZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztpQkFDaEM7O0FBRUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERlY2ltYWxJbnB1dERpcmVjdGl2ZSB9IGZyb20gJy4vZGVjaW1hbC1pbnB1dC5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuXHRkZWNsYXJhdGlvbnM6IFtEZWNpbWFsSW5wdXREaXJlY3RpdmVdLFxuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcblx0ZXhwb3J0czogW0RlY2ltYWxJbnB1dERpcmVjdGl2ZV1cbn0pXG5leHBvcnQgY2xhc3MgRGVjaW1hbElucHV0TW9kdWxlIHt9XG5leHBvcnQgeyBEZWNpbWFsSW5wdXREaXJlY3RpdmUgfTtcbiJdfQ==