@wawjs/ngx-prime 22.0.0

package/fesm2022/wawjs-ngx-prime-inputnumber.mjs

@@ -0,0 +1,1770 @@
+import * as i2 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Injectable, inject, ElementRef, input, booleanAttribute, numberAttribute, output, Directive, InjectionToken, forwardRef, Injector, contentChild, contentChildren, viewChild, effect, ContentChild, ViewEncapsulation, ChangeDetectionStrategy, Component, NgModule } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NgControl } from '@angular/forms';
+import { getSelection } from '@wawjs/css-prime-utils';
+import { PrimeTemplate, SharedModule } from '@wawjs/ngx-prime/api';
+import { AutoFocus } from '@wawjs/ngx-prime/autofocus';
+import { PARENT_INSTANCE } from '@wawjs/ngx-prime/basecomponent';
+import { BaseInput } from '@wawjs/ngx-prime/baseinput';
+import * as i1 from '@wawjs/ngx-prime/bind';
+import { Bind, BindModule } from '@wawjs/ngx-prime/bind';
+import { TimesIcon, AngleUpIcon, AngleDownIcon } from '@wawjs/ngx-prime/icons';
+import { InputText } from '@wawjs/ngx-prime/inputtext';
+import { style as style$1 } from '@wawjs/css-prime-styles/inputnumber';
+import { BaseStyle } from '@wawjs/ngx-prime/base';
+export * from '@wawjs/ngx-prime/types/inputnumber';
+
+const style = /*css*/ `
+    ${style$1}
+
+    /* For ngx-prime */
+    p-inputNumber.ng-invalid.ng-dirty > .p-inputtext,
+    p-input-number.ng-invalid.ng-dirty > .p-inputtext,
+    p-inputnumber.ng-invalid.ng-dirty > .p-inputtext {
+        border-color: dt('inputtext.invalid.border.color');
+    }
+
+    p-inputNumber.ng-invalid.ng-dirty > .p-inputtext:enabled:focus,
+    p-input-number.ng-invalid.ng-dirty > .p-inputtext:enabled:focus,
+    p-inputnumber.ng-invalid.ng-dirty > .p-inputtext:enabled:focus {
+        border-color: dt('inputtext.focus.border.color');
+    }
+
+    p-inputNumber.ng-invalid.ng-dirty > .p-inputtext::placeholder,
+    p-input-number.ng-invalid.ng-dirty > .p-inputtext::placeholder,
+    p-inputnumber.ng-invalid.ng-dirty > .p-inputtext::placeholder {
+        color: dt('inputtext.invalid.placeholder.color');
+    }
+`;
+const classes = {
+    root: ({ instance }) => [
+        'p-inputnumber p-component p-inputwrapper',
+        {
+            'p-inputwrapper-filled': instance.$filled() || instance.allowEmpty() === false,
+            'p-inputwrapper-focus': instance.focused,
+            'p-inputnumber-stacked': instance.showButtons() && instance.buttonLayout() === 'stacked',
+            'p-inputnumber-horizontal': instance.showButtons() && instance.buttonLayout() === 'horizontal',
+            'p-inputnumber-vertical': instance.showButtons() && instance.buttonLayout() === 'vertical',
+            'p-inputnumber-fluid': instance.hasFluid,
+            'p-invalid': instance.invalid()
+        }
+    ],
+    pcInputText: 'p-inputnumber-input',
+    buttonGroup: 'p-inputnumber-button-group',
+    incrementButton: ({ instance }) => [
+        'p-inputnumber-button p-inputnumber-increment-button',
+        {
+            'p-disabled': instance.showButtons() && instance.max() != null && instance.maxlength()
+        }
+    ],
+    decrementButton: ({ instance }) => [
+        'p-inputnumber-button p-inputnumber-decrement-button',
+        {
+            'p-disabled': instance.showButtons() && instance.min() != null && instance.minlength()
+        }
+    ],
+    clearIcon: 'p-inputnumber-clear-icon'
+};
+class InputNumberStyle extends BaseStyle {
+    name = 'inputnumber';
+    style = style;
+    classes = classes;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberStyle, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberStyle });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberStyle, decorators: [{
+            type: Injectable
+        }] });
+/**
+ *
+ * InputNumber is an input component to provide numerical input.
+ *
+ * [Live Demo](https://www.ngx-prime.org/inputnumber/)
+ *
+ * @module inputnumberstyle
+ *
+ */
+var InputNumberClasses;
+(function (InputNumberClasses) {
+    /**
+     * Class name of the root element
+     */
+    InputNumberClasses["root"] = "p-inputnumber";
+    /**
+     * Class name of the input element
+     */
+    InputNumberClasses["pcInputText"] = "p-inputnumber-input";
+    /**
+     * Class name of the button group element
+     */
+    InputNumberClasses["buttonGroup"] = "p-inputnumber-button-group";
+    /**
+     * Class name of the increment button element
+     */
+    InputNumberClasses["incrementButton"] = "p-inputnumber-increment-button";
+    /**
+     * Class name of the decrement button element
+     */
+    InputNumberClasses["decrementButton"] = "p-inputnumber-decrement-button";
+    /**
+     * Class name of the clear icon
+     */
+    InputNumberClasses["clearIcon"] = "p-autocomplete-clear-icon";
+})(InputNumberClasses || (InputNumberClasses = {}));
+
+/** Adds Prime state attributes to a native number input. */
+class InputNumberDirective {
+    element = inject(ElementRef);
+    invalid = input(false, { ...(ngDevMode ? { debugName: "invalid" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    disabled = input(false, { ...(ngDevMode ? { debugName: "disabled" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    required = input(false, { ...(ngDevMode ? { debugName: "required" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    readonly = input(false, { ...(ngDevMode ? { debugName: "readonly" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    min = input(undefined, { ...(ngDevMode ? { debugName: "min" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    max = input(undefined, { ...(ngDevMode ? { debugName: "max" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    step = input(undefined, { ...(ngDevMode ? { debugName: "step" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    inputId = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "inputId" }] : /* istanbul ignore next */ []));
+    name = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "name" }] : /* istanbul ignore next */ []));
+    tabindex = input(undefined, { ...(ngDevMode ? { debugName: "tabindex" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    placeholder = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "placeholder" }] : /* istanbul ignore next */ []));
+    title = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "title" }] : /* istanbul ignore next */ []));
+    autofocus = input(false, { ...(ngDevMode ? { debugName: "autofocus" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    ariaLabel = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaLabel" }] : /* istanbul ignore next */ []));
+    ariaLabelledBy = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaLabelledBy" }] : /* istanbul ignore next */ []));
+    ariaDescribedBy = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaDescribedBy" }] : /* istanbul ignore next */ []));
+    /** Signal Forms marks a field as touched when this emits after blur. */
+    touch = output();
+    onInput = output();
+    onFocus = output();
+    onBlur = output();
+    onKeyDown = output();
+    $disabled() {
+        return this.disabled();
+    }
+    get valueAsNumber() {
+        const value = this.element.nativeElement.valueAsNumber;
+        return Number.isNaN(value) ? null : value;
+    }
+    onNativeInput(event) {
+        const input = event.target;
+        this.onInput.emit({ originalEvent: event, value: Number.isNaN(input.valueAsNumber) ? null : input.valueAsNumber, formattedValue: input.value });
+    }
+    onNativeBlur(event) {
+        this.touch.emit();
+        this.onBlur.emit(event);
+    }
+    increment(steps = 1) {
+        this.stepBy('stepUp', steps);
+    }
+    decrement(steps = 1) {
+        this.stepBy('stepDown', steps);
+    }
+    focus(options) {
+        this.element.nativeElement.focus(options);
+    }
+    stepBy(method, steps) {
+        if (this.$disabled() || this.readonly()) {
+            return;
+        }
+        if (method === 'stepUp') {
+            this.element.nativeElement.stepUp(steps);
+        }
+        else {
+            this.element.nativeElement.stepDown(steps);
+        }
+        this.element.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.2", type: InputNumberDirective, isStandalone: true, selector: "input[type='number'][pInputNumber]", inputs: { invalid: { classPropertyName: "invalid", publicName: "invalid", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, required: { classPropertyName: "required", publicName: "required", isSignal: true, isRequired: false, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null }, min: { classPropertyName: "min", publicName: "min", isSignal: true, isRequired: false, transformFunction: null }, max: { classPropertyName: "max", publicName: "max", isSignal: true, isRequired: false, transformFunction: null }, step: { classPropertyName: "step", publicName: "step", isSignal: true, isRequired: false, transformFunction: null }, inputId: { classPropertyName: "inputId", publicName: "inputId", isSignal: true, isRequired: false, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: false, transformFunction: null }, tabindex: { classPropertyName: "tabindex", publicName: "tabindex", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, autofocus: { classPropertyName: "autofocus", publicName: "autofocus", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "ariaLabel", isSignal: true, isRequired: false, transformFunction: null }, ariaLabelledBy: { classPropertyName: "ariaLabelledBy", publicName: "ariaLabelledBy", isSignal: true, isRequired: false, transformFunction: null }, ariaDescribedBy: { classPropertyName: "ariaDescribedBy", publicName: "ariaDescribedBy", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { touch: "touch", onInput: "onInput", onFocus: "onFocus", onBlur: "onBlur", onKeyDown: "onKeyDown" }, host: { listeners: { "input": "onNativeInput($event)", "focus": "onFocus.emit($event)", "blur": "onNativeBlur($event)", "keydown": "onKeyDown.emit($event)" }, properties: { "class.p-invalid": "invalid()", "attr.data-pc-name": "'inputnumber'", "attr.data-pc-section": "'input'", "attr.data-p-invalid": "invalid() || null", "attr.aria-label": "ariaLabel() || null", "attr.aria-labelledby": "ariaLabelledBy() || null", "attr.aria-describedby": "ariaDescribedBy() || null", "attr.aria-required": "required() || null", "attr.aria-valuemin": "min() ?? null", "attr.aria-valuemax": "max() ?? null", "attr.aria-valuenow": "valueAsNumber ?? null", "attr.id": "inputId() || null", "attr.name": "name() || null", "attr.tabindex": "tabindex() ?? null", "attr.placeholder": "placeholder() || null", "attr.title": "title() || null", "readOnly": "readonly()", "autofocus": "autofocus()", "disabled": "$disabled()", "required": "required()", "min": "min() ?? null", "max": "max() ?? null", "step": "step() ?? null" }, classAttribute: "p-inputnumber-input p-inputtext p-component" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "input[type='number'][pInputNumber]",
+                    standalone: true,
+                    host: {
+                        class: 'p-inputnumber-input p-inputtext p-component',
+                        '[class.p-invalid]': 'invalid()',
+                        '[attr.data-pc-name]': "'inputnumber'",
+                        '[attr.data-pc-section]': "'input'",
+                        '[attr.data-p-invalid]': 'invalid() || null',
+                        '[attr.aria-label]': 'ariaLabel() || null',
+                        '[attr.aria-labelledby]': 'ariaLabelledBy() || null',
+                        '[attr.aria-describedby]': 'ariaDescribedBy() || null',
+                        '[attr.aria-required]': 'required() || null',
+                        '[attr.aria-valuemin]': 'min() ?? null',
+                        '[attr.aria-valuemax]': 'max() ?? null',
+                        '[attr.aria-valuenow]': 'valueAsNumber ?? null',
+                        '[attr.id]': 'inputId() || null',
+                        '[attr.name]': 'name() || null',
+                        '[attr.tabindex]': 'tabindex() ?? null',
+                        '[attr.placeholder]': 'placeholder() || null',
+                        '[attr.title]': 'title() || null',
+                        '[readOnly]': 'readonly()',
+                        '[autofocus]': 'autofocus()',
+                        '[disabled]': '$disabled()',
+                        '[required]': 'required()',
+                        '[min]': 'min() ?? null',
+                        '[max]': 'max() ?? null',
+                        '[step]': 'step() ?? null',
+                        '(input)': 'onNativeInput($event)',
+                        '(focus)': 'onFocus.emit($event)',
+                        '(blur)': 'onNativeBlur($event)',
+                        '(keydown)': 'onKeyDown.emit($event)'
+                    }
+                }]
+        }], propDecorators: { invalid: [{ type: i0.Input, args: [{ isSignal: true, alias: "invalid", required: false }] }], disabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "disabled", required: false }] }], required: [{ type: i0.Input, args: [{ isSignal: true, alias: "required", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], min: [{ type: i0.Input, args: [{ isSignal: true, alias: "min", required: false }] }], max: [{ type: i0.Input, args: [{ isSignal: true, alias: "max", required: false }] }], step: [{ type: i0.Input, args: [{ isSignal: true, alias: "step", required: false }] }], inputId: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputId", required: false }] }], name: [{ type: i0.Input, args: [{ isSignal: true, alias: "name", required: false }] }], tabindex: [{ type: i0.Input, args: [{ isSignal: true, alias: "tabindex", required: false }] }], placeholder: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeholder", required: false }] }], title: [{ type: i0.Input, args: [{ isSignal: true, alias: "title", required: false }] }], autofocus: [{ type: i0.Input, args: [{ isSignal: true, alias: "autofocus", required: false }] }], ariaLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabel", required: false }] }], ariaLabelledBy: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabelledBy", required: false }] }], ariaDescribedBy: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaDescribedBy", required: false }] }], touch: [{ type: i0.Output, args: ["touch"] }], onInput: [{ type: i0.Output, args: ["onInput"] }], onFocus: [{ type: i0.Output, args: ["onFocus"] }], onBlur: [{ type: i0.Output, args: ["onBlur"] }], onKeyDown: [{ type: i0.Output, args: ["onKeyDown"] }] } });
+
+const INPUTNUMBER_INSTANCE = new InjectionToken('INPUTNUMBER_INSTANCE');
+const INPUTNUMBER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => InputNumber),
+    multi: true
+};
+/**
+ * InputNumber is an input component to provide numerical input.
+ *
+ * @deprecated Use a native `<input type="number" pInputNumber>` instead.
+ * Locale/currency formatting, prefixes/suffixes, and custom spinner/template
+ * UI are wrapper-only features. This component remains available for
+ * compatibility and is planned for removal in v23.
+ * @group Components
+ */
+class InputNumber extends BaseInput {
+    injector = inject(Injector);
+    componentName = 'InputNumber';
+    $pcInputNumber = inject(INPUTNUMBER_INSTANCE, { optional: true, skipSelf: true }) ?? undefined;
+    _componentStyle = inject(InputNumberStyle);
+    bindDirectiveInstance = inject(Bind, { self: true });
+    onAfterViewChecked() {
+        this.bindDirectiveInstance.setAttrs(this.ptms(['host', 'root']));
+    }
+    /**
+     * Displays spinner buttons.
+     * @group Props
+     */
+    showButtons = input(false, { ...(ngDevMode ? { debugName: "showButtons" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Whether to format the value.
+     * @group Props
+     */
+    format = input(true, { ...(ngDevMode ? { debugName: "format" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Layout of the buttons, valid values are "stacked" (default), "horizontal" and "vertical".
+     * @group Props
+     */
+    buttonLayout = input('stacked', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "buttonLayout" }] : /* istanbul ignore next */ []));
+    /**
+     * Identifier of the focus input to match a label defined for the component.
+     * @group Props
+     */
+    inputId = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "inputId" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the component.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "styleClass" }] : /* istanbul ignore next */ []));
+    /**
+     * Advisory information to display on input.
+     * @group Props
+     */
+    placeholder = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "placeholder" }] : /* istanbul ignore next */ []));
+    /**
+     * Specifies tab order of the element.
+     * @group Props
+     */
+    tabindex = input(undefined, { ...(ngDevMode ? { debugName: "tabindex" } : /* istanbul ignore next */ {}), transform: numberAttribute });
+    /**
+     * Title text of the input text.
+     * @group Props
+     */
+    title = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "title" }] : /* istanbul ignore next */ []));
+    /**
+     * Specifies one or more IDs in the DOM that labels the input field.
+     * @group Props
+     */
+    ariaLabelledBy = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaLabelledBy" }] : /* istanbul ignore next */ []));
+    /**
+     * Specifies one or more IDs in the DOM that describes the input field.
+     * @group Props
+     */
+    ariaDescribedBy = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaDescribedBy" }] : /* istanbul ignore next */ []));
+    /**
+     * Used to define a string that labels the input element.
+     * @group Props
+     */
+    ariaLabel = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "ariaLabel" }] : /* istanbul ignore next */ []));
+    /**
+     * Used to indicate that user input is required on an element before a form can be submitted.
+     * @group Props
+     */
+    ariaRequired = input(undefined, { ...(ngDevMode ? { debugName: "ariaRequired" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Used to define a string that autocomplete attribute the current element.
+     * @group Props
+     */
+    autocomplete = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "autocomplete" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the increment button.
+     * @group Props
+     */
+    incrementButtonClass = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "incrementButtonClass" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the decrement button.
+     * @group Props
+     */
+    decrementButtonClass = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "decrementButtonClass" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the increment button.
+     * @group Props
+     */
+    incrementButtonIcon = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "incrementButtonIcon" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the decrement button.
+     * @group Props
+     */
+    decrementButtonIcon = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "decrementButtonIcon" }] : /* istanbul ignore next */ []));
+    /**
+     * When present, it specifies that an input field is read-only.
+     * @group Props
+     */
+    readonly = input(undefined, { ...(ngDevMode ? { debugName: "readonly" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Determines whether the input field is empty.
+     * @group Props
+     */
+    allowEmpty = input(true, { ...(ngDevMode ? { debugName: "allowEmpty" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Locale to be used in formatting.
+     * @group Props
+     */
+    locale = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "locale" }] : /* istanbul ignore next */ []));
+    /**
+     * The locale matching algorithm to use. Possible values are "lookup" and "best fit"; the default is "best fit". See Locale Negotiation for details.
+     * @group Props
+     */
+    localeMatcher = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "localeMatcher" }] : /* istanbul ignore next */ []));
+    /**
+     * Defines the behavior of the component, valid values are "decimal" and "currency".
+     * @group Props
+     */
+    mode = input('decimal', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "mode" }] : /* istanbul ignore next */ []));
+    /**
+     * The currency to use in currency formatting. Possible values are the ISO 4217 currency codes, such as "USD" for the US dollar, "EUR" for the euro, or "CNY" for the Chinese RMB. There is no default value; if the style is "currency", the currency property must be provided.
+     * @group Props
+     */
+    currency = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "currency" }] : /* istanbul ignore next */ []));
+    /**
+     * How to display the currency in currency formatting. Possible values are "symbol" to use a localized currency symbol such as €, ü"code" to use the ISO currency code, "name" to use a localized currency name such as "dollar"; the default is "symbol".
+     * @group Props
+     */
+    currencyDisplay = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "currencyDisplay" }] : /* istanbul ignore next */ []));
+    /**
+     * Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators.
+     * @group Props
+     */
+    useGrouping = input(true, { ...(ngDevMode ? { debugName: "useGrouping" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * The minimum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number and percent formatting is 0; the default for currency formatting is the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information).
+     * @group Props
+     */
+    minFractionDigits = input(undefined, { ...(ngDevMode ? { debugName: "minFractionDigits" } : /* istanbul ignore next */ {}), transform: (value) => numberAttribute(value, undefined) });
+    /**
+     * The maximum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number formatting is the larger of minimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the ISO 4217 currency code list (2 if the list doesn't provide that information).
+     * @group Props
+     */
+    maxFractionDigits = input(undefined, { ...(ngDevMode ? { debugName: "maxFractionDigits" } : /* istanbul ignore next */ {}), transform: (value) => numberAttribute(value, undefined) });
+    /**
+     * Text to display before the value.
+     * @group Props
+     */
+    prefix = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "prefix" }] : /* istanbul ignore next */ []));
+    /**
+     * Text to display after the value.
+     * @group Props
+     */
+    suffix = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "suffix" }] : /* istanbul ignore next */ []));
+    /**
+     * Inline style of the input field.
+     * @group Props
+     */
+    inputStyle = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "inputStyle" }] : /* istanbul ignore next */ []));
+    /**
+     * Style class of the input field.
+     * @group Props
+     */
+    inputStyleClass = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "inputStyleClass" }] : /* istanbul ignore next */ []));
+    /**
+     * When enabled, a clear icon is displayed to clear the value.
+     * @group Props
+     */
+    showClear = input(false, { ...(ngDevMode ? { debugName: "showClear" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * When present, it specifies that the component should automatically get focus on load.
+     * @group Props
+     */
+    autofocus = input(undefined, { ...(ngDevMode ? { debugName: "autofocus" } : /* istanbul ignore next */ {}), transform: booleanAttribute });
+    /**
+     * Callback to invoke on input.
+     * @param {InputNumberInputEvent} event - Custom input event.
+     * @group Emits
+     */
+    onInput = output();
+    /**
+     * Callback to invoke when the component receives focus.
+     * @param {Event} event - Browser event.
+     * @group Emits
+     */
+    onFocus = output();
+    /**
+     * Callback to invoke when the component loses focus.
+     * @param {Event} event - Browser event.
+     * @group Emits
+     */
+    onBlur = output();
+    /**
+     * Callback to invoke on input key press.
+     * @param {KeyboardEvent} event - Keyboard event.
+     * @group Emits
+     */
+    onKeyDown = output();
+    /**
+     * Callback to invoke when clear token is clicked.
+     * @group Emits
+     */
+    onClear = output();
+    /**
+     * Custom clear icon template.
+     * @group Templates
+     */
+    clearIconTemplate;
+    /**
+     * Custom increment button icon template.
+     * @group Templates
+     */
+    incrementButtonIconTemplate = contentChild('incrementbuttonicon', { ...(ngDevMode ? { debugName: "incrementButtonIconTemplate" } : /* istanbul ignore next */ {}), descendants: false });
+    /**
+     * Custom decrement button icon template.
+     * @group Templates
+     */
+    decrementButtonIconTemplate = contentChild('decrementbuttonicon', { ...(ngDevMode ? { debugName: "decrementButtonIconTemplate" } : /* istanbul ignore next */ {}), descendants: false });
+    templates = contentChildren(PrimeTemplate, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "templates" }] : /* istanbul ignore next */ []));
+    input = viewChild.required('input', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "input" }] : /* istanbul ignore next */ []));
+    _clearIconTemplate;
+    _incrementButtonIconTemplate;
+    _decrementButtonIconTemplate;
+    value;
+    focused;
+    initialized;
+    groupChar = '';
+    prefixChar = '';
+    suffixChar = '';
+    isSpecialChar;
+    timer;
+    lastValue;
+    _numeral;
+    numberFormat;
+    _decimal;
+    _decimalChar = '';
+    _group;
+    _minusSign;
+    _currency;
+    _prefix;
+    _suffix;
+    _index;
+    ngControl = null;
+    constructor() {
+        super();
+        effect(() => {
+            this.locale();
+            this.localeMatcher();
+            this.mode();
+            this.currency();
+            this.currencyDisplay();
+            this.useGrouping();
+            this.minFractionDigits();
+            this.maxFractionDigits();
+            this.prefix();
+            this.suffix();
+            this.updateConstructParser();
+        });
+    }
+    onInit() {
+        this.ngControl = this.injector.get(NgControl, null, { optional: true });
+        this.constructParser();
+        this.initialized = true;
+    }
+    onAfterContentInit() {
+        this.templates().forEach((item) => {
+            switch (item.getType()) {
+                case 'clearicon':
+                    this._clearIconTemplate = item.template;
+                    break;
+                case 'incrementbuttonicon':
+                    this._incrementButtonIconTemplate = item.template;
+                    break;
+                case 'decrementbuttonicon':
+                    this._decrementButtonIconTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    getOptions() {
+        // Validate fraction digits according to Intl.NumberFormat specifications
+        // Handle potential NaN, Infinity, or invalid values
+        const validateFractionDigits = (value, min, max) => {
+            if (value == null || isNaN(value) || !isFinite(value)) {
+                return undefined;
+            }
+            return Math.max(min, Math.min(max, Math.floor(value)));
+        };
+        const minFractionDigits = validateFractionDigits(this.minFractionDigits(), 0, 20);
+        const maxFractionDigits = validateFractionDigits(this.maxFractionDigits(), 0, 100);
+        // Ensure minFractionDigits <= maxFractionDigits
+        const validatedMinFractionDigits = minFractionDigits != null && maxFractionDigits != null && minFractionDigits > maxFractionDigits ? maxFractionDigits : minFractionDigits;
+        return {
+            localeMatcher: this.localeMatcher(),
+            style: this.mode(),
+            currency: this.currency(),
+            currencyDisplay: this.currencyDisplay(),
+            useGrouping: this.useGrouping(),
+            minimumFractionDigits: validatedMinFractionDigits,
+            maximumFractionDigits: maxFractionDigits
+        };
+    }
+    constructParser() {
+        const options = this.getOptions();
+        // Remove any properties with undefined or invalid values to let Intl.NumberFormat use defaults
+        const cleanOptions = Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+        this.numberFormat = new Intl.NumberFormat(this.locale(), cleanOptions);
+        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._decimalChar = this.getDecimalChar();
+        this._suffix = this.getSuffixExpression();
+        this._prefix = this.getPrefixExpression();
+        this._index = (d) => index.get(d);
+    }
+    updateConstructParser() {
+        if (this.initialized) {
+            this.constructParser();
+        }
+    }
+    escapeRegExp(text) {
+        return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    }
+    getDecimalExpression() {
+        const decimalChar = this.getDecimalChar();
+        return new RegExp(`[${decimalChar}]`, 'g');
+    }
+    getDecimalChar() {
+        const formatter = new Intl.NumberFormat(this.locale(), { ...this.getOptions(), useGrouping: false });
+        return formatter
+            .format(1.1)
+            .replace(this._currency, '')
+            .trim()
+            .replace(this._numeral, '');
+    }
+    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() && value != this.prefix()) {
+                    formattedValue = this.prefix() + formattedValue;
+                }
+                if (this.suffix() && value != this.suffix()) {
+                    formattedValue = formattedValue + this.suffix();
+                }
+                return formattedValue;
+            }
+            return value.toString();
+        }
+        return '';
+    }
+    parseValue(text) {
+        const suffixRegex = this._suffix ? new RegExp(this._suffix, '') : /(?:)/;
+        const prefixRegex = this._prefix ? new RegExp(this._prefix, '') : /(?:)/;
+        const currencyRegex = this._currency ? new RegExp(this._currency, '') : /(?:)/;
+        let filteredText = text
+            .replace(suffixRegex, '')
+            .replace(prefixRegex, '')
+            .trim()
+            .replace(/\s/g, '')
+            .replace(currencyRegex, '')
+            .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) {
+        let step = (this.step() ?? 1) * dir;
+        let currentValue = this.parseValue(this.input()?.nativeElement.value) || 0;
+        let newValue = this.validateValue(currentValue + step);
+        const max = this.maxlength();
+        if (max && max < this.formatValue(newValue).length) {
+            return;
+        }
+        this.updateInput(newValue, null, 'spin', null);
+        this.updateModel(event, newValue);
+        this.handleOnInput(event, currentValue, newValue);
+    }
+    clear() {
+        this.value = null;
+        this.onModelChange(this.value);
+        this.onClear.emit();
+    }
+    onUpButtonMouseDown(event) {
+        if (event.button === 2) {
+            this.clearTimer();
+            return;
+        }
+        if (!this.$disabled()) {
+            this.input()?.nativeElement.focus();
+            this.repeat(event, null, 1);
+            event.preventDefault();
+        }
+    }
+    onUpButtonMouseUp() {
+        if (!this.$disabled()) {
+            this.clearTimer();
+        }
+    }
+    onUpButtonMouseLeave() {
+        if (!this.$disabled()) {
+            this.clearTimer();
+        }
+    }
+    onUpButtonKeyDown(event) {
+        if (event.keyCode === 32 || event.keyCode === 13) {
+            this.repeat(event, null, 1);
+        }
+    }
+    onUpButtonKeyUp() {
+        if (!this.$disabled()) {
+            this.clearTimer();
+        }
+    }
+    onDownButtonMouseDown(event) {
+        if (event.button === 2) {
+            this.clearTimer();
+            return;
+        }
+        if (!this.$disabled()) {
+            this.input()?.nativeElement.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(event) {
+        if (this.readonly()) {
+            return;
+        }
+        if (this.isSpecialChar) {
+            event.target.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();
+        }
+        const input = this.input();
+        switch (event.key) {
+            case 'ArrowUp':
+                this.spin(event, 1);
+                event.preventDefault();
+                break;
+            case 'ArrowDown':
+                this.spin(event, -1);
+                event.preventDefault();
+                break;
+            case 'ArrowLeft':
+                for (let index = selectionStart; index <= inputValue.length; index++) {
+                    const previousCharIndex = index === 0 ? 0 : index - 1;
+                    if (this.isNumeralChar(inputValue.charAt(previousCharIndex))) {
+                        this.input().nativeElement.setSelectionRange(index, index);
+                        break;
+                    }
+                }
+                break;
+            case 'ArrowRight':
+                for (let index = selectionEnd; index >= 0; index--) {
+                    if (this.isNumeralChar(inputValue.charAt(index))) {
+                        this.input().nativeElement.setSelectionRange(index, index);
+                        break;
+                    }
+                }
+                break;
+            case 'Tab':
+            case 'Enter':
+                newValueStr = this.validateValue(this.parseValue(this.input().nativeElement.value));
+                input.nativeElement.value = this.formatValue(newValueStr);
+                input.nativeElement.setAttribute('aria-valuenow', newValueStr);
+                this.updateModel(event, newValueStr);
+                break;
+            case 'Backspace': {
+                event.preventDefault();
+                if (selectionStart === selectionEnd) {
+                    if ((selectionStart == 1 && this.prefix()) || (selectionStart == inputValue.length && this.suffix())) {
+                        break;
+                    }
+                    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.input()?.nativeElement.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);
+                        }
+                    }
+                    else if (this.mode() === 'currency' && this._currency && deleteChar.search(this._currency) != -1) {
+                        newValueStr = inputValue.slice(1);
+                    }
+                    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) {
+                    if ((selectionStart == 0 && this.prefix()) || (selectionStart == inputValue.length - 1 && this.suffix())) {
+                        break;
+                    }
+                    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.input()?.nativeElement.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;
+            default:
+                break;
+        }
+        this.onKeyDown.emit(event);
+    }
+    onInputKeyPress(event) {
+        if (this.readonly()) {
+            return;
+        }
+        let code = event.which || event.keyCode;
+        let char = String.fromCharCode(code);
+        let isDecimalSign = this.isDecimalSign(char);
+        const isMinusSign = this.isMinusSign(char);
+        if (code != 13) {
+            event.preventDefault();
+        }
+        if (!isDecimalSign && event.code === 'NumpadDecimal') {
+            isDecimalSign = true;
+            char = this._decimalChar;
+            code = char.charCodeAt(0);
+        }
+        const { value, selectionStart, selectionEnd } = this.input().nativeElement;
+        const newValue = this.parseValue(value + char);
+        const newValueStr = newValue != null ? newValue.toString() : '';
+        const selectedValue = value.substring(selectionStart, selectionEnd);
+        const selectedValueParsed = this.parseValue(selectedValue);
+        const selectedValueStr = selectedValueParsed != null ? selectedValueParsed.toString() : '';
+        if (selectionStart !== selectionEnd && selectedValueStr.length > 0) {
+            this.insert(event, char, { isDecimalSign, isMinusSign });
+            return;
+        }
+        const max = this.maxlength();
+        if (max && newValueStr.length > max) {
+            return;
+        }
+        if ((48 <= code && code <= 57) || isMinusSign || isDecimalSign) {
+            this.insert(event, char, { isDecimalSign, isMinusSign });
+        }
+    }
+    onPaste(event) {
+        if (!this.$disabled() && !this.readonly()) {
+            event.preventDefault();
+            let data = (event.clipboardData || this.document.defaultView['clipboardData']).getData('Text');
+            if (this.inputId() === 'integeronly' && /[^\d-]/.test(data)) {
+                return;
+            }
+            if (data) {
+                if (this.maxlength()) {
+                    data = data.toString().substring(0, this.maxlength());
+                }
+                let filteredData = this.parseValue(data);
+                if (filteredData != null) {
+                    this.insert(event, filteredData.toString());
+                }
+            }
+        }
+    }
+    allowMinusSign() {
+        const min = this.min();
+        return min == null || 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 input = this.input();
+        let selectionStart = input?.nativeElement.selectionStart;
+        let selectionEnd = input?.nativeElement.selectionEnd;
+        let inputValue = input?.nativeElement.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);
+                }
+            }
+            else {
+                newValueStr = this.insertText(inputValue, text, selectionStart, selectionEnd);
+                this.updateValue(event, newValueStr, text, operation);
+            }
+        }
+    }
+    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;
+        }
+        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() {
+        const input = this.input();
+        let selectionStart = input?.nativeElement.selectionStart;
+        let selectionEnd = input?.nativeElement.selectionEnd;
+        let inputValue = input?.nativeElement.value;
+        let valueLength = inputValue.length;
+        let index = null;
+        // remove prefix
+        let prefixLength = (this.prefixChar || '').length;
+        inputValue = inputValue.replace(this._prefix, '');
+        // Will allow selecting whole prefix. But not a part of it.
+        // Negative values will trigger clauses after this to fix the cursor position.
+        if (selectionStart === selectionEnd || selectionStart !== 0 || selectionEnd < prefixLength) {
+            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) {
+            input?.nativeElement.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) {
+                input?.nativeElement.setSelectionRange(index, index);
+            }
+        }
+        return index || 0;
+    }
+    onInputClick() {
+        const currentValue = this.input()?.nativeElement.value;
+        if (!this.readonly() && currentValue !== 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.input()?.nativeElement.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.input().nativeElement.value = this.formatValue(newValue);
+            this.input()?.nativeElement.setAttribute('aria-valuenow', newValue);
+            this.updateModel(event, newValue);
+            this.onInput.emit({ 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;
+        }
+        return false;
+    }
+    validateValue(value) {
+        if (value === '-' || value == null) {
+            return null;
+        }
+        const min = this.min();
+        const max = this.max();
+        if (min != null && value < min) {
+            return this.min();
+        }
+        if (max != null && value > max) {
+            return max;
+        }
+        return value;
+    }
+    updateInput(value, insertedValueStr, operation, valueStr) {
+        insertedValueStr = insertedValueStr || '';
+        const input = this.input();
+        let inputValue = input?.nativeElement.value;
+        let newValue = this.formatValue(value);
+        let currentLength = inputValue.length;
+        if (newValue !== valueStr) {
+            newValue = this.concatValues(newValue, valueStr);
+        }
+        if (currentLength === 0) {
+            input.nativeElement.value = newValue;
+            input.nativeElement.setSelectionRange(0, 0);
+            const index = this.initCursor();
+            const selectionEnd = index + insertedValueStr.length;
+            input.nativeElement.setSelectionRange(selectionEnd, selectionEnd);
+        }
+        else {
+            let selectionStart = input.nativeElement.selectionStart;
+            let selectionEnd = input.nativeElement.selectionEnd;
+            const maxlength = this.maxlength();
+            if (maxlength && newValue.length > maxlength) {
+                newValue = newValue.slice(0, maxlength);
+                selectionStart = Math.min(selectionStart, maxlength);
+                selectionEnd = Math.min(selectionEnd, maxlength);
+            }
+            if (maxlength && maxlength < newValue.length) {
+                return;
+            }
+            input.nativeElement.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;
+                input.nativeElement.setSelectionRange(selectionEnd, selectionEnd);
+            }
+            else if (newLength === currentLength) {
+                if (operation === 'insert' || operation === 'delete-back-single')
+                    input.nativeElement.setSelectionRange(selectionEnd + 1, selectionEnd + 1);
+                else if (operation === 'delete-single')
+                    input.nativeElement.setSelectionRange(selectionEnd - 1, selectionEnd - 1);
+                else if (operation === 'delete-range' || operation === 'spin')
+                    input.nativeElement.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;
+                input.nativeElement.setSelectionRange(selectionEnd, selectionEnd);
+            }
+            else if (inputValue === '-' && operation === 'insert') {
+                input.nativeElement.setSelectionRange(0, 0);
+                const index = this.initCursor();
+                const selectionEnd = index + insertedValueStr.length + 1;
+                input.nativeElement.setSelectionRange(selectionEnd, selectionEnd);
+            }
+            else {
+                selectionEnd = selectionEnd + (newLength - currentLength);
+                input.nativeElement.setSelectionRange(selectionEnd, selectionEnd);
+            }
+        }
+        input.nativeElement.setAttribute('aria-valuenow', value);
+    }
+    concatValues(val1, val2) {
+        if (val1 && val2) {
+            let 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(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;
+            }
+        }
+        return 0;
+    }
+    onInputFocus(event) {
+        this.focused = true;
+        this.onFocus.emit(event);
+    }
+    onInputBlur(event) {
+        this.focused = false;
+        const newValueNumber = this.validateValue(this.parseValue(this.input().nativeElement.value));
+        const newValueString = newValueNumber?.toString();
+        this.input().nativeElement.value = this.formatValue(newValueString);
+        this.input().nativeElement.setAttribute('aria-valuenow', newValueString);
+        this.updateModel(event, newValueNumber);
+        this.onModelTouched();
+        this.onBlur.emit(event);
+    }
+    formattedValue() {
+        const val = !this.value && !this.allowEmpty() ? 0 : this.value;
+        return this.formatValue(val);
+    }
+    updateModel(event, value) {
+        const isBlurUpdateOnMode = this.ngControl?.control?.updateOn === 'blur';
+        if (this.value !== value) {
+            this.value = value;
+            if (!(isBlurUpdateOnMode && this.focused)) {
+                this.onModelChange(value);
+            }
+        }
+        else if (isBlurUpdateOnMode) {
+            this.onModelChange(value);
+        }
+    }
+    /**
+     * @override
+     *
+     * @see {@link BaseEditableHolder.writeControlValue}
+     * Writes the value to the control.
+     */
+    writeControlValue(value, setModelValue) {
+        this.value = value ? Number(value) : value;
+        setModelValue(value);
+        this.cd.markForCheck();
+    }
+    clearTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+    }
+    get dataP() {
+        return this.cn({
+            invalid: this.invalid(),
+            disabled: this.$disabled(),
+            focus: this.focused,
+            fluid: this.hasFluid,
+            filled: this.$variant() === 'filled',
+            empty: !this.$filled(),
+            [this.size()]: this.size(),
+            [this.buttonLayout()]: this.showButtons() && this.buttonLayout()
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumber, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.1.2", type: InputNumber, isStandalone: true, selector: "p-inputNumber, p-inputnumber, p-input-number", inputs: { showButtons: { classPropertyName: "showButtons", publicName: "showButtons", isSignal: true, isRequired: false, transformFunction: null }, format: { classPropertyName: "format", publicName: "format", isSignal: true, isRequired: false, transformFunction: null }, buttonLayout: { classPropertyName: "buttonLayout", publicName: "buttonLayout", isSignal: true, isRequired: false, transformFunction: null }, inputId: { classPropertyName: "inputId", publicName: "inputId", isSignal: true, isRequired: false, transformFunction: null }, styleClass: { classPropertyName: "styleClass", publicName: "styleClass", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, tabindex: { classPropertyName: "tabindex", publicName: "tabindex", isSignal: true, isRequired: false, transformFunction: null }, title: { classPropertyName: "title", publicName: "title", isSignal: true, isRequired: false, transformFunction: null }, ariaLabelledBy: { classPropertyName: "ariaLabelledBy", publicName: "ariaLabelledBy", isSignal: true, isRequired: false, transformFunction: null }, ariaDescribedBy: { classPropertyName: "ariaDescribedBy", publicName: "ariaDescribedBy", isSignal: true, isRequired: false, transformFunction: null }, ariaLabel: { classPropertyName: "ariaLabel", publicName: "ariaLabel", isSignal: true, isRequired: false, transformFunction: null }, ariaRequired: { classPropertyName: "ariaRequired", publicName: "ariaRequired", isSignal: true, isRequired: false, transformFunction: null }, autocomplete: { classPropertyName: "autocomplete", publicName: "autocomplete", isSignal: true, isRequired: false, transformFunction: null }, incrementButtonClass: { classPropertyName: "incrementButtonClass", publicName: "incrementButtonClass", isSignal: true, isRequired: false, transformFunction: null }, decrementButtonClass: { classPropertyName: "decrementButtonClass", publicName: "decrementButtonClass", isSignal: true, isRequired: false, transformFunction: null }, incrementButtonIcon: { classPropertyName: "incrementButtonIcon", publicName: "incrementButtonIcon", isSignal: true, isRequired: false, transformFunction: null }, decrementButtonIcon: { classPropertyName: "decrementButtonIcon", publicName: "decrementButtonIcon", isSignal: true, isRequired: false, transformFunction: null }, readonly: { classPropertyName: "readonly", publicName: "readonly", isSignal: true, isRequired: false, transformFunction: null }, allowEmpty: { classPropertyName: "allowEmpty", publicName: "allowEmpty", isSignal: true, isRequired: false, transformFunction: null }, locale: { classPropertyName: "locale", publicName: "locale", isSignal: true, isRequired: false, transformFunction: null }, localeMatcher: { classPropertyName: "localeMatcher", publicName: "localeMatcher", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null }, currency: { classPropertyName: "currency", publicName: "currency", isSignal: true, isRequired: false, transformFunction: null }, currencyDisplay: { classPropertyName: "currencyDisplay", publicName: "currencyDisplay", isSignal: true, isRequired: false, transformFunction: null }, useGrouping: { classPropertyName: "useGrouping", publicName: "useGrouping", isSignal: true, isRequired: false, transformFunction: null }, minFractionDigits: { classPropertyName: "minFractionDigits", publicName: "minFractionDigits", isSignal: true, isRequired: false, transformFunction: null }, maxFractionDigits: { classPropertyName: "maxFractionDigits", publicName: "maxFractionDigits", isSignal: true, isRequired: false, transformFunction: null }, prefix: { classPropertyName: "prefix", publicName: "prefix", isSignal: true, isRequired: false, transformFunction: null }, suffix: { classPropertyName: "suffix", publicName: "suffix", isSignal: true, isRequired: false, transformFunction: null }, inputStyle: { classPropertyName: "inputStyle", publicName: "inputStyle", isSignal: true, isRequired: false, transformFunction: null }, inputStyleClass: { classPropertyName: "inputStyleClass", publicName: "inputStyleClass", isSignal: true, isRequired: false, transformFunction: null }, showClear: { classPropertyName: "showClear", publicName: "showClear", isSignal: true, isRequired: false, transformFunction: null }, autofocus: { classPropertyName: "autofocus", publicName: "autofocus", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onInput: "onInput", onFocus: "onFocus", onBlur: "onBlur", onKeyDown: "onKeyDown", onClear: "onClear" }, host: { properties: { "class": "cn(cx('root'), styleClass())", "attr.data-p": "dataP" } }, providers: [INPUTNUMBER_VALUE_ACCESSOR, InputNumberStyle, { provide: INPUTNUMBER_INSTANCE, useExisting: InputNumber }, { provide: PARENT_INSTANCE, useExisting: InputNumber }], queries: [{ propertyName: "incrementButtonIconTemplate", first: true, predicate: ["incrementbuttonicon"], isSignal: true }, { propertyName: "decrementButtonIconTemplate", first: true, predicate: ["decrementbuttonicon"], isSignal: true }, { propertyName: "templates", predicate: PrimeTemplate, isSignal: true }, { propertyName: "clearIconTemplate", first: true, predicate: ["clearicon"] }], viewQueries: [{ propertyName: "input", first: true, predicate: ["input"], descendants: true, isSignal: true }], usesInheritance: true, hostDirectives: [{ directive: i1.Bind }], ngImport: i0, template: `
+        <input
+            pInputText
+            #input
+            [attr.id]="inputId()"
+            role="spinbutton"
+            [class]="cn(cx('pcInputText'), inputStyleClass())"
+            [value]="formattedValue()"
+            [ngStyle]="inputStyle()"
+            [variant]="$variant()"
+            [invalid]="invalid()"
+            [attr.aria-valuemin]="min()"
+            [attr.aria-valuemax]="max()"
+            [attr.aria-valuenow]="value"
+            [attr.placeholder]="placeholder()"
+            [attr.aria-label]="ariaLabel()"
+            [attr.aria-labelledby]="ariaLabelledBy()"
+            [attr.aria-describedby]="ariaDescribedBy()"
+            [attr.title]="title()"
+            [pSize]="size()"
+            [attr.size]="inputSize()"
+            [attr.name]="name()"
+            [attr.autocomplete]="autocomplete()"
+            [attr.maxlength]="maxlength()"
+            [attr.minlength]="minlength()"
+            [attr.tabindex]="tabindex()"
+            [attr.aria-required]="ariaRequired()"
+            [attr.min]="min()"
+            [attr.max]="max()"
+            [attr.step]="step() ?? 1"
+            [attr.required]="required() ? '' : undefined"
+            [attr.readonly]="readonly() ? '' : undefined"
+            [attr.disabled]="$disabled() ? '' : undefined"
+            inputmode="decimal"
+            (input)="onUserInput($event)"
+            (keydown)="onInputKeyDown($event)"
+            (keypress)="onInputKeyPress($event)"
+            (paste)="onPaste($event)"
+            (click)="onInputClick()"
+            (focus)="onInputFocus($event)"
+            (blur)="onInputBlur($event)"
+            [pt]="ptm('pcInputText')"
+            [unstyled]="unstyled()"
+            [pAutoFocus]="autofocus()"
+            [fluid]="hasFluid"
+            [attr.data-p]="dataP"
+        />
+        @if (buttonLayout() !== 'vertical' && showClear() && value) {
+            @if (!clearIconTemplate && !_clearIconTemplate) {
+                <svg data-p-icon="times" [pBind]="ptm('clearIcon')" [class]="cx('clearIcon')" (click)="clear()" />
+            }
+            @if (clearIconTemplate || _clearIconTemplate) {
+                <span [pBind]="ptm('clearIcon')" (click)="clear()" [class]="cx('clearIcon')">
+                    <ng-template *ngTemplateOutlet="clearIconTemplate || _clearIconTemplate"></ng-template>
+                </span>
+            }
+        }
+        @if (showButtons() && buttonLayout() === 'stacked') {
+            <span [pBind]="ptm('buttonGroup')" [class]="cx('buttonGroup')" [attr.data-p]="dataP">
+                <button
+                    type="button"
+                    [pBind]="ptm('incrementButton')"
+                    [class]="cn(cx('incrementButton'), incrementButtonClass())"
+                    [attr.disabled]="$disabled() ? '' : undefined"
+                    tabindex="-1"
+                    (mousedown)="onUpButtonMouseDown($event)"
+                    (mouseup)="onUpButtonMouseUp()"
+                    (mouseleave)="onUpButtonMouseLeave()"
+                    (keydown)="onUpButtonKeyDown($event)"
+                    (keyup)="onUpButtonKeyUp()"
+                    [attr.aria-hidden]="true"
+                    [attr.data-p]="dataP"
+                >
+                    @if (incrementButtonIcon()) {
+                        <span [pBind]="ptm('incrementButtonIcon')" [ngClass]="incrementButtonIcon()"></span>
+                    }
+                    @if (!incrementButtonIcon()) {
+                        @if (!incrementButtonIconTemplate() && !_incrementButtonIconTemplate) {
+                            <svg data-p-icon="angle-up" [pBind]="ptm('incrementButtonIcon')" />
+                        }
+                        <ng-template *ngTemplateOutlet="incrementButtonIconTemplate() || _incrementButtonIconTemplate"></ng-template>
+                    }
+                </button>
+                <button
+                    type="button"
+                    [pBind]="ptm('decrementButton')"
+                    [class]="cn(cx('decrementButton'), decrementButtonClass())"
+                    [attr.disabled]="$disabled() ? '' : undefined"
+                    tabindex="-1"
+                    [attr.aria-hidden]="true"
+                    (mousedown)="onDownButtonMouseDown($event)"
+                    (mouseup)="onDownButtonMouseUp()"
+                    (mouseleave)="onDownButtonMouseLeave()"
+                    (keydown)="onDownButtonKeyDown($event)"
+                    (keyup)="onDownButtonKeyUp()"
+                    [attr.data-p]="dataP"
+                >
+                    @if (decrementButtonIcon()) {
+                        <span [pBind]="ptm('decrementButtonIcon')" [ngClass]="decrementButtonIcon()"></span>
+                    }
+                    @if (!decrementButtonIcon()) {
+                        @if (!decrementButtonIconTemplate() && !_decrementButtonIconTemplate) {
+                            <svg data-p-icon="angle-down" [pBind]="ptm('decrementButtonIcon')" />
+                        }
+                        <ng-template *ngTemplateOutlet="decrementButtonIconTemplate() || _decrementButtonIconTemplate"></ng-template>
+                    }
+                </button>
+            </span>
+        }
+        @if (showButtons() && buttonLayout() !== 'stacked') {
+            <button
+                type="button"
+                [pBind]="ptm('incrementButton')"
+                [class]="cn(cx('incrementButton'), incrementButtonClass())"
+                [attr.disabled]="$disabled() ? '' : undefined"
+                tabindex="-1"
+                [attr.aria-hidden]="true"
+                (mousedown)="onUpButtonMouseDown($event)"
+                (mouseup)="onUpButtonMouseUp()"
+                (mouseleave)="onUpButtonMouseLeave()"
+                (keydown)="onUpButtonKeyDown($event)"
+                (keyup)="onUpButtonKeyUp()"
+                [attr.data-p]="dataP"
+            >
+                @if (incrementButtonIcon()) {
+                    <span [pBind]="ptm('incrementButtonIcon')" [ngClass]="incrementButtonIcon()"></span>
+                }
+                @if (!incrementButtonIcon()) {
+                    @if (!incrementButtonIconTemplate() && !_incrementButtonIconTemplate) {
+                        <svg data-p-icon="angle-up" [pBind]="ptm('incrementButtonIcon')" />
+                    }
+                    <ng-template *ngTemplateOutlet="incrementButtonIconTemplate() || _incrementButtonIconTemplate"></ng-template>
+                }
+            </button>
+        }
+        @if (showButtons() && buttonLayout() !== 'stacked') {
+            <button
+                type="button"
+                [pBind]="ptm('decrementButton')"
+                [class]="cn(cx('decrementButton'), decrementButtonClass())"
+                [attr.disabled]="$disabled() ? '' : undefined"
+                tabindex="-1"
+                [attr.aria-hidden]="true"
+                (mousedown)="onDownButtonMouseDown($event)"
+                (mouseup)="onDownButtonMouseUp()"
+                (mouseleave)="onDownButtonMouseLeave()"
+                (keydown)="onDownButtonKeyDown($event)"
+                (keyup)="onDownButtonKeyUp()"
+                [attr.data-p]="dataP"
+            >
+                @if (decrementButtonIcon()) {
+                    <span [pBind]="ptm('decrementButtonIcon')" [ngClass]="decrementButtonIcon()"></span>
+                }
+                @if (!decrementButtonIcon()) {
+                    @if (!decrementButtonIconTemplate() && !_decrementButtonIconTemplate) {
+                        <svg data-p-icon="angle-down" [pBind]="ptm('decrementButtonIcon')" />
+                    }
+                    <ng-template *ngTemplateOutlet="decrementButtonIconTemplate() || _decrementButtonIconTemplate"></ng-template>
+                }
+            </button>
+        }
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: InputText, selector: "[pInputText]", inputs: ["hostName", "ptInputText", "pInputTextPT", "pInputTextUnstyled", "pSize", "variant", "fluid", "invalid"] }, { kind: "directive", type: AutoFocus, selector: "[pAutoFocus]", inputs: ["pAutoFocus"] }, { kind: "component", type: TimesIcon, selector: "[data-p-icon=\"times\"]" }, { kind: "component", type: AngleUpIcon, selector: "[data-p-icon=\"angle-up\"]" }, { kind: "component", type: AngleDownIcon, selector: "[data-p-icon=\"angle-down\"]" }, { kind: "ngmodule", type: SharedModule }, { kind: "ngmodule", type: BindModule }, { kind: "directive", type: i1.Bind, selector: "[pBind]", inputs: ["pBind"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumber, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-inputNumber, p-inputnumber, p-input-number',
+                    standalone: true,
+                    imports: [CommonModule, InputText, AutoFocus, TimesIcon, AngleUpIcon, AngleDownIcon, SharedModule, BindModule],
+                    template: `
+        <input
+            pInputText
+            #input
+            [attr.id]="inputId()"
+            role="spinbutton"
+            [class]="cn(cx('pcInputText'), inputStyleClass())"
+            [value]="formattedValue()"
+            [ngStyle]="inputStyle()"
+            [variant]="$variant()"
+            [invalid]="invalid()"
+            [attr.aria-valuemin]="min()"
+            [attr.aria-valuemax]="max()"
+            [attr.aria-valuenow]="value"
+            [attr.placeholder]="placeholder()"
+            [attr.aria-label]="ariaLabel()"
+            [attr.aria-labelledby]="ariaLabelledBy()"
+            [attr.aria-describedby]="ariaDescribedBy()"
+            [attr.title]="title()"
+            [pSize]="size()"
+            [attr.size]="inputSize()"
+            [attr.name]="name()"
+            [attr.autocomplete]="autocomplete()"
+            [attr.maxlength]="maxlength()"
+            [attr.minlength]="minlength()"
+            [attr.tabindex]="tabindex()"
+            [attr.aria-required]="ariaRequired()"
+            [attr.min]="min()"
+            [attr.max]="max()"
+            [attr.step]="step() ?? 1"
+            [attr.required]="required() ? '' : undefined"
+            [attr.readonly]="readonly() ? '' : undefined"
+            [attr.disabled]="$disabled() ? '' : undefined"
+            inputmode="decimal"
+            (input)="onUserInput($event)"
+            (keydown)="onInputKeyDown($event)"
+            (keypress)="onInputKeyPress($event)"
+            (paste)="onPaste($event)"
+            (click)="onInputClick()"
+            (focus)="onInputFocus($event)"
+            (blur)="onInputBlur($event)"
+            [pt]="ptm('pcInputText')"
+            [unstyled]="unstyled()"
+            [pAutoFocus]="autofocus()"
+            [fluid]="hasFluid"
+            [attr.data-p]="dataP"
+        />
+        @if (buttonLayout() !== 'vertical' && showClear() && value) {
+            @if (!clearIconTemplate && !_clearIconTemplate) {
+                <svg data-p-icon="times" [pBind]="ptm('clearIcon')" [class]="cx('clearIcon')" (click)="clear()" />
+            }
+            @if (clearIconTemplate || _clearIconTemplate) {
+                <span [pBind]="ptm('clearIcon')" (click)="clear()" [class]="cx('clearIcon')">
+                    <ng-template *ngTemplateOutlet="clearIconTemplate || _clearIconTemplate"></ng-template>
+                </span>
+            }
+        }
+        @if (showButtons() && buttonLayout() === 'stacked') {
+            <span [pBind]="ptm('buttonGroup')" [class]="cx('buttonGroup')" [attr.data-p]="dataP">
+                <button
+                    type="button"
+                    [pBind]="ptm('incrementButton')"
+                    [class]="cn(cx('incrementButton'), incrementButtonClass())"
+                    [attr.disabled]="$disabled() ? '' : undefined"
+                    tabindex="-1"
+                    (mousedown)="onUpButtonMouseDown($event)"
+                    (mouseup)="onUpButtonMouseUp()"
+                    (mouseleave)="onUpButtonMouseLeave()"
+                    (keydown)="onUpButtonKeyDown($event)"
+                    (keyup)="onUpButtonKeyUp()"
+                    [attr.aria-hidden]="true"
+                    [attr.data-p]="dataP"
+                >
+                    @if (incrementButtonIcon()) {
+                        <span [pBind]="ptm('incrementButtonIcon')" [ngClass]="incrementButtonIcon()"></span>
+                    }
+                    @if (!incrementButtonIcon()) {
+                        @if (!incrementButtonIconTemplate() && !_incrementButtonIconTemplate) {
+                            <svg data-p-icon="angle-up" [pBind]="ptm('incrementButtonIcon')" />
+                        }
+                        <ng-template *ngTemplateOutlet="incrementButtonIconTemplate() || _incrementButtonIconTemplate"></ng-template>
+                    }
+                </button>
+                <button
+                    type="button"
+                    [pBind]="ptm('decrementButton')"
+                    [class]="cn(cx('decrementButton'), decrementButtonClass())"
+                    [attr.disabled]="$disabled() ? '' : undefined"
+                    tabindex="-1"
+                    [attr.aria-hidden]="true"
+                    (mousedown)="onDownButtonMouseDown($event)"
+                    (mouseup)="onDownButtonMouseUp()"
+                    (mouseleave)="onDownButtonMouseLeave()"
+                    (keydown)="onDownButtonKeyDown($event)"
+                    (keyup)="onDownButtonKeyUp()"
+                    [attr.data-p]="dataP"
+                >
+                    @if (decrementButtonIcon()) {
+                        <span [pBind]="ptm('decrementButtonIcon')" [ngClass]="decrementButtonIcon()"></span>
+                    }
+                    @if (!decrementButtonIcon()) {
+                        @if (!decrementButtonIconTemplate() && !_decrementButtonIconTemplate) {
+                            <svg data-p-icon="angle-down" [pBind]="ptm('decrementButtonIcon')" />
+                        }
+                        <ng-template *ngTemplateOutlet="decrementButtonIconTemplate() || _decrementButtonIconTemplate"></ng-template>
+                    }
+                </button>
+            </span>
+        }
+        @if (showButtons() && buttonLayout() !== 'stacked') {
+            <button
+                type="button"
+                [pBind]="ptm('incrementButton')"
+                [class]="cn(cx('incrementButton'), incrementButtonClass())"
+                [attr.disabled]="$disabled() ? '' : undefined"
+                tabindex="-1"
+                [attr.aria-hidden]="true"
+                (mousedown)="onUpButtonMouseDown($event)"
+                (mouseup)="onUpButtonMouseUp()"
+                (mouseleave)="onUpButtonMouseLeave()"
+                (keydown)="onUpButtonKeyDown($event)"
+                (keyup)="onUpButtonKeyUp()"
+                [attr.data-p]="dataP"
+            >
+                @if (incrementButtonIcon()) {
+                    <span [pBind]="ptm('incrementButtonIcon')" [ngClass]="incrementButtonIcon()"></span>
+                }
+                @if (!incrementButtonIcon()) {
+                    @if (!incrementButtonIconTemplate() && !_incrementButtonIconTemplate) {
+                        <svg data-p-icon="angle-up" [pBind]="ptm('incrementButtonIcon')" />
+                    }
+                    <ng-template *ngTemplateOutlet="incrementButtonIconTemplate() || _incrementButtonIconTemplate"></ng-template>
+                }
+            </button>
+        }
+        @if (showButtons() && buttonLayout() !== 'stacked') {
+            <button
+                type="button"
+                [pBind]="ptm('decrementButton')"
+                [class]="cn(cx('decrementButton'), decrementButtonClass())"
+                [attr.disabled]="$disabled() ? '' : undefined"
+                tabindex="-1"
+                [attr.aria-hidden]="true"
+                (mousedown)="onDownButtonMouseDown($event)"
+                (mouseup)="onDownButtonMouseUp()"
+                (mouseleave)="onDownButtonMouseLeave()"
+                (keydown)="onDownButtonKeyDown($event)"
+                (keyup)="onDownButtonKeyUp()"
+                [attr.data-p]="dataP"
+            >
+                @if (decrementButtonIcon()) {
+                    <span [pBind]="ptm('decrementButtonIcon')" [ngClass]="decrementButtonIcon()"></span>
+                }
+                @if (!decrementButtonIcon()) {
+                    @if (!decrementButtonIconTemplate() && !_decrementButtonIconTemplate) {
+                        <svg data-p-icon="angle-down" [pBind]="ptm('decrementButtonIcon')" />
+                    }
+                    <ng-template *ngTemplateOutlet="decrementButtonIconTemplate() || _decrementButtonIconTemplate"></ng-template>
+                }
+            </button>
+        }
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [INPUTNUMBER_VALUE_ACCESSOR, InputNumberStyle, { provide: INPUTNUMBER_INSTANCE, useExisting: InputNumber }, { provide: PARENT_INSTANCE, useExisting: InputNumber }],
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        '[class]': "cn(cx('root'), styleClass())",
+                        '[attr.data-p]': 'dataP'
+                    },
+                    hostDirectives: [Bind]
+                }]
+        }], ctorParameters: () => [], propDecorators: { showButtons: [{ type: i0.Input, args: [{ isSignal: true, alias: "showButtons", required: false }] }], format: [{ type: i0.Input, args: [{ isSignal: true, alias: "format", required: false }] }], buttonLayout: [{ type: i0.Input, args: [{ isSignal: true, alias: "buttonLayout", required: false }] }], inputId: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputId", required: false }] }], styleClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "styleClass", required: false }] }], placeholder: [{ type: i0.Input, args: [{ isSignal: true, alias: "placeholder", required: false }] }], tabindex: [{ type: i0.Input, args: [{ isSignal: true, alias: "tabindex", required: false }] }], title: [{ type: i0.Input, args: [{ isSignal: true, alias: "title", required: false }] }], ariaLabelledBy: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabelledBy", required: false }] }], ariaDescribedBy: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaDescribedBy", required: false }] }], ariaLabel: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaLabel", required: false }] }], ariaRequired: [{ type: i0.Input, args: [{ isSignal: true, alias: "ariaRequired", required: false }] }], autocomplete: [{ type: i0.Input, args: [{ isSignal: true, alias: "autocomplete", required: false }] }], incrementButtonClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "incrementButtonClass", required: false }] }], decrementButtonClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "decrementButtonClass", required: false }] }], incrementButtonIcon: [{ type: i0.Input, args: [{ isSignal: true, alias: "incrementButtonIcon", required: false }] }], decrementButtonIcon: [{ type: i0.Input, args: [{ isSignal: true, alias: "decrementButtonIcon", required: false }] }], readonly: [{ type: i0.Input, args: [{ isSignal: true, alias: "readonly", required: false }] }], allowEmpty: [{ type: i0.Input, args: [{ isSignal: true, alias: "allowEmpty", required: false }] }], locale: [{ type: i0.Input, args: [{ isSignal: true, alias: "locale", required: false }] }], localeMatcher: [{ type: i0.Input, args: [{ isSignal: true, alias: "localeMatcher", required: false }] }], mode: [{ type: i0.Input, args: [{ isSignal: true, alias: "mode", required: false }] }], currency: [{ type: i0.Input, args: [{ isSignal: true, alias: "currency", required: false }] }], currencyDisplay: [{ type: i0.Input, args: [{ isSignal: true, alias: "currencyDisplay", required: false }] }], useGrouping: [{ type: i0.Input, args: [{ isSignal: true, alias: "useGrouping", required: false }] }], minFractionDigits: [{ type: i0.Input, args: [{ isSignal: true, alias: "minFractionDigits", required: false }] }], maxFractionDigits: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxFractionDigits", required: false }] }], prefix: [{ type: i0.Input, args: [{ isSignal: true, alias: "prefix", required: false }] }], suffix: [{ type: i0.Input, args: [{ isSignal: true, alias: "suffix", required: false }] }], inputStyle: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputStyle", required: false }] }], inputStyleClass: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputStyleClass", required: false }] }], showClear: [{ type: i0.Input, args: [{ isSignal: true, alias: "showClear", required: false }] }], autofocus: [{ type: i0.Input, args: [{ isSignal: true, alias: "autofocus", required: false }] }], onInput: [{ type: i0.Output, args: ["onInput"] }], onFocus: [{ type: i0.Output, args: ["onFocus"] }], onBlur: [{ type: i0.Output, args: ["onBlur"] }], onKeyDown: [{ type: i0.Output, args: ["onKeyDown"] }], onClear: [{ type: i0.Output, args: ["onClear"] }], clearIconTemplate: [{
+                type: ContentChild,
+                args: ['clearicon', { descendants: false }]
+            }], incrementButtonIconTemplate: [{ type: i0.ContentChild, args: ['incrementbuttonicon', { ...{ descendants: false }, isSignal: true }] }], decrementButtonIconTemplate: [{ type: i0.ContentChild, args: ['decrementbuttonicon', { ...{ descendants: false }, isSignal: true }] }], templates: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => PrimeTemplate), { isSignal: true }] }], input: [{ type: i0.ViewChild, args: ['input', { isSignal: true }] }] } });
+class InputNumberModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.1.2", ngImport: i0, type: InputNumberModule, imports: [InputNumber, InputNumberDirective, SharedModule], exports: [InputNumber, InputNumberDirective, SharedModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberModule, imports: [InputNumber, SharedModule, SharedModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.2", ngImport: i0, type: InputNumberModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [InputNumber, InputNumberDirective, SharedModule],
+                    exports: [InputNumber, InputNumberDirective, SharedModule]
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { INPUTNUMBER_VALUE_ACCESSOR, InputNumber, InputNumberClasses, InputNumberDirective, InputNumberModule, InputNumberStyle };
+//# sourceMappingURL=wawjs-ngx-prime-inputnumber.mjs.map