appmax-client-vue3 5.0.4 → 5.0.6

package/dist/index-Cz7X93CO.js

@@ -0,0 +1,1433 @@
+import { cl as script$4, g as createElementBlock, h as openBlock, j as createBaseVNode, E as mergeProps, Y as BaseStyle, aB as script$5, bj as script$6, a2 as cn, cx as clearSelection, cH as getSelection, a3 as isNotEmpty, a9 as resolveComponent, i as createVNode, k as createCommentVNode, a6 as renderSlot, S as normalizeStyle, n as normalizeClass, v as createBlock, ar as resolveDynamicComponent, cI as toHandlers } from "./main-ByGSHXk8.js";
+var script$3 = {
+  name: "AngleDownIcon",
+  "extends": script$4
+};
+function render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", mergeProps({
+    width: "14",
+    height: "14",
+    viewBox: "0 0 14 14",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, _ctx.pti()), _cache[0] || (_cache[0] = [createBaseVNode("path", {
+    d: "M3.58659 4.5007C3.68513 4.50023 3.78277 4.51945 3.87379 4.55723C3.9648 4.59501 4.04735 4.65058 4.11659 4.7207L7.11659 7.7207L10.1166 4.7207C10.2619 4.65055 10.4259 4.62911 10.5843 4.65956C10.7427 4.69002 10.8871 4.77074 10.996 4.88976C11.1049 5.00877 11.1726 5.15973 11.1889 5.32022C11.2052 5.48072 11.1693 5.6422 11.0866 5.7807L7.58659 9.2807C7.44597 9.42115 7.25534 9.50004 7.05659 9.50004C6.85784 9.50004 6.66722 9.42115 6.52659 9.2807L3.02659 5.7807C2.88614 5.64007 2.80725 5.44945 2.80725 5.2507C2.80725 5.05195 2.88614 4.86132 3.02659 4.7207C3.09932 4.64685 3.18675 4.58911 3.28322 4.55121C3.37969 4.51331 3.48305 4.4961 3.58659 4.5007Z",
+    fill: "currentColor"
+  }, null, -1)]), 16);
+}
+script$3.render = render$2;
+var script$2 = {
+  name: "AngleUpIcon",
+  "extends": script$4
+};
+function render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("svg", mergeProps({
+    width: "14",
+    height: "14",
+    viewBox: "0 0 14 14",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg"
+  }, _ctx.pti()), _cache[0] || (_cache[0] = [createBaseVNode("path", {
+    d: "M10.4134 9.49931C10.3148 9.49977 10.2172 9.48055 10.1262 9.44278C10.0352 9.405 9.95263 9.34942 9.88338 9.27931L6.88338 6.27931L3.88338 9.27931C3.73811 9.34946 3.57409 9.3709 3.41567 9.34044C3.25724 9.30999 3.11286 9.22926 3.00395 9.11025C2.89504 8.99124 2.82741 8.84028 2.8111 8.67978C2.79478 8.51928 2.83065 8.35781 2.91338 8.21931L6.41338 4.71931C6.55401 4.57886 6.74463 4.49997 6.94338 4.49997C7.14213 4.49997 7.33276 4.57886 7.47338 4.71931L10.9734 8.21931C11.1138 8.35994 11.1927 8.55056 11.1927 8.74931C11.1927 8.94806 11.1138 9.13868 10.9734 9.27931C10.9007 9.35315 10.8132 9.41089 10.7168 9.44879C10.6203 9.48669 10.5169 9.5039 10.4134 9.49931Z",
+    fill: "currentColor"
+  }, null, -1)]), 16);
+}
+script$2.render = render$1;
+var style = ({ dt: n }) => `
+.p-inputnumber {
+    display: inline-flex;
+    position: relative;
+}
+
+.p-inputnumber-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex: 0 0 auto;
+    cursor: pointer;
+    background: ${n("inputnumber.button.background")};
+    color: ${n("inputnumber.button.color")};
+    width: ${n("inputnumber.button.width")};
+    transition: background ${n("inputnumber.transition.duration")}, color ${n("inputnumber.transition.duration")}, border-color ${n("inputnumber.transition.duration")}, outline-color ${n("inputnumber.transition.duration")};
+}
+
+.p-inputnumber-button:disabled {
+    cursor: auto;
+}
+
+.p-inputnumber-button:not(:disabled):hover {
+    background: ${n("inputnumber.button.hover.background")};
+    color: ${n("inputnumber.button.hover.color")};
+}
+
+.p-inputnumber-button:not(:disabled):active {
+    background: ${n("inputnumber.button.active.background")};
+    color: ${n("inputnumber.button.active.color")};
+}
+
+.p-inputnumber-stacked .p-inputnumber-button {
+    position: relative;
+    border: 0 none;
+}
+
+.p-inputnumber-stacked .p-inputnumber-button-group {
+    display: flex;
+    flex-direction: column;
+    position: absolute;
+    inset-block-start: 1px;
+    inset-inline-end: 1px;
+    height: calc(100% - 2px);
+    z-index: 1;
+}
+
+.p-inputnumber-stacked .p-inputnumber-increment-button {
+    padding: 0;
+    border-start-end-radius: calc(${n("inputnumber.button.border.radius")} - 1px);
+}
+
+.p-inputnumber-stacked .p-inputnumber-decrement-button {
+    padding: 0;
+    border-end-end-radius: calc(${n("inputnumber.button.border.radius")} - 1px);
+}
+
+.p-inputnumber-stacked .p-inputnumber-button {
+    flex: 1 1 auto;
+    border: 0 none;
+}
+
+.p-inputnumber-horizontal .p-inputnumber-button {
+    border: 1px solid ${n("inputnumber.button.border.color")};
+}
+
+.p-inputnumber-horizontal .p-inputnumber-button:hover {
+    border-color: ${n("inputnumber.button.hover.border.color")};
+}
+
+.p-inputnumber-horizontal .p-inputnumber-button:active {
+    border-color: ${n("inputnumber.button.active.border.color")};
+}
+
+.p-inputnumber-horizontal .p-inputnumber-increment-button {
+    order: 3;
+    border-start-end-radius: ${n("inputnumber.button.border.radius")};
+    border-end-end-radius: ${n("inputnumber.button.border.radius")};
+    border-inline-start: 0 none;
+}
+
+.p-inputnumber-horizontal .p-inputnumber-input {
+    order: 2;
+    border-radius: 0;
+}
+
+.p-inputnumber-horizontal .p-inputnumber-decrement-button {
+    order: 1;
+    border-start-start-radius: ${n("inputnumber.button.border.radius")};
+    border-end-start-radius: ${n("inputnumber.button.border.radius")};
+    border-inline-end: 0 none;
+}
+
+.p-floatlabel:has(.p-inputnumber-horizontal) label {
+    margin-inline-start: ${n("inputnumber.button.width")};
+}
+
+.p-inputnumber-vertical {
+    flex-direction: column;
+}
+
+.p-inputnumber-vertical .p-inputnumber-button {
+    border: 1px solid ${n("inputnumber.button.border.color")};
+    padding: ${n("inputnumber.button.vertical.padding")};
+}
+
+.p-inputnumber-vertical .p-inputnumber-button:hover {
+    border-color: ${n("inputnumber.button.hover.border.color")};
+}
+
+.p-inputnumber-vertical .p-inputnumber-button:active {
+    border-color: ${n("inputnumber.button.active.border.color")};
+}
+
+.p-inputnumber-vertical .p-inputnumber-increment-button {
+    order: 1;
+    border-start-start-radius: ${n("inputnumber.button.border.radius")};
+    border-start-end-radius: ${n("inputnumber.button.border.radius")};
+    width: 100%;
+    border-block-end: 0 none;
+}
+
+.p-inputnumber-vertical .p-inputnumber-input {
+    order: 2;
+    border-radius: 0;
+    text-align: center;
+}
+
+.p-inputnumber-vertical .p-inputnumber-decrement-button {
+    order: 3;
+    border-end-start-radius: ${n("inputnumber.button.border.radius")};
+    border-end-end-radius: ${n("inputnumber.button.border.radius")};
+    width: 100%;
+    border-block-start: 0 none;
+}
+
+.p-inputnumber-input {
+    flex: 1 1 auto;
+}
+
+.p-inputnumber-fluid {
+    width: 100%;
+}
+
+.p-inputnumber-fluid .p-inputnumber-input {
+    width: 1%;
+}
+
+.p-inputnumber-fluid.p-inputnumber-vertical .p-inputnumber-input {
+    width: 100%;
+}
+
+.p-inputnumber:has(.p-inputtext-sm) .p-inputnumber-button .p-icon {
+    font-size: ${n("form.field.sm.font.size")};
+    width: ${n("form.field.sm.font.size")};
+    height: ${n("form.field.sm.font.size")};
+}
+
+.p-inputnumber:has(.p-inputtext-lg) .p-inputnumber-button .p-icon {
+    font-size: ${n("form.field.lg.font.size")};
+    width: ${n("form.field.lg.font.size")};
+    height: ${n("form.field.lg.font.size")};
+}
+`;
+var classes = {
+  root: function root(_ref) {
+    var instance = _ref.instance, props = _ref.props;
+    return ["p-inputnumber p-component p-inputwrapper", {
+      "p-invalid": instance.$invalid,
+      "p-inputwrapper-filled": instance.$filled || props.allowEmpty === false,
+      "p-inputwrapper-focus": instance.focused,
+      "p-inputnumber-stacked": props.showButtons && props.buttonLayout === "stacked",
+      "p-inputnumber-horizontal": props.showButtons && props.buttonLayout === "horizontal",
+      "p-inputnumber-vertical": props.showButtons && props.buttonLayout === "vertical",
+      "p-inputnumber-fluid": instance.$fluid
+    }];
+  },
+  pcInputText: "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-increment-button", {
+      "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-decrement-button", {
+      "p-disabled": props.showButtons && props.min !== null && instance.minBoundry()
+    }];
+  }
+};
+var InputNumberStyle = BaseStyle.extend({
+  name: "inputnumber",
+  style,
+  classes
+});
+var script$1 = {
+  name: "BaseInputNumber",
+  "extends": script$6,
+  props: {
+    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": void 0
+    },
+    incrementIcon: {
+      type: String,
+      "default": void 0
+    },
+    decrementButtonIcon: {
+      type: String,
+      "default": void 0
+    },
+    decrementIcon: {
+      type: String,
+      "default": void 0
+    },
+    locale: {
+      type: String,
+      "default": void 0
+    },
+    localeMatcher: {
+      type: String,
+      "default": void 0
+    },
+    mode: {
+      type: String,
+      "default": "decimal"
+    },
+    prefix: {
+      type: String,
+      "default": null
+    },
+    suffix: {
+      type: String,
+      "default": null
+    },
+    currency: {
+      type: String,
+      "default": void 0
+    },
+    currencyDisplay: {
+      type: String,
+      "default": void 0
+    },
+    useGrouping: {
+      type: Boolean,
+      "default": true
+    },
+    minFractionDigits: {
+      type: Number,
+      "default": void 0
+    },
+    maxFractionDigits: {
+      type: Number,
+      "default": void 0
+    },
+    roundingMode: {
+      type: String,
+      "default": "halfExpand",
+      validator: function validator(value) {
+        return ["ceil", "floor", "expand", "trunc", "halfCeil", "halfFloor", "halfExpand", "halfTrunc", "halfEven"].includes(value);
+      }
+    },
+    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
+    },
+    placeholder: {
+      type: String,
+      "default": null
+    },
+    inputId: {
+      type: String,
+      "default": null
+    },
+    inputClass: {
+      type: [String, Object],
+      "default": null
+    },
+    inputStyle: {
+      type: Object,
+      "default": null
+    },
+    ariaLabelledby: {
+      type: String,
+      "default": null
+    },
+    ariaLabel: {
+      type: String,
+      "default": null
+    },
+    required: {
+      type: Boolean,
+      "default": false
+    }
+  },
+  style: InputNumberStyle,
+  provide: function provide() {
+    return {
+      $pcInputNumber: this,
+      $parentInstance: this
+    };
+  }
+};
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: true, configurable: true, writable: true }) : e[r] = t, e;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _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(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+var script = {
+  name: "InputNumber",
+  "extends": script$1,
+  inheritAttrs: false,
+  emits: ["input", "focus", "blur"],
+  inject: {
+    $pcFluid: {
+      "default": null
+    }
+  },
+  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 {
+      // @deprecated
+      d_modelValue: this.d_value,
+      focused: false
+    };
+  },
+  watch: {
+    d_value: function d_value(newValue) {
+      this.d_modelValue = newValue;
+    },
+    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);
+    },
+    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,
+        roundingMode: this.roundingMode
+      };
+    },
+    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();
+      }
+    },
+    escapeRegExp: function escapeRegExp(text) {
+      return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    },
+    getDecimalExpression: function getDecimalExpression() {
+      var formatter = new Intl.NumberFormat(this.locale, _objectSpread(_objectSpread({}, 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(1e6).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,
+          roundingMode: this.roundingMode
+        });
+        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,
+          roundingMode: this.roundingMode
+        });
+        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 === "-") {
+          return value;
+        }
+        if (this.format) {
+          var formatter = new Intl.NumberFormat(this.locale, this.getOptions());
+          var formattedValue2 = formatter.format(value);
+          if (this.prefix) {
+            formattedValue2 = this.prefix + formattedValue2;
+          }
+          if (this.suffix) {
+            formattedValue2 = formattedValue2 + this.suffix;
+          }
+          return formattedValue2;
+        }
+        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 === "-")
+          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.code === "Space" || event.code === "Enter" || event.code === "NumpadEnter") {
+        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.code === "Space" || event.code === "Enter" || event.code === "NumpadEnter") {
+        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;
+      }
+      if (event.altKey || event.ctrlKey || event.metaKey) {
+        this.isSpecialChar = true;
+        this.lastValue = this.$refs.input.$el.value;
+        return;
+      }
+      this.lastValue = event.target.value;
+      var selectionStart = event.target.selectionStart;
+      var selectionEnd = event.target.selectionEnd;
+      var selectionRange = selectionEnd - selectionStart;
+      var inputValue = event.target.value;
+      var newValueStr = null;
+      var code = event.code || event.key;
+      switch (code) {
+        case "ArrowUp":
+          this.spin(event, 1);
+          event.preventDefault();
+          break;
+        case "ArrowDown":
+          this.spin(event, -1);
+          event.preventDefault();
+          break;
+        case "ArrowLeft":
+          if (selectionRange > 1) {
+            var cursorPosition = this.isNumeralChar(inputValue.charAt(selectionStart)) ? selectionStart + 1 : selectionStart + 2;
+            this.$refs.input.$el.setSelectionRange(cursorPosition, cursorPosition);
+          } else if (!this.isNumeralChar(inputValue.charAt(selectionStart - 1))) {
+            event.preventDefault();
+          }
+          break;
+        case "ArrowRight":
+          if (selectionRange > 1) {
+            var _cursorPosition = selectionEnd - 1;
+            this.$refs.input.$el.setSelectionRange(_cursorPosition, _cursorPosition);
+          } else if (!this.isNumeralChar(inputValue.charAt(selectionStart))) {
+            event.preventDefault();
+          }
+          break;
+        case "Tab":
+        case "Enter":
+        case "NumpadEnter":
+          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 = 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) {
+            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 (_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) {
+                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);
+              }
+            }
+            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":
+          event.preventDefault();
+          if (isNotEmpty(this.min)) {
+            this.updateModel(event, this.min);
+          }
+          break;
+        case "End":
+          event.preventDefault();
+          if (isNotEmpty(this.max)) {
+            this.updateModel(event, this.max);
+          }
+          break;
+      }
+    },
+    onInputKeyPress: function onInputKeyPress(event) {
+      if (this.readonly) {
+        return;
+      }
+      var _char = event.key;
+      var isDecimalSign2 = this.isDecimalSign(_char);
+      var isMinusSign2 = this.isMinusSign(_char);
+      if (event.code !== "Enter") {
+        event.preventDefault();
+      }
+      if (Number(_char) >= 0 && Number(_char) <= 9 || isMinusSign2 || isDecimalSign2) {
+        this.insert(event, _char, {
+          isDecimalSign: isDecimalSign2,
+          isMinusSign: isMinusSign2
+        });
+      }
+    },
+    onPaste: function onPaste(event) {
+      event.preventDefault();
+      var data2 = (event.clipboardData || window["clipboardData"]).getData("Text");
+      if (data2) {
+        var filteredData = this.parseValue(data2);
+        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) {
+      var _this$locale;
+      if ((_this$locale = this.locale) !== null && _this$locale !== void 0 && _this$locale.includes("fr") && [".", ","].includes(_char3) || 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,
+        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,
+        minusCharIndex,
+        suffixCharIndex,
+        currencyCharIndex
+      };
+    },
+    insert: function insert(event, text) {
+      var sign = arguments.length > 2 && arguments[2] !== void 0 ? 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) {
+        var isNewMinusSign = minusCharIndex === -1;
+        if (selectionStart === 0 || selectionStart === currencyCharIndex + 1) {
+          newValueStr = inputValue;
+          if (isNewMinusSign || 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 maxFractionDigits2 = this.numberFormat.resolvedOptions().maximumFractionDigits;
+        var operation = selectionStart !== selectionEnd ? "range-insert" : "insert";
+        if (decimalCharIndex > 0 && selectionStart > decimalCharIndex) {
+          if (selectionStart + text.length - (decimalCharIndex + 1) <= maxFractionDigits2) {
+            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) : this.formatValue(text) || value;
+      } 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;
+      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;
+      }
+      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 !== 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 ? this.min || 0 : newValue;
+        this.updateInput(newValue, insertedValueStr, operation, valueStr);
+        this.handleOnInput(event, currentValue, newValue);
+      }
+    },
+    handleOnInput: function handleOnInput(event, currentValue, newValue) {
+      if (this.isValueChanged(currentValue, newValue)) {
+        var _this$formField$onInp, _this$formField;
+        this.$emit("input", {
+          originalEvent: event,
+          value: newValue,
+          formattedValue: currentValue
+        });
+        (_this$formField$onInp = (_this$formField = this.formField).onInput) === null || _this$formField$onInp === void 0 || _this$formField$onInp.call(_this$formField, {
+          originalEvent: event,
+          value: newValue
+        });
+      }
+    },
+    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.writeValue(value, event);
+    },
+    onInputFocus: function onInputFocus(event) {
+      this.focused = true;
+      if (!this.disabled && !this.readonly && this.$refs.input.$el.value !== getSelection() && this.highlightOnFocus) {
+        event.target.select();
+      }
+      this.$emit("focus", event);
+    },
+    onInputBlur: function onInputBlur(event) {
+      var _this$formField$onBlu, _this$formField2;
+      this.focused = false;
+      var input = event.target;
+      var newValue = this.validateValue(this.parseValue(input.value));
+      this.$emit("blur", {
+        originalEvent: event,
+        value: input.value
+      });
+      (_this$formField$onBlu = (_this$formField2 = this.formField).onBlur) === null || _this$formField$onBlu === void 0 || _this$formField$onBlu.call(_this$formField2, event);
+      input.value = this.formatValue(newValue);
+      input.setAttribute("aria-valuenow", newValue);
+      this.updateModel(event, newValue);
+      if (!this.disabled && !this.readonly && this.highlightOnFocus) {
+        clearSelection();
+      }
+    },
+    clearTimer: function clearTimer() {
+      if (this.timer) {
+        clearTimeout(this.timer);
+      }
+    },
+    maxBoundry: function maxBoundry() {
+      return this.d_value >= this.max;
+    },
+    minBoundry: function minBoundry() {
+      return this.d_value <= this.min;
+    }
+  },
+  computed: {
+    upButtonListeners: function upButtonListeners() {
+      var _this2 = this;
+      return {
+        mousedown: function mousedown(event) {
+          return _this2.onUpButtonMouseDown(event);
+        },
+        mouseup: function mouseup(event) {
+          return _this2.onUpButtonMouseUp(event);
+        },
+        mouseleave: function mouseleave(event) {
+          return _this2.onUpButtonMouseLeave(event);
+        },
+        keydown: function keydown(event) {
+          return _this2.onUpButtonKeyDown(event);
+        },
+        keyup: function keyup(event) {
+          return _this2.onUpButtonKeyUp(event);
+        }
+      };
+    },
+    downButtonListeners: function downButtonListeners() {
+      var _this3 = this;
+      return {
+        mousedown: function mousedown(event) {
+          return _this3.onDownButtonMouseDown(event);
+        },
+        mouseup: function mouseup(event) {
+          return _this3.onDownButtonMouseUp(event);
+        },
+        mouseleave: function mouseleave(event) {
+          return _this3.onDownButtonMouseLeave(event);
+        },
+        keydown: function keydown(event) {
+          return _this3.onDownButtonKeyDown(event);
+        },
+        keyup: function keyup(event) {
+          return _this3.onDownButtonKeyUp(event);
+        }
+      };
+    },
+    formattedValue: function formattedValue() {
+      var val = !this.d_value && !this.allowEmpty ? 0 : this.d_value;
+      return this.formatValue(val);
+    },
+    getFormatter: function getFormatter() {
+      return this.numberFormat;
+    },
+    dataP: function dataP() {
+      return cn(_defineProperty(_defineProperty({
+        invalid: this.$invalid,
+        fluid: this.$fluid,
+        filled: this.$variant === "filled"
+      }, this.size, this.size), this.buttonLayout, this.showButtons && this.buttonLayout));
+    }
+  },
+  components: {
+    InputText: script$5,
+    AngleUpIcon: script$2,
+    AngleDownIcon: script$3
+  }
+};
+var _hoisted_1 = ["data-p"];
+var _hoisted_2 = ["data-p"];
+var _hoisted_3 = ["disabled", "data-p"];
+var _hoisted_4 = ["disabled", "data-p"];
+var _hoisted_5 = ["disabled", "data-p"];
+var _hoisted_6 = ["disabled", "data-p"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  var _component_InputText = resolveComponent("InputText");
+  return openBlock(), createElementBlock("span", mergeProps({
+    "class": _ctx.cx("root")
+  }, _ctx.ptmi("root"), {
+    "data-p": $options.dataP
+  }), [createVNode(_component_InputText, {
+    ref: "input",
+    id: _ctx.inputId,
+    name: _ctx.$formName,
+    role: "spinbutton",
+    "class": normalizeClass([_ctx.cx("pcInputText"), _ctx.inputClass]),
+    style: normalizeStyle(_ctx.inputStyle),
+    value: $options.formattedValue,
+    "aria-valuemin": _ctx.min,
+    "aria-valuemax": _ctx.max,
+    "aria-valuenow": _ctx.d_value,
+    inputmode: _ctx.mode === "decimal" && !_ctx.minFractionDigits ? "numeric" : "decimal",
+    disabled: _ctx.disabled,
+    readonly: _ctx.readonly,
+    placeholder: _ctx.placeholder,
+    "aria-labelledby": _ctx.ariaLabelledby,
+    "aria-label": _ctx.ariaLabel,
+    required: _ctx.required,
+    size: _ctx.size,
+    invalid: _ctx.invalid,
+    variant: _ctx.variant,
+    onInput: $options.onUserInput,
+    onKeydown: $options.onInputKeyDown,
+    onKeypress: $options.onInputKeyPress,
+    onPaste: $options.onPaste,
+    onClick: $options.onInputClick,
+    onFocus: $options.onInputFocus,
+    onBlur: $options.onInputBlur,
+    pt: _ctx.ptm("pcInputText"),
+    unstyled: _ctx.unstyled,
+    "data-p": $options.dataP
+  }, null, 8, ["id", "name", "class", "style", "value", "aria-valuemin", "aria-valuemax", "aria-valuenow", "inputmode", "disabled", "readonly", "placeholder", "aria-labelledby", "aria-label", "required", "size", "invalid", "variant", "onInput", "onKeydown", "onKeypress", "onPaste", "onClick", "onFocus", "onBlur", "pt", "unstyled", "data-p"]), _ctx.showButtons && _ctx.buttonLayout === "stacked" ? (openBlock(), createElementBlock("span", mergeProps({
+    key: 0,
+    "class": _ctx.cx("buttonGroup")
+  }, _ctx.ptm("buttonGroup"), {
+    "data-p": $options.dataP
+  }), [renderSlot(_ctx.$slots, "incrementbutton", {
+    listeners: $options.upButtonListeners
+  }, function() {
+    return [createBaseVNode("button", mergeProps({
+      "class": [_ctx.cx("incrementButton"), _ctx.incrementButtonClass]
+    }, toHandlers($options.upButtonListeners), {
+      disabled: _ctx.disabled,
+      tabindex: -1,
+      "aria-hidden": "true",
+      type: "button"
+    }, _ctx.ptm("incrementButton"), {
+      "data-p": $options.dataP
+    }), [renderSlot(_ctx.$slots, _ctx.$slots.incrementicon ? "incrementicon" : "incrementbuttonicon", {}, function() {
+      return [(openBlock(), createBlock(resolveDynamicComponent(_ctx.incrementIcon || _ctx.incrementButtonIcon ? "span" : "AngleUpIcon"), mergeProps({
+        "class": [_ctx.incrementIcon, _ctx.incrementButtonIcon]
+      }, _ctx.ptm("incrementIcon"), {
+        "data-pc-section": "incrementicon"
+      }), null, 16, ["class"]))];
+    })], 16, _hoisted_3)];
+  }), renderSlot(_ctx.$slots, "decrementbutton", {
+    listeners: $options.downButtonListeners
+  }, function() {
+    return [createBaseVNode("button", mergeProps({
+      "class": [_ctx.cx("decrementButton"), _ctx.decrementButtonClass]
+    }, toHandlers($options.downButtonListeners), {
+      disabled: _ctx.disabled,
+      tabindex: -1,
+      "aria-hidden": "true",
+      type: "button"
+    }, _ctx.ptm("decrementButton"), {
+      "data-p": $options.dataP
+    }), [renderSlot(_ctx.$slots, _ctx.$slots.decrementicon ? "decrementicon" : "decrementbuttonicon", {}, function() {
+      return [(openBlock(), createBlock(resolveDynamicComponent(_ctx.decrementIcon || _ctx.decrementButtonIcon ? "span" : "AngleDownIcon"), mergeProps({
+        "class": [_ctx.decrementIcon, _ctx.decrementButtonIcon]
+      }, _ctx.ptm("decrementIcon"), {
+        "data-pc-section": "decrementicon"
+      }), null, 16, ["class"]))];
+    })], 16, _hoisted_4)];
+  })], 16, _hoisted_2)) : createCommentVNode("", true), renderSlot(_ctx.$slots, "incrementbutton", {
+    listeners: $options.upButtonListeners
+  }, function() {
+    return [_ctx.showButtons && _ctx.buttonLayout !== "stacked" ? (openBlock(), createElementBlock("button", mergeProps({
+      key: 0,
+      "class": [_ctx.cx("incrementButton"), _ctx.incrementButtonClass]
+    }, toHandlers($options.upButtonListeners), {
+      disabled: _ctx.disabled,
+      tabindex: -1,
+      "aria-hidden": "true",
+      type: "button"
+    }, _ctx.ptm("incrementButton"), {
+      "data-p": $options.dataP
+    }), [renderSlot(_ctx.$slots, _ctx.$slots.incrementicon ? "incrementicon" : "incrementbuttonicon", {}, function() {
+      return [(openBlock(), createBlock(resolveDynamicComponent(_ctx.incrementIcon || _ctx.incrementButtonIcon ? "span" : "AngleUpIcon"), mergeProps({
+        "class": [_ctx.incrementIcon, _ctx.incrementButtonIcon]
+      }, _ctx.ptm("incrementIcon"), {
+        "data-pc-section": "incrementicon"
+      }), null, 16, ["class"]))];
+    })], 16, _hoisted_5)) : createCommentVNode("", true)];
+  }), renderSlot(_ctx.$slots, "decrementbutton", {
+    listeners: $options.downButtonListeners
+  }, function() {
+    return [_ctx.showButtons && _ctx.buttonLayout !== "stacked" ? (openBlock(), createElementBlock("button", mergeProps({
+      key: 0,
+      "class": [_ctx.cx("decrementButton"), _ctx.decrementButtonClass]
+    }, toHandlers($options.downButtonListeners), {
+      disabled: _ctx.disabled,
+      tabindex: -1,
+      "aria-hidden": "true",
+      type: "button"
+    }, _ctx.ptm("decrementButton"), {
+      "data-p": $options.dataP
+    }), [renderSlot(_ctx.$slots, _ctx.$slots.decrementicon ? "decrementicon" : "decrementbuttonicon", {}, function() {
+      return [(openBlock(), createBlock(resolveDynamicComponent(_ctx.decrementIcon || _ctx.decrementButtonIcon ? "span" : "AngleDownIcon"), mergeProps({
+        "class": [_ctx.decrementIcon, _ctx.decrementButtonIcon]
+      }, _ctx.ptm("decrementIcon"), {
+        "data-pc-section": "decrementicon"
+      }), null, 16, ["class"]))];
+    })], 16, _hoisted_6)) : createCommentVNode("", true)];
+  })], 16, _hoisted_1);
+}
+script.render = render;
+export {
+  script as s
+};