primevue 3.29.2 → 3.30.0

package/inputnumber/inputnumber.cjs.js

@@ -1,1209 +1,1165 @@
 'use strict';
 
-var BaseComponent = require('primevue/basecomponent');
 var Button = require('primevue/button');
 var AngleDownIcon = require('primevue/icons/angledown');
 var AngleUpIcon = require('primevue/icons/angleup');
 var InputText = require('primevue/inputtext');
 var utils = require('primevue/utils');
+var BaseComponent = require('primevue/basecomponent');
+var usestyle = require('primevue/usestyle');
 var vue = require('vue');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent);
 var Button__default = /*#__PURE__*/_interopDefaultLegacy(Button);
 var AngleDownIcon__default = /*#__PURE__*/_interopDefaultLegacy(AngleDownIcon);
 var AngleUpIcon__default = /*#__PURE__*/_interopDefaultLegacy(AngleUpIcon);
 var InputText__default = /*#__PURE__*/_interopDefaultLegacy(InputText);
+var BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent);
 
+var styles = "\n.p-inputnumber {\n    display: inline-flex;\n}\n\n.p-inputnumber-button {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    flex: 0 0 auto;\n}\n\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button .p-button-label,\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button .p-button-label {\n    display: none;\n}\n\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button-up {\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n    border-bottom-right-radius: 0;\n    padding: 0;\n}\n\n.p-inputnumber-buttons-stacked .p-inputnumber-input {\n    border-top-right-radius: 0;\n    border-bottom-right-radius: 0;\n}\n\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button-down {\n    border-top-left-radius: 0;\n    border-top-right-radius: 0;\n    border-bottom-left-radius: 0;\n    padding: 0;\n}\n\n.p-inputnumber-buttons-stacked .p-inputnumber-button-group {\n    display: flex;\n    flex-direction: column;\n}\n\n.p-inputnumber-buttons-stacked .p-inputnumber-button-group .p-button.p-inputnumber-button {\n    flex: 1 1 auto;\n}\n\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button-up {\n    order: 3;\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n}\n\n.p-inputnumber-buttons-horizontal .p-inputnumber-input {\n    order: 2;\n    border-radius: 0;\n}\n\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button-down {\n    order: 1;\n    border-top-right-radius: 0;\n    border-bottom-right-radius: 0;\n}\n\n.p-inputnumber-buttons-vertical {\n    flex-direction: column;\n}\n\n.p-inputnumber-buttons-vertical .p-button.p-inputnumber-button-up {\n    order: 1;\n    border-bottom-left-radius: 0;\n    border-bottom-right-radius: 0;\n    width: 100%;\n}\n\n.p-inputnumber-buttons-vertical .p-inputnumber-input {\n    order: 2;\n    border-radius: 0;\n    text-align: center;\n}\n\n.p-inputnumber-buttons-vertical .p-button.p-inputnumber-button-down {\n    order: 3;\n    border-top-left-radius: 0;\n    border-top-right-radius: 0;\n    width: 100%;\n}\n\n.p-inputnumber-input {\n    flex: 1 1 auto;\n}\n\n.p-fluid .p-inputnumber {\n    width: 100%;\n}\n\n.p-fluid .p-inputnumber .p-inputnumber-input {\n    width: 1%;\n}\n\n.p-fluid .p-inputnumber-buttons-vertical .p-inputnumber-input {\n    width: 100%;\n}\n";
+var classes = {
+  root: function root(_ref) {
+    var instance = _ref.instance,
+      props = _ref.props;
+    return ['p-inputnumber p-component p-inputwrapper', {
+      'p-inputwrapper-filled': instance.filled,
+      'p-inputwrapper-focus': instance.focused,
+      'p-inputnumber-buttons-stacked': props.showButtons && props.buttonLayout === 'stacked',
+      'p-inputnumber-buttons-horizontal': props.showButtons && props.buttonLayout === 'horizontal',
+      'p-inputnumber-buttons-vertical': props.showButtons && props.buttonLayout === 'vertical'
+    }];
+  },
+  input: 'p-inputnumber-input',
+  buttonGroup: 'p-inputnumber-button-group',
+  incrementButton: function incrementButton(_ref2) {
+    var instance = _ref2.instance,
+      props = _ref2.props;
+    return ['p-inputnumber-button p-inputnumber-button-up', {
+      'p-disabled': props.showButtons && props.max !== null && instance.maxBoundry()
+    }];
+  },
+  decrementButton: function decrementButton(_ref3) {
+    var instance = _ref3.instance,
+      props = _ref3.props;
+    return ['p-inputnumber-button p-inputnumber-button-down', {
+      'p-disabled': props.showButtons && props.min !== null && instance.minBoundry()
+    }];
+  }
+};
+var _useStyle = usestyle.useStyle(styles, {
+    name: 'inputnumber',
+    manual: true
+  }),
+  loadStyle = _useStyle.load;
+var script$1 = {
+  name: 'BaseInputNumber',
+  "extends": BaseComponent__default["default"],
+  props: {
+    modelValue: {
+      type: Number,
+      "default": null
+    },
+    format: {
+      type: Boolean,
+      "default": true
+    },
+    showButtons: {
+      type: Boolean,
+      "default": false
+    },
+    buttonLayout: {
+      type: String,
+      "default": 'stacked'
+    },
+    incrementButtonClass: {
+      type: String,
+      "default": null
+    },
+    decrementButtonClass: {
+      type: String,
+      "default": null
+    },
+    incrementButtonIcon: {
+      type: String,
+      "default": undefined
+    },
+    decrementButtonIcon: {
+      type: String,
+      "default": undefined
+    },
+    locale: {
+      type: String,
+      "default": undefined
+    },
+    localeMatcher: {
+      type: String,
+      "default": undefined
+    },
+    mode: {
+      type: String,
+      "default": 'decimal'
+    },
+    prefix: {
+      type: String,
+      "default": null
+    },
+    suffix: {
+      type: String,
+      "default": null
+    },
+    currency: {
+      type: String,
+      "default": undefined
+    },
+    currencyDisplay: {
+      type: String,
+      "default": undefined
+    },
+    useGrouping: {
+      type: Boolean,
+      "default": true
+    },
+    minFractionDigits: {
+      type: Number,
+      "default": undefined
+    },
+    maxFractionDigits: {
+      type: Number,
+      "default": undefined
+    },
+    min: {
+      type: Number,
+      "default": null
+    },
+    max: {
+      type: Number,
+      "default": null
+    },
+    step: {
+      type: Number,
+      "default": 1
+    },
+    allowEmpty: {
+      type: Boolean,
+      "default": true
+    },
+    highlightOnFocus: {
+      type: Boolean,
+      "default": false
+    },
+    readonly: {
+      type: Boolean,
+      "default": false
+    },
+    disabled: {
+      type: Boolean,
+      "default": false
+    },
+    placeholder: {
+      type: String,
+      "default": null
+    },
+    inputId: {
+      type: String,
+      "default": null
+    },
+    inputClass: {
+      type: [String, Object],
+      "default": null
+    },
+    inputStyle: {
+      type: Object,
+      "default": null
+    },
+    inputProps: {
+      type: null,
+      "default": null
+    },
+    incrementButtonProps: {
+      type: null,
+      "default": null
+    },
+    decrementButtonProps: {
+      type: null,
+      "default": null
+    },
+    'aria-labelledby': {
+      type: String,
+      "default": null
+    },
+    'aria-label': {
+      type: String,
+      "default": null
+    }
+  },
+  css: {
+    classes: classes,
+    loadStyle: loadStyle
+  },
+  provide: function provide() {
+    return {
+      $parentInstance: this
+    };
+  }
+};
+
+function _typeof$1(obj) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof$1(obj); }
+function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys$1(Object(source), !0).forEach(function (key) { _defineProperty$1(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty$1(obj, key, value) { key = _toPropertyKey$1(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey$1(arg) { var key = _toPrimitive$1(arg, "string"); return _typeof$1(key) === "symbol" ? key : String(key); }
+function _toPrimitive$1(input, hint) { if (_typeof$1(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof$1(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 var script = {
-    name: 'InputNumber',
-    extends: BaseComponent__default["default"],
-    emits: ['update:modelValue', 'input', 'focus', 'blur'],
-    props: {
-        modelValue: {
-            type: Number,
-            default: null
-        },
-        format: {
-            type: Boolean,
-            default: true
-        },
-        showButtons: {
-            type: Boolean,
-            default: false
-        },
-        buttonLayout: {
-            type: String,
-            default: 'stacked'
-        },
-        incrementButtonClass: {
-            type: String,
-            default: null
-        },
-        decrementButtonClass: {
-            type: String,
-            default: null
-        },
-        incrementButtonIcon: {
-            type: String,
-            default: undefined
-        },
-        decrementButtonIcon: {
-            type: String,
-            default: undefined
-        },
-        locale: {
-            type: String,
-            default: undefined
-        },
-        localeMatcher: {
-            type: String,
-            default: undefined
-        },
-        mode: {
-            type: String,
-            default: 'decimal'
-        },
-        prefix: {
-            type: String,
-            default: null
-        },
-        suffix: {
-            type: String,
-            default: null
-        },
-        currency: {
-            type: String,
-            default: undefined
-        },
-        currencyDisplay: {
-            type: String,
-            default: undefined
-        },
-        useGrouping: {
-            type: Boolean,
-            default: true
-        },
-        minFractionDigits: {
-            type: Number,
-            default: undefined
-        },
-        maxFractionDigits: {
-            type: Number,
-            default: undefined
-        },
-        min: {
-            type: Number,
-            default: null
-        },
-        max: {
-            type: Number,
-            default: null
-        },
-        step: {
-            type: Number,
-            default: 1
-        },
-        allowEmpty: {
-            type: Boolean,
-            default: true
-        },
-        highlightOnFocus: {
-            type: Boolean,
-            default: false
-        },
-        readonly: {
-            type: Boolean,
-            default: false
-        },
-        disabled: {
-            type: Boolean,
-            default: false
-        },
-        placeholder: {
-            type: String,
-            default: null
-        },
-        inputId: {
-            type: String,
-            default: null
-        },
-        inputClass: {
-            type: [String, Object],
-            default: null
-        },
-        inputStyle: {
-            type: Object,
-            default: null
-        },
-        inputProps: {
-            type: null,
-            default: null
-        },
-        incrementButtonProps: {
-            type: null,
-            default: null
-        },
-        decrementButtonProps: {
-            type: null,
-            default: null
-        },
-        'aria-labelledby': {
-            type: String,
-            default: null
-        },
-        'aria-label': {
-            type: String,
-            default: null
-        }
+  name: 'InputNumber',
+  "extends": script$1,
+  emits: ['update:modelValue', 'input', 'focus', 'blur'],
+  numberFormat: null,
+  _numeral: null,
+  _decimal: null,
+  _group: null,
+  _minusSign: null,
+  _currency: null,
+  _suffix: null,
+  _prefix: null,
+  _index: null,
+  groupChar: '',
+  isSpecialChar: null,
+  prefixChar: null,
+  suffixChar: null,
+  timer: null,
+  data: function data() {
+    return {
+      d_modelValue: this.modelValue,
+      focused: false
+    };
+  },
+  watch: {
+    modelValue: function modelValue(newValue) {
+      this.d_modelValue = newValue;
     },
-    numberFormat: null,
-    _numeral: null,
-    _decimal: null,
-    _group: null,
-    _minusSign: null,
-    _currency: null,
-    _suffix: null,
-    _prefix: null,
-    _index: null,
-    groupChar: '',
-    isSpecialChar: null,
-    prefixChar: null,
-    suffixChar: null,
-    timer: null,
-    data() {
-        return {
-            d_modelValue: this.modelValue,
-            focused: false
-        };
-    },
-    watch: {
-        modelValue(newValue) {
-            this.d_modelValue = newValue;
-        },
-        locale(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        localeMatcher(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        mode(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        currency(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        currencyDisplay(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        useGrouping(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        minFractionDigits(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        maxFractionDigits(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        suffix(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        },
-        prefix(newValue, oldValue) {
-            this.updateConstructParser(newValue, oldValue);
-        }
+    locale: function locale(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    localeMatcher: function localeMatcher(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    mode: function mode(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
     },
-    created() {
+    currency: function currency(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    currencyDisplay: function currencyDisplay(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    useGrouping: function useGrouping(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    minFractionDigits: function minFractionDigits(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    maxFractionDigits: function maxFractionDigits(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    suffix: function suffix(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    },
+    prefix: function prefix(newValue, oldValue) {
+      this.updateConstructParser(newValue, oldValue);
+    }
+  },
+  created: function created() {
+    this.constructParser();
+  },
+  methods: {
+    getOptions: function getOptions() {
+      return {
+        localeMatcher: this.localeMatcher,
+        style: this.mode,
+        currency: this.currency,
+        currencyDisplay: this.currencyDisplay,
+        useGrouping: this.useGrouping,
+        minimumFractionDigits: this.minFractionDigits,
+        maximumFractionDigits: this.maxFractionDigits
+      };
+    },
+    constructParser: function constructParser() {
+      this.numberFormat = new Intl.NumberFormat(this.locale, this.getOptions());
+      var numerals = _toConsumableArray(new Intl.NumberFormat(this.locale, {
+        useGrouping: false
+      }).format(9876543210)).reverse();
+      var index = new Map(numerals.map(function (d, i) {
+        return [d, i];
+      }));
+      this._numeral = new RegExp("[".concat(numerals.join(''), "]"), 'g');
+      this._group = this.getGroupingExpression();
+      this._minusSign = this.getMinusSignExpression();
+      this._currency = this.getCurrencyExpression();
+      this._decimal = this.getDecimalExpression();
+      this._suffix = this.getSuffixExpression();
+      this._prefix = this.getPrefixExpression();
+      this._index = function (d) {
+        return index.get(d);
+      };
+    },
+    updateConstructParser: function updateConstructParser(newValue, oldValue) {
+      if (newValue !== oldValue) {
         this.constructParser();
+      }
     },
-    methods: {
-        getOptions() {
-            return {
-                localeMatcher: this.localeMatcher,
-                style: this.mode,
-                currency: this.currency,
-                currencyDisplay: this.currencyDisplay,
-                useGrouping: this.useGrouping,
-                minimumFractionDigits: this.minFractionDigits,
-                maximumFractionDigits: this.maxFractionDigits
-            };
-        },
-        constructParser() {
-            this.numberFormat = new Intl.NumberFormat(this.locale, this.getOptions());
-            const numerals = [...new Intl.NumberFormat(this.locale, { useGrouping: false }).format(9876543210)].reverse();
-            const index = new Map(numerals.map((d, i) => [d, i]));
-
-            this._numeral = new RegExp(`[${numerals.join('')}]`, 'g');
-            this._group = this.getGroupingExpression();
-            this._minusSign = this.getMinusSignExpression();
-            this._currency = this.getCurrencyExpression();
-            this._decimal = this.getDecimalExpression();
-            this._suffix = this.getSuffixExpression();
-            this._prefix = this.getPrefixExpression();
-            this._index = (d) => index.get(d);
-        },
-        updateConstructParser(newValue, oldValue) {
-            if (newValue !== oldValue) {
-                this.constructParser();
-            }
-        },
-        escapeRegExp(text) {
-            return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-        },
-        getDecimalExpression() {
-            const formatter = new Intl.NumberFormat(this.locale, { ...this.getOptions(), useGrouping: false });
-
-            return new RegExp(`[${formatter.format(1.1).replace(this._currency, '').trim().replace(this._numeral, '')}]`, 'g');
-        },
-        getGroupingExpression() {
-            const formatter = new Intl.NumberFormat(this.locale, { useGrouping: true });
-
-            this.groupChar = formatter.format(1000000).trim().replace(this._numeral, '').charAt(0);
-
-            return new RegExp(`[${this.groupChar}]`, 'g');
-        },
-        getMinusSignExpression() {
-            const formatter = new Intl.NumberFormat(this.locale, { useGrouping: false });
-
-            return new RegExp(`[${formatter.format(-1).trim().replace(this._numeral, '')}]`, 'g');
-        },
-        getCurrencyExpression() {
-            if (this.currency) {
-                const formatter = new Intl.NumberFormat(this.locale, { style: 'currency', currency: this.currency, currencyDisplay: this.currencyDisplay, minimumFractionDigits: 0, maximumFractionDigits: 0 });
-
-                return new RegExp(`[${formatter.format(1).replace(/\s/g, '').replace(this._numeral, '').replace(this._group, '')}]`, 'g');
-            }
-
-            return new RegExp(`[]`, 'g');
-        },
-        getPrefixExpression() {
-            if (this.prefix) {
-                this.prefixChar = this.prefix;
-            } else {
-                const formatter = new Intl.NumberFormat(this.locale, { style: this.mode, currency: this.currency, currencyDisplay: this.currencyDisplay });
-
-                this.prefixChar = formatter.format(1).split('1')[0];
-            }
-
-            return new RegExp(`${this.escapeRegExp(this.prefixChar || '')}`, 'g');
-        },
-        getSuffixExpression() {
-            if (this.suffix) {
-                this.suffixChar = this.suffix;
-            } else {
-                const formatter = new Intl.NumberFormat(this.locale, { style: this.mode, currency: this.currency, currencyDisplay: this.currencyDisplay, minimumFractionDigits: 0, maximumFractionDigits: 0 });
-
-                this.suffixChar = formatter.format(1).split('1')[1];
-            }
-
-            return new RegExp(`${this.escapeRegExp(this.suffixChar || '')}`, 'g');
-        },
-        formatValue(value) {
-            if (value != null) {
-                if (value === '-') {
-                    // Minus sign
-                    return value;
-                }
-
-                if (this.format) {
-                    let formatter = new Intl.NumberFormat(this.locale, this.getOptions());
-                    let formattedValue = formatter.format(value);
-
-                    if (this.prefix) {
-                        formattedValue = this.prefix + formattedValue;
-                    }
-
-                    if (this.suffix) {
-                        formattedValue = formattedValue + this.suffix;
-                    }
-
-                    return formattedValue;
-                }
-
-                return value.toString();
-            }
-
-            return '';
-        },
-        parseValue(text) {
-            let filteredText = text
-                .replace(this._suffix, '')
-                .replace(this._prefix, '')
-                .trim()
-                .replace(/\s/g, '')
-                .replace(this._currency, '')
-                .replace(this._group, '')
-                .replace(this._minusSign, '-')
-                .replace(this._decimal, '.')
-                .replace(this._numeral, this._index);
-
-            if (filteredText) {
-                if (filteredText === '-')
-                    // Minus sign
-                    return filteredText;
-
-                let parsedValue = +filteredText;
-
-                return isNaN(parsedValue) ? null : parsedValue;
-            }
-
-            return null;
-        },
-        repeat(event, interval, dir) {
-            if (this.readonly) {
-                return;
-            }
-
-            let i = interval || 500;
-
-            this.clearTimer();
-            this.timer = setTimeout(() => {
-                this.repeat(event, 40, dir);
-            }, i);
-
-            this.spin(event, dir);
-        },
-        spin(event, dir) {
-            if (this.$refs.input) {
-                let step = this.step * dir;
-                let currentValue = this.parseValue(this.$refs.input.$el.value) || 0;
-                let newValue = this.validateValue(currentValue + step);
-
-                this.updateInput(newValue, null, 'spin');
-                this.updateModel(event, newValue);
-
-                this.handleOnInput(event, currentValue, newValue);
-            }
-        },
-        onUpButtonMouseDown(event) {
-            if (!this.disabled) {
-                this.$refs.input.$el.focus();
-                this.repeat(event, null, 1);
-                event.preventDefault();
-            }
-        },
-        onUpButtonMouseUp() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onUpButtonMouseLeave() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onUpButtonKeyUp() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onUpButtonKeyDown(event) {
-            if (event.keyCode === 32 || event.keyCode === 13) {
-                this.repeat(event, null, 1);
-            }
-        },
-        onDownButtonMouseDown(event) {
-            if (!this.disabled) {
-                this.$refs.input.$el.focus();
-                this.repeat(event, null, -1);
-                event.preventDefault();
-            }
-        },
-        onDownButtonMouseUp() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onDownButtonMouseLeave() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onDownButtonKeyUp() {
-            if (!this.disabled) {
-                this.clearTimer();
-            }
-        },
-        onDownButtonKeyDown(event) {
-            if (event.keyCode === 32 || event.keyCode === 13) {
-                this.repeat(event, null, -1);
-            }
-        },
-        onUserInput() {
-            if (this.isSpecialChar) {
-                this.$refs.input.$el.value = this.lastValue;
-            }
-
-            this.isSpecialChar = false;
-        },
-        onInputKeyDown(event) {
-            if (this.readonly) {
-                return;
-            }
-
-            this.lastValue = event.target.value;
-
-            if (event.shiftKey || event.altKey) {
-                this.isSpecialChar = true;
-
-                return;
-            }
-
-            let selectionStart = event.target.selectionStart;
-            let selectionEnd = event.target.selectionEnd;
-            let inputValue = event.target.value;
-            let newValueStr = null;
-
-            if (event.altKey) {
-                event.preventDefault();
-            }
-
-            switch (event.code) {
-                case 'ArrowUp':
-                    this.spin(event, 1);
-                    event.preventDefault();
-                    break;
-
-                case 'ArrowDown':
-                    this.spin(event, -1);
-                    event.preventDefault();
-                    break;
-
-                case 'ArrowLeft':
-                    if (!this.isNumeralChar(inputValue.charAt(selectionStart - 1))) {
-                        event.preventDefault();
-                    }
-
-                    break;
-
-                case 'ArrowRight':
-                    if (!this.isNumeralChar(inputValue.charAt(selectionStart))) {
-                        event.preventDefault();
-                    }
-
-                    break;
-
-                case 'Tab':
-                case 'Enter':
-                    newValueStr = this.validateValue(this.parseValue(inputValue));
-                    this.$refs.input.$el.value = this.formatValue(newValueStr);
-                    this.$refs.input.$el.setAttribute('aria-valuenow', newValueStr);
-                    this.updateModel(event, newValueStr);
-                    break;
-
-                case 'Backspace': {
-                    event.preventDefault();
-
-                    if (selectionStart === selectionEnd) {
-                        const deleteChar = inputValue.charAt(selectionStart - 1);
-                        const { decimalCharIndex, decimalCharIndexWithoutPrefix } = this.getDecimalCharIndexes(inputValue);
-
-                        if (this.isNumeralChar(deleteChar)) {
-                            const decimalLength = this.getDecimalLength(inputValue);
-
-                            if (this._group.test(deleteChar)) {
-                                this._group.lastIndex = 0;
-                                newValueStr = inputValue.slice(0, selectionStart - 2) + inputValue.slice(selectionStart - 1);
-                            } else if (this._decimal.test(deleteChar)) {
-                                this._decimal.lastIndex = 0;
-
-                                if (decimalLength) {
-                                    this.$refs.input.$el.setSelectionRange(selectionStart - 1, selectionStart - 1);
-                                } else {
-                                    newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
-                                }
-                            } else if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
-                                const insertedText = this.isDecimalMode() && (this.minFractionDigits || 0) < decimalLength ? '' : '0';
-
-                                newValueStr = inputValue.slice(0, selectionStart - 1) + insertedText + inputValue.slice(selectionStart);
-                            } else if (decimalCharIndexWithoutPrefix === 1) {
-                                newValueStr = inputValue.slice(0, selectionStart - 1) + '0' + inputValue.slice(selectionStart);
-                                newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
-                            } else {
-                                newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
-                            }
-                        }
-
-                        this.updateValue(event, newValueStr, null, 'delete-single');
-                    } else {
-                        newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
-                        this.updateValue(event, newValueStr, null, 'delete-range');
-                    }
-
-                    break;
-                }
-
-                case 'Delete':
-                    event.preventDefault();
-
-                    if (selectionStart === selectionEnd) {
-                        const deleteChar = inputValue.charAt(selectionStart);
-                        const { decimalCharIndex, decimalCharIndexWithoutPrefix } = this.getDecimalCharIndexes(inputValue);
-
-                        if (this.isNumeralChar(deleteChar)) {
-                            const decimalLength = this.getDecimalLength(inputValue);
-
-                            if (this._group.test(deleteChar)) {
-                                this._group.lastIndex = 0;
-                                newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 2);
-                            } else if (this._decimal.test(deleteChar)) {
-                                this._decimal.lastIndex = 0;
-
-                                if (decimalLength) {
-                                    this.$refs.input.$el.setSelectionRange(selectionStart + 1, selectionStart + 1);
-                                } else {
-                                    newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
-                                }
-                            } else if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
-                                const insertedText = this.isDecimalMode() && (this.minFractionDigits || 0) < decimalLength ? '' : '0';
-
-                                newValueStr = inputValue.slice(0, selectionStart) + insertedText + inputValue.slice(selectionStart + 1);
-                            } else if (decimalCharIndexWithoutPrefix === 1) {
-                                newValueStr = inputValue.slice(0, selectionStart) + '0' + inputValue.slice(selectionStart + 1);
-                                newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
-                            } else {
-                                newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
-                            }
-                        }
-
-                        this.updateValue(event, newValueStr, null, 'delete-back-single');
-                    } else {
-                        newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
-                        this.updateValue(event, newValueStr, null, 'delete-range');
-                    }
-
-                    break;
-
-                case 'Home':
-                    if (this.min) {
-                        this.updateModel(event, this.min);
-                        event.preventDefault();
-                    }
-
-                    break;
-
-                case 'End':
-                    if (this.max) {
-                        this.updateModel(event, this.max);
-                        event.preventDefault();
-                    }
-
-                    break;
-            }
-        },
-        onInputKeyPress(event) {
-            if (this.readonly) {
-                return;
-            }
-
+    escapeRegExp: function escapeRegExp(text) {
+      return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    },
+    getDecimalExpression: function getDecimalExpression() {
+      var formatter = new Intl.NumberFormat(this.locale, _objectSpread$1(_objectSpread$1({}, this.getOptions()), {}, {
+        useGrouping: false
+      }));
+      return new RegExp("[".concat(formatter.format(1.1).replace(this._currency, '').trim().replace(this._numeral, ''), "]"), 'g');
+    },
+    getGroupingExpression: function getGroupingExpression() {
+      var formatter = new Intl.NumberFormat(this.locale, {
+        useGrouping: true
+      });
+      this.groupChar = formatter.format(1000000).trim().replace(this._numeral, '').charAt(0);
+      return new RegExp("[".concat(this.groupChar, "]"), 'g');
+    },
+    getMinusSignExpression: function getMinusSignExpression() {
+      var formatter = new Intl.NumberFormat(this.locale, {
+        useGrouping: false
+      });
+      return new RegExp("[".concat(formatter.format(-1).trim().replace(this._numeral, ''), "]"), 'g');
+    },
+    getCurrencyExpression: function getCurrencyExpression() {
+      if (this.currency) {
+        var formatter = new Intl.NumberFormat(this.locale, {
+          style: 'currency',
+          currency: this.currency,
+          currencyDisplay: this.currencyDisplay,
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0
+        });
+        return new RegExp("[".concat(formatter.format(1).replace(/\s/g, '').replace(this._numeral, '').replace(this._group, ''), "]"), 'g');
+      }
+      return new RegExp("[]", 'g');
+    },
+    getPrefixExpression: function getPrefixExpression() {
+      if (this.prefix) {
+        this.prefixChar = this.prefix;
+      } else {
+        var formatter = new Intl.NumberFormat(this.locale, {
+          style: this.mode,
+          currency: this.currency,
+          currencyDisplay: this.currencyDisplay
+        });
+        this.prefixChar = formatter.format(1).split('1')[0];
+      }
+      return new RegExp("".concat(this.escapeRegExp(this.prefixChar || '')), 'g');
+    },
+    getSuffixExpression: function getSuffixExpression() {
+      if (this.suffix) {
+        this.suffixChar = this.suffix;
+      } else {
+        var formatter = new Intl.NumberFormat(this.locale, {
+          style: this.mode,
+          currency: this.currency,
+          currencyDisplay: this.currencyDisplay,
+          minimumFractionDigits: 0,
+          maximumFractionDigits: 0
+        });
+        this.suffixChar = formatter.format(1).split('1')[1];
+      }
+      return new RegExp("".concat(this.escapeRegExp(this.suffixChar || '')), 'g');
+    },
+    formatValue: function formatValue(value) {
+      if (value != null) {
+        if (value === '-') {
+          // Minus sign
+          return value;
+        }
+        if (this.format) {
+          var formatter = new Intl.NumberFormat(this.locale, this.getOptions());
+          var formattedValue = formatter.format(value);
+          if (this.prefix) {
+            formattedValue = this.prefix + formattedValue;
+          }
+          if (this.suffix) {
+            formattedValue = formattedValue + this.suffix;
+          }
+          return formattedValue;
+        }
+        return value.toString();
+      }
+      return '';
+    },
+    parseValue: function parseValue(text) {
+      var filteredText = text.replace(this._suffix, '').replace(this._prefix, '').trim().replace(/\s/g, '').replace(this._currency, '').replace(this._group, '').replace(this._minusSign, '-').replace(this._decimal, '.').replace(this._numeral, this._index);
+      if (filteredText) {
+        if (filteredText === '-')
+          // Minus sign
+          return filteredText;
+        var parsedValue = +filteredText;
+        return isNaN(parsedValue) ? null : parsedValue;
+      }
+      return null;
+    },
+    repeat: function repeat(event, interval, dir) {
+      var _this = this;
+      if (this.readonly) {
+        return;
+      }
+      var i = interval || 500;
+      this.clearTimer();
+      this.timer = setTimeout(function () {
+        _this.repeat(event, 40, dir);
+      }, i);
+      this.spin(event, dir);
+    },
+    spin: function spin(event, dir) {
+      if (this.$refs.input) {
+        var step = this.step * dir;
+        var currentValue = this.parseValue(this.$refs.input.$el.value) || 0;
+        var newValue = this.validateValue(currentValue + step);
+        this.updateInput(newValue, null, 'spin');
+        this.updateModel(event, newValue);
+        this.handleOnInput(event, currentValue, newValue);
+      }
+    },
+    onUpButtonMouseDown: function onUpButtonMouseDown(event) {
+      if (!this.disabled) {
+        this.$refs.input.$el.focus();
+        this.repeat(event, null, 1);
+        event.preventDefault();
+      }
+    },
+    onUpButtonMouseUp: function onUpButtonMouseUp() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onUpButtonMouseLeave: function onUpButtonMouseLeave() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onUpButtonKeyUp: function onUpButtonKeyUp() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onUpButtonKeyDown: function onUpButtonKeyDown(event) {
+      if (event.keyCode === 32 || event.keyCode === 13) {
+        this.repeat(event, null, 1);
+      }
+    },
+    onDownButtonMouseDown: function onDownButtonMouseDown(event) {
+      if (!this.disabled) {
+        this.$refs.input.$el.focus();
+        this.repeat(event, null, -1);
+        event.preventDefault();
+      }
+    },
+    onDownButtonMouseUp: function onDownButtonMouseUp() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onDownButtonMouseLeave: function onDownButtonMouseLeave() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onDownButtonKeyUp: function onDownButtonKeyUp() {
+      if (!this.disabled) {
+        this.clearTimer();
+      }
+    },
+    onDownButtonKeyDown: function onDownButtonKeyDown(event) {
+      if (event.keyCode === 32 || event.keyCode === 13) {
+        this.repeat(event, null, -1);
+      }
+    },
+    onUserInput: function onUserInput() {
+      if (this.isSpecialChar) {
+        this.$refs.input.$el.value = this.lastValue;
+      }
+      this.isSpecialChar = false;
+    },
+    onInputKeyDown: function onInputKeyDown(event) {
+      if (this.readonly) {
+        return;
+      }
+      this.lastValue = event.target.value;
+      if (event.shiftKey || event.altKey) {
+        this.isSpecialChar = true;
+        return;
+      }
+      var selectionStart = event.target.selectionStart;
+      var selectionEnd = event.target.selectionEnd;
+      var inputValue = event.target.value;
+      var newValueStr = null;
+      if (event.altKey) {
+        event.preventDefault();
+      }
+      switch (event.code) {
+        case 'ArrowUp':
+          this.spin(event, 1);
+          event.preventDefault();
+          break;
+        case 'ArrowDown':
+          this.spin(event, -1);
+          event.preventDefault();
+          break;
+        case 'ArrowLeft':
+          if (!this.isNumeralChar(inputValue.charAt(selectionStart - 1))) {
             event.preventDefault();
-            let code = event.which || event.keyCode;
-            let char = String.fromCharCode(code);
-            const isDecimalSign = this.isDecimalSign(char);
-            const isMinusSign = this.isMinusSign(char);
-
-            if ((48 <= code && code <= 57) || isMinusSign || isDecimalSign) {
-                this.insert(event, char, { isDecimalSign, isMinusSign });
-            }
-        },
-        onPaste(event) {
+          }
+          break;
+        case 'ArrowRight':
+          if (!this.isNumeralChar(inputValue.charAt(selectionStart))) {
             event.preventDefault();
-            let data = (event.clipboardData || window['clipboardData']).getData('Text');
-
-            if (data) {
-                let filteredData = this.parseValue(data);
-
-                if (filteredData != null) {
-                    this.insert(event, filteredData.toString());
-                }
-            }
-        },
-        allowMinusSign() {
-            return this.min === null || this.min < 0;
-        },
-        isMinusSign(char) {
-            if (this._minusSign.test(char) || char === '-') {
-                this._minusSign.lastIndex = 0;
-
-                return true;
-            }
-
-            return false;
-        },
-        isDecimalSign(char) {
-            if (this._decimal.test(char)) {
-                this._decimal.lastIndex = 0;
-
-                return true;
-            }
-
-            return false;
-        },
-        isDecimalMode() {
-            return this.mode === 'decimal';
-        },
-        getDecimalCharIndexes(val) {
-            let decimalCharIndex = val.search(this._decimal);
-
-            this._decimal.lastIndex = 0;
-
-            const filteredVal = val.replace(this._prefix, '').trim().replace(/\s/g, '').replace(this._currency, '');
-            const decimalCharIndexWithoutPrefix = filteredVal.search(this._decimal);
-
-            this._decimal.lastIndex = 0;
-
-            return { decimalCharIndex, decimalCharIndexWithoutPrefix };
-        },
-        getCharIndexes(val) {
-            const decimalCharIndex = val.search(this._decimal);
-
-            this._decimal.lastIndex = 0;
-            const minusCharIndex = val.search(this._minusSign);
-
-            this._minusSign.lastIndex = 0;
-            const suffixCharIndex = val.search(this._suffix);
-
-            this._suffix.lastIndex = 0;
-            const currencyCharIndex = val.search(this._currency);
-
-            this._currency.lastIndex = 0;
-
-            return { decimalCharIndex, minusCharIndex, suffixCharIndex, currencyCharIndex };
-        },
-        insert(event, text, sign = { isDecimalSign: false, isMinusSign: false }) {
-            const minusCharIndexOnText = text.search(this._minusSign);
-
-            this._minusSign.lastIndex = 0;
-
-            if (!this.allowMinusSign() && minusCharIndexOnText !== -1) {
-                return;
-            }
-
-            const selectionStart = this.$refs.input.$el.selectionStart;
-            const selectionEnd = this.$refs.input.$el.selectionEnd;
-            let inputValue = this.$refs.input.$el.value.trim();
-            const { decimalCharIndex, minusCharIndex, suffixCharIndex, currencyCharIndex } = this.getCharIndexes(inputValue);
-            let newValueStr;
-
-            if (sign.isMinusSign) {
-                if (selectionStart === 0) {
-                    newValueStr = inputValue;
-
-                    if (minusCharIndex === -1 || selectionEnd !== 0) {
-                        newValueStr = this.insertText(inputValue, text, 0, selectionEnd);
-                    }
-
-                    this.updateValue(event, newValueStr, text, 'insert');
-                }
-            } else if (sign.isDecimalSign) {
-                if (decimalCharIndex > 0 && selectionStart === decimalCharIndex) {
-                    this.updateValue(event, inputValue, text, 'insert');
-                } else if (decimalCharIndex > selectionStart && decimalCharIndex < selectionEnd) {
-                    newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
-                    this.updateValue(event, newValueStr, text, 'insert');
-                } else if (decimalCharIndex === -1 && this.maxFractionDigits) {
-                    newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
-                    this.updateValue(event, newValueStr, text, 'insert');
-                }
-            } else {
-                const maxFractionDigits = this.numberFormat.resolvedOptions().maximumFractionDigits;
-                const operation = selectionStart !== selectionEnd ? 'range-insert' : 'insert';
-
-                if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
-                    if (selectionStart + text.length - (decimalCharIndex + 1) <= maxFractionDigits) {
-                        const charIndex = currencyCharIndex >= selectionStart ? currencyCharIndex - 1 : suffixCharIndex >= selectionStart ? suffixCharIndex : inputValue.length;
-
-                        newValueStr = inputValue.slice(0, selectionStart) + text + inputValue.slice(selectionStart + text.length, charIndex) + inputValue.slice(charIndex);
-                        this.updateValue(event, newValueStr, text, operation);
-                    }
+          }
+          break;
+        case 'Tab':
+        case 'Enter':
+          newValueStr = this.validateValue(this.parseValue(inputValue));
+          this.$refs.input.$el.value = this.formatValue(newValueStr);
+          this.$refs.input.$el.setAttribute('aria-valuenow', newValueStr);
+          this.updateModel(event, newValueStr);
+          break;
+        case 'Backspace':
+          {
+            event.preventDefault();
+            if (selectionStart === selectionEnd) {
+              var deleteChar = inputValue.charAt(selectionStart - 1);
+              var _this$getDecimalCharI = this.getDecimalCharIndexes(inputValue),
+                decimalCharIndex = _this$getDecimalCharI.decimalCharIndex,
+                decimalCharIndexWithoutPrefix = _this$getDecimalCharI.decimalCharIndexWithoutPrefix;
+              if (this.isNumeralChar(deleteChar)) {
+                var decimalLength = this.getDecimalLength(inputValue);
+                if (this._group.test(deleteChar)) {
+                  this._group.lastIndex = 0;
+                  newValueStr = inputValue.slice(0, selectionStart - 2) + inputValue.slice(selectionStart - 1);
+                } else if (this._decimal.test(deleteChar)) {
+                  this._decimal.lastIndex = 0;
+                  if (decimalLength) {
+                    this.$refs.input.$el.setSelectionRange(selectionStart - 1, selectionStart - 1);
+                  } else {
+                    newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
+                  }
+                } else if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
+                  var insertedText = this.isDecimalMode() && (this.minFractionDigits || 0) < decimalLength ? '' : '0';
+                  newValueStr = inputValue.slice(0, selectionStart - 1) + insertedText + inputValue.slice(selectionStart);
+                } else if (decimalCharIndexWithoutPrefix === 1) {
+                  newValueStr = inputValue.slice(0, selectionStart - 1) + '0' + inputValue.slice(selectionStart);
+                  newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
                 } else {
-                    newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
-                    this.updateValue(event, newValueStr, text, operation);
+                  newValueStr = inputValue.slice(0, selectionStart - 1) + inputValue.slice(selectionStart);
                 }
-            }
-        },
-        insertText(value, text, start, end) {
-            let textSplit = text === '.' ? text : text.split('.');
-
-            if (textSplit.length === 2) {
-                const decimalCharIndex = value.slice(start, end).search(this._decimal);
-
-                this._decimal.lastIndex = 0;
-
-                return decimalCharIndex > 0 ? value.slice(0, start) + this.formatValue(text) + value.slice(end) : value || this.formatValue(text);
-            } else if (end - start === value.length) {
-                return this.formatValue(text);
-            } else if (start === 0) {
-                return text + value.slice(end);
-            } else if (end === value.length) {
-                return value.slice(0, start) + text;
+              }
+              this.updateValue(event, newValueStr, null, 'delete-single');
             } else {
-                return value.slice(0, start) + text + value.slice(end);
-            }
-        },
-        deleteRange(value, start, end) {
-            let newValueStr;
-
-            if (end - start === value.length) newValueStr = '';
-            else if (start === 0) newValueStr = value.slice(end);
-            else if (end === value.length) newValueStr = value.slice(0, start);
-            else newValueStr = value.slice(0, start) + value.slice(end);
-
-            return newValueStr;
-        },
-        initCursor() {
-            let selectionStart = this.$refs.input.$el.selectionStart;
-            let inputValue = this.$refs.input.$el.value;
-            let valueLength = inputValue.length;
-            let index = null;
-
-            // remove prefix
-            let prefixLength = (this.prefixChar || '').length;
-
-            inputValue = inputValue.replace(this._prefix, '');
-            selectionStart = selectionStart - prefixLength;
-
-            let char = inputValue.charAt(selectionStart);
-
-            if (this.isNumeralChar(char)) {
-                return selectionStart + prefixLength;
-            }
-
-            //left
-            let i = selectionStart - 1;
-
-            while (i >= 0) {
-                char = inputValue.charAt(i);
-
-                if (this.isNumeralChar(char)) {
-                    index = i + prefixLength;
-                    break;
-                } else {
-                    i--;
-                }
-            }
-
-            if (index !== null) {
-                this.$refs.input.$el.setSelectionRange(index + 1, index + 1);
-            } else {
-                i = selectionStart;
-
-                while (i < valueLength) {
-                    char = inputValue.charAt(i);
-
-                    if (this.isNumeralChar(char)) {
-                        index = i + prefixLength;
-                        break;
-                    } else {
-                        i++;
-                    }
-                }
-
-                if (index !== null) {
-                    this.$refs.input.$el.setSelectionRange(index, index);
-                }
-            }
-
-            return index || 0;
-        },
-        onInputClick() {
-            const currentValue = this.$refs.input.$el.value;
-
-            if (!this.readonly && currentValue !== utils.DomHandler.getSelection()) {
-                this.initCursor();
-            }
-        },
-        isNumeralChar(char) {
-            if (char.length === 1 && (this._numeral.test(char) || this._decimal.test(char) || this._group.test(char) || this._minusSign.test(char))) {
-                this.resetRegex();
-
-                return true;
-            }
-
-            return false;
-        },
-        resetRegex() {
-            this._numeral.lastIndex = 0;
-            this._decimal.lastIndex = 0;
-            this._group.lastIndex = 0;
-            this._minusSign.lastIndex = 0;
-        },
-        updateValue(event, valueStr, insertedValueStr, operation) {
-            let currentValue = this.$refs.input.$el.value;
-            let newValue = null;
-
-            if (valueStr != null) {
-                newValue = this.parseValue(valueStr);
-                newValue = !newValue && !this.allowEmpty ? 0 : newValue;
-                this.updateInput(newValue, insertedValueStr, operation, valueStr);
-
-                this.handleOnInput(event, currentValue, newValue);
-            }
-        },
-        handleOnInput(event, currentValue, newValue) {
-            if (this.isValueChanged(currentValue, newValue)) {
-                this.$emit('input', { originalEvent: event, value: newValue, formattedValue: currentValue });
-            }
-        },
-        isValueChanged(currentValue, newValue) {
-            if (newValue === null && currentValue !== null) {
-                return true;
-            }
-
-            if (newValue != null) {
-                let parsedCurrentValue = typeof currentValue === 'string' ? this.parseValue(currentValue) : currentValue;
-
-                return newValue !== parsedCurrentValue;
+              newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
+              this.updateValue(event, newValueStr, null, 'delete-range');
             }
-
-            return false;
-        },
-        validateValue(value) {
-            if (value === '-' || value == null) {
-                return null;
-            }
-
-            if (this.min != null && value < this.min) {
-                return this.min;
-            }
-
-            if (this.max != null && value > this.max) {
-                return this.max;
-            }
-
-            return value;
-        },
-        updateInput(value, insertedValueStr, operation, valueStr) {
-            insertedValueStr = insertedValueStr || '';
-
-            let inputValue = this.$refs.input.$el.value;
-            let newValue = this.formatValue(value);
-            let currentLength = inputValue.length;
-
-            if (newValue !== valueStr) {
-                newValue = this.concatValues(newValue, valueStr);
-            }
-
-            if (currentLength === 0) {
-                this.$refs.input.$el.value = newValue;
-                this.$refs.input.$el.setSelectionRange(0, 0);
-                const index = this.initCursor();
-                const selectionEnd = index + insertedValueStr.length;
-
-                this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-            } else {
-                let selectionStart = this.$refs.input.$el.selectionStart;
-                let selectionEnd = this.$refs.input.$el.selectionEnd;
-
-                this.$refs.input.$el.value = newValue;
-                let newLength = newValue.length;
-
-                if (operation === 'range-insert') {
-                    const startValue = this.parseValue((inputValue || '').slice(0, selectionStart));
-                    const startValueStr = startValue !== null ? startValue.toString() : '';
-                    const startExpr = startValueStr.split('').join(`(${this.groupChar})?`);
-                    const sRegex = new RegExp(startExpr, 'g');
-
-                    sRegex.test(newValue);
-
-                    const tExpr = insertedValueStr.split('').join(`(${this.groupChar})?`);
-                    const tRegex = new RegExp(tExpr, 'g');
-
-                    tRegex.test(newValue.slice(sRegex.lastIndex));
-
-                    selectionEnd = sRegex.lastIndex + tRegex.lastIndex;
-                    this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-                } else if (newLength === currentLength) {
-                    if (operation === 'insert' || operation === 'delete-back-single') this.$refs.input.$el.setSelectionRange(selectionEnd + 1, selectionEnd + 1);
-                    else if (operation === 'delete-single') this.$refs.input.$el.setSelectionRange(selectionEnd - 1, selectionEnd - 1);
-                    else if (operation === 'delete-range' || operation === 'spin') this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-                } else if (operation === 'delete-back-single') {
-                    let prevChar = inputValue.charAt(selectionEnd - 1);
-                    let nextChar = inputValue.charAt(selectionEnd);
-                    let diff = currentLength - newLength;
-                    let isGroupChar = this._group.test(nextChar);
-
-                    if (isGroupChar && diff === 1) {
-                        selectionEnd += 1;
-                    } else if (!isGroupChar && this.isNumeralChar(prevChar)) {
-                        selectionEnd += -1 * diff + 1;
-                    }
-
-                    this._group.lastIndex = 0;
-                    this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-                } else if (inputValue === '-' && operation === 'insert') {
-                    this.$refs.input.$el.setSelectionRange(0, 0);
-                    const index = this.initCursor();
-                    const selectionEnd = index + insertedValueStr.length + 1;
-
-                    this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-                } else {
-                    selectionEnd = selectionEnd + (newLength - currentLength);
-                    this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
-                }
-            }
-
-            this.$refs.input.$el.setAttribute('aria-valuenow', value);
-        },
-        concatValues(val1, val2) {
-            if (val1 && val2) {
-                let decimalCharIndex = val2.search(this._decimal);
-
+            break;
+          }
+        case 'Delete':
+          event.preventDefault();
+          if (selectionStart === selectionEnd) {
+            var _deleteChar = inputValue.charAt(selectionStart);
+            var _this$getDecimalCharI2 = this.getDecimalCharIndexes(inputValue),
+              _decimalCharIndex = _this$getDecimalCharI2.decimalCharIndex,
+              _decimalCharIndexWithoutPrefix = _this$getDecimalCharI2.decimalCharIndexWithoutPrefix;
+            if (this.isNumeralChar(_deleteChar)) {
+              var _decimalLength = this.getDecimalLength(inputValue);
+              if (this._group.test(_deleteChar)) {
+                this._group.lastIndex = 0;
+                newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 2);
+              } else if (this._decimal.test(_deleteChar)) {
                 this._decimal.lastIndex = 0;
-
-                if (this.suffixChar) {
-                    return val1.replace(this.suffixChar, '').split(this._decimal)[0] + val2.replace(this.suffixChar, '').slice(decimalCharIndex) + this.suffixChar;
+                if (_decimalLength) {
+                  this.$refs.input.$el.setSelectionRange(selectionStart + 1, selectionStart + 1);
                 } else {
-                    return decimalCharIndex !== -1 ? val1.split(this._decimal)[0] + val2.slice(decimalCharIndex) : val1;
-                }
-            }
-
-            return val1;
-        },
-        getDecimalLength(value) {
-            if (value) {
-                const valueSplit = value.split(this._decimal);
-
-                if (valueSplit.length === 2) {
-                    return valueSplit[1].replace(this._suffix, '').trim().replace(/\s/g, '').replace(this._currency, '').length;
+                  newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
                 }
+              } else if (_decimalCharIndex > 0 && selectionStart > _decimalCharIndex) {
+                var _insertedText = this.isDecimalMode() && (this.minFractionDigits || 0) < _decimalLength ? '' : '0';
+                newValueStr = inputValue.slice(0, selectionStart) + _insertedText + inputValue.slice(selectionStart + 1);
+              } else if (_decimalCharIndexWithoutPrefix === 1) {
+                newValueStr = inputValue.slice(0, selectionStart) + '0' + inputValue.slice(selectionStart + 1);
+                newValueStr = this.parseValue(newValueStr) > 0 ? newValueStr : '';
+              } else {
+                newValueStr = inputValue.slice(0, selectionStart) + inputValue.slice(selectionStart + 1);
+              }
             }
-
-            return 0;
-        },
-        updateModel(event, value) {
-            this.d_modelValue = value;
-            this.$emit('update:modelValue', value);
-        },
-        onInputFocus(event) {
-            this.focused = true;
-
-            if (!this.disabled && !this.readonly && this.$refs.input.$el.value !== utils.DomHandler.getSelection() && this.highlightOnFocus) {
-                event.target.select();
-            }
-
-            this.$emit('focus', event);
+            this.updateValue(event, newValueStr, null, 'delete-back-single');
+          } else {
+            newValueStr = this.deleteRange(inputValue, selectionStart, selectionEnd);
+            this.updateValue(event, newValueStr, null, 'delete-range');
+          }
+          break;
+        case 'Home':
+          if (this.min) {
+            this.updateModel(event, this.min);
+            event.preventDefault();
+          }
+          break;
+        case 'End':
+          if (this.max) {
+            this.updateModel(event, this.max);
+            event.preventDefault();
+          }
+          break;
+      }
+    },
+    onInputKeyPress: function onInputKeyPress(event) {
+      if (this.readonly) {
+        return;
+      }
+      event.preventDefault();
+      var code = event.which || event.keyCode;
+      var _char = String.fromCharCode(code);
+      var isDecimalSign = this.isDecimalSign(_char);
+      var isMinusSign = this.isMinusSign(_char);
+      if (48 <= code && code <= 57 || isMinusSign || isDecimalSign) {
+        this.insert(event, _char, {
+          isDecimalSign: isDecimalSign,
+          isMinusSign: isMinusSign
+        });
+      }
+    },
+    onPaste: function onPaste(event) {
+      event.preventDefault();
+      var data = (event.clipboardData || window['clipboardData']).getData('Text');
+      if (data) {
+        var filteredData = this.parseValue(data);
+        if (filteredData != null) {
+          this.insert(event, filteredData.toString());
+        }
+      }
+    },
+    allowMinusSign: function allowMinusSign() {
+      return this.min === null || this.min < 0;
+    },
+    isMinusSign: function isMinusSign(_char2) {
+      if (this._minusSign.test(_char2) || _char2 === '-') {
+        this._minusSign.lastIndex = 0;
+        return true;
+      }
+      return false;
+    },
+    isDecimalSign: function isDecimalSign(_char3) {
+      if (this._decimal.test(_char3)) {
+        this._decimal.lastIndex = 0;
+        return true;
+      }
+      return false;
+    },
+    isDecimalMode: function isDecimalMode() {
+      return this.mode === 'decimal';
+    },
+    getDecimalCharIndexes: function getDecimalCharIndexes(val) {
+      var decimalCharIndex = val.search(this._decimal);
+      this._decimal.lastIndex = 0;
+      var filteredVal = val.replace(this._prefix, '').trim().replace(/\s/g, '').replace(this._currency, '');
+      var decimalCharIndexWithoutPrefix = filteredVal.search(this._decimal);
+      this._decimal.lastIndex = 0;
+      return {
+        decimalCharIndex: decimalCharIndex,
+        decimalCharIndexWithoutPrefix: decimalCharIndexWithoutPrefix
+      };
+    },
+    getCharIndexes: function getCharIndexes(val) {
+      var decimalCharIndex = val.search(this._decimal);
+      this._decimal.lastIndex = 0;
+      var minusCharIndex = val.search(this._minusSign);
+      this._minusSign.lastIndex = 0;
+      var suffixCharIndex = val.search(this._suffix);
+      this._suffix.lastIndex = 0;
+      var currencyCharIndex = val.search(this._currency);
+      this._currency.lastIndex = 0;
+      return {
+        decimalCharIndex: decimalCharIndex,
+        minusCharIndex: minusCharIndex,
+        suffixCharIndex: suffixCharIndex,
+        currencyCharIndex: currencyCharIndex
+      };
+    },
+    insert: function insert(event, text) {
+      var sign = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+        isDecimalSign: false,
+        isMinusSign: false
+      };
+      var minusCharIndexOnText = text.search(this._minusSign);
+      this._minusSign.lastIndex = 0;
+      if (!this.allowMinusSign() && minusCharIndexOnText !== -1) {
+        return;
+      }
+      var selectionStart = this.$refs.input.$el.selectionStart;
+      var selectionEnd = this.$refs.input.$el.selectionEnd;
+      var inputValue = this.$refs.input.$el.value.trim();
+      var _this$getCharIndexes = this.getCharIndexes(inputValue),
+        decimalCharIndex = _this$getCharIndexes.decimalCharIndex,
+        minusCharIndex = _this$getCharIndexes.minusCharIndex,
+        suffixCharIndex = _this$getCharIndexes.suffixCharIndex,
+        currencyCharIndex = _this$getCharIndexes.currencyCharIndex;
+      var newValueStr;
+      if (sign.isMinusSign) {
+        if (selectionStart === 0) {
+          newValueStr = inputValue;
+          if (minusCharIndex === -1 || selectionEnd !== 0) {
+            newValueStr = this.insertText(inputValue, text, 0, selectionEnd);
+          }
+          this.updateValue(event, newValueStr, text, 'insert');
+        }
+      } else if (sign.isDecimalSign) {
+        if (decimalCharIndex > 0 && selectionStart === decimalCharIndex) {
+          this.updateValue(event, inputValue, text, 'insert');
+        } else if (decimalCharIndex > selectionStart && decimalCharIndex < selectionEnd) {
+          newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
+          this.updateValue(event, newValueStr, text, 'insert');
+        } else if (decimalCharIndex === -1 && this.maxFractionDigits) {
+          newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
+          this.updateValue(event, newValueStr, text, 'insert');
+        }
+      } else {
+        var maxFractionDigits = this.numberFormat.resolvedOptions().maximumFractionDigits;
+        var operation = selectionStart !== selectionEnd ? 'range-insert' : 'insert';
+        if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
+          if (selectionStart + text.length - (decimalCharIndex + 1) <= maxFractionDigits) {
+            var charIndex = currencyCharIndex >= selectionStart ? currencyCharIndex - 1 : suffixCharIndex >= selectionStart ? suffixCharIndex : inputValue.length;
+            newValueStr = inputValue.slice(0, selectionStart) + text + inputValue.slice(selectionStart + text.length, charIndex) + inputValue.slice(charIndex);
+            this.updateValue(event, newValueStr, text, operation);
+          }
+        } else {
+          newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
+          this.updateValue(event, newValueStr, text, operation);
+        }
+      }
+    },
+    insertText: function insertText(value, text, start, end) {
+      var textSplit = text === '.' ? text : text.split('.');
+      if (textSplit.length === 2) {
+        var decimalCharIndex = value.slice(start, end).search(this._decimal);
+        this._decimal.lastIndex = 0;
+        return decimalCharIndex > 0 ? value.slice(0, start) + this.formatValue(text) + value.slice(end) : value || this.formatValue(text);
+      } else if (end - start === value.length) {
+        return this.formatValue(text);
+      } else if (start === 0) {
+        return text + value.slice(end);
+      } else if (end === value.length) {
+        return value.slice(0, start) + text;
+      } else {
+        return value.slice(0, start) + text + value.slice(end);
+      }
+    },
+    deleteRange: function deleteRange(value, start, end) {
+      var newValueStr;
+      if (end - start === value.length) newValueStr = '';else if (start === 0) newValueStr = value.slice(end);else if (end === value.length) newValueStr = value.slice(0, start);else newValueStr = value.slice(0, start) + value.slice(end);
+      return newValueStr;
+    },
+    initCursor: function initCursor() {
+      var selectionStart = this.$refs.input.$el.selectionStart;
+      var inputValue = this.$refs.input.$el.value;
+      var valueLength = inputValue.length;
+      var index = null;
+
+      // remove prefix
+      var prefixLength = (this.prefixChar || '').length;
+      inputValue = inputValue.replace(this._prefix, '');
+      selectionStart = selectionStart - prefixLength;
+      var _char4 = inputValue.charAt(selectionStart);
+      if (this.isNumeralChar(_char4)) {
+        return selectionStart + prefixLength;
+      }
+
+      //left
+      var i = selectionStart - 1;
+      while (i >= 0) {
+        _char4 = inputValue.charAt(i);
+        if (this.isNumeralChar(_char4)) {
+          index = i + prefixLength;
+          break;
+        } else {
+          i--;
+        }
+      }
+      if (index !== null) {
+        this.$refs.input.$el.setSelectionRange(index + 1, index + 1);
+      } else {
+        i = selectionStart;
+        while (i < valueLength) {
+          _char4 = inputValue.charAt(i);
+          if (this.isNumeralChar(_char4)) {
+            index = i + prefixLength;
+            break;
+          } else {
+            i++;
+          }
+        }
+        if (index !== null) {
+          this.$refs.input.$el.setSelectionRange(index, index);
+        }
+      }
+      return index || 0;
+    },
+    onInputClick: function onInputClick() {
+      var currentValue = this.$refs.input.$el.value;
+      if (!this.readonly && currentValue !== utils.DomHandler.getSelection()) {
+        this.initCursor();
+      }
+    },
+    isNumeralChar: function isNumeralChar(_char5) {
+      if (_char5.length === 1 && (this._numeral.test(_char5) || this._decimal.test(_char5) || this._group.test(_char5) || this._minusSign.test(_char5))) {
+        this.resetRegex();
+        return true;
+      }
+      return false;
+    },
+    resetRegex: function resetRegex() {
+      this._numeral.lastIndex = 0;
+      this._decimal.lastIndex = 0;
+      this._group.lastIndex = 0;
+      this._minusSign.lastIndex = 0;
+    },
+    updateValue: function updateValue(event, valueStr, insertedValueStr, operation) {
+      var currentValue = this.$refs.input.$el.value;
+      var newValue = null;
+      if (valueStr != null) {
+        newValue = this.parseValue(valueStr);
+        newValue = !newValue && !this.allowEmpty ? 0 : newValue;
+        this.updateInput(newValue, insertedValueStr, operation, valueStr);
+        this.handleOnInput(event, currentValue, newValue);
+      }
+    },
+    handleOnInput: function handleOnInput(event, currentValue, newValue) {
+      if (this.isValueChanged(currentValue, newValue)) {
+        this.$emit('input', {
+          originalEvent: event,
+          value: newValue,
+          formattedValue: currentValue
+        });
+      }
+    },
+    isValueChanged: function isValueChanged(currentValue, newValue) {
+      if (newValue === null && currentValue !== null) {
+        return true;
+      }
+      if (newValue != null) {
+        var parsedCurrentValue = typeof currentValue === 'string' ? this.parseValue(currentValue) : currentValue;
+        return newValue !== parsedCurrentValue;
+      }
+      return false;
+    },
+    validateValue: function validateValue(value) {
+      if (value === '-' || value == null) {
+        return null;
+      }
+      if (this.min != null && value < this.min) {
+        return this.min;
+      }
+      if (this.max != null && value > this.max) {
+        return this.max;
+      }
+      return value;
+    },
+    updateInput: function updateInput(value, insertedValueStr, operation, valueStr) {
+      insertedValueStr = insertedValueStr || '';
+      var inputValue = this.$refs.input.$el.value;
+      var newValue = this.formatValue(value);
+      var currentLength = inputValue.length;
+      if (newValue !== valueStr) {
+        newValue = this.concatValues(newValue, valueStr);
+      }
+      if (currentLength === 0) {
+        this.$refs.input.$el.value = newValue;
+        this.$refs.input.$el.setSelectionRange(0, 0);
+        var index = this.initCursor();
+        var selectionEnd = index + insertedValueStr.length;
+        this.$refs.input.$el.setSelectionRange(selectionEnd, selectionEnd);
+      } else {
+        var selectionStart = this.$refs.input.$el.selectionStart;
+        var _selectionEnd = this.$refs.input.$el.selectionEnd;
+        this.$refs.input.$el.value = newValue;
+        var newLength = newValue.length;
+        if (operation === 'range-insert') {
+          var startValue = this.parseValue((inputValue || '').slice(0, selectionStart));
+          var startValueStr = startValue !== null ? startValue.toString() : '';
+          var startExpr = startValueStr.split('').join("(".concat(this.groupChar, ")?"));
+          var sRegex = new RegExp(startExpr, 'g');
+          sRegex.test(newValue);
+          var tExpr = insertedValueStr.split('').join("(".concat(this.groupChar, ")?"));
+          var tRegex = new RegExp(tExpr, 'g');
+          tRegex.test(newValue.slice(sRegex.lastIndex));
+          _selectionEnd = sRegex.lastIndex + tRegex.lastIndex;
+          this.$refs.input.$el.setSelectionRange(_selectionEnd, _selectionEnd);
+        } else if (newLength === currentLength) {
+          if (operation === 'insert' || operation === 'delete-back-single') this.$refs.input.$el.setSelectionRange(_selectionEnd + 1, _selectionEnd + 1);else if (operation === 'delete-single') this.$refs.input.$el.setSelectionRange(_selectionEnd - 1, _selectionEnd - 1);else if (operation === 'delete-range' || operation === 'spin') this.$refs.input.$el.setSelectionRange(_selectionEnd, _selectionEnd);
+        } else if (operation === 'delete-back-single') {
+          var prevChar = inputValue.charAt(_selectionEnd - 1);
+          var nextChar = inputValue.charAt(_selectionEnd);
+          var diff = currentLength - newLength;
+          var isGroupChar = this._group.test(nextChar);
+          if (isGroupChar && diff === 1) {
+            _selectionEnd += 1;
+          } else if (!isGroupChar && this.isNumeralChar(prevChar)) {
+            _selectionEnd += -1 * diff + 1;
+          }
+          this._group.lastIndex = 0;
+          this.$refs.input.$el.setSelectionRange(_selectionEnd, _selectionEnd);
+        } else if (inputValue === '-' && operation === 'insert') {
+          this.$refs.input.$el.setSelectionRange(0, 0);
+          var _index = this.initCursor();
+          var _selectionEnd2 = _index + insertedValueStr.length + 1;
+          this.$refs.input.$el.setSelectionRange(_selectionEnd2, _selectionEnd2);
+        } else {
+          _selectionEnd = _selectionEnd + (newLength - currentLength);
+          this.$refs.input.$el.setSelectionRange(_selectionEnd, _selectionEnd);
+        }
+      }
+      this.$refs.input.$el.setAttribute('aria-valuenow', value);
+    },
+    concatValues: function concatValues(val1, val2) {
+      if (val1 && val2) {
+        var decimalCharIndex = val2.search(this._decimal);
+        this._decimal.lastIndex = 0;
+        if (this.suffixChar) {
+          return decimalCharIndex !== -1 ? val1.replace(this.suffixChar, '').split(this._decimal)[0] + val2.replace(this.suffixChar, '').slice(decimalCharIndex) + this.suffixChar : val1;
+        } else {
+          return decimalCharIndex !== -1 ? val1.split(this._decimal)[0] + val2.slice(decimalCharIndex) : val1;
+        }
+      }
+      return val1;
+    },
+    getDecimalLength: function getDecimalLength(value) {
+      if (value) {
+        var valueSplit = value.split(this._decimal);
+        if (valueSplit.length === 2) {
+          return valueSplit[1].replace(this._suffix, '').trim().replace(/\s/g, '').replace(this._currency, '').length;
+        }
+      }
+      return 0;
+    },
+    updateModel: function updateModel(event, value) {
+      this.d_modelValue = value;
+      this.$emit('update:modelValue', value);
+    },
+    onInputFocus: function onInputFocus(event) {
+      this.focused = true;
+      if (!this.disabled && !this.readonly && this.$refs.input.$el.value !== utils.DomHandler.getSelection() && this.highlightOnFocus) {
+        event.target.select();
+      }
+      this.$emit('focus', event);
+    },
+    onInputBlur: function onInputBlur(event) {
+      this.focused = false;
+      var input = event.target;
+      var newValue = this.validateValue(this.parseValue(input.value));
+      this.$emit('blur', {
+        originalEvent: event,
+        value: input.value
+      });
+      input.value = this.formatValue(newValue);
+      input.setAttribute('aria-valuenow', newValue);
+      this.updateModel(event, newValue);
+    },
+    clearTimer: function clearTimer() {
+      if (this.timer) {
+        clearInterval(this.timer);
+      }
+    },
+    maxBoundry: function maxBoundry() {
+      return this.d_modelValue >= this.max;
+    },
+    minBoundry: function minBoundry() {
+      return this.d_modelValue <= this.min;
+    }
+  },
+  computed: {
+    filled: function filled() {
+      return this.modelValue != null && this.modelValue.toString().length > 0;
+    },
+    upButtonListeners: function upButtonListeners() {
+      var _this2 = this;
+      return {
+        mousedown: function mousedown(event) {
+          return _this2.onUpButtonMouseDown(event);
         },
-        onInputBlur(event) {
-            this.focused = false;
-
-            let input = event.target;
-            let newValue = this.validateValue(this.parseValue(input.value));
-
-            this.$emit('blur', { originalEvent: event, value: input.value });
-
-            input.value = this.formatValue(newValue);
-            input.setAttribute('aria-valuenow', newValue);
-            this.updateModel(event, newValue);
+        mouseup: function mouseup(event) {
+          return _this2.onUpButtonMouseUp(event);
         },
-        clearTimer() {
-            if (this.timer) {
-                clearInterval(this.timer);
-            }
+        mouseleave: function mouseleave(event) {
+          return _this2.onUpButtonMouseLeave(event);
         },
-        maxBoundry() {
-            return this.d_modelValue >= this.max;
+        keydown: function keydown(event) {
+          return _this2.onUpButtonKeyDown(event);
         },
-        minBoundry() {
-            return this.d_modelValue <= this.min;
+        keyup: function keyup(event) {
+          return _this2.onUpButtonKeyUp(event);
         }
+      };
     },
-    computed: {
-        containerClass() {
-            return [
-                'p-inputnumber p-component p-inputwrapper',
-                {
-                    'p-inputwrapper-filled': this.filled,
-                    'p-inputwrapper-focus': this.focused,
-                    'p-inputnumber-buttons-stacked': this.showButtons && this.buttonLayout === 'stacked',
-                    'p-inputnumber-buttons-horizontal': this.showButtons && this.buttonLayout === 'horizontal',
-                    'p-inputnumber-buttons-vertical': this.showButtons && this.buttonLayout === 'vertical'
-                }
-            ];
+    downButtonListeners: function downButtonListeners() {
+      var _this3 = this;
+      return {
+        mousedown: function mousedown(event) {
+          return _this3.onDownButtonMouseDown(event);
         },
-
-        upButtonClass() {
-            return [
-                'p-inputnumber-button p-inputnumber-button-up',
-                this.incrementButtonClass,
-                {
-                    'p-disabled': this.showButtons && this.max !== null && this.maxBoundry()
-                }
-            ];
-        },
-        downButtonClass() {
-            return [
-                'p-inputnumber-button p-inputnumber-button-down',
-                this.decrementButtonClass,
-                {
-                    'p-disabled': this.showButtons && this.min !== null && this.minBoundry()
-                }
-            ];
+        mouseup: function mouseup(event) {
+          return _this3.onDownButtonMouseUp(event);
         },
-        filled() {
-            return this.modelValue != null && this.modelValue.toString().length > 0;
+        mouseleave: function mouseleave(event) {
+          return _this3.onDownButtonMouseLeave(event);
         },
-        upButtonListeners() {
-            return {
-                mousedown: (event) => this.onUpButtonMouseDown(event),
-                mouseup: (event) => this.onUpButtonMouseUp(event),
-                mouseleave: (event) => this.onUpButtonMouseLeave(event),
-                keydown: (event) => this.onUpButtonKeyDown(event),
-                keyup: (event) => this.onUpButtonKeyUp(event)
-            };
-        },
-        downButtonListeners() {
-            return {
-                mousedown: (event) => this.onDownButtonMouseDown(event),
-                mouseup: (event) => this.onDownButtonMouseUp(event),
-                mouseleave: (event) => this.onDownButtonMouseLeave(event),
-                keydown: (event) => this.onDownButtonKeyDown(event),
-                keyup: (event) => this.onDownButtonKeyUp(event)
-            };
-        },
-        formattedValue() {
-            const val = !this.modelValue && !this.allowEmpty ? 0 : this.modelValue;
-
-            return this.formatValue(val);
+        keydown: function keydown(event) {
+          return _this3.onDownButtonKeyDown(event);
         },
-        getFormatter() {
-            return this.numberFormat;
+        keyup: function keyup(event) {
+          return _this3.onDownButtonKeyUp(event);
         }
+      };
     },
-    components: {
-        INInputText: InputText__default["default"],
-        INButton: Button__default["default"],
-        AngleUpIcon: AngleUpIcon__default["default"],
-        AngleDownIcon: AngleDownIcon__default["default"]
+    formattedValue: function formattedValue() {
+      var val = !this.modelValue && !this.allowEmpty ? 0 : this.modelValue;
+      return this.formatValue(val);
+    },
+    getFormatter: function getFormatter() {
+      return this.numberFormat;
     }
+  },
+  components: {
+    INInputText: InputText__default["default"],
+    INButton: Button__default["default"],
+    AngleUpIcon: AngleUpIcon__default["default"],
+    AngleDownIcon: AngleDownIcon__default["default"]
+  }
 };
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 function render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_INInputText = vue.resolveComponent("INInputText");
-  const _component_INButton = vue.resolveComponent("INButton");
-
-  return (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({ class: $options.containerClass }, _ctx.ptm('root')), [
-    vue.createVNode(_component_INInputText, vue.mergeProps({
-      ref: "input",
-      id: $props.inputId,
-      class: ["p-inputnumber-input", $props.inputClass],
-      role: "spinbutton",
-      style: $props.inputStyle,
-      value: $options.formattedValue,
-      "aria-valuemin": $props.min,
-      "aria-valuemax": $props.max,
-      "aria-valuenow": $props.modelValue,
-      disabled: $props.disabled,
-      readonly: $props.readonly,
-      placeholder: $props.placeholder,
-      "aria-labelledby": _ctx.ariaLabelledby,
-      "aria-label": _ctx.ariaLabel,
-      onInput: $options.onUserInput,
-      onKeydown: $options.onInputKeyDown,
-      onKeypress: $options.onInputKeyPress,
-      onPaste: $options.onPaste,
-      onClick: $options.onInputClick,
-      onFocus: $options.onInputFocus,
-      onBlur: $options.onInputBlur
-    }, { ...$props.inputProps, ..._ctx.ptm('input') }), null, 16, ["id", "class", "style", "value", "aria-valuemin", "aria-valuemax", "aria-valuenow", "disabled", "readonly", "placeholder", "aria-labelledby", "aria-label", "onInput", "onKeydown", "onKeypress", "onPaste", "onClick", "onFocus", "onBlur"]),
-    ($props.showButtons && $props.buttonLayout === 'stacked')
-      ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
-          key: 0,
-          class: "p-inputnumber-button-group"
-        }, _ctx.ptm('buttonGroup')), [
-          vue.createVNode(_component_INButton, vue.mergeProps({ class: $options.upButtonClass }, vue.toHandlers($options.upButtonListeners), {
-            disabled: $props.disabled,
-            tabindex: -1,
-            "aria-hidden": "true"
-          }, { ...$props.incrementButtonProps, ..._ctx.ptm('incrementButton') }), {
-            icon: vue.withCtx(() => [
-              vue.renderSlot(_ctx.$slots, "incrementbuttonicon", {}, () => [
-                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.incrementButtonIcon ? 'span' : 'AngleUpIcon'), vue.mergeProps({ class: $props.incrementButtonIcon }, _ctx.ptm('incrementButton')['icon']), null, 16, ["class"]))
-              ])
-            ]),
-            _: 3
-          }, 16, ["class", "disabled"]),
-          vue.createVNode(_component_INButton, vue.mergeProps({ class: $options.downButtonClass }, vue.toHandlers($options.downButtonListeners), {
-            disabled: $props.disabled,
-            tabindex: -1,
-            "aria-hidden": "true"
-          }, { ...$props.decrementButtonProps, ..._ctx.ptm('decrementButton') }), {
-            icon: vue.withCtx(() => [
-              vue.renderSlot(_ctx.$slots, "decrementbuttonicon", {}, () => [
-                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.decrementButtonIcon ? 'span' : 'AngleDownIcon'), vue.mergeProps({ class: $props.decrementButtonIcon }, _ctx.ptm('decrementButton')['icon']), null, 16, ["class"]))
-              ])
-            ]),
-            _: 3
-          }, 16, ["class", "disabled"])
-        ], 16))
-      : vue.createCommentVNode("", true),
-    ($props.showButtons && $props.buttonLayout !== 'stacked')
-      ? (vue.openBlock(), vue.createBlock(_component_INButton, vue.mergeProps({
-          key: 1,
-          class: $options.upButtonClass
-        }, vue.toHandlers($options.upButtonListeners), {
-          disabled: $props.disabled,
-          tabindex: -1,
-          "aria-hidden": "true"
-        }, { ...$props.incrementButtonProps, ..._ctx.ptm('incrementButton') }), {
-          icon: vue.withCtx(() => [
-            vue.renderSlot(_ctx.$slots, "incrementbuttonicon", {}, () => [
-              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.incrementButtonIcon ? 'span' : 'AngleUpIcon'), vue.mergeProps({ class: $props.incrementButtonIcon }, _ctx.ptm('incrementButton')['icon']), null, 16, ["class"]))
-            ])
-          ]),
-          _: 3
-        }, 16, ["class", "disabled"]))
-      : vue.createCommentVNode("", true),
-    ($props.showButtons && $props.buttonLayout !== 'stacked')
-      ? (vue.openBlock(), vue.createBlock(_component_INButton, vue.mergeProps({
-          key: 2,
-          class: $options.downButtonClass
-        }, vue.toHandlers($options.downButtonListeners), {
-          disabled: $props.disabled,
-          tabindex: -1,
-          "aria-hidden": "true"
-        }, { ...$props.decrementButtonProps, ..._ctx.ptm('decrementButton') }), {
-          icon: vue.withCtx(() => [
-            vue.renderSlot(_ctx.$slots, "decrementbuttonicon", {}, () => [
-              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent($props.decrementButtonIcon ? 'span' : 'AngleDownIcon'), vue.mergeProps({ class: $props.decrementButtonIcon }, _ctx.ptm('decrementButton')['icon']), null, 16, ["class"]))
-            ])
-          ]),
-          _: 3
-        }, 16, ["class", "disabled"]))
-      : vue.createCommentVNode("", true)
-  ], 16))
+  var _component_INInputText = vue.resolveComponent("INInputText");
+  var _component_INButton = vue.resolveComponent("INButton");
+  return vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+    "class": _ctx.cx('root')
+  }, _ctx.ptm('root'), {
+    "data-pc-name": "inputnumber"
+  }), [vue.createVNode(_component_INInputText, vue.mergeProps({
+    ref: "input",
+    id: _ctx.inputId,
+    role: "spinbutton",
+    "class": [_ctx.cx('input'), _ctx.inputClass],
+    style: _ctx.inputStyle,
+    value: $options.formattedValue,
+    "aria-valuemin": _ctx.min,
+    "aria-valuemax": _ctx.max,
+    "aria-valuenow": _ctx.modelValue,
+    disabled: _ctx.disabled,
+    readonly: _ctx.readonly,
+    placeholder: _ctx.placeholder,
+    "aria-labelledby": _ctx.ariaLabelledby,
+    "aria-label": _ctx.ariaLabel,
+    onInput: $options.onUserInput,
+    onKeydown: $options.onInputKeyDown,
+    onKeypress: $options.onInputKeyPress,
+    onPaste: $options.onPaste,
+    onClick: $options.onInputClick,
+    onFocus: $options.onInputFocus,
+    onBlur: $options.onInputBlur
+  }, _objectSpread(_objectSpread({}, _ctx.inputProps), _ctx.ptm('input')), {
+    unstyled: _ctx.unstyled,
+    "data-pc-section": "input"
+  }), null, 16, ["id", "class", "style", "value", "aria-valuemin", "aria-valuemax", "aria-valuenow", "disabled", "readonly", "placeholder", "aria-labelledby", "aria-label", "onInput", "onKeydown", "onKeypress", "onPaste", "onClick", "onFocus", "onBlur", "unstyled"]), _ctx.showButtons && _ctx.buttonLayout === 'stacked' ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+    key: 0,
+    "class": _ctx.cx('buttonGroup')
+  }, _ctx.ptm('buttonGroup')), [vue.createVNode(_component_INButton, vue.mergeProps({
+    "class": [_ctx.cx('incrementButton'), _ctx.incrementButtonClass]
+  }, vue.toHandlers($options.upButtonListeners), {
+    disabled: _ctx.disabled,
+    tabindex: -1,
+    "aria-hidden": "true"
+  }, _objectSpread(_objectSpread({}, _ctx.incrementButtonProps), _ctx.ptm('incrementButton')), {
+    unstyled: _ctx.unstyled,
+    "data-pc-section": "incrementbutton"
+  }), {
+    icon: vue.withCtx(function () {
+      return [vue.renderSlot(_ctx.$slots, "incrementbuttonicon", {}, function () {
+        return [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.incrementButtonIcon ? 'span' : 'AngleUpIcon'), vue.mergeProps({
+          "class": _ctx.incrementButtonIcon
+        }, _ctx.ptm('incrementButton')['icon']), null, 16, ["class"]))];
+      })];
+    }),
+    _: 3
+  }, 16, ["class", "disabled", "unstyled"]), vue.createVNode(_component_INButton, vue.mergeProps({
+    "class": [_ctx.cx('decrementButton'), _ctx.decrementButtonClass]
+  }, vue.toHandlers($options.downButtonListeners), {
+    disabled: _ctx.disabled,
+    tabindex: -1,
+    "aria-hidden": "true"
+  }, _objectSpread(_objectSpread({}, _ctx.decrementButtonProps), _ctx.ptm('decrementButton')), {
+    unstyled: _ctx.unstyled,
+    "data-pc-section": "decrementbutton"
+  }), {
+    icon: vue.withCtx(function () {
+      return [vue.renderSlot(_ctx.$slots, "decrementbuttonicon", {}, function () {
+        return [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.decrementButtonIcon ? 'span' : 'AngleDownIcon'), vue.mergeProps({
+          "class": _ctx.decrementButtonIcon
+        }, _ctx.ptm('decrementButton')['icon']), null, 16, ["class"]))];
+      })];
+    }),
+    _: 3
+  }, 16, ["class", "disabled", "unstyled"])], 16)) : vue.createCommentVNode("", true), _ctx.showButtons && _ctx.buttonLayout !== 'stacked' ? (vue.openBlock(), vue.createBlock(_component_INButton, vue.mergeProps({
+    key: 1,
+    "class": [_ctx.cx('incrementButton'), _ctx.incrementButtonClass]
+  }, vue.toHandlers($options.upButtonListeners), {
+    disabled: _ctx.disabled,
+    tabindex: -1,
+    "aria-hidden": "true"
+  }, _objectSpread(_objectSpread({}, _ctx.incrementButtonProps), _ctx.ptm('incrementButton')), {
+    unstyled: _ctx.unstyled,
+    "data-pc-section": "incrementbutton"
+  }), {
+    icon: vue.withCtx(function () {
+      return [vue.renderSlot(_ctx.$slots, "incrementbuttonicon", {}, function () {
+        return [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.incrementButtonIcon ? 'span' : 'AngleUpIcon'), vue.mergeProps({
+          "class": _ctx.incrementButtonIcon
+        }, _ctx.ptm('incrementButton')['icon']), null, 16, ["class"]))];
+      })];
+    }),
+    _: 3
+  }, 16, ["class", "disabled", "unstyled"])) : vue.createCommentVNode("", true), _ctx.showButtons && _ctx.buttonLayout !== 'stacked' ? (vue.openBlock(), vue.createBlock(_component_INButton, vue.mergeProps({
+    key: 2,
+    "class": [_ctx.cx('decrementButton'), _ctx.decrementButtonClass]
+  }, vue.toHandlers($options.downButtonListeners), {
+    disabled: _ctx.disabled,
+    tabindex: -1,
+    "aria-hidden": "true"
+  }, _objectSpread(_objectSpread({}, _ctx.decrementButtonProps), _ctx.ptm('decrementButton')), {
+    unstyled: _ctx.unstyled,
+    "data-pc-section": "decrementbutton"
+  }), {
+    icon: vue.withCtx(function () {
+      return [vue.renderSlot(_ctx.$slots, "decrementbuttonicon", {}, function () {
+        return [(vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.decrementButtonIcon ? 'span' : 'AngleDownIcon'), vue.mergeProps({
+          "class": _ctx.decrementButtonIcon
+        }, _ctx.ptm('decrementButton')['icon']), null, 16, ["class"]))];
+      })];
+    }),
+    _: 3
+  }, 16, ["class", "disabled", "unstyled"])) : vue.createCommentVNode("", true)], 16);
 }
 
-function styleInject(css, ref) {
-  if ( ref === void 0 ) ref = {};
-  var insertAt = ref.insertAt;
-
-  if (!css || typeof document === 'undefined') { return; }
-
-  var head = document.head || document.getElementsByTagName('head')[0];
-  var style = document.createElement('style');
-  style.type = 'text/css';
-
-  if (insertAt === 'top') {
-    if (head.firstChild) {
-      head.insertBefore(style, head.firstChild);
-    } else {
-      head.appendChild(style);
-    }
-  } else {
-    head.appendChild(style);
-  }
-
-  if (style.styleSheet) {
-    style.styleSheet.cssText = css;
-  } else {
-    style.appendChild(document.createTextNode(css));
-  }
-}
-
-var css_248z = "\n.p-inputnumber {\n    display: inline-flex;\n}\n.p-inputnumber-button {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    flex: 0 0 auto;\n}\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button .p-button-label,\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button .p-button-label {\n    display: none;\n}\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button-up {\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n    border-bottom-right-radius: 0;\n    padding: 0;\n}\n.p-inputnumber-buttons-stacked .p-inputnumber-input {\n    border-top-right-radius: 0;\n    border-bottom-right-radius: 0;\n}\n.p-inputnumber-buttons-stacked .p-button.p-inputnumber-button-down {\n    border-top-left-radius: 0;\n    border-top-right-radius: 0;\n    border-bottom-left-radius: 0;\n    padding: 0;\n}\n.p-inputnumber-buttons-stacked .p-inputnumber-button-group {\n    display: flex;\n    flex-direction: column;\n}\n.p-inputnumber-buttons-stacked .p-inputnumber-button-group .p-button.p-inputnumber-button {\n    flex: 1 1 auto;\n}\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button-up {\n    order: 3;\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n}\n.p-inputnumber-buttons-horizontal .p-inputnumber-input {\n    order: 2;\n    border-radius: 0;\n}\n.p-inputnumber-buttons-horizontal .p-button.p-inputnumber-button-down {\n    order: 1;\n    border-top-right-radius: 0;\n    border-bottom-right-radius: 0;\n}\n.p-inputnumber-buttons-vertical {\n    flex-direction: column;\n}\n.p-inputnumber-buttons-vertical .p-button.p-inputnumber-button-up {\n    order: 1;\n    border-bottom-left-radius: 0;\n    border-bottom-right-radius: 0;\n    width: 100%;\n}\n.p-inputnumber-buttons-vertical .p-inputnumber-input {\n    order: 2;\n    border-radius: 0;\n    text-align: center;\n}\n.p-inputnumber-buttons-vertical .p-button.p-inputnumber-button-down {\n    order: 3;\n    border-top-left-radius: 0;\n    border-top-right-radius: 0;\n    width: 100%;\n}\n.p-inputnumber-input {\n    flex: 1 1 auto;\n}\n.p-fluid .p-inputnumber {\n    width: 100%;\n}\n.p-fluid .p-inputnumber .p-inputnumber-input {\n    width: 1%;\n}\n.p-fluid .p-inputnumber-buttons-vertical .p-inputnumber-input {\n    width: 100%;\n}\n";
-styleInject(css_248z);
-
 script.render = render;
 
 module.exports = script;