@design-factory/design-factory 15.2.0

package/esm2022/lib/angular/slider/lib/slider.component.mjs

@@ -0,0 +1,2020 @@
+import { Component, ViewChild, HostBinding, HostListener, Input, EventEmitter, Output, ContentChild, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged, filter } from 'rxjs/operators';
+import { Options, LabelType } from './options';
+import { PointerType } from './pointer-type';
+import { ChangeContext } from './change-context';
+import { ValueHelper } from './value-helper';
+import { CompatibilityHelper } from './compatibility-helper';
+import { MathHelper } from './math-helper';
+import { EventListenerHelper, supportsPassiveEvents } from './event-listener-helper';
+import { SliderElementDirective } from './slider-element.directive';
+import { SliderHandleDirective } from './slider-handle.directive';
+import { SliderLabelDirective } from './slider-label.directive';
+import { CommonModule } from '@angular/common';
+import { TooltipWrapperComponent } from './tooltip-wrapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class Tick {
+    constructor() {
+        this.selected = false;
+        this.style = {};
+    }
+}
+class Dragging {
+    constructor() {
+        this.active = false;
+        this.value = 0;
+        this.difference = 0;
+        this.position = 0;
+        this.lowLimit = 0;
+        this.highLimit = 0;
+    }
+}
+class ModelValues {
+    static compare(x, y) {
+        if (ValueHelper.isNullOrUndefined(x) && ValueHelper.isNullOrUndefined(y)) {
+            return false;
+        }
+        if (ValueHelper.isNullOrUndefined(x) !== ValueHelper.isNullOrUndefined(y)) {
+            return false;
+        }
+        return x.value === y.value && x.highValue === y.highValue;
+    }
+}
+class ModelChange extends ModelValues {
+    static compare(x, y) {
+        if (ValueHelper.isNullOrUndefined(x) && ValueHelper.isNullOrUndefined(y)) {
+            return false;
+        }
+        if (ValueHelper.isNullOrUndefined(x) !== ValueHelper.isNullOrUndefined(y)) {
+            return false;
+        }
+        return x.value === y.value &&
+            x.highValue === y.highValue &&
+            x.forceChange === y.forceChange;
+    }
+}
+class InputModelChange extends ModelChange {
+}
+class OutputModelChange extends ModelChange {
+}
+const NGX_SLIDER_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    /* tslint:disable-next-line: no-use-before-declare */
+    useExisting: forwardRef(() => SliderComponent),
+    multi: true
+};
+export class SliderComponent {
+    // Input event that triggers slider refresh (re-positioning of slider elements)
+    set manualRefresh(manualRefresh) {
+        this.unsubscribeManualRefresh();
+        this.manualRefreshSubscription = manualRefresh.subscribe(() => {
+            setTimeout(() => this.calculateViewDimensionsAndDetectChanges());
+        });
+    }
+    // Input event that triggers setting focus on given slider handle
+    set triggerFocus(triggerFocus) {
+        this.unsubscribeTriggerFocus();
+        this.triggerFocusSubscription = triggerFocus.subscribe((pointerType) => {
+            this.focusPointer(pointerType);
+        });
+    }
+    // Slider type, true means range slider
+    get range() {
+        return !ValueHelper.isNullOrUndefined(this.value) && !ValueHelper.isNullOrUndefined(this.highValue);
+    }
+    // Whether to show/hide ticks
+    get showTicks() {
+        return this.viewOptions.showTicks || false;
+    }
+    constructor(renderer, elementRef, changeDetectionRef, zone) {
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.changeDetectionRef = changeDetectionRef;
+        this.zone = zone;
+        this.class = 'ngx-slider';
+        // Output for low value slider to support two-way bindings
+        this.valueChange = new EventEmitter();
+        // Output for high value slider to support two-way bindings
+        this.highValueChange = new EventEmitter();
+        // An object with all the other options of the slider.
+        // Each option can be updated at runtime and the slider will automatically be re-rendered.
+        this.options = new Options();
+        // Event emitted when user starts interaction with the slider
+        this.userChangeStart = new EventEmitter();
+        // Event emitted on each change coming from user interaction
+        this.userChange = new EventEmitter();
+        // Event emitted when user finishes interaction with the slider
+        this.userChangeEnd = new EventEmitter();
+        // Set to true if init method already executed
+        this.initHasRun = false;
+        // Changes in model inputs are passed through this subject
+        // These are all changes coming in from outside the component through input bindings or reactive form inputs
+        this.inputModelChangeSubject = new Subject();
+        // Changes to model outputs are passed through this subject
+        // These are all changes that need to be communicated to output emitters and registered callbacks
+        this.outputModelChangeSubject = new Subject();
+        // Options synced to model options, based on defaults
+        this.viewOptions = new Options();
+        // Half of the width or height of the slider handles
+        this.handleHalfDimension = 0;
+        // Maximum position the slider handle can have
+        this.maxHandlePosition = 0;
+        // Used to call onStart on the first keydown event
+        this.firstKeyDown = false;
+        // Values recorded when first dragging the bar
+        this.dragging = new Dragging();
+        // Host element class bindings
+        this.sliderElementVerticalClass = false;
+        this.sliderElementAnimateClass = false;
+        this.sliderElementWithLegendClass = false;
+        this.sliderElementAriaLabel = 'ngx-slider';
+        // CSS styles and class flags
+        this.barStyle = {};
+        this.minPointerStyle = {};
+        this.maxPointerStyle = {};
+        this.fullBarTransparentClass = false;
+        this.selectionBarDraggableClass = false;
+        this.ticksUnderValuesClass = false;
+        /* If tickStep is set or ticksArray is specified.
+           In this case, ticks values should be displayed below the slider. */
+        this.intermediateTicks = false;
+        // Ticks array as displayed in view
+        this.ticks = [];
+        // Whether currently moving the slider (between onStart() and onEnd())
+        this.moving = false;
+        this.eventListenerHelper = new EventListenerHelper(this.renderer);
+    }
+    // OnInit interface
+    ngOnInit() {
+        this.viewOptions = new Options();
+        Object.assign(this.viewOptions, this.options);
+        // We need to run these two things first, before the rest of the init in ngAfterViewInit(),
+        // because these two settings are set through @HostBinding and Angular change detection
+        // mechanism doesn't like them changing in ngAfterViewInit()
+        this.updateDisabledState();
+        this.updateVerticalState();
+        this.updateAriaLabel();
+    }
+    // AfterViewInit interface
+    ngAfterViewInit() {
+        this.applyOptions();
+        this.subscribeInputModelChangeSubject();
+        this.subscribeOutputModelChangeSubject();
+        // Once we apply options, we need to normalise model values for the first time
+        this.renormaliseModelValues();
+        this.viewLowValue = this.modelValueToViewValue(this.value);
+        if (this.range) {
+            this.viewHighValue = this.modelValueToViewValue(this.highValue);
+        }
+        else {
+            this.viewHighValue = undefined;
+        }
+        this.updateVerticalState(); // need to run this again to cover changes to slider elements
+        this.manageElementsStyle();
+        this.updateDisabledState();
+        this.calculateViewDimensions();
+        this.addAccessibility();
+        this.updateCeilLabel();
+        this.updateFloorLabel();
+        this.initHandles();
+        this.manageEventsBindings();
+        this.updateAriaLabel();
+        this.subscribeResizeObserver();
+        this.initHasRun = true;
+        // Run change detection manually to resolve some issues when init procedure changes values used in the view
+        if (!this.isRefDestroyed()) {
+            this.changeDetectionRef.detectChanges();
+        }
+    }
+    // OnChanges interface
+    ngOnChanges(changes) {
+        // Always apply options first
+        const options = changes['options'];
+        if (!ValueHelper.isNullOrUndefined(options) &&
+            JSON.stringify(options.previousValue) !== JSON.stringify(options.currentValue)) {
+            this.onChangeOptions();
+        }
+        // Then value changes
+        if (!ValueHelper.isNullOrUndefined(changes['value']) ||
+            !ValueHelper.isNullOrUndefined(changes['highValue'])) {
+            this.inputModelChangeSubject.next({
+                value: this.value,
+                highValue: this.highValue,
+                forceChange: false,
+                internalChange: false
+            });
+        }
+    }
+    // OnDestroy interface
+    ngOnDestroy() {
+        this.unbindEvents();
+        this.unsubscribeResizeObserver();
+        this.unsubscribeInputModelChangeSubject();
+        this.unsubscribeOutputModelChangeSubject();
+        this.unsubscribeManualRefresh();
+        this.unsubscribeTriggerFocus();
+    }
+    // ControlValueAccessor interface
+    writeValue(obj) {
+        if (obj instanceof Array) {
+            this.value = obj[0];
+            this.highValue = obj[1];
+        }
+        else {
+            this.value = obj;
+        }
+        // ngOnChanges() is not called in this instance, so we need to communicate the change manually
+        this.inputModelChangeSubject.next({
+            value: this.value,
+            highValue: this.highValue,
+            forceChange: false,
+            internalChange: false
+        });
+    }
+    // ControlValueAccessor interface
+    registerOnChange(onChangeCallback) {
+        this.onChangeCallback = onChangeCallback;
+    }
+    // ControlValueAccessor interface
+    registerOnTouched(onTouchedCallback) {
+        this.onTouchedCallback = onTouchedCallback;
+    }
+    // ControlValueAccessor interface
+    setDisabledState(isDisabled) {
+        this.viewOptions.disabled = isDisabled;
+        this.updateDisabledState();
+    }
+    setAriaLabel(ariaLabel) {
+        this.viewOptions.ariaLabel = ariaLabel;
+        this.updateAriaLabel();
+    }
+    onResize(event) {
+        this.calculateViewDimensionsAndDetectChanges();
+    }
+    subscribeInputModelChangeSubject() {
+        this.inputModelChangeSubscription = this.inputModelChangeSubject
+            .pipe(distinctUntilChanged(ModelChange.compare), 
+        // Hack to reset the status of the distinctUntilChanged() - if a "fake" event comes through with forceChange=true,
+        // we forcefully by-pass distinctUntilChanged(), but otherwise drop the event
+        filter((modelChange) => !modelChange.forceChange && !modelChange.internalChange))
+            .subscribe((modelChange) => this.applyInputModelChange(modelChange));
+    }
+    subscribeOutputModelChangeSubject() {
+        this.outputModelChangeSubscription = this.outputModelChangeSubject
+            .pipe(distinctUntilChanged(ModelChange.compare))
+            .subscribe((modelChange) => this.publishOutputModelChange(modelChange));
+    }
+    subscribeResizeObserver() {
+        if (CompatibilityHelper.isResizeObserverAvailable()) {
+            this.resizeObserver = new ResizeObserver(() => this.calculateViewDimensionsAndDetectChanges());
+            this.resizeObserver.observe(this.elementRef.nativeElement);
+        }
+    }
+    unsubscribeResizeObserver() {
+        if (CompatibilityHelper.isResizeObserverAvailable() && this.resizeObserver !== null) {
+            this.resizeObserver?.disconnect();
+            this.resizeObserver = undefined;
+        }
+    }
+    unsubscribeOnMove() {
+        if (!ValueHelper.isNullOrUndefined(this.onMoveEventListener)) {
+            this.eventListenerHelper?.detachEventListener(this.onMoveEventListener);
+            this.onMoveEventListener = undefined;
+        }
+    }
+    unsubscribeOnEnd() {
+        if (!ValueHelper.isNullOrUndefined(this.onEndEventListener)) {
+            this.eventListenerHelper?.detachEventListener(this.onEndEventListener);
+            this.onEndEventListener = undefined;
+        }
+    }
+    unsubscribeInputModelChangeSubject() {
+        if (!ValueHelper.isNullOrUndefined(this.inputModelChangeSubscription)) {
+            this.inputModelChangeSubscription?.unsubscribe();
+            this.inputModelChangeSubscription = undefined;
+        }
+    }
+    unsubscribeOutputModelChangeSubject() {
+        if (!ValueHelper.isNullOrUndefined(this.outputModelChangeSubscription)) {
+            this.outputModelChangeSubscription?.unsubscribe();
+            this.outputModelChangeSubscription = undefined;
+        }
+    }
+    unsubscribeManualRefresh() {
+        if (!ValueHelper.isNullOrUndefined(this.manualRefreshSubscription)) {
+            this.manualRefreshSubscription.unsubscribe();
+            this.manualRefreshSubscription = undefined;
+        }
+    }
+    unsubscribeTriggerFocus() {
+        if (!ValueHelper.isNullOrUndefined(this.triggerFocusSubscription)) {
+            this.triggerFocusSubscription.unsubscribe();
+            this.triggerFocusSubscription = null;
+        }
+    }
+    getPointerElement(pointerType) {
+        if (pointerType === PointerType.Min) {
+            return this.minHandleElement;
+        }
+        else if (pointerType === PointerType.Max) {
+            return this.maxHandleElement;
+        }
+        return undefined;
+    }
+    getCurrentTrackingValue() {
+        if (this.currentTrackingPointer === PointerType.Min) {
+            return this.viewLowValue;
+        }
+        else if (this.currentTrackingPointer === PointerType.Max) {
+            return this.viewHighValue;
+        }
+        return undefined;
+    }
+    modelValueToViewValue(modelValue) {
+        if (ValueHelper.isNullOrUndefined(modelValue)) {
+            return NaN;
+        }
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {
+            return ValueHelper.findStepIndex(+modelValue, this.viewOptions.stepsArray);
+        }
+        return +modelValue;
+    }
+    viewValueToModelValue(viewValue) {
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {
+            return this.getStepValue(viewValue);
+        }
+        return viewValue;
+    }
+    getStepValue(sliderValue) {
+        const step = this.viewOptions.stepsArray[sliderValue];
+        return (!ValueHelper.isNullOrUndefined(step)) ? step.value : NaN;
+    }
+    applyViewChange() {
+        this.value = this.viewValueToModelValue(this.viewLowValue);
+        if (this.range) {
+            this.highValue = this.viewValueToModelValue(this.viewHighValue);
+        }
+        this.outputModelChangeSubject.next({
+            value: this.value,
+            highValue: this.highValue,
+            userEventInitiated: true,
+            forceChange: false
+        });
+        // At this point all changes are applied and outputs are emitted, so we should be done.
+        // However, input changes are communicated in different stream and we need to be ready to
+        // act on the next input change even if it is exactly the same as last input change.
+        // Therefore, we send a special event to reset the stream.
+        this.inputModelChangeSubject.next({
+            value: this.value,
+            highValue: this.highValue,
+            forceChange: false,
+            internalChange: true
+        });
+    }
+    // Apply model change to the slider view
+    applyInputModelChange(modelChange) {
+        const normalisedModelChange = this.normaliseModelValues(modelChange);
+        // If normalised model change is different, apply the change to the model values
+        const normalisationChange = !ModelValues.compare(modelChange, normalisedModelChange);
+        if (normalisationChange) {
+            this.value = normalisedModelChange.value;
+            this.highValue = normalisedModelChange.highValue;
+        }
+        this.viewLowValue = this.modelValueToViewValue(normalisedModelChange.value);
+        if (this.range) {
+            this.viewHighValue = this.modelValueToViewValue(normalisedModelChange.highValue);
+        }
+        else {
+            this.viewHighValue = undefined;
+        }
+        this.updateLowHandle(this.valueToPosition(this.viewLowValue));
+        if (this.range) {
+            this.updateHighHandle(this.valueToPosition(this.viewHighValue));
+        }
+        this.updateSelectionBar();
+        this.updateTicksScale();
+        this.updateAriaAttributes();
+        if (this.range) {
+            this.updateCombinedLabel();
+        }
+        // At the end, we need to communicate the model change to the outputs as well
+        // Normalisation changes are also always forced out to ensure that subscribers always end up in correct state
+        this.outputModelChangeSubject.next({
+            value: normalisedModelChange.value,
+            highValue: normalisedModelChange.highValue,
+            forceChange: normalisationChange,
+            userEventInitiated: false
+        });
+    }
+    // Publish model change to output event emitters and registered callbacks
+    publishOutputModelChange(modelChange) {
+        const emitOutputs = () => {
+            this.valueChange.emit(modelChange.value);
+            if (this.range) {
+                this.highValueChange.emit(modelChange.highValue);
+            }
+            if (!ValueHelper.isNullOrUndefined(this.onChangeCallback)) {
+                if (this.range) {
+                    this.onChangeCallback([modelChange.value, modelChange.highValue]);
+                }
+                else {
+                    this.onChangeCallback(modelChange.value);
+                }
+            }
+            if (!ValueHelper.isNullOrUndefined(this.onTouchedCallback)) {
+                if (this.range) {
+                    this.onTouchedCallback([modelChange.value, modelChange.highValue]);
+                }
+                else {
+                    this.onTouchedCallback(modelChange.value);
+                }
+            }
+        };
+        if (modelChange.userEventInitiated) {
+            // If this change was initiated by a user event, we can emit outputs in the same tick
+            emitOutputs();
+            this.userChange.emit(this.getChangeContext());
+        }
+        else {
+            // But, if the change was initated by something else like a change in input bindings,
+            // we need to wait until next tick to emit the outputs to keep Angular change detection happy
+            setTimeout(() => { emitOutputs(); });
+        }
+    }
+    normaliseModelValues(input) {
+        const normalisedInput = new ModelValues();
+        normalisedInput.value = input.value;
+        normalisedInput.highValue = input.highValue;
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {
+            // When using steps array, only round to nearest step in the array
+            // No other enforcement can be done, as the step array may be out of order, and that is perfectly fine
+            if (this.viewOptions.enforceStepsArray) {
+                const valueIndex = ValueHelper.findStepIndex(normalisedInput.value, this.viewOptions.stepsArray);
+                normalisedInput.value = this.viewOptions.stepsArray[valueIndex].value;
+                if (this.range) {
+                    const highValueIndex = ValueHelper.findStepIndex(normalisedInput.highValue, this.viewOptions.stepsArray);
+                    normalisedInput.highValue = this.viewOptions.stepsArray[highValueIndex].value;
+                }
+            }
+            return normalisedInput;
+        }
+        if (this.viewOptions.enforceStep) {
+            normalisedInput.value = this.roundStep(normalisedInput.value);
+            if (this.range) {
+                normalisedInput.highValue = this.roundStep(normalisedInput.highValue);
+            }
+        }
+        if (this.viewOptions.enforceRange) {
+            normalisedInput.value = MathHelper.clampToRange(normalisedInput.value, this.viewOptions.floor, this.viewOptions.ceil);
+            if (this.range) {
+                normalisedInput.highValue = MathHelper.clampToRange(normalisedInput.highValue, this.viewOptions.floor, this.viewOptions.ceil);
+            }
+            // Make sure that range slider invariant (value <= highValue) is always satisfied
+            if (this.range && input.value > input.highValue) {
+                // We know that both values are now clamped correctly, they may just be in the wrong order
+                // So the easy solution is to swap them... except swapping is sometimes disabled in options, so we make the two values the same
+                if (this.viewOptions.noSwitching) {
+                    normalisedInput.value = normalisedInput.highValue;
+                }
+                else {
+                    const tempValue = input.value;
+                    normalisedInput.value = input.highValue;
+                    normalisedInput.highValue = tempValue;
+                }
+            }
+        }
+        return normalisedInput;
+    }
+    renormaliseModelValues() {
+        const previousModelValues = {
+            value: this.value,
+            highValue: this.highValue
+        };
+        const normalisedModelValues = this.normaliseModelValues(previousModelValues);
+        if (!ModelValues.compare(normalisedModelValues, previousModelValues)) {
+            this.value = normalisedModelValues.value;
+            this.highValue = normalisedModelValues.highValue;
+            this.outputModelChangeSubject.next({
+                value: this.value,
+                highValue: this.highValue,
+                forceChange: true,
+                userEventInitiated: false
+            });
+        }
+    }
+    onChangeOptions() {
+        if (!this.initHasRun) {
+            return;
+        }
+        const previousOptionsInfluencingEventBindings = this.getOptionsInfluencingEventBindings(this.viewOptions);
+        this.applyOptions();
+        const newOptionsInfluencingEventBindings = this.getOptionsInfluencingEventBindings(this.viewOptions);
+        // Avoid re-binding events in case nothing changes that can influence it
+        // It makes it possible to change options while dragging the slider
+        const rebindEvents = !ValueHelper.areArraysEqual(previousOptionsInfluencingEventBindings, newOptionsInfluencingEventBindings);
+        // With new options, we need to re-normalise model values if necessary
+        this.renormaliseModelValues();
+        this.viewLowValue = this.modelValueToViewValue(this.value);
+        if (this.range) {
+            this.viewHighValue = this.modelValueToViewValue(this.highValue);
+        }
+        else {
+            this.viewHighValue = undefined;
+        }
+        this.resetSlider(rebindEvents);
+    }
+    // Read the user options and apply them to the slider model
+    applyOptions() {
+        this.viewOptions = new Options();
+        Object.assign(this.viewOptions, this.options);
+        this.viewOptions.draggableRange = this.range && this.viewOptions.draggableRange;
+        this.viewOptions.draggableRangeOnly = this.range && this.viewOptions.draggableRangeOnly;
+        if (this.viewOptions.draggableRangeOnly) {
+            this.viewOptions.draggableRange = true;
+        }
+        this.viewOptions.showTicks = this.viewOptions.showTicks ||
+            this.viewOptions.showTicksValues ||
+            !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray);
+        if (this.viewOptions.showTicks &&
+            (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep) || !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray))) {
+            this.intermediateTicks = true;
+        }
+        this.viewOptions.showSelectionBar = this.viewOptions.showSelectionBar ||
+            this.viewOptions.showSelectionBarEnd ||
+            !ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue);
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {
+            this.applyStepsArrayOptions();
+        }
+        else {
+            this.applyFloorCeilOptions();
+        }
+        if (ValueHelper.isNullOrUndefined(this.viewOptions.combineLabels)) {
+            this.viewOptions.combineLabels = (minValue, maxValue) => {
+                return minValue + ' - ' + maxValue;
+            };
+        }
+        if (this.viewOptions.logScale && this.viewOptions.floor === 0) {
+            throw Error('Can\'t use floor=0 with logarithmic scale');
+        }
+    }
+    applyStepsArrayOptions() {
+        this.viewOptions.floor = 0;
+        this.viewOptions.ceil = this.viewOptions.stepsArray.length - 1;
+        this.viewOptions.step = 1;
+        if (ValueHelper.isNullOrUndefined(this.viewOptions.translate)) {
+            this.viewOptions.translate = (modelValue) => {
+                if (this.viewOptions.bindIndexForStepsArray) {
+                    return String(this.getStepValue(modelValue));
+                }
+                return String(modelValue);
+            };
+        }
+    }
+    applyFloorCeilOptions() {
+        if (ValueHelper.isNullOrUndefined(this.viewOptions.step)) {
+            this.viewOptions.step = 1;
+        }
+        else {
+            this.viewOptions.step = +this.viewOptions.step;
+            if (this.viewOptions.step <= 0) {
+                this.viewOptions.step = 1;
+            }
+        }
+        if (ValueHelper.isNullOrUndefined(this.viewOptions.ceil) ||
+            ValueHelper.isNullOrUndefined(this.viewOptions.floor)) {
+            throw Error('floor and ceil options must be supplied');
+        }
+        this.viewOptions.ceil = +this.viewOptions.ceil;
+        this.viewOptions.floor = +this.viewOptions.floor;
+        if (ValueHelper.isNullOrUndefined(this.viewOptions.translate)) {
+            this.viewOptions.translate = (value) => String(value);
+        }
+    }
+    // Resets slider
+    resetSlider(rebindEvents = true) {
+        this.manageElementsStyle();
+        this.addAccessibility();
+        this.updateCeilLabel();
+        this.updateFloorLabel();
+        if (rebindEvents) {
+            this.unbindEvents();
+            this.manageEventsBindings();
+        }
+        this.updateDisabledState();
+        this.updateAriaLabel();
+        this.calculateViewDimensions();
+        this.refocusPointerIfNeeded();
+    }
+    // Sets focus on the specified pointer
+    focusPointer(pointerType) {
+        // If not supplied, use min pointer as default
+        if (pointerType !== PointerType.Min && pointerType !== PointerType.Max) {
+            pointerType = PointerType.Min;
+        }
+        if (pointerType === PointerType.Min) {
+            this.minHandleElement?.focus();
+        }
+        else if (this.range && pointerType === PointerType.Max) {
+            this.maxHandleElement?.focus();
+        }
+    }
+    refocusPointerIfNeeded() {
+        if (!ValueHelper.isNullOrUndefined(this.currentFocusPointer)) {
+            this.onPointerFocus(this.currentFocusPointer);
+            const element = this.getPointerElement(this.currentFocusPointer);
+            element?.focus();
+        }
+    }
+    // Update each elements style based on options
+    manageElementsStyle() {
+        this.updateScale();
+        this.floorLabelElement?.setAlwaysHide(this.viewOptions.showTicksValues || this.viewOptions.hideLimitLabels);
+        this.ceilLabelElement?.setAlwaysHide(this.viewOptions.showTicksValues || this.viewOptions.hideLimitLabels);
+        const hideLabelsForTicks = this.viewOptions.showTicksValues && !this.intermediateTicks;
+        this.minHandleLabelElement?.setAlwaysHide(hideLabelsForTicks || this.viewOptions.hidePointerLabels);
+        this.maxHandleLabelElement?.setAlwaysHide(hideLabelsForTicks || !this.range || this.viewOptions.hidePointerLabels);
+        this.combinedLabelElement?.setAlwaysHide(hideLabelsForTicks || !this.range || this.viewOptions.hidePointerLabels);
+        this.selectionBarElement?.setAlwaysHide(!this.range && !this.viewOptions.showSelectionBar);
+        this.leftOuterSelectionBarElement?.setAlwaysHide(!this.range || !this.viewOptions.showOuterSelectionBars);
+        this.rightOuterSelectionBarElement?.setAlwaysHide(!this.range || !this.viewOptions.showOuterSelectionBars);
+        this.fullBarTransparentClass = this.range && this.viewOptions.showOuterSelectionBars;
+        this.selectionBarDraggableClass = this.viewOptions.draggableRange && !this.viewOptions.onlyBindHandles;
+        this.ticksUnderValuesClass = this.intermediateTicks && this.options.showTicksValues;
+        if (this.sliderElementVerticalClass !== this.viewOptions.vertical) {
+            this.updateVerticalState();
+            // The above change in host component class will not be applied until the end of this cycle
+            // However, functions calculating the slider position expect the slider to be already styled as vertical
+            // So as a workaround, we need to reset the slider once again to compute the correct values
+            setTimeout(() => { this.resetSlider(); });
+        }
+        // Changing animate class may interfere with slider reset/initialisation, so we should set it separately,
+        // after all is properly set up
+        if (this.sliderElementAnimateClass !== this.viewOptions.animate) {
+            setTimeout(() => { this.sliderElementAnimateClass = this.viewOptions.animate; });
+        }
+        this.updateRotate();
+    }
+    // Manage the events bindings based on readOnly and disabled options
+    manageEventsBindings() {
+        if (this.viewOptions.disabled || this.viewOptions.readOnly) {
+            this.unbindEvents();
+        }
+        else {
+            this.bindEvents();
+        }
+    }
+    // Set the disabled state based on disabled option
+    updateDisabledState() {
+        this.sliderElementDisabledAttr = this.viewOptions.disabled ? 'disabled' : undefined;
+    }
+    // Set the aria-label state based on ariaLabel option
+    updateAriaLabel() {
+        this.sliderElementAriaLabel = this.viewOptions.ariaLabel || 'nxg-slider';
+    }
+    // Set vertical state based on vertical option
+    updateVerticalState() {
+        this.sliderElementVerticalClass = this.viewOptions.vertical;
+        for (const element of this.getAllSliderElements()) {
+            // This is also called before ngAfterInit, so need to check that view child bindings work
+            if (!ValueHelper.isNullOrUndefined(element)) {
+                element.setVertical(this.viewOptions.vertical);
+            }
+        }
+    }
+    updateScale() {
+        for (const element of this.getAllSliderElements()) {
+            element.setScale(this.viewOptions.scale);
+        }
+    }
+    updateRotate() {
+        for (const element of this.getAllSliderElements()) {
+            element.setRotate(this.viewOptions.rotate);
+        }
+    }
+    getAllSliderElements() {
+        return [this.leftOuterSelectionBarElement,
+            this.rightOuterSelectionBarElement,
+            this.fullBarElement,
+            this.selectionBarElement,
+            this.minHandleElement,
+            this.maxHandleElement,
+            this.floorLabelElement,
+            this.ceilLabelElement,
+            this.minHandleLabelElement,
+            this.maxHandleLabelElement,
+            this.combinedLabelElement,
+            this.ticksElement
+        ];
+    }
+    // Initialize slider handles positions and labels
+    // Run only once during initialization and every time view port changes size
+    initHandles() {
+        this.updateLowHandle(this.valueToPosition(this.viewLowValue));
+        /*
+       the order here is important since the selection bar should be
+       updated after the high handle but before the combined label
+       */
+        if (this.range) {
+            this.updateHighHandle(this.valueToPosition(this.viewHighValue));
+        }
+        this.updateSelectionBar();
+        if (this.range) {
+            this.updateCombinedLabel();
+        }
+        this.updateTicksScale();
+    }
+    // Adds accessibility attributes, run only once during initialization
+    addAccessibility() {
+        this.updateAriaAttributes();
+        this.minHandleElement.role = 'slider';
+        if (this.viewOptions.keyboardSupport &&
+            !(this.viewOptions.readOnly || this.viewOptions.disabled)) {
+            this.minHandleElement.tabindex = '0';
+        }
+        else {
+            this.minHandleElement.tabindex = '';
+        }
+        this.minHandleElement.ariaOrientation = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? 'vertical' : 'horizontal';
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabel)) {
+            this.minHandleElement.ariaLabel = this.viewOptions.ariaLabel;
+        }
+        else if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelledBy)) {
+            this.minHandleElement.ariaLabelledBy = this.viewOptions.ariaLabelledBy;
+        }
+        if (this.range) {
+            this.maxHandleElement.role = 'slider';
+            if (this.viewOptions.keyboardSupport &&
+                !(this.viewOptions.readOnly || this.viewOptions.disabled)) {
+                this.maxHandleElement.tabindex = '0';
+            }
+            else {
+                this.maxHandleElement.tabindex = '';
+            }
+            this.maxHandleElement.ariaOrientation = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? 'vertical' : 'horizontal';
+            if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelHigh)) {
+                this.maxHandleElement.ariaLabel = this.viewOptions.ariaLabelHigh;
+            }
+            else if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelledByHigh)) {
+                this.maxHandleElement.ariaLabelledBy = this.viewOptions.ariaLabelledByHigh;
+            }
+        }
+    }
+    // Updates aria attributes according to current values
+    updateAriaAttributes() {
+        this.minHandleElement.ariaValueNow = (+this.value).toString();
+        this.minHandleElement.ariaValueText = this.viewOptions.translate(+this.value, LabelType.Low);
+        this.minHandleElement.ariaValueMin = this.viewOptions.floor.toString();
+        this.minHandleElement.ariaValueMax = this.viewOptions.ceil.toString();
+        if (this.range) {
+            this.maxHandleElement.ariaValueNow = (+this.highValue).toString();
+            this.maxHandleElement.ariaValueText = this.viewOptions.translate(+this.highValue, LabelType.High);
+            this.maxHandleElement.ariaValueMin = this.viewOptions.floor.toString();
+            this.maxHandleElement.ariaValueMax = this.viewOptions.ceil.toString();
+        }
+    }
+    // Calculate dimensions that are dependent on view port size
+    // Run once during initialization and every time view port changes size.
+    calculateViewDimensions() {
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.handleDimension)) {
+            this.minHandleElement.setDimension(this.viewOptions.handleDimension);
+        }
+        else {
+            this.minHandleElement.calculateDimension();
+        }
+        const handleWidth = this.minHandleElement.dimension;
+        this.handleHalfDimension = handleWidth / 2;
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.barDimension)) {
+            this.fullBarElement.setDimension(this.viewOptions.barDimension);
+        }
+        else {
+            this.fullBarElement.calculateDimension();
+        }
+        this.maxHandlePosition = this.fullBarElement.dimension - handleWidth;
+        if (this.initHasRun) {
+            this.updateFloorLabel();
+            this.updateCeilLabel();
+            this.initHandles();
+        }
+    }
+    calculateViewDimensionsAndDetectChanges() {
+        this.calculateViewDimensions();
+        if (!this.isRefDestroyed()) {
+            this.changeDetectionRef.detectChanges();
+        }
+    }
+    /**
+     * If the slider reference is already destroyed
+     * @returns boolean - true if ref is destroyed
+     */
+    isRefDestroyed() {
+        return this.changeDetectionRef['destroyed'];
+    }
+    // Update the ticks position
+    updateTicksScale() {
+        if (!this.viewOptions.showTicks) {
+            setTimeout(() => { this.sliderElementWithLegendClass = false; });
+            return;
+        }
+        const ticksArray = !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray)
+            ? this.viewOptions.ticksArray
+            : this.getTicksArray();
+        const translate = this.viewOptions.vertical ? 'translateY' : 'translateX';
+        if (this.viewOptions.rightToLeft) {
+            ticksArray.reverse();
+        }
+        const tickValueStep = !ValueHelper.isNullOrUndefined(this.viewOptions.tickValueStep) ? this.viewOptions.tickValueStep :
+            (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep) ? this.viewOptions.tickStep : this.viewOptions.step);
+        let hasAtLeastOneLegend = false;
+        const newTicks = ticksArray.map((value) => {
+            let position = this.valueToPosition(value);
+            if (this.viewOptions.vertical) {
+                position = this.maxHandlePosition - position;
+            }
+            const translation = translate + '(' + Math.round(position) + 'px)';
+            const tick = new Tick();
+            tick.selected = this.isTickSelected(value);
+            tick.style = {
+                '-webkit-transform': translation,
+                '-moz-transform': translation,
+                '-o-transform': translation,
+                '-ms-transform': translation,
+                transform: translation
+            };
+            if (tick.selected && !ValueHelper.isNullOrUndefined(this.viewOptions.getSelectionBarColor)) {
+                tick.style['background-color'] = this.getSelectionBarColor();
+            }
+            if (!tick.selected && !ValueHelper.isNullOrUndefined(this.viewOptions.getTickColor)) {
+                tick.style['background-color'] = this.getTickColor(value);
+            }
+            if (!ValueHelper.isNullOrUndefined(this.viewOptions.ticksTooltip)) {
+                tick.tooltip = this.viewOptions.ticksTooltip(value);
+                tick.tooltipPlacement = this.viewOptions.vertical ? 'right' : 'top';
+            }
+            if (this.viewOptions.showTicksValues && !ValueHelper.isNullOrUndefined(tickValueStep) &&
+                MathHelper.isModuloWithinPrecisionLimit(value, tickValueStep, this.viewOptions.precisionLimit)) {
+                tick.value = this.getDisplayValue(value, LabelType.TickValue);
+                if (!ValueHelper.isNullOrUndefined(this.viewOptions.ticksValuesTooltip)) {
+                    tick.valueTooltip = this.viewOptions.ticksValuesTooltip(value);
+                    tick.valueTooltipPlacement = this.viewOptions.vertical
+                        ? 'right'
+                        : 'top';
+                }
+            }
+            let legend;
+            if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {
+                const step = this.viewOptions.stepsArray[value];
+                if (!ValueHelper.isNullOrUndefined(this.viewOptions.getStepLegend)) {
+                    legend = this.viewOptions.getStepLegend(step);
+                }
+                else if (!ValueHelper.isNullOrUndefined(step)) {
+                    legend = step.legend;
+                }
+            }
+            else if (!ValueHelper.isNullOrUndefined(this.viewOptions.getLegend)) {
+                legend = this.viewOptions.getLegend(value);
+            }
+            if (!ValueHelper.isNullOrUndefined(legend)) {
+                tick.legend = legend;
+                hasAtLeastOneLegend = true;
+            }
+            return tick;
+        });
+        setTimeout(() => { this.sliderElementWithLegendClass = hasAtLeastOneLegend; });
+        // We should avoid re-creating the ticks array if possible
+        // This both improves performance and makes CSS animations work correctly
+        if (!ValueHelper.isNullOrUndefined(this.ticks) && this.ticks.length === newTicks.length) {
+            for (let i = 0; i < newTicks.length; ++i) {
+                Object.assign(this.ticks[i], newTicks[i]);
+            }
+        }
+        else {
+            this.ticks = newTicks;
+        }
+        if (!this.isRefDestroyed()) {
+            this.changeDetectionRef.detectChanges();
+        }
+    }
+    getTicksArray() {
+        const step = (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep)) ? this.viewOptions.tickStep : this.viewOptions.step;
+        const ticksArray = [];
+        const numberOfValues = 1 + Math.floor(MathHelper.roundToPrecisionLimit(Math.abs(this.viewOptions.ceil - this.viewOptions.floor) / step, this.viewOptions.precisionLimit));
+        for (let index = 0; index < numberOfValues; ++index) {
+            ticksArray.push(MathHelper.roundToPrecisionLimit(this.viewOptions.floor + step * index, this.viewOptions.precisionLimit));
+        }
+        return ticksArray;
+    }
+    isTickSelected(value) {
+        if (!this.range) {
+            if (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue)) {
+                const center = this.viewOptions.showSelectionBarFromValue;
+                if (this.viewLowValue > center &&
+                    value >= center &&
+                    value <= this.viewLowValue) {
+                    return true;
+                }
+                else if (this.viewLowValue < center &&
+                    value <= center &&
+                    value >= this.viewLowValue) {
+                    return true;
+                }
+            }
+            else if (this.viewOptions.showSelectionBarEnd) {
+                if (value >= this.viewLowValue) {
+                    return true;
+                }
+            }
+            else if (this.viewOptions.showSelectionBar && value <= this.viewLowValue) {
+                return true;
+            }
+        }
+        if (this.range && value >= this.viewLowValue && value <= this.viewHighValue) {
+            return true;
+        }
+        return false;
+    }
+    // Update position of the floor label
+    updateFloorLabel() {
+        if (!this.floorLabelElement.alwaysHide) {
+            this.floorLabelElement.setValue(this.getDisplayValue(this.viewOptions.floor, LabelType.Floor));
+            this.floorLabelElement.calculateDimension();
+            const position = this.viewOptions.rightToLeft
+                ? this.fullBarElement.dimension - this.floorLabelElement.dimension
+                : 0;
+            this.floorLabelElement.setPosition(position);
+        }
+    }
+    // Update position of the ceiling label
+    updateCeilLabel() {
+        if (!this.ceilLabelElement.alwaysHide) {
+            this.ceilLabelElement.setValue(this.getDisplayValue(this.viewOptions.ceil, LabelType.Ceil));
+            this.ceilLabelElement.calculateDimension();
+            const position = this.viewOptions.rightToLeft
+                ? 0
+                : this.fullBarElement.dimension - this.ceilLabelElement.dimension;
+            this.ceilLabelElement.setPosition(position);
+        }
+    }
+    // Update slider handles and label positions
+    updateHandles(which, newPos) {
+        if (which === PointerType.Min) {
+            this.updateLowHandle(newPos);
+        }
+        else if (which === PointerType.Max) {
+            this.updateHighHandle(newPos);
+        }
+        this.updateSelectionBar();
+        this.updateTicksScale();
+        if (this.range) {
+            this.updateCombinedLabel();
+        }
+    }
+    // Helper function to work out the position for handle labels depending on RTL or not
+    getHandleLabelPos(labelType, newPos) {
+        const labelDimension = (labelType === PointerType.Min)
+            ? this.minHandleLabelElement.dimension
+            : this.maxHandleLabelElement.dimension;
+        const nearHandlePos = newPos - labelDimension / 2 + this.handleHalfDimension;
+        const endOfBarPos = this.fullBarElement.dimension - labelDimension;
+        if (!this.viewOptions.boundPointerLabels) {
+            return nearHandlePos;
+        }
+        if ((this.viewOptions.rightToLeft && labelType === PointerType.Min) ||
+            (!this.viewOptions.rightToLeft && labelType === PointerType.Max)) {
+            return Math.min(nearHandlePos, endOfBarPos);
+        }
+        else {
+            return Math.min(Math.max(nearHandlePos, 0), endOfBarPos);
+        }
+    }
+    // Update low slider handle position and label
+    updateLowHandle(newPos) {
+        this.minHandleElement.setPosition(newPos);
+        this.minHandleLabelElement.setValue(this.getDisplayValue(this.viewLowValue, LabelType.Low));
+        this.minHandleLabelElement.setPosition(this.getHandleLabelPos(PointerType.Min, newPos));
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.getPointerColor)) {
+            this.minPointerStyle = {
+                backgroundColor: this.getPointerColor(PointerType.Min)
+            };
+        }
+        if (this.viewOptions.autoHideLimitLabels) {
+            this.updateFloorAndCeilLabelsVisibility();
+        }
+    }
+    // Update high slider handle position and label
+    updateHighHandle(newPos) {
+        this.maxHandleElement.setPosition(newPos);
+        this.maxHandleLabelElement.setValue(this.getDisplayValue(this.viewHighValue, LabelType.High));
+        this.maxHandleLabelElement.setPosition(this.getHandleLabelPos(PointerType.Max, newPos));
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.getPointerColor)) {
+            this.maxPointerStyle = {
+                backgroundColor: this.getPointerColor(PointerType.Max)
+            };
+        }
+        if (this.viewOptions.autoHideLimitLabels) {
+            this.updateFloorAndCeilLabelsVisibility();
+        }
+    }
+    // Show/hide floor/ceiling label
+    updateFloorAndCeilLabelsVisibility() {
+        // Show based only on hideLimitLabels if pointer labels are hidden
+        if (this.viewOptions.hidePointerLabels) {
+            return;
+        }
+        let floorLabelHidden = false;
+        let ceilLabelHidden = false;
+        const isMinLabelAtFloor = this.isLabelBelowFloorLabel(this.minHandleLabelElement);
+        const isMinLabelAtCeil = this.isLabelAboveCeilLabel(this.minHandleLabelElement);
+        const isMaxLabelAtCeil = this.isLabelAboveCeilLabel(this.maxHandleLabelElement);
+        const isCombinedLabelAtFloor = this.isLabelBelowFloorLabel(this.combinedLabelElement);
+        const isCombinedLabelAtCeil = this.isLabelAboveCeilLabel(this.combinedLabelElement);
+        if (isMinLabelAtFloor) {
+            floorLabelHidden = true;
+            this.floorLabelElement.hide();
+        }
+        else {
+            floorLabelHidden = false;
+            this.floorLabelElement.show();
+        }
+        if (isMinLabelAtCeil) {
+            ceilLabelHidden = true;
+            this.ceilLabelElement.hide();
+        }
+        else {
+            ceilLabelHidden = false;
+            this.ceilLabelElement.show();
+        }
+        if (this.range) {
+            const hideCeil = this.combinedLabelElement.isVisible() ? isCombinedLabelAtCeil : isMaxLabelAtCeil;
+            const hideFloor = this.combinedLabelElement.isVisible() ? isCombinedLabelAtFloor : isMinLabelAtFloor;
+            if (hideCeil) {
+                this.ceilLabelElement.hide();
+            }
+            else if (!ceilLabelHidden) {
+                this.ceilLabelElement.show();
+            }
+            // Hide or show floor label
+            if (hideFloor) {
+                this.floorLabelElement.hide();
+            }
+            else if (!floorLabelHidden) {
+                this.floorLabelElement.show();
+            }
+        }
+    }
+    isLabelBelowFloorLabel(label) {
+        const pos = label.position;
+        const dim = label.dimension;
+        const floorPos = this.floorLabelElement.position;
+        const floorDim = this.floorLabelElement.dimension;
+        return this.viewOptions.rightToLeft
+            ? pos + dim >= floorPos - 2
+            : pos <= floorPos + floorDim + 2;
+    }
+    isLabelAboveCeilLabel(label) {
+        const pos = label.position;
+        const dim = label.dimension;
+        const ceilPos = this.ceilLabelElement.position;
+        const ceilDim = this.ceilLabelElement.dimension;
+        return this.viewOptions.rightToLeft
+            ? pos <= ceilPos + ceilDim + 2
+            : pos + dim >= ceilPos - 2;
+    }
+    // Update slider selection bar, combined label and range label
+    updateSelectionBar() {
+        let position = 0;
+        let dimension = 0;
+        const isSelectionBarFromRight = this.viewOptions.rightToLeft
+            ? !this.viewOptions.showSelectionBarEnd
+            : this.viewOptions.showSelectionBarEnd;
+        const positionForRange = this.viewOptions.rightToLeft
+            ? this.maxHandleElement.position + this.handleHalfDimension
+            : this.minHandleElement.position + this.handleHalfDimension;
+        if (this.range) {
+            dimension = Math.abs(this.maxHandleElement.position - this.minHandleElement.position);
+            position = positionForRange;
+        }
+        else {
+            if (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue)) {
+                const center = this.viewOptions.showSelectionBarFromValue;
+                const centerPosition = this.valueToPosition(center);
+                const isModelGreaterThanCenter = this.viewOptions.rightToLeft
+                    ? this.viewLowValue <= center
+                    : this.viewLowValue > center;
+                if (isModelGreaterThanCenter) {
+                    dimension = this.minHandleElement.position - centerPosition;
+                    position = centerPosition + this.handleHalfDimension;
+                }
+                else {
+                    dimension = centerPosition - this.minHandleElement.position;
+                    position = this.minHandleElement.position + this.handleHalfDimension;
+                }
+            }
+            else if (isSelectionBarFromRight) {
+                dimension = Math.ceil(Math.abs(this.maxHandlePosition - this.minHandleElement.position) + this.handleHalfDimension);
+                position = Math.floor(this.minHandleElement.position + this.handleHalfDimension);
+            }
+            else {
+                dimension = this.minHandleElement.position + this.handleHalfDimension;
+                position = 0;
+            }
+        }
+        this.selectionBarElement.setDimension(dimension);
+        this.selectionBarElement.setPosition(position);
+        if (this.range && this.viewOptions.showOuterSelectionBars) {
+            if (this.viewOptions.rightToLeft) {
+                this.rightOuterSelectionBarElement.setDimension(position);
+                this.rightOuterSelectionBarElement.setPosition(0);
+                this.fullBarElement.calculateDimension();
+                this.leftOuterSelectionBarElement.setDimension(this.fullBarElement.dimension - (position + dimension));
+                this.leftOuterSelectionBarElement.setPosition(position + dimension);
+            }
+            else {
+                this.leftOuterSelectionBarElement.setDimension(position);
+                this.leftOuterSelectionBarElement.setPosition(0);
+                this.fullBarElement.calculateDimension();
+                this.rightOuterSelectionBarElement.setDimension(this.fullBarElement.dimension - (position + dimension));
+                this.rightOuterSelectionBarElement.setPosition(position + dimension);
+            }
+        }
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.getSelectionBarColor)) {
+            const color = this.getSelectionBarColor();
+            this.barStyle = {
+                backgroundColor: color
+            };
+        }
+        else if (!ValueHelper.isNullOrUndefined(this.viewOptions.selectionBarGradient)) {
+            const offset = (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue))
+                ? this.valueToPosition(this.viewOptions.showSelectionBarFromValue)
+                : 0;
+            const reversed = (offset - position > 0 && !isSelectionBarFromRight) || (offset - position <= 0 && isSelectionBarFromRight);
+            const direction = this.viewOptions.vertical
+                ? reversed ? 'bottom' : 'top'
+                : reversed ? 'left' : 'right';
+            this.barStyle = {
+                backgroundImage: 'linear-gradient(to ' +
+                    direction +
+                    ', ' +
+                    this.viewOptions.selectionBarGradient.from +
+                    ' 0%,' +
+                    this.viewOptions.selectionBarGradient.to +
+                    ' 100%)'
+            };
+            if (this.viewOptions.vertical) {
+                this.barStyle.backgroundPosition =
+                    'center ' +
+                        (offset +
+                            dimension +
+                            position +
+                            (reversed ? -this.handleHalfDimension : 0)) +
+                        'px';
+                this.barStyle.backgroundSize =
+                    '100% ' + (this.fullBarElement.dimension - this.handleHalfDimension) + 'px';
+            }
+            else {
+                this.barStyle.backgroundPosition =
+                    offset -
+                        position +
+                        (reversed ? this.handleHalfDimension : 0) +
+                        'px center';
+                this.barStyle.backgroundSize =
+                    this.fullBarElement.dimension - this.handleHalfDimension + 'px 100%';
+            }
+        }
+    }
+    // Wrapper around the getSelectionBarColor of the user to pass to correct parameters
+    getSelectionBarColor() {
+        if (this.range) {
+            return this.viewOptions.getSelectionBarColor(this.value, this.highValue);
+        }
+        return this.viewOptions.getSelectionBarColor(this.value);
+    }
+    // Wrapper around the getPointerColor of the user to pass to  correct parameters
+    getPointerColor(pointerType) {
+        if (pointerType === PointerType.Max) {
+            return this.viewOptions.getPointerColor(this.highValue, pointerType);
+        }
+        return this.viewOptions.getPointerColor(this.value, pointerType);
+    }
+    // Wrapper around the getTickColor of the user to pass to correct parameters
+    getTickColor(value) {
+        return this.viewOptions.getTickColor(value);
+    }
+    // Update combined label position and value
+    updateCombinedLabel() {
+        let isLabelOverlap = false;
+        if (this.viewOptions.rightToLeft) {
+            isLabelOverlap =
+                this.minHandleLabelElement.position - this.minHandleLabelElement.dimension - 10 <= this.maxHandleLabelElement.position;
+        }
+        else {
+            isLabelOverlap =
+                this.minHandleLabelElement.position + this.minHandleLabelElement.dimension + 10 >= this.maxHandleLabelElement.position;
+        }
+        if (isLabelOverlap) {
+            const lowDisplayValue = this.getDisplayValue(this.viewLowValue, LabelType.Low);
+            const highDisplayValue = this.getDisplayValue(this.viewHighValue, LabelType.High);
+            const combinedLabelValue = this.viewOptions.rightToLeft
+                ? this.viewOptions.combineLabels(highDisplayValue, lowDisplayValue)
+                : this.viewOptions.combineLabels(lowDisplayValue, highDisplayValue);
+            this.combinedLabelElement.setValue(combinedLabelValue);
+            const pos = this.viewOptions.boundPointerLabels
+                ? Math.min(Math.max(this.selectionBarElement.position +
+                    this.selectionBarElement.dimension / 2 -
+                    this.combinedLabelElement.dimension / 2, 0), this.fullBarElement.dimension - this.combinedLabelElement.dimension)
+                : this.selectionBarElement.position + this.selectionBarElement.dimension / 2 - this.combinedLabelElement.dimension / 2;
+            this.combinedLabelElement.setPosition(pos);
+            this.minHandleLabelElement.hide();
+            this.maxHandleLabelElement.hide();
+            this.combinedLabelElement.show();
+        }
+        else {
+            this.updateHighHandle(this.valueToPosition(this.viewHighValue));
+            this.updateLowHandle(this.valueToPosition(this.viewLowValue));
+            this.maxHandleLabelElement.show();
+            this.minHandleLabelElement.show();
+            this.combinedLabelElement.hide();
+        }
+        if (this.viewOptions.autoHideLimitLabels) {
+            this.updateFloorAndCeilLabelsVisibility();
+        }
+    }
+    // Return the translated value if a translate function is provided else the original value
+    getDisplayValue(value, which) {
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {
+            value = this.getStepValue(value);
+        }
+        return this.viewOptions.translate(value, which);
+    }
+    // Round value to step and precision based on minValue
+    roundStep(value, customStep) {
+        const step = !ValueHelper.isNullOrUndefined(customStep) ? customStep : this.viewOptions.step;
+        let steppedDifference = MathHelper.roundToPrecisionLimit((value - this.viewOptions.floor) / step, this.viewOptions.precisionLimit);
+        steppedDifference = Math.round(steppedDifference) * step;
+        return MathHelper.roundToPrecisionLimit(this.viewOptions.floor + steppedDifference, this.viewOptions.precisionLimit);
+    }
+    // Translate value to pixel position
+    valueToPosition(val) {
+        let fn = ValueHelper.linearValueToPosition;
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.customValueToPosition)) {
+            fn = this.viewOptions.customValueToPosition;
+        }
+        else if (this.viewOptions.logScale) {
+            fn = ValueHelper.logValueToPosition;
+        }
+        val = MathHelper.clampToRange(val, this.viewOptions.floor, this.viewOptions.ceil);
+        let percent = fn(val, this.viewOptions.floor, this.viewOptions.ceil);
+        if (ValueHelper.isNullOrUndefined(percent)) {
+            percent = 0;
+        }
+        if (this.viewOptions.rightToLeft) {
+            percent = 1 - percent;
+        }
+        return percent * this.maxHandlePosition;
+    }
+    // Translate position to model value
+    positionToValue(position) {
+        let percent = position / this.maxHandlePosition;
+        if (this.viewOptions.rightToLeft) {
+            percent = 1 - percent;
+        }
+        let fn = ValueHelper.linearPositionToValue;
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.customPositionToValue)) {
+            fn = this.viewOptions.customPositionToValue;
+        }
+        else if (this.viewOptions.logScale) {
+            fn = ValueHelper.logPositionToValue;
+        }
+        const value = fn(percent, this.viewOptions.floor, this.viewOptions.ceil);
+        return !ValueHelper.isNullOrUndefined(value) ? value : 0;
+    }
+    // Get the X-coordinate or Y-coordinate of an event
+    getEventXY(event, targetTouchId) {
+        if (event instanceof MouseEvent) {
+            return (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? event.clientY : event.clientX;
+        }
+        let touchIndex = 0;
+        const touches = event.touches;
+        if (!ValueHelper.isNullOrUndefined(targetTouchId)) {
+            for (let i = 0; i < touches.length; i++) {
+                if (touches[i].identifier === targetTouchId) {
+                    touchIndex = i;
+                    break;
+                }
+            }
+        }
+        // Return the target touch or if the target touch was not found in the event
+        // returns the coordinates of the first touch
+        return (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? touches[touchIndex].clientY : touches[touchIndex].clientX;
+    }
+    // Compute the event position depending on whether the slider is horizontal or vertical
+    getEventPosition(event, targetTouchId) {
+        const sliderElementBoundingRect = this.elementRef.nativeElement.getBoundingClientRect();
+        const sliderPos = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ?
+            sliderElementBoundingRect.bottom : sliderElementBoundingRect.left;
+        let eventPos = 0;
+        if (this.viewOptions.vertical || this.viewOptions.rotate !== 0) {
+            eventPos = -this.getEventXY(event, targetTouchId) + sliderPos;
+        }
+        else {
+            eventPos = this.getEventXY(event, targetTouchId) - sliderPos;
+        }
+        return eventPos * this.viewOptions.scale - this.handleHalfDimension;
+    }
+    // Get the handle closest to an event
+    getNearestHandle(event) {
+        if (!this.range) {
+            return PointerType.Min;
+        }
+        const position = this.getEventPosition(event);
+        const distanceMin = Math.abs(position - this.minHandleElement.position);
+        const distanceMax = Math.abs(position - this.maxHandleElement.position);
+        if (distanceMin < distanceMax) {
+            return PointerType.Min;
+        }
+        else if (distanceMin > distanceMax) {
+            return PointerType.Max;
+        }
+        else if (!this.viewOptions.rightToLeft) {
+            // if event is at the same distance from min/max then if it's at left of minH, we return minH else maxH
+            return position < this.minHandleElement.position ? PointerType.Min : PointerType.Max;
+        }
+        // reverse in rtl
+        return position > this.minHandleElement.position ? PointerType.Min : PointerType.Max;
+    }
+    // Bind mouse and touch events to slider handles
+    bindEvents() {
+        const draggableRange = this.viewOptions.draggableRange;
+        if (!this.viewOptions.onlyBindHandles) {
+            this.selectionBarElement.on('mousedown', (event) => this.onBarStart(draggableRange, event, true, true, undefined, true));
+        }
+        if (this.viewOptions.draggableRangeOnly) {
+            this.minHandleElement.on('mousedown', (event) => this.onBarStart(draggableRange, event, true, true, PointerType.Min));
+            this.maxHandleElement.on('mousedown', (event) => this.onBarStart(draggableRange, event, true, true, PointerType.Max));
+        }
+        else {
+            this.minHandleElement.on('mousedown', (event) => this.onStart(event, true, true, PointerType.Min));
+            if (this.range) {
+                this.maxHandleElement.on('mousedown', (event) => this.onStart(event, true, true, PointerType.Max));
+            }
+            if (!this.viewOptions.onlyBindHandles) {
+                this.fullBarElement.on('mousedown', (event) => this.onStart(event, true, true, undefined, true));
+                this.ticksElement.on('mousedown', (event) => this.onStart(event, true, true, undefined, true, true));
+            }
+        }
+        if (!this.viewOptions.onlyBindHandles) {
+            this.selectionBarElement.onPassive('touchstart', (event) => this.onBarStart(draggableRange, event, true, true, undefined, true));
+        }
+        if (this.viewOptions.draggableRangeOnly) {
+            this.minHandleElement.onPassive('touchstart', (event) => this.onBarStart(draggableRange, event, true, true, PointerType.Min));
+            this.maxHandleElement.onPassive('touchstart', (event) => this.onBarStart(draggableRange, event, true, true, PointerType.Max));
+        }
+        else {
+            this.minHandleElement.onPassive('touchstart', (event) => this.onStart(event, true, true, PointerType.Min));
+            if (this.range) {
+                this.maxHandleElement.onPassive('touchstart', (event) => this.onStart(event, true, true, PointerType.Max));
+            }
+            if (!this.viewOptions.onlyBindHandles) {
+                this.fullBarElement.onPassive('touchstart', (event) => this.onStart(event, true, true, undefined, true));
+                this.ticksElement.onPassive('touchstart', (event) => this.onStart(event, false, false, undefined, true, true));
+            }
+        }
+        if (this.viewOptions.keyboardSupport) {
+            this.minHandleElement.on('focus', () => this.onPointerFocus(PointerType.Min));
+            if (this.range) {
+                this.maxHandleElement.on('focus', () => this.onPointerFocus(PointerType.Max));
+            }
+        }
+    }
+    getOptionsInfluencingEventBindings(options) {
+        return [
+            options.disabled,
+            options.readOnly,
+            options.draggableRange,
+            options.draggableRangeOnly,
+            options.onlyBindHandles,
+            options.keyboardSupport
+        ];
+    }
+    // Unbind mouse and touch events to slider handles
+    unbindEvents() {
+        this.unsubscribeOnMove();
+        this.unsubscribeOnEnd();
+        for (const element of this.getAllSliderElements()) {
+            if (!ValueHelper.isNullOrUndefined(element)) {
+                element.off();
+            }
+        }
+    }
+    onBarStart(draggableRange, event, bindMove, bindEnd, pointerType, simulateImmediateMove, simulateImmediateEnd) {
+        if (draggableRange) {
+            this.onDragStart(event, bindMove, bindEnd, pointerType);
+        }
+        else {
+            this.onStart(event, bindMove, bindEnd, pointerType, simulateImmediateMove, simulateImmediateEnd);
+        }
+    }
+    // onStart event handler
+    onStart(event, bindMove, bindEnd, pointerType, simulateImmediateMove, simulateImmediateEnd) {
+        event.stopPropagation();
+        // Only call preventDefault() when handling non-passive events (passive events don't need it)
+        if (!CompatibilityHelper.isTouchEvent(event) && !supportsPassiveEvents) {
+            event.preventDefault();
+        }
+        this.moving = false;
+        // We have to do this in case the HTML where the sliders are on
+        // have been animated into view.
+        this.calculateViewDimensions();
+        if (ValueHelper.isNullOrUndefined(pointerType)) {
+            pointerType = this.getNearestHandle(event);
+        }
+        this.currentTrackingPointer = pointerType;
+        const pointerElement = this.getPointerElement(pointerType);
+        pointerElement.active = true;
+        if (this.viewOptions.keyboardSupport) {
+            pointerElement.focus();
+        }
+        if (bindMove) {
+            this.unsubscribeOnMove();
+            const onMoveCallback = (e) => this.dragging.active ? this.onDragMove(e) : this.onMove(e);
+            if (CompatibilityHelper.isTouchEvent(event)) {
+                this.onMoveEventListener = this.eventListenerHelper.attachPassiveEventListener(document, 'touchmove', onMoveCallback);
+            }
+            else {
+                this.onMoveEventListener = this.eventListenerHelper.attachEventListener(document, 'mousemove', onMoveCallback);
+            }
+        }
+        if (bindEnd) {
+            this.unsubscribeOnEnd();
+            const onEndCallback = (e) => this.onEnd(e);
+            if (CompatibilityHelper.isTouchEvent(event)) {
+                this.onEndEventListener = this.eventListenerHelper.attachPassiveEventListener(document, 'touchend', onEndCallback);
+            }
+            else {
+                this.onEndEventListener = this.eventListenerHelper.attachEventListener(document, 'mouseup', onEndCallback);
+            }
+        }
+        this.userChangeStart.emit(this.getChangeContext());
+        if (CompatibilityHelper.isTouchEvent(event) && !ValueHelper.isNullOrUndefined(event.changedTouches)) {
+            // Store the touch identifier
+            if (ValueHelper.isNullOrUndefined(this.touchId)) {
+                this.touchId = event.changedTouches[0].identifier;
+            }
+        }
+        // Click events, either with mouse or touch gesture are weird. Sometimes they result in full
+        // start, move, end sequence, and sometimes, they don't - they only invoke mousedown
+        // As a workaround, we simulate the first move event and the end event if it's necessary
+        if (simulateImmediateMove) {
+            this.onMove(event, true);
+        }
+        if (simulateImmediateEnd) {
+            this.onEnd(event);
+        }
+    }
+    // onMove event handler
+    onMove(event, fromTick) {
+        let touchForThisSlider;
+        if (CompatibilityHelper.isTouchEvent(event)) {
+            const changedTouches = event.changedTouches;
+            for (let i = 0; i < changedTouches.length; i++) {
+                if (changedTouches[i].identifier === this.touchId) {
+                    touchForThisSlider = changedTouches[i];
+                    break;
+                }
+            }
+            if (ValueHelper.isNullOrUndefined(touchForThisSlider)) {
+                return;
+            }
+        }
+        if (this.viewOptions.animate && !this.viewOptions.animateOnMove) {
+            if (this.moving) {
+                this.sliderElementAnimateClass = false;
+            }
+        }
+        this.moving = true;
+        const newPos = !ValueHelper.isNullOrUndefined(touchForThisSlider)
+            ? this.getEventPosition(event, touchForThisSlider.identifier)
+            : this.getEventPosition(event);
+        let newValue;
+        const ceilValue = this.viewOptions.rightToLeft
+            ? this.viewOptions.floor
+            : this.viewOptions.ceil;
+        const floorValue = this.viewOptions.rightToLeft ? this.viewOptions.ceil : this.viewOptions.floor;
+        if (newPos <= 0) {
+            newValue = floorValue;
+        }
+        else if (newPos >= this.maxHandlePosition) {
+            newValue = ceilValue;
+        }
+        else {
+            newValue = this.positionToValue(newPos);
+            if (fromTick && !ValueHelper.isNullOrUndefined(this.viewOptions.tickStep)) {
+                newValue = this.roundStep(newValue, this.viewOptions.tickStep);
+            }
+            else {
+                newValue = this.roundStep(newValue);
+            }
+        }
+        this.positionTrackingHandle(newValue);
+    }
+    onEnd(event) {
+        if (CompatibilityHelper.isTouchEvent(event)) {
+            const changedTouches = event.changedTouches;
+            if (changedTouches[0].identifier !== this.touchId) {
+                return;
+            }
+        }
+        this.moving = false;
+        if (this.viewOptions.animate) {
+            this.sliderElementAnimateClass = true;
+        }
+        this.touchId = undefined;
+        if (!this.viewOptions.keyboardSupport) {
+            this.minHandleElement.active = false;
+            this.maxHandleElement.active = false;
+            this.currentTrackingPointer = undefined;
+        }
+        this.dragging.active = false;
+        this.unsubscribeOnMove();
+        this.unsubscribeOnEnd();
+        this.userChangeEnd.emit(this.getChangeContext());
+    }
+    onPointerFocus(pointerType) {
+        const pointerElement = this.getPointerElement(pointerType);
+        pointerElement.on('blur', () => this.onPointerBlur(pointerElement));
+        pointerElement.on('keydown', (event) => this.onKeyboardEvent(event));
+        pointerElement.on('keyup', () => this.onKeyUp());
+        pointerElement.active = true;
+        this.currentTrackingPointer = pointerType;
+        this.currentFocusPointer = pointerType;
+        this.firstKeyDown = true;
+    }
+    onKeyUp() {
+        this.firstKeyDown = true;
+        this.userChangeEnd.emit(this.getChangeContext());
+    }
+    onPointerBlur(pointer) {
+        pointer.off('blur');
+        pointer.off('keydown');
+        pointer.off('keyup');
+        pointer.active = false;
+        if (ValueHelper.isNullOrUndefined(this.touchId)) {
+            this.currentTrackingPointer = undefined;
+            this.currentFocusPointer = undefined;
+        }
+    }
+    getKeyActions(currentValue) {
+        const valueRange = this.viewOptions.ceil - this.viewOptions.floor;
+        let increaseStep = currentValue + this.viewOptions.step;
+        let decreaseStep = currentValue - this.viewOptions.step;
+        let increasePage = currentValue + valueRange / 10;
+        let decreasePage = currentValue - valueRange / 10;
+        if (this.viewOptions.reversedControls) {
+            increaseStep = currentValue - this.viewOptions.step;
+            decreaseStep = currentValue + this.viewOptions.step;
+            increasePage = currentValue - valueRange / 10;
+            decreasePage = currentValue + valueRange / 10;
+        }
+        // Left to right default actions
+        const actions = {
+            UP: increaseStep,
+            DOWN: decreaseStep,
+            LEFT: decreaseStep,
+            RIGHT: increaseStep,
+            PAGEUP: increasePage,
+            PAGEDOWN: decreasePage,
+            HOME: this.viewOptions.reversedControls ? this.viewOptions.ceil : this.viewOptions.floor,
+            END: this.viewOptions.reversedControls ? this.viewOptions.floor : this.viewOptions.ceil
+        };
+        // right to left means swapping right and left arrows
+        if (this.viewOptions.rightToLeft) {
+            actions['LEFT'] = increaseStep;
+            actions['RIGHT'] = decreaseStep;
+            // right to left and vertical means we also swap up and down
+            if (this.viewOptions.vertical || this.viewOptions.rotate !== 0) {
+                actions['UP'] = decreaseStep;
+                actions['DOWN'] = increaseStep;
+            }
+        }
+        return actions;
+    }
+    onKeyboardEvent(event) {
+        const currentValue = this.getCurrentTrackingValue();
+        const keyCode = !ValueHelper.isNullOrUndefined(event.keyCode)
+            ? event.keyCode
+            : event.which;
+        const keys = {
+            38: 'UP',
+            40: 'DOWN',
+            37: 'LEFT',
+            39: 'RIGHT',
+            33: 'PAGEUP',
+            34: 'PAGEDOWN',
+            36: 'HOME',
+            35: 'END'
+        };
+        const actions = this.getKeyActions(currentValue);
+        const key = keys[keyCode];
+        const action = actions[key];
+        if (ValueHelper.isNullOrUndefined(action) || ValueHelper.isNullOrUndefined(this.currentTrackingPointer)) {
+            return;
+        }
+        event.preventDefault();
+        if (this.firstKeyDown) {
+            this.firstKeyDown = false;
+            this.userChangeStart.emit(this.getChangeContext());
+        }
+        const actionValue = MathHelper.clampToRange(action, this.viewOptions.floor, this.viewOptions.ceil);
+        const newValue = this.roundStep(actionValue);
+        if (!this.viewOptions.draggableRangeOnly) {
+            this.positionTrackingHandle(newValue);
+        }
+        else {
+            const difference = this.viewHighValue - this.viewLowValue;
+            let newMinValue;
+            let newMaxValue;
+            if (this.currentTrackingPointer === PointerType.Min) {
+                newMinValue = newValue;
+                newMaxValue = newValue + difference;
+                if (newMaxValue > this.viewOptions.ceil) {
+                    newMaxValue = this.viewOptions.ceil;
+                    newMinValue = newMaxValue - difference;
+                }
+            }
+            else if (this.currentTrackingPointer === PointerType.Max) {
+                newMaxValue = newValue;
+                newMinValue = newValue - difference;
+                if (newMinValue < this.viewOptions.floor) {
+                    newMinValue = this.viewOptions.floor;
+                    newMaxValue = newMinValue + difference;
+                }
+            }
+            this.positionTrackingBar(newMinValue, newMaxValue);
+        }
+    }
+    // onDragStart event handler, handles dragging of the middle bar
+    onDragStart(event, bindMove, bindEnd, pointerType) {
+        const position = this.getEventPosition(event);
+        this.dragging = new Dragging();
+        this.dragging.active = true;
+        this.dragging.value = this.positionToValue(position);
+        this.dragging.difference = this.viewHighValue - this.viewLowValue;
+        this.dragging.lowLimit = this.viewOptions.rightToLeft
+            ? this.minHandleElement.position - position
+            : position - this.minHandleElement.position;
+        this.dragging.highLimit = this.viewOptions.rightToLeft
+            ? position - this.maxHandleElement.position
+            : this.maxHandleElement.position - position;
+        this.onStart(event, bindMove, bindEnd, pointerType);
+    }
+    /** Get min value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */
+    getMinValue(newPos, outOfBounds, isAbove) {
+        const isRTL = this.viewOptions.rightToLeft;
+        let value;
+        if (outOfBounds) {
+            if (isAbove) {
+                value = isRTL
+                    ? this.viewOptions.floor
+                    : this.viewOptions.ceil - this.dragging.difference;
+            }
+            else {
+                value = isRTL
+                    ? this.viewOptions.ceil - this.dragging.difference
+                    : this.viewOptions.floor;
+            }
+        }
+        else {
+            value = isRTL
+                ? this.positionToValue(newPos + this.dragging.lowLimit)
+                : this.positionToValue(newPos - this.dragging.lowLimit);
+        }
+        return this.roundStep(value);
+    }
+    /** Get max value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */
+    getMaxValue(newPos, outOfBounds, isAbove) {
+        const isRTL = this.viewOptions.rightToLeft;
+        let value;
+        if (outOfBounds) {
+            if (isAbove) {
+                value = isRTL
+                    ? this.viewOptions.floor + this.dragging.difference
+                    : this.viewOptions.ceil;
+            }
+            else {
+                value = isRTL
+                    ? this.viewOptions.ceil
+                    : this.viewOptions.floor + this.dragging.difference;
+            }
+        }
+        else {
+            if (isRTL) {
+                value =
+                    this.positionToValue(newPos + this.dragging.lowLimit) +
+                        this.dragging.difference;
+            }
+            else {
+                value =
+                    this.positionToValue(newPos - this.dragging.lowLimit) +
+                        this.dragging.difference;
+            }
+        }
+        return this.roundStep(value);
+    }
+    onDragMove(event) {
+        const newPos = this.getEventPosition(event);
+        if (this.viewOptions.animate && !this.viewOptions.animateOnMove) {
+            if (this.moving) {
+                this.sliderElementAnimateClass = false;
+            }
+        }
+        this.moving = true;
+        let ceilLimit, floorLimit, floorHandleElement, ceilHandleElement;
+        if (this.viewOptions.rightToLeft) {
+            ceilLimit = this.dragging.lowLimit;
+            floorLimit = this.dragging.highLimit;
+            floorHandleElement = this.maxHandleElement;
+            ceilHandleElement = this.minHandleElement;
+        }
+        else {
+            ceilLimit = this.dragging.highLimit;
+            floorLimit = this.dragging.lowLimit;
+            floorHandleElement = this.minHandleElement;
+            ceilHandleElement = this.maxHandleElement;
+        }
+        const isUnderFloorLimit = (newPos <= floorLimit);
+        const isOverCeilLimit = (newPos >= this.maxHandlePosition - ceilLimit);
+        let newMinValue;
+        let newMaxValue;
+        if (isUnderFloorLimit) {
+            if (floorHandleElement.position === 0) {
+                return;
+            }
+            newMinValue = this.getMinValue(newPos, true, false);
+            newMaxValue = this.getMaxValue(newPos, true, false);
+        }
+        else if (isOverCeilLimit) {
+            if (ceilHandleElement.position === this.maxHandlePosition) {
+                return;
+            }
+            newMaxValue = this.getMaxValue(newPos, true, true);
+            newMinValue = this.getMinValue(newPos, true, true);
+        }
+        else {
+            newMinValue = this.getMinValue(newPos, false, false);
+            newMaxValue = this.getMaxValue(newPos, false, false);
+        }
+        this.positionTrackingBar(newMinValue, newMaxValue);
+    }
+    // Set the new value and position for the entire bar
+    positionTrackingBar(newMinValue, newMaxValue) {
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.minLimit) &&
+            newMinValue < this.viewOptions.minLimit) {
+            newMinValue = this.viewOptions.minLimit;
+            newMaxValue = MathHelper.roundToPrecisionLimit(newMinValue + this.dragging.difference, this.viewOptions.precisionLimit);
+        }
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxLimit) &&
+            newMaxValue > this.viewOptions.maxLimit) {
+            newMaxValue = this.viewOptions.maxLimit;
+            newMinValue = MathHelper.roundToPrecisionLimit(newMaxValue - this.dragging.difference, this.viewOptions.precisionLimit);
+        }
+        this.viewLowValue = newMinValue;
+        this.viewHighValue = newMaxValue;
+        this.applyViewChange();
+        this.updateHandles(PointerType.Min, this.valueToPosition(newMinValue));
+        this.updateHandles(PointerType.Max, this.valueToPosition(newMaxValue));
+    }
+    // Set the new value and position to the current tracking handle
+    positionTrackingHandle(newValue) {
+        newValue = this.applyMinMaxLimit(newValue);
+        if (this.range) {
+            if (this.viewOptions.pushRange) {
+                newValue = this.applyPushRange(newValue);
+            }
+            else {
+                if (this.viewOptions.noSwitching) {
+                    if (this.currentTrackingPointer === PointerType.Min &&
+                        newValue > this.viewHighValue) {
+                        newValue = this.applyMinMaxRange(this.viewHighValue);
+                    }
+                    else if (this.currentTrackingPointer === PointerType.Max &&
+                        newValue < this.viewLowValue) {
+                        newValue = this.applyMinMaxRange(this.viewLowValue);
+                    }
+                }
+                newValue = this.applyMinMaxRange(newValue);
+                /* This is to check if we need to switch the min and max handles */
+                if (this.currentTrackingPointer === PointerType.Min && newValue > this.viewHighValue) {
+                    this.viewLowValue = this.viewHighValue;
+                    this.applyViewChange();
+                    this.updateHandles(PointerType.Min, this.maxHandleElement.position);
+                    this.updateAriaAttributes();
+                    this.currentTrackingPointer = PointerType.Max;
+                    this.minHandleElement.active = false;
+                    this.maxHandleElement.active = true;
+                    if (this.viewOptions.keyboardSupport) {
+                        this.maxHandleElement.focus();
+                    }
+                }
+                else if (this.currentTrackingPointer === PointerType.Max &&
+                    newValue < this.viewLowValue) {
+                    this.viewHighValue = this.viewLowValue;
+                    this.applyViewChange();
+                    this.updateHandles(PointerType.Max, this.minHandleElement.position);
+                    this.updateAriaAttributes();
+                    this.currentTrackingPointer = PointerType.Min;
+                    this.maxHandleElement.active = false;
+                    this.minHandleElement.active = true;
+                    if (this.viewOptions.keyboardSupport) {
+                        this.minHandleElement.focus();
+                    }
+                }
+            }
+        }
+        if (this.getCurrentTrackingValue() !== newValue) {
+            if (this.currentTrackingPointer === PointerType.Min) {
+                this.viewLowValue = newValue;
+                this.applyViewChange();
+            }
+            else if (this.currentTrackingPointer === PointerType.Max) {
+                this.viewHighValue = newValue;
+                this.applyViewChange();
+            }
+            this.updateHandles(this.currentTrackingPointer, this.valueToPosition(newValue));
+            this.updateAriaAttributes();
+        }
+    }
+    applyMinMaxLimit(newValue) {
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.minLimit) && newValue < this.viewOptions.minLimit) {
+            return this.viewOptions.minLimit;
+        }
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxLimit) && newValue > this.viewOptions.maxLimit) {
+            return this.viewOptions.maxLimit;
+        }
+        return newValue;
+    }
+    applyMinMaxRange(newValue) {
+        const oppositeValue = (this.currentTrackingPointer === PointerType.Min)
+            ? this.viewHighValue
+            : this.viewLowValue;
+        const difference = Math.abs(newValue - oppositeValue);
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.minRange)) {
+            if (difference < this.viewOptions.minRange) {
+                if (this.currentTrackingPointer === PointerType.Min) {
+                    return MathHelper.roundToPrecisionLimit(this.viewHighValue - this.viewOptions.minRange, this.viewOptions.precisionLimit);
+                }
+                else if (this.currentTrackingPointer === PointerType.Max) {
+                    return MathHelper.roundToPrecisionLimit(this.viewLowValue + this.viewOptions.minRange, this.viewOptions.precisionLimit);
+                }
+            }
+        }
+        if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxRange)) {
+            if (difference > this.viewOptions.maxRange) {
+                if (this.currentTrackingPointer === PointerType.Min) {
+                    return MathHelper.roundToPrecisionLimit(this.viewHighValue - this.viewOptions.maxRange, this.viewOptions.precisionLimit);
+                }
+                else if (this.currentTrackingPointer === PointerType.Max) {
+                    return MathHelper.roundToPrecisionLimit(this.viewLowValue + this.viewOptions.maxRange, this.viewOptions.precisionLimit);
+                }
+            }
+        }
+        return newValue;
+    }
+    applyPushRange(newValue) {
+        const difference = (this.currentTrackingPointer === PointerType.Min)
+            ? this.viewHighValue - newValue
+            : newValue - this.viewLowValue;
+        const minRange = (!ValueHelper.isNullOrUndefined(this.viewOptions.minRange))
+            ? this.viewOptions.minRange
+            : this.viewOptions.step;
+        const maxRange = this.viewOptions.maxRange;
+        // if smaller than minRange
+        if (difference < minRange) {
+            if (this.currentTrackingPointer === PointerType.Min) {
+                this.viewHighValue = MathHelper.roundToPrecisionLimit(Math.min(newValue + minRange, this.viewOptions.ceil), this.viewOptions.precisionLimit);
+                newValue = MathHelper.roundToPrecisionLimit(this.viewHighValue - minRange, this.viewOptions.precisionLimit);
+                this.applyViewChange();
+                this.updateHandles(PointerType.Max, this.valueToPosition(this.viewHighValue));
+            }
+            else if (this.currentTrackingPointer === PointerType.Max) {
+                this.viewLowValue = MathHelper.roundToPrecisionLimit(Math.max(newValue - minRange, this.viewOptions.floor), this.viewOptions.precisionLimit);
+                newValue = MathHelper.roundToPrecisionLimit(this.viewLowValue + minRange, this.viewOptions.precisionLimit);
+                this.applyViewChange();
+                this.updateHandles(PointerType.Min, this.valueToPosition(this.viewLowValue));
+            }
+            this.updateAriaAttributes();
+        }
+        else if (!ValueHelper.isNullOrUndefined(maxRange) && difference > maxRange) {
+            // if greater than maxRange
+            if (this.currentTrackingPointer === PointerType.Min) {
+                this.viewHighValue = MathHelper.roundToPrecisionLimit(newValue + maxRange, this.viewOptions.precisionLimit);
+                this.applyViewChange();
+                this.updateHandles(PointerType.Max, this.valueToPosition(this.viewHighValue));
+            }
+            else if (this.currentTrackingPointer === PointerType.Max) {
+                this.viewLowValue = MathHelper.roundToPrecisionLimit(newValue - maxRange, this.viewOptions.precisionLimit);
+                this.applyViewChange();
+                this.updateHandles(PointerType.Min, this.valueToPosition(this.viewLowValue));
+            }
+            this.updateAriaAttributes();
+        }
+        return newValue;
+    }
+    getChangeContext() {
+        const changeContext = new ChangeContext();
+        changeContext.pointerType = this.currentTrackingPointer;
+        changeContext.value = +this.value;
+        if (this.range) {
+            changeContext.highValue = +this.highValue;
+        }
+        return changeContext;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: SliderComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: SliderComponent, isStandalone: true, selector: "ngx-slider", inputs: { value: "value", highValue: "highValue", options: "options", manualRefresh: "manualRefresh", triggerFocus: "triggerFocus" }, outputs: { valueChange: "valueChange", highValueChange: "highValueChange", userChangeStart: "userChangeStart", userChange: "userChange", userChangeEnd: "userChangeEnd" }, host: { listeners: { "window:resize": "onResize($event)" }, properties: { "class": "this.class", "class.vertical": "this.sliderElementVerticalClass", "class.animate": "this.sliderElementAnimateClass", "class.with-legend": "this.sliderElementWithLegendClass", "attr.disabled": "this.sliderElementDisabledAttr", "attr.aria-label": "this.sliderElementAriaLabel" } }, providers: [NGX_SLIDER_CONTROL_VALUE_ACCESSOR], queries: [{ propertyName: "tooltipTemplate", first: true, predicate: ["tooltipTemplate"], descendants: true }], viewQueries: [{ propertyName: "leftOuterSelectionBarElement", first: true, predicate: ["leftOuterSelectionBar"], descendants: true, read: SliderElementDirective }, { propertyName: "rightOuterSelectionBarElement", first: true, predicate: ["rightOuterSelectionBar"], descendants: true, read: SliderElementDirective }, { propertyName: "fullBarElement", first: true, predicate: ["fullBar"], descendants: true, read: SliderElementDirective }, { propertyName: "selectionBarElement", first: true, predicate: ["selectionBar"], descendants: true, read: SliderElementDirective }, { propertyName: "minHandleElement", first: true, predicate: ["minHandle"], descendants: true, read: SliderHandleDirective }, { propertyName: "maxHandleElement", first: true, predicate: ["maxHandle"], descendants: true, read: SliderHandleDirective }, { propertyName: "floorLabelElement", first: true, predicate: ["floorLabel"], descendants: true, read: SliderLabelDirective }, { propertyName: "ceilLabelElement", first: true, predicate: ["ceilLabel"], descendants: true, read: SliderLabelDirective }, { propertyName: "minHandleLabelElement", first: true, predicate: ["minHandleLabel"], descendants: true, read: SliderLabelDirective }, { propertyName: "maxHandleLabelElement", first: true, predicate: ["maxHandleLabel"], descendants: true, read: SliderLabelDirective }, { propertyName: "combinedLabelElement", first: true, predicate: ["combinedLabel"], descendants: true, read: SliderLabelDirective }, { propertyName: "ticksElement", first: true, predicate: ["ticksElement"], descendants: true, read: SliderElementDirective }], usesOnChanges: true, ngImport: i0, template: "<!-- // 0 Left selection bar outside two handles -->\n<span ngxSliderElement #leftOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-left-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 1 Right selection bar outside two handles -->\n<span ngxSliderElement #rightOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-right-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 2 The whole slider bar -->\n<span ngxSliderElement #fullBar [class.ngx-slider-transparent]=\"fullBarTransparentClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-full-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 3 Selection bar between two handles -->\n<span ngxSliderElement #selectionBar [class.ngx-slider-draggable]=\"selectionBarDraggableClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-selection-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar ngx-slider-selection\" [ngStyle]=\"barStyle\"></span>\n</span>\n<!-- // 4 Low slider handle -->\n<span ngxSliderHandle #minHandle class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-min\" [ngStyle]=minPointerStyle></span>\n<!-- // 5 High slider handle -->\n<span ngxSliderHandle #maxHandle [style.display]=\"range ? 'inherit' : 'none'\" class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-max\" [ngStyle]=maxPointerStyle></span>\n<!-- // 6 Floor label -->\n<span ngxSliderLabel #floorLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-floor\"></span>\n<!-- // 7 Ceiling label -->\n<span ngxSliderLabel #ceilLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-ceil\"></span>\n<!-- // 8 Label above the low slider handle -->\n<span ngxSliderLabel #minHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-value\"></span>\n<!-- // 9 Label above the high slider handle -->\n<span ngxSliderLabel #maxHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-high\"></span>\n<!-- // 10 Combined range label when the slider handles are close ex. 15 - 17 -->\n<span ngxSliderLabel #combinedLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-combined\"></span>\n<!-- // 11 The ticks -->\n<span ngxSliderElement #ticksElement [hidden]=\"!showTicks\" [class.ngx-slider-ticks-values-under]=\"ticksUnderValuesClass\" class=\"ngx-slider-ticks\">\n  <span *ngFor=\"let t of ticks\" class=\"ngx-slider-tick\" [ngClass]=\"{'ngx-slider-selected': t.selected}\" [ngStyle]=\"t.style\">\n    <ngx-slider-tooltip-wrapper [template]=\"tooltipTemplate\" [tooltip]=\"t.tooltip\" [placement]=\"t.tooltipPlacement\"></ngx-slider-tooltip-wrapper>\n    <ngx-slider-tooltip-wrapper *ngIf=\"t.value !== null\" class=\"ngx-slider-span ngx-slider-tick-value\"\n        [template]=\"tooltipTemplate\" [tooltip]=\"t.valueTooltip\" [placement]=\"t.valueTooltipPlacement\" [content]=\"t.value\"></ngx-slider-tooltip-wrapper>\n    <span *ngIf=\"t.legend !== null\" class=\"ngx-slider-span ngx-slider-tick-legend\" [innerHTML]=\"t.legend\"></span>\n  </span>\n</span>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: TooltipWrapperComponent, selector: "ngx-slider-tooltip-wrapper", inputs: ["template", "tooltip", "placement", "content"] }, { kind: "directive", type: SliderLabelDirective, selector: "[ngxSliderLabel]" }, { kind: "directive", type: SliderHandleDirective, selector: "[ngxSliderHandle]" }, { kind: "directive", type: SliderElementDirective, selector: "[ngxSliderElement]" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: SliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-slider', providers: [NGX_SLIDER_CONTROL_VALUE_ACCESSOR], standalone: true, imports: [CommonModule, TooltipWrapperComponent, SliderLabelDirective, SliderHandleDirective, SliderElementDirective], template: "<!-- // 0 Left selection bar outside two handles -->\n<span ngxSliderElement #leftOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-left-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 1 Right selection bar outside two handles -->\n<span ngxSliderElement #rightOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-right-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 2 The whole slider bar -->\n<span ngxSliderElement #fullBar [class.ngx-slider-transparent]=\"fullBarTransparentClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-full-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 3 Selection bar between two handles -->\n<span ngxSliderElement #selectionBar [class.ngx-slider-draggable]=\"selectionBarDraggableClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-selection-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar ngx-slider-selection\" [ngStyle]=\"barStyle\"></span>\n</span>\n<!-- // 4 Low slider handle -->\n<span ngxSliderHandle #minHandle class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-min\" [ngStyle]=minPointerStyle></span>\n<!-- // 5 High slider handle -->\n<span ngxSliderHandle #maxHandle [style.display]=\"range ? 'inherit' : 'none'\" class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-max\" [ngStyle]=maxPointerStyle></span>\n<!-- // 6 Floor label -->\n<span ngxSliderLabel #floorLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-floor\"></span>\n<!-- // 7 Ceiling label -->\n<span ngxSliderLabel #ceilLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-ceil\"></span>\n<!-- // 8 Label above the low slider handle -->\n<span ngxSliderLabel #minHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-value\"></span>\n<!-- // 9 Label above the high slider handle -->\n<span ngxSliderLabel #maxHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-high\"></span>\n<!-- // 10 Combined range label when the slider handles are close ex. 15 - 17 -->\n<span ngxSliderLabel #combinedLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-combined\"></span>\n<!-- // 11 The ticks -->\n<span ngxSliderElement #ticksElement [hidden]=\"!showTicks\" [class.ngx-slider-ticks-values-under]=\"ticksUnderValuesClass\" class=\"ngx-slider-ticks\">\n  <span *ngFor=\"let t of ticks\" class=\"ngx-slider-tick\" [ngClass]=\"{'ngx-slider-selected': t.selected}\" [ngStyle]=\"t.style\">\n    <ngx-slider-tooltip-wrapper [template]=\"tooltipTemplate\" [tooltip]=\"t.tooltip\" [placement]=\"t.tooltipPlacement\"></ngx-slider-tooltip-wrapper>\n    <ngx-slider-tooltip-wrapper *ngIf=\"t.value !== null\" class=\"ngx-slider-span ngx-slider-tick-value\"\n        [template]=\"tooltipTemplate\" [tooltip]=\"t.valueTooltip\" [placement]=\"t.valueTooltipPlacement\" [content]=\"t.value\"></ngx-slider-tooltip-wrapper>\n    <span *ngIf=\"t.legend !== null\" class=\"ngx-slider-span ngx-slider-tick-legend\" [innerHTML]=\"t.legend\"></span>\n  </span>\n</span>" }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }]; }, propDecorators: { class: [{
+                type: HostBinding,
+                args: ['class']
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], highValue: [{
+                type: Input
+            }], highValueChange: [{
+                type: Output
+            }], options: [{
+                type: Input
+            }], userChangeStart: [{
+                type: Output
+            }], userChange: [{
+                type: Output
+            }], userChangeEnd: [{
+                type: Output
+            }], manualRefresh: [{
+                type: Input
+            }], triggerFocus: [{
+                type: Input
+            }], leftOuterSelectionBarElement: [{
+                type: ViewChild,
+                args: ['leftOuterSelectionBar', { read: SliderElementDirective }]
+            }], rightOuterSelectionBarElement: [{
+                type: ViewChild,
+                args: ['rightOuterSelectionBar', { read: SliderElementDirective }]
+            }], fullBarElement: [{
+                type: ViewChild,
+                args: ['fullBar', { read: SliderElementDirective }]
+            }], selectionBarElement: [{
+                type: ViewChild,
+                args: ['selectionBar', { read: SliderElementDirective }]
+            }], minHandleElement: [{
+                type: ViewChild,
+                args: ['minHandle', { read: SliderHandleDirective }]
+            }], maxHandleElement: [{
+                type: ViewChild,
+                args: ['maxHandle', { read: SliderHandleDirective }]
+            }], floorLabelElement: [{
+                type: ViewChild,
+                args: ['floorLabel', { read: SliderLabelDirective }]
+            }], ceilLabelElement: [{
+                type: ViewChild,
+                args: ['ceilLabel', { read: SliderLabelDirective }]
+            }], minHandleLabelElement: [{
+                type: ViewChild,
+                args: ['minHandleLabel', { read: SliderLabelDirective }]
+            }], maxHandleLabelElement: [{
+                type: ViewChild,
+                args: ['maxHandleLabel', { read: SliderLabelDirective }]
+            }], combinedLabelElement: [{
+                type: ViewChild,
+                args: ['combinedLabel', { read: SliderLabelDirective }]
+            }], ticksElement: [{
+                type: ViewChild,
+                args: ['ticksElement', { read: SliderElementDirective }]
+            }], tooltipTemplate: [{
+                type: ContentChild,
+                args: ['tooltipTemplate']
+            }], sliderElementVerticalClass: [{
+                type: HostBinding,
+                args: ['class.vertical']
+            }], sliderElementAnimateClass: [{
+                type: HostBinding,
+                args: ['class.animate']
+            }], sliderElementWithLegendClass: [{
+                type: HostBinding,
+                args: ['class.with-legend']
+            }], sliderElementDisabledAttr: [{
+                type: HostBinding,
+                args: ['attr.disabled']
+            }], sliderElementAriaLabel: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.component.js","sourceRoot":"","sources":["../../../../../../../projects/design-factory/src/lib/angular/slider/lib/slider.component.ts","../../../../../../../projects/design-factory/src/lib/angular/slider/lib/slider.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  ViewChild,\n  AfterViewInit,\n  OnChanges,\n  OnDestroy,\n  HostBinding,\n  HostListener,\n  Input,\n  ElementRef,\n  Renderer2,\n  EventEmitter,\n  Output,\n  ContentChild,\n  TemplateRef,\n  ChangeDetectorRef,\n  SimpleChanges,\n  forwardRef,\n  NgZone\n} from '@angular/core';\n\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { Subject, Subscription } from 'rxjs';\nimport { distinctUntilChanged, filter } from 'rxjs/operators';\n\nimport {\n  Options,\n  LabelType,\n  ValueToPositionFunction,\n  PositionToValueFunction,\n  CustomStepDefinition\n} from './options';\nimport { PointerType } from './pointer-type';\nimport { ChangeContext } from './change-context';\nimport { ValueHelper } from './value-helper';\nimport { CompatibilityHelper } from './compatibility-helper';\nimport { MathHelper } from './math-helper';\nimport { EventListener } from './event-listener';\nimport { EventListenerHelper, supportsPassiveEvents } from './event-listener-helper';\nimport { SliderElementDirective } from './slider-element.directive';\nimport { SliderHandleDirective } from './slider-handle.directive';\nimport { SliderLabelDirective } from './slider-label.directive';\nimport { CommonModule } from '@angular/common';\nimport { TooltipWrapperComponent } from './tooltip-wrapper.component';\n\n// Declaration for ResizeObserver a new API available in some of newest browsers:\n// https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver\ndeclare class ResizeObserver {\n  constructor(callback: () => void);\n  observe(target: any): void;\n  unobserve(target: any): void;\n  disconnect(): void;\n}\n\nexport class Tick {\n  selected: boolean = false;\n  style: any = {};\n  tooltip?: string;\n  tooltipPlacement?: string;\n  value?: string;\n  valueTooltip?: string;\n  valueTooltipPlacement?: string;\n  legend?: string;\n}\n\nclass Dragging {\n  active: boolean = false;\n  value: number = 0;\n  difference: number = 0;\n  position: number = 0;\n  lowLimit: number = 0;\n  highLimit: number = 0;\n}\n\nclass ModelValues {\n  value?: number;\n  highValue?: number;\n\n  public static compare(x?: ModelValues, y?: ModelValues): boolean {\n    if (ValueHelper.isNullOrUndefined(x) && ValueHelper.isNullOrUndefined(y)) {\n      return false;\n    }\n    if (ValueHelper.isNullOrUndefined(x) !== ValueHelper.isNullOrUndefined(y)) {\n      return false;\n    }\n    return x!.value === y!.value && x!.highValue === y!.highValue;\n  }\n}\n\nclass ModelChange extends ModelValues {\n  // Flag used to by-pass distinctUntilChanged() filter on input values\n  // (sometimes there is a need to pass values through even though the model values have not changed)\n  forceChange?: boolean;\n\n  public static override compare(x?: ModelChange, y?: ModelChange): boolean {\n    if (ValueHelper.isNullOrUndefined(x) && ValueHelper.isNullOrUndefined(y)) {\n      return false;\n    }\n    if (ValueHelper.isNullOrUndefined(x) !== ValueHelper.isNullOrUndefined(y)) {\n      return false;\n    }\n    return x!.value === y!.value &&\n      x!.highValue === y!.highValue &&\n      x!.forceChange === y!.forceChange;\n  }\n}\n\nclass InputModelChange extends ModelChange {\n  internalChange?: boolean;\n}\n\nclass OutputModelChange extends ModelChange {\n  userEventInitiated?: boolean;\n}\n\nconst NGX_SLIDER_CONTROL_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  /* tslint:disable-next-line: no-use-before-declare */\n  useExisting: forwardRef(() => SliderComponent),\n  multi: true\n};\n\n\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'ngx-slider',\n  templateUrl: './slider.component.html',\n  providers: [NGX_SLIDER_CONTROL_VALUE_ACCESSOR],\n  standalone: true,\n  imports: [CommonModule, TooltipWrapperComponent, SliderLabelDirective, SliderHandleDirective, SliderElementDirective]\n})\nexport class SliderComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy, ControlValueAccessor {\n  @HostBinding('class') class = 'ngx-slider';\n  // Model for low value of slider. For simple slider, this is the only input. For range slider, this is the low value.\n  @Input()\n  public value?: number;\n  // Output for low value slider to support two-way bindings\n  @Output()\n  public valueChange: EventEmitter<number> = new EventEmitter();\n\n  // Model for high value of slider. Not used in simple slider. For range slider, this is the high value.\n  @Input()\n  public highValue?: number;\n  // Output for high value slider to support two-way bindings\n  @Output()\n  public highValueChange: EventEmitter<number> = new EventEmitter();\n\n  // An object with all the other options of the slider.\n  // Each option can be updated at runtime and the slider will automatically be re-rendered.\n  @Input()\n  public options: Options = new Options();\n\n  // Event emitted when user starts interaction with the slider\n  @Output()\n  public userChangeStart: EventEmitter<ChangeContext> = new EventEmitter();\n\n  // Event emitted on each change coming from user interaction\n  @Output()\n  public userChange: EventEmitter<ChangeContext> = new EventEmitter();\n\n  // Event emitted when user finishes interaction with the slider\n  @Output()\n  public userChangeEnd: EventEmitter<ChangeContext> = new EventEmitter();\n\n  private manualRefreshSubscription: any;\n  // Input event that triggers slider refresh (re-positioning of slider elements)\n  @Input() set manualRefresh(manualRefresh: EventEmitter<void>) {\n    this.unsubscribeManualRefresh();\n\n    this.manualRefreshSubscription = manualRefresh.subscribe(() => {\n      setTimeout(() => this.calculateViewDimensionsAndDetectChanges());\n    });\n  }\n\n  private triggerFocusSubscription: any;\n  // Input event that triggers setting focus on given slider handle\n  @Input() set triggerFocus(triggerFocus: EventEmitter<void>) {\n    this.unsubscribeTriggerFocus();\n\n    this.triggerFocusSubscription = triggerFocus.subscribe((pointerType: PointerType) => {\n      this.focusPointer(pointerType);\n    });\n  }\n\n  // Slider type, true means range slider\n  public get range(): boolean {\n    return !ValueHelper.isNullOrUndefined(this.value) && !ValueHelper.isNullOrUndefined(this.highValue);\n  }\n\n  // Set to true if init method already executed\n  private initHasRun: boolean = false;\n\n  // Changes in model inputs are passed through this subject\n  // These are all changes coming in from outside the component through input bindings or reactive form inputs\n  private inputModelChangeSubject: Subject<InputModelChange> = new Subject<InputModelChange>();\n  private inputModelChangeSubscription?: Subscription;\n\n  // Changes to model outputs are passed through this subject\n  // These are all changes that need to be communicated to output emitters and registered callbacks\n  private outputModelChangeSubject: Subject<OutputModelChange> = new Subject<OutputModelChange>();\n  private outputModelChangeSubscription?: Subscription;\n\n  // Low value synced to model low value\n  private viewLowValue?: number;\n  // High value synced to model high value\n  private viewHighValue?: number;\n  // Options synced to model options, based on defaults\n  private viewOptions: Options = new Options();\n\n  // Half of the width or height of the slider handles\n  private handleHalfDimension: number = 0;\n  // Maximum position the slider handle can have\n  private maxHandlePosition: number = 0;\n\n  // Which handle is currently tracked for move events\n  private currentTrackingPointer?: PointerType;\n  // Internal variable to keep track of the focus element\n  private currentFocusPointer?: PointerType;\n  // Used to call onStart on the first keydown event\n  private firstKeyDown = false;\n  // Current touch id of touch event being handled\n  private touchId?: number;\n  // Values recorded when first dragging the bar\n  private dragging: Dragging = new Dragging();\n\n  /* Slider DOM elements */\n\n  // Left selection bar outside two handles\n  @ViewChild('leftOuterSelectionBar', { read: SliderElementDirective })\n  private leftOuterSelectionBarElement?: SliderElementDirective;\n\n  // Right selection bar outside two handles\n  @ViewChild('rightOuterSelectionBar', { read: SliderElementDirective })\n  private rightOuterSelectionBarElement?: SliderElementDirective;\n\n  // The whole slider bar\n  @ViewChild('fullBar', { read: SliderElementDirective })\n  private fullBarElement?: SliderElementDirective;\n\n  // Highlight between two handles\n  @ViewChild('selectionBar', { read: SliderElementDirective })\n  private selectionBarElement?: SliderElementDirective;\n\n  // Left slider handle\n  @ViewChild('minHandle', { read: SliderHandleDirective })\n  private minHandleElement?: SliderHandleDirective;\n\n  // Right slider handle\n  @ViewChild('maxHandle', { read: SliderHandleDirective })\n  private maxHandleElement?: SliderHandleDirective;\n\n  // Floor label\n  @ViewChild('floorLabel', { read: SliderLabelDirective })\n  private floorLabelElement?: SliderLabelDirective;\n\n  // Ceiling label\n  @ViewChild('ceilLabel', { read: SliderLabelDirective })\n  private ceilLabelElement?: SliderLabelDirective;\n\n  // Label above the low value\n  @ViewChild('minHandleLabel', { read: SliderLabelDirective })\n  private minHandleLabelElement?: SliderLabelDirective;\n\n  // Label above the high value\n  @ViewChild('maxHandleLabel', { read: SliderLabelDirective })\n  private maxHandleLabelElement?: SliderLabelDirective;\n\n  // Combined label\n  @ViewChild('combinedLabel', { read: SliderLabelDirective })\n  private combinedLabelElement?: SliderLabelDirective;\n\n  // The ticks\n  @ViewChild('ticksElement', { read: SliderElementDirective })\n  private ticksElement?: SliderElementDirective;\n\n  // Optional custom template for displaying tooltips\n  @ContentChild('tooltipTemplate')\n  public tooltipTemplate!: TemplateRef<any>;\n\n  // Host element class bindings\n  @HostBinding('class.vertical')\n  public sliderElementVerticalClass = false;\n  @HostBinding('class.animate')\n  public sliderElementAnimateClass = false;\n  @HostBinding('class.with-legend')\n  public sliderElementWithLegendClass = false;\n  @HostBinding('attr.disabled')\n  public sliderElementDisabledAttr?: string;\n  @HostBinding('attr.aria-label')\n  public sliderElementAriaLabel: string = 'ngx-slider';\n\n  // CSS styles and class flags\n  public barStyle: any = {};\n  public minPointerStyle: any = {};\n  public maxPointerStyle: any = {};\n  public fullBarTransparentClass = false;\n  public selectionBarDraggableClass = false;\n  public ticksUnderValuesClass = false;\n\n  // Whether to show/hide ticks\n  public get showTicks(): boolean {\n    return this.viewOptions.showTicks || false;\n  }\n\n  /* If tickStep is set or ticksArray is specified.\n     In this case, ticks values should be displayed below the slider. */\n  private intermediateTicks: boolean = false;\n  // Ticks array as displayed in view\n  public ticks: Tick[] = [];\n\n  // Event listeners\n  private eventListenerHelper?: EventListenerHelper;\n  private onMoveEventListener?: EventListener;\n  private onEndEventListener?: EventListener;\n  // Whether currently moving the slider (between onStart() and onEnd())\n  private moving: boolean = false;\n\n  // Observer for slider element resize events\n  private resizeObserver?: ResizeObserver;\n\n  // Callbacks for reactive forms support\n  private onTouchedCallback?: (value: any) => void;\n  private onChangeCallback?: (value: any) => void;\n\n\n  public constructor(private renderer: Renderer2,\n    private elementRef: ElementRef,\n    private changeDetectionRef: ChangeDetectorRef,\n    private zone: NgZone) {\n    this.eventListenerHelper = new EventListenerHelper(this.renderer);\n  }\n\n  // OnInit interface\n  public ngOnInit(): void {\n    this.viewOptions = new Options();\n    Object.assign(this.viewOptions, this.options);\n\n    // We need to run these two things first, before the rest of the init in ngAfterViewInit(),\n    // because these two settings are set through @HostBinding and Angular change detection\n    // mechanism doesn't like them changing in ngAfterViewInit()\n\n    this.updateDisabledState();\n    this.updateVerticalState();\n    this.updateAriaLabel();\n  }\n\n  // AfterViewInit interface\n  public ngAfterViewInit(): void {\n    this.applyOptions();\n\n    this.subscribeInputModelChangeSubject();\n    this.subscribeOutputModelChangeSubject();\n\n    // Once we apply options, we need to normalise model values for the first time\n    this.renormaliseModelValues();\n\n    this.viewLowValue = this.modelValueToViewValue(this.value!);\n    if (this.range) {\n      this.viewHighValue = this.modelValueToViewValue(this.highValue!);\n    } else {\n      this.viewHighValue = undefined;\n    }\n\n    this.updateVerticalState(); // need to run this again to cover changes to slider elements\n    this.manageElementsStyle();\n    this.updateDisabledState();\n    this.calculateViewDimensions();\n    this.addAccessibility();\n    this.updateCeilLabel();\n    this.updateFloorLabel();\n    this.initHandles();\n    this.manageEventsBindings();\n    this.updateAriaLabel();\n\n    this.subscribeResizeObserver();\n\n    this.initHasRun = true;\n\n    // Run change detection manually to resolve some issues when init procedure changes values used in the view\n    if (!this.isRefDestroyed()) {\n      this.changeDetectionRef.detectChanges();\n    }\n  }\n\n  // OnChanges interface\n  public ngOnChanges(changes: SimpleChanges): void {\n    // Always apply options first\n    const options = changes['options'];\n    if (!ValueHelper.isNullOrUndefined(options) &&\n      JSON.stringify(options.previousValue) !== JSON.stringify(options.currentValue)) {\n      this.onChangeOptions();\n    }\n\n    // Then value changes\n    if (!ValueHelper.isNullOrUndefined(changes['value']) ||\n      !ValueHelper.isNullOrUndefined(changes['highValue'])) {\n      this.inputModelChangeSubject.next({\n        value: this.value,\n        highValue: this.highValue,\n        forceChange: false,\n        internalChange: false\n      });\n    }\n  }\n\n  // OnDestroy interface\n  public ngOnDestroy(): void {\n    this.unbindEvents();\n\n    this.unsubscribeResizeObserver();\n    this.unsubscribeInputModelChangeSubject();\n    this.unsubscribeOutputModelChangeSubject();\n    this.unsubscribeManualRefresh();\n    this.unsubscribeTriggerFocus();\n  }\n\n  // ControlValueAccessor interface\n  public writeValue(obj: any): void {\n    if (obj instanceof Array) {\n      this.value = obj[0];\n      this.highValue = obj[1];\n    } else {\n      this.value = obj;\n    }\n\n    // ngOnChanges() is not called in this instance, so we need to communicate the change manually\n    this.inputModelChangeSubject.next({\n      value: this.value,\n      highValue: this.highValue,\n      forceChange: false,\n      internalChange: false\n    });\n  }\n\n  // ControlValueAccessor interface\n  public registerOnChange(onChangeCallback: any): void {\n    this.onChangeCallback = onChangeCallback;\n  }\n\n  // ControlValueAccessor interface\n  public registerOnTouched(onTouchedCallback: any): void {\n    this.onTouchedCallback = onTouchedCallback;\n  }\n\n  // ControlValueAccessor interface\n  public setDisabledState(isDisabled: boolean): void {\n    this.viewOptions.disabled = isDisabled;\n    this.updateDisabledState();\n  }\n\n  public setAriaLabel(ariaLabel: string): void {\n    this.viewOptions.ariaLabel = ariaLabel;\n    this.updateAriaLabel();\n  }\n\n\n  @HostListener('window:resize', ['$event'])\n  public onResize(event: any): void {\n    this.calculateViewDimensionsAndDetectChanges();\n  }\n\n  private subscribeInputModelChangeSubject(): void {\n    this.inputModelChangeSubscription = this.inputModelChangeSubject\n      .pipe(\n        distinctUntilChanged(ModelChange.compare as unknown as any),\n        // Hack to reset the status of the distinctUntilChanged() - if a \"fake\" event comes through with forceChange=true,\n        // we forcefully by-pass distinctUntilChanged(), but otherwise drop the event\n        filter((modelChange: InputModelChange) => !modelChange.forceChange && !modelChange.internalChange)\n      )\n      .subscribe((modelChange: InputModelChange) => this.applyInputModelChange(modelChange));\n  }\n\n  private subscribeOutputModelChangeSubject(): void {\n    this.outputModelChangeSubscription = this.outputModelChangeSubject\n      .pipe(\n        distinctUntilChanged(ModelChange.compare)\n      )\n      .subscribe((modelChange: any) => this.publishOutputModelChange(modelChange));\n  }\n\n  private subscribeResizeObserver(): void {\n    if (CompatibilityHelper.isResizeObserverAvailable()) {\n      this.resizeObserver = new ResizeObserver((): void => this.calculateViewDimensionsAndDetectChanges());\n      this.resizeObserver.observe(this.elementRef.nativeElement);\n    }\n  }\n\n  private unsubscribeResizeObserver(): void {\n    if (CompatibilityHelper.isResizeObserverAvailable() && this.resizeObserver !== null) {\n      this.resizeObserver?.disconnect();\n      this.resizeObserver = undefined;\n    }\n  }\n\n  private unsubscribeOnMove(): void {\n    if (!ValueHelper.isNullOrUndefined(this.onMoveEventListener)) {\n      this.eventListenerHelper?.detachEventListener(this.onMoveEventListener!);\n      this.onMoveEventListener = undefined;\n    }\n  }\n\n  private unsubscribeOnEnd(): void {\n    if (!ValueHelper.isNullOrUndefined(this.onEndEventListener)) {\n      this.eventListenerHelper?.detachEventListener(this.onEndEventListener!);\n      this.onEndEventListener = undefined;\n    }\n  }\n\n  private unsubscribeInputModelChangeSubject(): void {\n    if (!ValueHelper.isNullOrUndefined(this.inputModelChangeSubscription)) {\n      this.inputModelChangeSubscription?.unsubscribe();\n      this.inputModelChangeSubscription = undefined;\n    }\n  }\n\n  private unsubscribeOutputModelChangeSubject(): void {\n    if (!ValueHelper.isNullOrUndefined(this.outputModelChangeSubscription)) {\n      this.outputModelChangeSubscription?.unsubscribe();\n      this.outputModelChangeSubscription = undefined;\n    }\n  }\n\n  private unsubscribeManualRefresh(): void {\n    if (!ValueHelper.isNullOrUndefined(this.manualRefreshSubscription)) {\n      this.manualRefreshSubscription.unsubscribe();\n      this.manualRefreshSubscription = undefined;\n    }\n  }\n\n  private unsubscribeTriggerFocus(): void {\n    if (!ValueHelper.isNullOrUndefined(this.triggerFocusSubscription)) {\n      this.triggerFocusSubscription.unsubscribe();\n      this.triggerFocusSubscription = null;\n    }\n  }\n\n  private getPointerElement(pointerType: PointerType): SliderHandleDirective | undefined {\n    if (pointerType === PointerType.Min) {\n      return this.minHandleElement;\n    } else if (pointerType === PointerType.Max) {\n      return this.maxHandleElement;\n    }\n    return undefined;\n  }\n\n  private getCurrentTrackingValue(): number | undefined {\n    if (this.currentTrackingPointer === PointerType.Min) {\n      return this.viewLowValue;\n    } else if (this.currentTrackingPointer === PointerType.Max) {\n      return this.viewHighValue;\n    }\n    return undefined;\n  }\n\n  private modelValueToViewValue(modelValue: number): number {\n    if (ValueHelper.isNullOrUndefined(modelValue)) {\n      return NaN;\n    }\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {\n      return ValueHelper.findStepIndex(+modelValue, this.viewOptions.stepsArray!);\n    }\n    return +modelValue;\n  }\n\n  private viewValueToModelValue(viewValue: number): number {\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {\n      return this.getStepValue(viewValue);\n    }\n    return viewValue;\n  }\n\n  private getStepValue(sliderValue: number): number {\n    const step: CustomStepDefinition = this.viewOptions.stepsArray![sliderValue];\n    return (!ValueHelper.isNullOrUndefined(step)) ? step.value : NaN;\n  }\n\n  private applyViewChange(): void {\n    this.value = this.viewValueToModelValue(this.viewLowValue!);\n    if (this.range) {\n      this.highValue = this.viewValueToModelValue(this.viewHighValue!);\n    }\n\n    this.outputModelChangeSubject.next({\n      value: this.value,\n      highValue: this.highValue,\n      userEventInitiated: true,\n      forceChange: false\n    });\n\n    // At this point all changes are applied and outputs are emitted, so we should be done.\n    // However, input changes are communicated in different stream and we need to be ready to\n    // act on the next input change even if it is exactly the same as last input change.\n    // Therefore, we send a special event to reset the stream.\n    this.inputModelChangeSubject.next({\n      value: this.value,\n      highValue: this.highValue,\n      forceChange: false,\n      internalChange: true\n    });\n  }\n\n  // Apply model change to the slider view\n  private applyInputModelChange(modelChange: InputModelChange): void {\n    const normalisedModelChange: ModelValues = this.normaliseModelValues(modelChange);\n\n    // If normalised model change is different, apply the change to the model values\n    const normalisationChange: boolean = !ModelValues.compare(modelChange, normalisedModelChange);\n    if (normalisationChange) {\n      this.value = normalisedModelChange.value;\n      this.highValue = normalisedModelChange.highValue;\n    }\n\n    this.viewLowValue = this.modelValueToViewValue(normalisedModelChange.value!);\n    if (this.range) {\n      this.viewHighValue = this.modelValueToViewValue(normalisedModelChange.highValue!);\n    } else {\n      this.viewHighValue = undefined;\n    }\n\n    this.updateLowHandle(this.valueToPosition(this.viewLowValue));\n    if (this.range) {\n      this.updateHighHandle(this.valueToPosition(this.viewHighValue!));\n    }\n    this.updateSelectionBar();\n    this.updateTicksScale();\n    this.updateAriaAttributes();\n    if (this.range) {\n      this.updateCombinedLabel();\n    }\n\n    // At the end, we need to communicate the model change to the outputs as well\n    // Normalisation changes are also always forced out to ensure that subscribers always end up in correct state\n    this.outputModelChangeSubject.next({\n      value: normalisedModelChange.value,\n      highValue: normalisedModelChange.highValue,\n      forceChange: normalisationChange,\n      userEventInitiated: false\n    });\n  }\n\n  // Publish model change to output event emitters and registered callbacks\n  private publishOutputModelChange(modelChange: OutputModelChange): void {\n    const emitOutputs: () => void = (): void => {\n      this.valueChange.emit(modelChange.value);\n      if (this.range) {\n        this.highValueChange.emit(modelChange.highValue);\n      }\n\n      if (!ValueHelper.isNullOrUndefined(this.onChangeCallback)) {\n        if (this.range) {\n          this.onChangeCallback!([modelChange.value, modelChange.highValue]);\n        } else {\n          this.onChangeCallback!(modelChange.value);\n        }\n      }\n      if (!ValueHelper.isNullOrUndefined(this.onTouchedCallback)) {\n        if (this.range) {\n          this.onTouchedCallback!([modelChange.value, modelChange.highValue]);\n        } else {\n          this.onTouchedCallback!(modelChange.value);\n        }\n      }\n    };\n\n    if (modelChange.userEventInitiated) {\n      // If this change was initiated by a user event, we can emit outputs in the same tick\n      emitOutputs();\n      this.userChange.emit(this.getChangeContext());\n    } else {\n      // But, if the change was initated by something else like a change in input bindings,\n      // we need to wait until next tick to emit the outputs to keep Angular change detection happy\n      setTimeout(() => { emitOutputs(); });\n    }\n  }\n\n  private normaliseModelValues(input: ModelValues): ModelValues {\n    const normalisedInput: ModelValues = new ModelValues();\n    normalisedInput.value = input.value;\n    normalisedInput.highValue = input.highValue;\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {\n      // When using steps array, only round to nearest step in the array\n      // No other enforcement can be done, as the step array may be out of order, and that is perfectly fine\n      if (this.viewOptions.enforceStepsArray) {\n        const valueIndex: number = ValueHelper.findStepIndex(normalisedInput.value!, this.viewOptions.stepsArray!);\n        normalisedInput.value = this.viewOptions.stepsArray![valueIndex].value;\n\n        if (this.range) {\n          const highValueIndex: number = ValueHelper.findStepIndex(normalisedInput.highValue!, this.viewOptions.stepsArray!);\n          normalisedInput.highValue = this.viewOptions.stepsArray![highValueIndex].value;\n        }\n      }\n\n      return normalisedInput;\n    }\n\n    if (this.viewOptions.enforceStep) {\n      normalisedInput.value = this.roundStep(normalisedInput.value!);\n      if (this.range) {\n        normalisedInput.highValue = this.roundStep(normalisedInput.highValue!);\n      }\n    }\n\n    if (this.viewOptions.enforceRange) {\n      normalisedInput.value = MathHelper.clampToRange(normalisedInput.value!, this.viewOptions.floor!, this.viewOptions.ceil!);\n\n      if (this.range) {\n        normalisedInput.highValue = MathHelper.clampToRange(normalisedInput.highValue!, this.viewOptions.floor!, this.viewOptions.ceil!);\n      }\n\n      // Make sure that range slider invariant (value <= highValue) is always satisfied\n      if (this.range && input.value! > input.highValue!) {\n        // We know that both values are now clamped correctly, they may just be in the wrong order\n        // So the easy solution is to swap them... except swapping is sometimes disabled in options, so we make the two values the same\n        if (this.viewOptions.noSwitching) {\n          normalisedInput.value = normalisedInput.highValue;\n        } else {\n          const tempValue = input.value;\n          normalisedInput.value = input.highValue;\n          normalisedInput.highValue = tempValue;\n        }\n      }\n    }\n\n    return normalisedInput;\n  }\n\n  private renormaliseModelValues(): void {\n    const previousModelValues: ModelValues = {\n      value: this.value,\n      highValue: this.highValue\n    };\n    const normalisedModelValues: ModelValues = this.normaliseModelValues(previousModelValues);\n    if (!ModelValues.compare(normalisedModelValues, previousModelValues)) {\n      this.value = normalisedModelValues.value;\n      this.highValue = normalisedModelValues.highValue;\n\n      this.outputModelChangeSubject.next({\n        value: this.value,\n        highValue: this.highValue,\n        forceChange: true,\n        userEventInitiated: false\n      });\n    }\n  }\n\n  private onChangeOptions(): void {\n    if (!this.initHasRun) {\n      return;\n    }\n\n    const previousOptionsInfluencingEventBindings: boolean[] = this.getOptionsInfluencingEventBindings(this.viewOptions);\n\n    this.applyOptions();\n\n    const newOptionsInfluencingEventBindings: boolean[] = this.getOptionsInfluencingEventBindings(this.viewOptions);\n    // Avoid re-binding events in case nothing changes that can influence it\n    // It makes it possible to change options while dragging the slider\n    const rebindEvents: boolean = !ValueHelper.areArraysEqual(previousOptionsInfluencingEventBindings, newOptionsInfluencingEventBindings);\n\n    // With new options, we need to re-normalise model values if necessary\n    this.renormaliseModelValues();\n\n    this.viewLowValue = this.modelValueToViewValue(this.value!);\n    if (this.range) {\n      this.viewHighValue = this.modelValueToViewValue(this.highValue!);\n    } else {\n      this.viewHighValue = undefined;\n    }\n\n    this.resetSlider(rebindEvents);\n  }\n\n  // Read the user options and apply them to the slider model\n  private applyOptions(): void {\n    this.viewOptions = new Options();\n    Object.assign(this.viewOptions, this.options);\n\n    this.viewOptions.draggableRange = this.range && this.viewOptions.draggableRange;\n    this.viewOptions.draggableRangeOnly = this.range && this.viewOptions.draggableRangeOnly;\n    if (this.viewOptions.draggableRangeOnly) {\n      this.viewOptions.draggableRange = true;\n    }\n\n    this.viewOptions.showTicks = this.viewOptions.showTicks ||\n      this.viewOptions.showTicksValues ||\n      !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray);\n    if (this.viewOptions.showTicks &&\n      (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep) || !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray))) {\n      this.intermediateTicks = true;\n    }\n\n    this.viewOptions.showSelectionBar = this.viewOptions.showSelectionBar ||\n      this.viewOptions.showSelectionBarEnd ||\n      !ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue);\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {\n      this.applyStepsArrayOptions();\n    } else {\n      this.applyFloorCeilOptions();\n    }\n\n    if (ValueHelper.isNullOrUndefined(this.viewOptions.combineLabels)) {\n      this.viewOptions.combineLabels = (minValue: string, maxValue: string): string => {\n        return minValue + ' - ' + maxValue;\n      };\n    }\n\n    if (this.viewOptions.logScale && this.viewOptions.floor === 0) {\n      throw Error('Can\\'t use floor=0 with logarithmic scale');\n    }\n  }\n\n  private applyStepsArrayOptions(): void {\n    this.viewOptions.floor = 0;\n    this.viewOptions.ceil = this.viewOptions.stepsArray!.length - 1;\n    this.viewOptions.step = 1;\n\n    if (ValueHelper.isNullOrUndefined(this.viewOptions.translate)) {\n      this.viewOptions.translate = (modelValue: number): string => {\n        if (this.viewOptions.bindIndexForStepsArray) {\n          return String(this.getStepValue(modelValue));\n        }\n        return String(modelValue);\n      };\n    }\n  }\n\n  private applyFloorCeilOptions(): void {\n    if (ValueHelper.isNullOrUndefined(this.viewOptions.step)) {\n      this.viewOptions.step = 1;\n    } else {\n      this.viewOptions.step = +this.viewOptions.step!;\n      if (this.viewOptions.step <= 0) {\n        this.viewOptions.step = 1;\n      }\n    }\n\n    if (ValueHelper.isNullOrUndefined(this.viewOptions.ceil) ||\n      ValueHelper.isNullOrUndefined(this.viewOptions.floor)) {\n      throw Error('floor and ceil options must be supplied');\n    }\n    this.viewOptions.ceil = +this.viewOptions.ceil!;\n    this.viewOptions.floor = +this.viewOptions.floor!;\n\n    if (ValueHelper.isNullOrUndefined(this.viewOptions.translate)) {\n      this.viewOptions.translate = (value: number): string => String(value);\n    }\n  }\n\n  // Resets slider\n  private resetSlider(rebindEvents: boolean = true): void {\n    this.manageElementsStyle();\n    this.addAccessibility();\n    this.updateCeilLabel();\n    this.updateFloorLabel();\n    if (rebindEvents) {\n      this.unbindEvents();\n      this.manageEventsBindings();\n    }\n    this.updateDisabledState();\n    this.updateAriaLabel();\n    this.calculateViewDimensions();\n    this.refocusPointerIfNeeded();\n  }\n\n  // Sets focus on the specified pointer\n  private focusPointer(pointerType: PointerType): void {\n    // If not supplied, use min pointer as default\n    if (pointerType !== PointerType.Min && pointerType !== PointerType.Max) {\n      pointerType = PointerType.Min;\n    }\n\n    if (pointerType === PointerType.Min) {\n      this.minHandleElement?.focus();\n    } else if (this.range && pointerType === PointerType.Max) {\n      this.maxHandleElement?.focus();\n    }\n  }\n\n  private refocusPointerIfNeeded(): void {\n    if (!ValueHelper.isNullOrUndefined(this.currentFocusPointer)) {\n      this.onPointerFocus(this.currentFocusPointer!);\n      const element = this.getPointerElement(this.currentFocusPointer!);\n      element?.focus();\n    }\n  }\n\n  // Update each elements style based on options\n  private manageElementsStyle(): void {\n    this.updateScale();\n    this.floorLabelElement?.setAlwaysHide(this.viewOptions.showTicksValues! || this.viewOptions.hideLimitLabels!);\n    this.ceilLabelElement?.setAlwaysHide(this.viewOptions.showTicksValues! || this.viewOptions.hideLimitLabels!);\n\n    const hideLabelsForTicks: boolean = this.viewOptions.showTicksValues! && !this.intermediateTicks!;\n    this.minHandleLabelElement?.setAlwaysHide(hideLabelsForTicks || this.viewOptions.hidePointerLabels!);\n    this.maxHandleLabelElement?.setAlwaysHide(hideLabelsForTicks || !this.range || this.viewOptions.hidePointerLabels!);\n    this.combinedLabelElement?.setAlwaysHide(hideLabelsForTicks || !this.range || this.viewOptions.hidePointerLabels!);\n    this.selectionBarElement?.setAlwaysHide(!this.range && !this.viewOptions.showSelectionBar);\n    this.leftOuterSelectionBarElement?.setAlwaysHide(!this.range || !this.viewOptions.showOuterSelectionBars);\n    this.rightOuterSelectionBarElement?.setAlwaysHide(!this.range || !this.viewOptions.showOuterSelectionBars);\n\n    this.fullBarTransparentClass = this.range && this.viewOptions.showOuterSelectionBars!;\n    this.selectionBarDraggableClass = this.viewOptions.draggableRange! && !this.viewOptions.onlyBindHandles!;\n    this.ticksUnderValuesClass = this.intermediateTicks && this.options.showTicksValues!;\n\n    if (this.sliderElementVerticalClass !== this.viewOptions.vertical) {\n      this.updateVerticalState();\n      // The above change in host component class will not be applied until the end of this cycle\n      // However, functions calculating the slider position expect the slider to be already styled as vertical\n      // So as a workaround, we need to reset the slider once again to compute the correct values\n      setTimeout((): void => { this.resetSlider(); });\n    }\n\n    // Changing animate class may interfere with slider reset/initialisation, so we should set it separately,\n    // after all is properly set up\n    if (this.sliderElementAnimateClass !== this.viewOptions.animate) {\n      setTimeout((): void => { this.sliderElementAnimateClass = this.viewOptions.animate!; });\n    }\n    this.updateRotate();\n  }\n\n  // Manage the events bindings based on readOnly and disabled options\n  private manageEventsBindings(): void {\n    if (this.viewOptions.disabled || this.viewOptions.readOnly) {\n      this.unbindEvents();\n    } else {\n      this.bindEvents();\n    }\n  }\n\n  // Set the disabled state based on disabled option\n  private updateDisabledState(): void {\n    this.sliderElementDisabledAttr = this.viewOptions.disabled ? 'disabled' : undefined;\n  }\n\n  // Set the aria-label state based on ariaLabel option\n  private updateAriaLabel(): void {\n    this.sliderElementAriaLabel = this.viewOptions.ariaLabel || 'nxg-slider';\n  }\n\n  // Set vertical state based on vertical option\n  private updateVerticalState(): void {\n    this.sliderElementVerticalClass = this.viewOptions.vertical!;\n    for (const element of this.getAllSliderElements()) {\n      // This is also called before ngAfterInit, so need to check that view child bindings work\n      if (!ValueHelper.isNullOrUndefined(element)) {\n        element.setVertical(this.viewOptions.vertical!);\n      }\n    }\n  }\n\n  private updateScale(): void {\n    for (const element of this.getAllSliderElements()) {\n      element.setScale(this.viewOptions.scale!);\n    }\n  }\n\n  private updateRotate(): void {\n    for (const element of this.getAllSliderElements()) {\n      element.setRotate(this.viewOptions.rotate!);\n    }\n  }\n\n  private getAllSliderElements(): SliderElementDirective[] {\n    return [this.leftOuterSelectionBarElement!,\n    this.rightOuterSelectionBarElement!,\n    this.fullBarElement!,\n    this.selectionBarElement!,\n    this.minHandleElement!,\n    this.maxHandleElement!,\n    this.floorLabelElement!,\n    this.ceilLabelElement!,\n    this.minHandleLabelElement!,\n    this.maxHandleLabelElement!,\n    this.combinedLabelElement!,\n    this.ticksElement!\n    ];\n  }\n\n  // Initialize slider handles positions and labels\n  // Run only once during initialization and every time view port changes size\n  private initHandles(): void {\n    this.updateLowHandle(this.valueToPosition(this.viewLowValue!));\n\n    /*\n   the order here is important since the selection bar should be\n   updated after the high handle but before the combined label\n   */\n    if (this.range) {\n      this.updateHighHandle(this.valueToPosition(this.viewHighValue!));\n    }\n\n    this.updateSelectionBar();\n\n    if (this.range) {\n      this.updateCombinedLabel();\n    }\n\n    this.updateTicksScale();\n  }\n\n  // Adds accessibility attributes, run only once during initialization\n  private addAccessibility(): void {\n    this.updateAriaAttributes();\n\n    this.minHandleElement!.role = 'slider';\n\n    if (this.viewOptions.keyboardSupport &&\n      !(this.viewOptions.readOnly || this.viewOptions.disabled)) {\n      this.minHandleElement!.tabindex = '0';\n    } else {\n      this.minHandleElement!.tabindex = '';\n    }\n\n    this.minHandleElement!.ariaOrientation = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? 'vertical' : 'horizontal';\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabel)) {\n      this.minHandleElement!.ariaLabel = this.viewOptions.ariaLabel!;\n    } else if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelledBy)) {\n      this.minHandleElement!.ariaLabelledBy = this.viewOptions.ariaLabelledBy!;\n    }\n\n    if (this.range) {\n      this.maxHandleElement!.role = 'slider';\n\n      if (this.viewOptions.keyboardSupport &&\n        !(this.viewOptions.readOnly || this.viewOptions.disabled)) {\n        this.maxHandleElement!.tabindex = '0';\n      } else {\n        this.maxHandleElement!.tabindex = '';\n      }\n\n      this.maxHandleElement!.ariaOrientation = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? 'vertical' : 'horizontal';\n\n      if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelHigh)) {\n        this.maxHandleElement!.ariaLabel = this.viewOptions.ariaLabelHigh!;\n      } else if (!ValueHelper.isNullOrUndefined(this.viewOptions.ariaLabelledByHigh)) {\n        this.maxHandleElement!.ariaLabelledBy = this.viewOptions.ariaLabelledByHigh!;\n      }\n    }\n  }\n\n  // Updates aria attributes according to current values\n  private updateAriaAttributes(): void {\n    this.minHandleElement!.ariaValueNow = (+this.value!).toString();\n    this.minHandleElement!.ariaValueText = this.viewOptions.translate!(+this.value!, LabelType.Low);\n    this.minHandleElement!.ariaValueMin = this.viewOptions.floor!.toString();\n    this.minHandleElement!.ariaValueMax = this.viewOptions.ceil!.toString();\n\n    if (this.range) {\n      this.maxHandleElement!.ariaValueNow = (+this.highValue!).toString();\n      this.maxHandleElement!.ariaValueText = this.viewOptions.translate!(+this.highValue!, LabelType.High);\n      this.maxHandleElement!.ariaValueMin = this.viewOptions.floor!.toString();\n      this.maxHandleElement!.ariaValueMax = this.viewOptions.ceil!.toString();\n    }\n  }\n\n  // Calculate dimensions that are dependent on view port size\n  // Run once during initialization and every time view port changes size.\n  private calculateViewDimensions(): void {\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.handleDimension)) {\n      this.minHandleElement!.setDimension(this.viewOptions.handleDimension!);\n    } else {\n      this.minHandleElement!.calculateDimension();\n    }\n\n    const handleWidth = this.minHandleElement!.dimension;\n\n    this.handleHalfDimension = handleWidth / 2;\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.barDimension)) {\n      this.fullBarElement!.setDimension(this.viewOptions.barDimension!);\n    } else {\n      this.fullBarElement!.calculateDimension();\n    }\n\n    this.maxHandlePosition = this.fullBarElement!.dimension - handleWidth;\n\n    if (this.initHasRun) {\n      this.updateFloorLabel();\n      this.updateCeilLabel();\n      this.initHandles();\n    }\n  }\n\n  private calculateViewDimensionsAndDetectChanges(): void {\n    this.calculateViewDimensions();\n    if (!this.isRefDestroyed()) {\n      this.changeDetectionRef.detectChanges();\n    }\n  }\n\n  /**\n   * If the slider reference is already destroyed\n   * @returns boolean - true if ref is destroyed\n   */\n  private isRefDestroyed(): boolean {\n    return (this.changeDetectionRef as any)['destroyed'];\n  }\n\n  // Update the ticks position\n  private updateTicksScale(): void {\n    if (!this.viewOptions.showTicks) {\n      setTimeout(() => { this.sliderElementWithLegendClass = false; });\n      return;\n    }\n\n    const ticksArray = !ValueHelper.isNullOrUndefined(this.viewOptions.ticksArray)\n      ? this.viewOptions.ticksArray\n      : this.getTicksArray();\n    const translate: string = this.viewOptions.vertical ? 'translateY' : 'translateX';\n\n    if (this.viewOptions.rightToLeft) {\n      ticksArray!.reverse();\n    }\n\n    const tickValueStep = !ValueHelper.isNullOrUndefined(this.viewOptions.tickValueStep) ? this.viewOptions.tickValueStep :\n      (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep) ? this.viewOptions.tickStep : this.viewOptions.step);\n\n    let hasAtLeastOneLegend: boolean = false;\n\n    const newTicks: Tick[] = ticksArray!.map((value: number): Tick => {\n      let position: number = this.valueToPosition(value);\n\n      if (this.viewOptions.vertical) {\n        position = this.maxHandlePosition - position;\n      }\n\n      const translation: string = translate + '(' + Math.round(position) + 'px)';\n      const tick: Tick = new Tick();\n      tick.selected = this.isTickSelected(value);\n      tick.style = {\n        '-webkit-transform': translation,\n        '-moz-transform': translation,\n        '-o-transform': translation,\n        '-ms-transform': translation,\n        transform: translation\n      };\n      if (tick.selected && !ValueHelper.isNullOrUndefined(this.viewOptions.getSelectionBarColor)) {\n        tick.style['background-color'] = this.getSelectionBarColor();\n      }\n      if (!tick.selected && !ValueHelper.isNullOrUndefined(this.viewOptions.getTickColor)) {\n        tick.style['background-color'] = this.getTickColor(value);\n      }\n      if (!ValueHelper.isNullOrUndefined(this.viewOptions.ticksTooltip)) {\n        tick.tooltip = this.viewOptions.ticksTooltip!(value);\n        tick.tooltipPlacement = this.viewOptions.vertical ? 'right' : 'top';\n      }\n      if (this.viewOptions.showTicksValues && !ValueHelper.isNullOrUndefined(tickValueStep) &&\n        MathHelper.isModuloWithinPrecisionLimit(value, tickValueStep!, this.viewOptions.precisionLimit!)) {\n        tick.value = this.getDisplayValue(value, LabelType.TickValue);\n        if (!ValueHelper.isNullOrUndefined(this.viewOptions.ticksValuesTooltip)) {\n          tick.valueTooltip = this.viewOptions.ticksValuesTooltip!(value);\n          tick.valueTooltipPlacement = this.viewOptions.vertical\n            ? 'right'\n            : 'top';\n        }\n      }\n\n      let legend: string;\n      if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray)) {\n        const step: CustomStepDefinition = this.viewOptions.stepsArray![value];\n        if (!ValueHelper.isNullOrUndefined(this.viewOptions.getStepLegend)) {\n          legend = this.viewOptions.getStepLegend!(step);\n        } else if (!ValueHelper.isNullOrUndefined(step)) {\n          legend = step.legend!;\n        }\n      } else if (!ValueHelper.isNullOrUndefined(this.viewOptions.getLegend)) {\n        legend = this.viewOptions.getLegend!(value);\n      }\n      if (!ValueHelper.isNullOrUndefined(legend!)) {\n        tick.legend = legend!;\n        hasAtLeastOneLegend = true;\n      }\n\n      return tick;\n    });\n\n    setTimeout(() => { this.sliderElementWithLegendClass = hasAtLeastOneLegend; });\n\n    // We should avoid re-creating the ticks array if possible\n    // This both improves performance and makes CSS animations work correctly\n    if (!ValueHelper.isNullOrUndefined(this.ticks) && this.ticks.length === newTicks.length) {\n      for (let i: number = 0; i < newTicks.length; ++i) {\n        Object.assign(this.ticks[i], newTicks[i]);\n      }\n    } else {\n      this.ticks = newTicks;\n    }\n\n    if (!this.isRefDestroyed()) {\n      this.changeDetectionRef.detectChanges();\n    }\n  }\n\n  private getTicksArray(): number[] {\n    const step = (!ValueHelper.isNullOrUndefined(this.viewOptions.tickStep)) ? this.viewOptions.tickStep : this.viewOptions.step;\n    const ticksArray: number[] = [];\n\n    const numberOfValues: number = 1 + Math.floor(MathHelper.roundToPrecisionLimit(\n      Math.abs(this.viewOptions.ceil! - this.viewOptions.floor!) / step!,\n      this.viewOptions.precisionLimit!\n    ));\n    for (let index: number = 0; index < numberOfValues; ++index) {\n      ticksArray.push(MathHelper.roundToPrecisionLimit(this.viewOptions.floor! + step! * index, this.viewOptions.precisionLimit!));\n    }\n\n    return ticksArray;\n  }\n\n  private isTickSelected(value: number): boolean {\n    if (!this.range) {\n      if (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue)) {\n        const center = this.viewOptions.showSelectionBarFromValue;\n        if (this.viewLowValue! > center! &&\n          value >= center! &&\n          value <= this.viewLowValue!) {\n          return true;\n        } else if (this.viewLowValue! < center! &&\n          value <= center! &&\n          value >= this.viewLowValue!) {\n          return true;\n        }\n      } else if (this.viewOptions.showSelectionBarEnd) {\n        if (value >= this.viewLowValue!) {\n          return true;\n        }\n      } else if (this.viewOptions.showSelectionBar && value <= this.viewLowValue!) {\n        return true;\n      }\n    }\n\n    if (this.range && value >= this.viewLowValue! && value <= this.viewHighValue!) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Update position of the floor label\n  private updateFloorLabel(): void {\n    if (!this.floorLabelElement!.alwaysHide) {\n      this.floorLabelElement!.setValue(this.getDisplayValue(this.viewOptions.floor!, LabelType.Floor));\n      this.floorLabelElement!.calculateDimension();\n      const position: number = this.viewOptions.rightToLeft\n        ? this.fullBarElement!.dimension - this.floorLabelElement!.dimension\n        : 0;\n      this.floorLabelElement!.setPosition(position);\n    }\n  }\n\n  // Update position of the ceiling label\n  private updateCeilLabel(): void {\n    if (!this.ceilLabelElement!.alwaysHide) {\n      this.ceilLabelElement!.setValue(this.getDisplayValue(this.viewOptions.ceil!, LabelType.Ceil));\n      this.ceilLabelElement!.calculateDimension();\n      const position: number = this.viewOptions.rightToLeft\n        ? 0\n        : this.fullBarElement!.dimension - this.ceilLabelElement!.dimension;\n      this.ceilLabelElement!.setPosition(position);\n    }\n  }\n\n  // Update slider handles and label positions\n  private updateHandles(which: PointerType, newPos: number): void {\n    if (which === PointerType.Min) {\n      this.updateLowHandle(newPos);\n    } else if (which === PointerType.Max) {\n      this.updateHighHandle(newPos);\n    }\n\n    this.updateSelectionBar();\n    this.updateTicksScale();\n    if (this.range) {\n      this.updateCombinedLabel();\n    }\n  }\n\n  // Helper function to work out the position for handle labels depending on RTL or not\n  private getHandleLabelPos(labelType: PointerType, newPos: number): number {\n    const labelDimension: number = (labelType === PointerType.Min)\n      ? this.minHandleLabelElement!.dimension\n      : this.maxHandleLabelElement!.dimension;\n    const nearHandlePos: number = newPos - labelDimension / 2 + this.handleHalfDimension;\n    const endOfBarPos: number = this.fullBarElement!.dimension - labelDimension;\n\n    if (!this.viewOptions.boundPointerLabels) {\n      return nearHandlePos;\n    }\n\n    if ((this.viewOptions.rightToLeft && labelType === PointerType.Min) ||\n      (!this.viewOptions.rightToLeft && labelType === PointerType.Max)) {\n      return Math.min(nearHandlePos, endOfBarPos);\n    } else {\n      return Math.min(Math.max(nearHandlePos, 0), endOfBarPos);\n    }\n  }\n\n  // Update low slider handle position and label\n  private updateLowHandle(newPos: number): void {\n    this.minHandleElement!.setPosition(newPos);\n    this.minHandleLabelElement!.setValue(this.getDisplayValue(this.viewLowValue!, LabelType.Low));\n    this.minHandleLabelElement!.setPosition(this.getHandleLabelPos(PointerType.Min, newPos));\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.getPointerColor)) {\n      this.minPointerStyle = {\n        backgroundColor: this.getPointerColor(PointerType.Min)\n      };\n    }\n\n    if (this.viewOptions.autoHideLimitLabels) {\n      this.updateFloorAndCeilLabelsVisibility();\n    }\n  }\n\n  // Update high slider handle position and label\n  private updateHighHandle(newPos: number): void {\n    this.maxHandleElement!.setPosition(newPos);\n    this.maxHandleLabelElement!.setValue(this.getDisplayValue(this.viewHighValue!, LabelType.High));\n    this.maxHandleLabelElement!.setPosition(this.getHandleLabelPos(PointerType.Max, newPos));\n\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.getPointerColor)) {\n      this.maxPointerStyle = {\n        backgroundColor: this.getPointerColor(PointerType.Max)\n      };\n    }\n    if (this.viewOptions.autoHideLimitLabels) {\n      this.updateFloorAndCeilLabelsVisibility();\n    }\n  }\n\n  // Show/hide floor/ceiling label\n  private updateFloorAndCeilLabelsVisibility(): void {\n    // Show based only on hideLimitLabels if pointer labels are hidden\n    if (this.viewOptions.hidePointerLabels) {\n      return;\n    }\n    let floorLabelHidden: boolean = false;\n    let ceilLabelHidden: boolean = false;\n    const isMinLabelAtFloor: boolean = this.isLabelBelowFloorLabel(this.minHandleLabelElement!);\n    const isMinLabelAtCeil: boolean = this.isLabelAboveCeilLabel(this.minHandleLabelElement!);\n    const isMaxLabelAtCeil: boolean = this.isLabelAboveCeilLabel(this.maxHandleLabelElement!);\n    const isCombinedLabelAtFloor: boolean = this.isLabelBelowFloorLabel(this.combinedLabelElement!);\n    const isCombinedLabelAtCeil: boolean = this.isLabelAboveCeilLabel(this.combinedLabelElement!);\n\n    if (isMinLabelAtFloor) {\n      floorLabelHidden = true;\n      this.floorLabelElement!.hide();\n    } else {\n      floorLabelHidden = false;\n      this.floorLabelElement!.show();\n    }\n\n    if (isMinLabelAtCeil) {\n      ceilLabelHidden = true;\n      this.ceilLabelElement!.hide();\n    } else {\n      ceilLabelHidden = false;\n      this.ceilLabelElement!.show();\n    }\n\n    if (this.range) {\n      const hideCeil: boolean = this.combinedLabelElement!.isVisible() ? isCombinedLabelAtCeil : isMaxLabelAtCeil;\n      const hideFloor: boolean = this.combinedLabelElement!.isVisible() ? isCombinedLabelAtFloor : isMinLabelAtFloor;\n\n      if (hideCeil) {\n        this.ceilLabelElement!.hide();\n      } else if (!ceilLabelHidden) {\n        this.ceilLabelElement!.show();\n      }\n\n      // Hide or show floor label\n      if (hideFloor) {\n        this.floorLabelElement!.hide();\n      } else if (!floorLabelHidden) {\n        this.floorLabelElement!.show();\n      }\n    }\n  }\n\n  private isLabelBelowFloorLabel(label: SliderLabelDirective): boolean {\n    const pos: number = label.position;\n    const dim: number = label.dimension;\n    const floorPos: number = this.floorLabelElement!.position;\n    const floorDim: number = this.floorLabelElement!.dimension;\n    return this.viewOptions.rightToLeft\n      ? pos + dim >= floorPos - 2\n      : pos <= floorPos + floorDim + 2;\n  }\n\n  private isLabelAboveCeilLabel(label: SliderLabelDirective): boolean {\n    const pos: number = label.position;\n    const dim: number = label.dimension;\n    const ceilPos: number = this.ceilLabelElement!.position;\n    const ceilDim: number = this.ceilLabelElement!.dimension;\n    return this.viewOptions.rightToLeft\n      ? pos <= ceilPos + ceilDim + 2\n      : pos + dim >= ceilPos - 2;\n  }\n\n  // Update slider selection bar, combined label and range label\n  private updateSelectionBar(): void {\n    let position: number = 0;\n    let dimension: number = 0;\n    const isSelectionBarFromRight: boolean = this.viewOptions.rightToLeft\n      ? !this.viewOptions.showSelectionBarEnd!\n      : this.viewOptions.showSelectionBarEnd!;\n    const positionForRange: number = this.viewOptions.rightToLeft\n      ? this.maxHandleElement!.position + this.handleHalfDimension\n      : this.minHandleElement!.position + this.handleHalfDimension;\n\n    if (this.range) {\n      dimension = Math.abs(this.maxHandleElement!.position - this.minHandleElement!.position);\n      position = positionForRange;\n    } else {\n      if (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue)) {\n        const center = this.viewOptions.showSelectionBarFromValue;\n        const centerPosition: number = this.valueToPosition(center!);\n        const isModelGreaterThanCenter: boolean = this.viewOptions.rightToLeft\n          ? this.viewLowValue! <= center!\n          : this.viewLowValue! > center!;\n        if (isModelGreaterThanCenter) {\n          dimension = this.minHandleElement!.position - centerPosition;\n          position = centerPosition + this.handleHalfDimension;\n        } else {\n          dimension = centerPosition - this.minHandleElement!.position;\n          position = this.minHandleElement!.position + this.handleHalfDimension;\n        }\n      } else if (isSelectionBarFromRight) {\n        dimension = Math.ceil(Math.abs(this.maxHandlePosition - this.minHandleElement!.position) + this.handleHalfDimension);\n        position = Math.floor(this.minHandleElement!.position + this.handleHalfDimension);\n      } else {\n        dimension = this.minHandleElement!.position + this.handleHalfDimension;\n        position = 0;\n      }\n    }\n    this.selectionBarElement!.setDimension(dimension);\n    this.selectionBarElement!.setPosition(position);\n    if (this.range && this.viewOptions.showOuterSelectionBars) {\n      if (this.viewOptions.rightToLeft) {\n        this.rightOuterSelectionBarElement!.setDimension(position);\n        this.rightOuterSelectionBarElement!.setPosition(0);\n        this.fullBarElement!.calculateDimension();\n        this.leftOuterSelectionBarElement!.setDimension(this.fullBarElement!.dimension - (position + dimension));\n        this.leftOuterSelectionBarElement!.setPosition(position + dimension);\n      } else {\n        this.leftOuterSelectionBarElement!.setDimension(position);\n        this.leftOuterSelectionBarElement!.setPosition(0);\n        this.fullBarElement!.calculateDimension();\n        this.rightOuterSelectionBarElement!.setDimension(this.fullBarElement!.dimension - (position + dimension));\n        this.rightOuterSelectionBarElement!.setPosition(position + dimension);\n      }\n    }\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.getSelectionBarColor)) {\n      const color: string = this.getSelectionBarColor();\n      this.barStyle = {\n        backgroundColor: color\n      };\n    } else if (!ValueHelper.isNullOrUndefined(this.viewOptions.selectionBarGradient)) {\n      const offset: number = (!ValueHelper.isNullOrUndefined(this.viewOptions.showSelectionBarFromValue))\n        ? this.valueToPosition(this.viewOptions.showSelectionBarFromValue!)\n        : 0;\n      const reversed: boolean = (offset - position > 0 && !isSelectionBarFromRight) || (offset - position <= 0 && isSelectionBarFromRight);\n      const direction: string = this.viewOptions.vertical\n        ? reversed ? 'bottom' : 'top'\n        : reversed ? 'left' : 'right';\n      this.barStyle = {\n        backgroundImage:\n          'linear-gradient(to ' +\n          direction +\n          ', ' +\n          this.viewOptions.selectionBarGradient!.from +\n          ' 0%,' +\n          this.viewOptions.selectionBarGradient!.to +\n          ' 100%)'\n      };\n      if (this.viewOptions.vertical) {\n        this.barStyle.backgroundPosition =\n          'center ' +\n          (offset +\n            dimension +\n            position +\n            (reversed ? -this.handleHalfDimension : 0)) +\n          'px';\n        this.barStyle.backgroundSize =\n          '100% ' + (this.fullBarElement!.dimension - this.handleHalfDimension) + 'px';\n      } else {\n        this.barStyle.backgroundPosition =\n          offset -\n          position +\n          (reversed ? this.handleHalfDimension : 0) +\n          'px center';\n        this.barStyle.backgroundSize =\n          this.fullBarElement!.dimension - this.handleHalfDimension + 'px 100%';\n      }\n    }\n  }\n\n  // Wrapper around the getSelectionBarColor of the user to pass to correct parameters\n  private getSelectionBarColor(): string {\n    if (this.range) {\n      return this.viewOptions.getSelectionBarColor!(\n        this.value!,\n        this.highValue\n      );\n    }\n    return this.viewOptions.getSelectionBarColor!(this.value!);\n  }\n\n  // Wrapper around the getPointerColor of the user to pass to  correct parameters\n  private getPointerColor(pointerType: PointerType): string {\n    if (pointerType === PointerType.Max) {\n      return this.viewOptions.getPointerColor!(\n        this.highValue!,\n        pointerType\n      );\n    }\n    return this.viewOptions.getPointerColor!(\n      this.value!,\n      pointerType\n    );\n  }\n\n  // Wrapper around the getTickColor of the user to pass to correct parameters\n  private getTickColor(value: number): string {\n    return this.viewOptions.getTickColor!(value);\n  }\n\n  // Update combined label position and value\n  private updateCombinedLabel(): void {\n    let isLabelOverlap = false;\n    if (this.viewOptions.rightToLeft) {\n      isLabelOverlap =\n        this.minHandleLabelElement!.position - this.minHandleLabelElement!.dimension - 10 <= this.maxHandleLabelElement!.position;\n    } else {\n      isLabelOverlap =\n        this.minHandleLabelElement!.position + this.minHandleLabelElement!.dimension + 10 >= this.maxHandleLabelElement!.position;\n    }\n\n    if (isLabelOverlap) {\n      const lowDisplayValue: string = this.getDisplayValue(this.viewLowValue!, LabelType.Low);\n      const highDisplayValue: string = this.getDisplayValue(this.viewHighValue!, LabelType.High);\n      const combinedLabelValue: string = this.viewOptions.rightToLeft\n        ? this.viewOptions.combineLabels!(highDisplayValue, lowDisplayValue)\n        : this.viewOptions.combineLabels!(lowDisplayValue, highDisplayValue);\n\n      this.combinedLabelElement!.setValue(combinedLabelValue);\n      const pos: number = this.viewOptions.boundPointerLabels\n        ? Math.min(\n          Math.max(\n            this.selectionBarElement!.position +\n            this.selectionBarElement!.dimension / 2 -\n            this.combinedLabelElement!.dimension / 2,\n            0\n          ),\n          this.fullBarElement!.dimension - this.combinedLabelElement!.dimension\n        )\n        : this.selectionBarElement!.position + this.selectionBarElement!.dimension / 2 - this.combinedLabelElement!.dimension / 2;\n\n      this.combinedLabelElement!.setPosition(pos);\n      this.minHandleLabelElement!.hide();\n      this.maxHandleLabelElement!.hide();\n      this.combinedLabelElement!.show();\n    } else {\n      this.updateHighHandle(this.valueToPosition(this.viewHighValue!));\n      this.updateLowHandle(this.valueToPosition(this.viewLowValue!));\n      this.maxHandleLabelElement!.show();\n      this.minHandleLabelElement!.show();\n      this.combinedLabelElement!.hide();\n    }\n    if (this.viewOptions.autoHideLimitLabels) {\n      this.updateFloorAndCeilLabelsVisibility();\n    }\n  }\n\n  // Return the translated value if a translate function is provided else the original value\n  private getDisplayValue(value: number, which: LabelType): string {\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.stepsArray) && !this.viewOptions.bindIndexForStepsArray) {\n      value = this.getStepValue(value);\n    }\n    return this.viewOptions.translate!(value, which);\n  }\n\n  // Round value to step and precision based on minValue\n  private roundStep(value: number, customStep?: number): number {\n    const step = !ValueHelper.isNullOrUndefined(customStep) ? customStep : this.viewOptions.step;\n    let steppedDifference: number = MathHelper.roundToPrecisionLimit(\n      (value - this.viewOptions.floor!) / step!, this.viewOptions.precisionLimit!);\n    steppedDifference = Math.round(steppedDifference) * step!;\n    return MathHelper.roundToPrecisionLimit(this.viewOptions.floor! + steppedDifference, this.viewOptions.precisionLimit!);\n  }\n\n  // Translate value to pixel position\n  private valueToPosition(val: number): number {\n    let fn: ValueToPositionFunction = ValueHelper.linearValueToPosition;\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.customValueToPosition)) {\n      fn = this.viewOptions.customValueToPosition!;\n    } else if (this.viewOptions.logScale) {\n      fn = ValueHelper.logValueToPosition;\n    }\n\n    val = MathHelper.clampToRange(val, this.viewOptions.floor!, this.viewOptions.ceil!);\n    let percent: number = fn(val, this.viewOptions.floor!, this.viewOptions.ceil!);\n    if (ValueHelper.isNullOrUndefined(percent)) {\n      percent = 0;\n    }\n    if (this.viewOptions.rightToLeft) {\n      percent = 1 - percent;\n    }\n    return percent * this.maxHandlePosition;\n  }\n\n  // Translate position to model value\n  private positionToValue(position: number): number {\n    let percent: number = position / this.maxHandlePosition;\n    if (this.viewOptions.rightToLeft) {\n      percent = 1 - percent;\n    }\n    let fn: PositionToValueFunction = ValueHelper.linearPositionToValue;\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.customPositionToValue)) {\n      fn = this.viewOptions.customPositionToValue!;\n    } else if (this.viewOptions.logScale) {\n      fn = ValueHelper.logPositionToValue;\n    }\n    const value: number = fn(percent, this.viewOptions.floor!, this.viewOptions.ceil!);\n    return !ValueHelper.isNullOrUndefined(value) ? value : 0;\n  }\n\n  // Get the X-coordinate or Y-coordinate of an event\n  private getEventXY(event: MouseEvent | TouchEvent, targetTouchId?: number): number {\n    if (event instanceof MouseEvent) {\n      return (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? event.clientY : event.clientX;\n    }\n\n    let touchIndex: number = 0;\n    const touches: TouchList = event.touches;\n    if (!ValueHelper.isNullOrUndefined(targetTouchId)) {\n      for (let i: number = 0; i < touches.length; i++) {\n        if (touches[i].identifier === targetTouchId) {\n          touchIndex = i;\n          break;\n        }\n      }\n    }\n\n    // Return the target touch or if the target touch was not found in the event\n    // returns the coordinates of the first touch\n    return (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ? touches[touchIndex].clientY : touches[touchIndex].clientX;\n  }\n\n  // Compute the event position depending on whether the slider is horizontal or vertical\n  private getEventPosition(event: MouseEvent | TouchEvent, targetTouchId?: number): number {\n    const sliderElementBoundingRect: ClientRect = this.elementRef.nativeElement.getBoundingClientRect();\n\n    const sliderPos: number = (this.viewOptions.vertical || this.viewOptions.rotate !== 0) ?\n      sliderElementBoundingRect.bottom : sliderElementBoundingRect.left;\n    let eventPos: number = 0;\n\n    if (this.viewOptions.vertical || this.viewOptions.rotate !== 0) {\n      eventPos = -this.getEventXY(event, targetTouchId) + sliderPos;\n    } else {\n      eventPos = this.getEventXY(event, targetTouchId) - sliderPos;\n    }\n\n    return eventPos * this.viewOptions.scale! - this.handleHalfDimension;\n  }\n\n  // Get the handle closest to an event\n  private getNearestHandle(event: MouseEvent | TouchEvent): PointerType {\n    if (!this.range) {\n      return PointerType.Min;\n    }\n\n    const position: number = this.getEventPosition(event);\n    const distanceMin: number = Math.abs(position - this.minHandleElement!.position);\n    const distanceMax: number = Math.abs(position - this.maxHandleElement!.position);\n\n    if (distanceMin < distanceMax) {\n      return PointerType.Min;\n    } else if (distanceMin > distanceMax) {\n      return PointerType.Max;\n    } else if (!this.viewOptions.rightToLeft) {\n      // if event is at the same distance from min/max then if it's at left of minH, we return minH else maxH\n      return position < this.minHandleElement!.position ? PointerType.Min : PointerType.Max;\n    }\n    // reverse in rtl\n    return position > this.minHandleElement!.position ? PointerType.Min : PointerType.Max;\n  }\n\n  // Bind mouse and touch events to slider handles\n  private bindEvents(): void {\n    const draggableRange: boolean = this.viewOptions.draggableRange!;\n\n    if (!this.viewOptions.onlyBindHandles) {\n      this.selectionBarElement!.on('mousedown',\n        (event: MouseEvent): void => this.onBarStart(draggableRange, event, true, true, undefined, true)\n      );\n    }\n\n    if (this.viewOptions.draggableRangeOnly) {\n      this.minHandleElement!.on('mousedown',\n        (event: MouseEvent): void => this.onBarStart(draggableRange, event, true, true, PointerType.Min)\n      );\n      this.maxHandleElement!.on('mousedown',\n        (event: MouseEvent): void => this.onBarStart(draggableRange, event, true, true, PointerType.Max)\n      );\n    } else {\n      this.minHandleElement!.on('mousedown',\n        (event: MouseEvent): void => this.onStart(event, true, true, PointerType.Min)\n      );\n\n      if (this.range) {\n        this.maxHandleElement!.on('mousedown',\n          (event: MouseEvent): void => this.onStart(event, true, true, PointerType.Max)\n        );\n      }\n      if (!this.viewOptions.onlyBindHandles) {\n        this.fullBarElement!.on('mousedown',\n          (event: MouseEvent): void => this.onStart(event, true, true, undefined, true)\n        );\n        this.ticksElement!.on('mousedown',\n          (event: MouseEvent): void => this.onStart(event, true, true, undefined, true, true)\n        );\n      }\n    }\n\n    if (!this.viewOptions.onlyBindHandles) {\n      this.selectionBarElement!.onPassive('touchstart',\n        (event: TouchEvent): void => this.onBarStart(draggableRange, event, true, true, undefined, true)\n      );\n    }\n    if (this.viewOptions.draggableRangeOnly) {\n      this.minHandleElement!.onPassive('touchstart',\n        (event: TouchEvent): void => this.onBarStart(draggableRange, event, true, true, PointerType.Min)\n      );\n      this.maxHandleElement!.onPassive('touchstart',\n        (event: TouchEvent): void => this.onBarStart(draggableRange, event, true, true, PointerType.Max)\n      );\n    } else {\n      this.minHandleElement!.onPassive('touchstart',\n        (event: TouchEvent): void => this.onStart(event, true, true, PointerType.Min)\n      );\n      if (this.range) {\n        this.maxHandleElement!.onPassive('touchstart',\n          (event: TouchEvent): void => this.onStart(event, true, true, PointerType.Max)\n        );\n      }\n      if (!this.viewOptions.onlyBindHandles) {\n        this.fullBarElement!.onPassive('touchstart',\n          (event: TouchEvent): void => this.onStart(event, true, true, undefined, true)\n        );\n        this.ticksElement!.onPassive('touchstart',\n          (event: TouchEvent): void => this.onStart(event, false, false, undefined, true, true)\n        );\n      }\n    }\n\n    if (this.viewOptions.keyboardSupport) {\n      this.minHandleElement!.on('focus', (): void => this.onPointerFocus(PointerType.Min));\n      if (this.range) {\n        this.maxHandleElement!.on('focus', (): void => this.onPointerFocus(PointerType.Max));\n      }\n    }\n  }\n\n  private getOptionsInfluencingEventBindings(options: Options): boolean[] {\n    return [\n      options.disabled!,\n      options.readOnly!,\n      options.draggableRange!,\n      options.draggableRangeOnly!,\n      options.onlyBindHandles!,\n      options.keyboardSupport!\n    ];\n  }\n\n  // Unbind mouse and touch events to slider handles\n  private unbindEvents(): void {\n    this.unsubscribeOnMove();\n    this.unsubscribeOnEnd();\n\n    for (const element of this.getAllSliderElements()) {\n      if (!ValueHelper.isNullOrUndefined(element)) {\n        element.off();\n      }\n    }\n  }\n\n  private onBarStart(draggableRange: boolean, event: MouseEvent | TouchEvent,\n    bindMove: boolean, bindEnd: boolean, pointerType?: PointerType, simulateImmediateMove?: boolean, simulateImmediateEnd?: boolean): void {\n    if (draggableRange) {\n      this.onDragStart(event, bindMove, bindEnd, pointerType);\n    } else {\n      this.onStart(event, bindMove, bindEnd, pointerType, simulateImmediateMove, simulateImmediateEnd);\n    }\n  }\n\n  // onStart event handler\n  private onStart(event: MouseEvent | TouchEvent,\n    bindMove: boolean, bindEnd: boolean, pointerType?: PointerType, simulateImmediateMove?: boolean, simulateImmediateEnd?: boolean): void {\n    event.stopPropagation();\n    // Only call preventDefault() when handling non-passive events (passive events don't need it)\n    if (!CompatibilityHelper.isTouchEvent(event) && !supportsPassiveEvents) {\n      event.preventDefault();\n    }\n\n    this.moving = false;\n\n    // We have to do this in case the HTML where the sliders are on\n    // have been animated into view.\n    this.calculateViewDimensions();\n\n    if (ValueHelper.isNullOrUndefined(pointerType)) {\n      pointerType = this.getNearestHandle(event);\n    }\n\n    this.currentTrackingPointer = pointerType;\n\n    const pointerElement: SliderHandleDirective = this.getPointerElement(pointerType!)!;\n    pointerElement.active = true;\n\n    if (this.viewOptions.keyboardSupport) {\n      pointerElement.focus();\n    }\n\n    if (bindMove) {\n      this.unsubscribeOnMove();\n\n      const onMoveCallback: ((e: MouseEvent | TouchEvent) => void) =\n        (e: MouseEvent | TouchEvent): void => this.dragging.active ? this.onDragMove(e) : this.onMove(e);\n\n      if (CompatibilityHelper.isTouchEvent(event)) {\n        this.onMoveEventListener = this.eventListenerHelper!.attachPassiveEventListener(\n          document, 'touchmove', onMoveCallback);\n      } else {\n        this.onMoveEventListener = this.eventListenerHelper!.attachEventListener(\n          document, 'mousemove', onMoveCallback);\n      }\n    }\n\n    if (bindEnd) {\n      this.unsubscribeOnEnd();\n\n      const onEndCallback: ((e: MouseEvent | TouchEvent) => void) =\n        (e: MouseEvent | TouchEvent): void => this.onEnd(e);\n\n      if (CompatibilityHelper.isTouchEvent(event)) {\n        this.onEndEventListener = this.eventListenerHelper!.attachPassiveEventListener(document, 'touchend', onEndCallback);\n      } else {\n        this.onEndEventListener = this.eventListenerHelper!.attachEventListener(document, 'mouseup', onEndCallback);\n      }\n    }\n\n    this.userChangeStart.emit(this.getChangeContext());\n\n    if (CompatibilityHelper.isTouchEvent(event) && !ValueHelper.isNullOrUndefined((event as TouchEvent).changedTouches)) {\n      // Store the touch identifier\n      if (ValueHelper.isNullOrUndefined(this.touchId)) {\n        this.touchId = (event as TouchEvent).changedTouches[0].identifier;\n      }\n    }\n\n    // Click events, either with mouse or touch gesture are weird. Sometimes they result in full\n    // start, move, end sequence, and sometimes, they don't - they only invoke mousedown\n    // As a workaround, we simulate the first move event and the end event if it's necessary\n    if (simulateImmediateMove) {\n      this.onMove(event, true);\n    }\n\n    if (simulateImmediateEnd) {\n      this.onEnd(event);\n    }\n  }\n\n  // onMove event handler\n  private onMove(event: MouseEvent | TouchEvent, fromTick?: boolean): void {\n    let touchForThisSlider: Touch;\n\n    if (CompatibilityHelper.isTouchEvent(event)) {\n      const changedTouches: TouchList = (event as TouchEvent).changedTouches;\n      for (let i: number = 0; i < changedTouches.length; i++) {\n        if (changedTouches[i].identifier === this.touchId) {\n          touchForThisSlider = changedTouches[i];\n          break;\n        }\n      }\n\n      if (ValueHelper.isNullOrUndefined(touchForThisSlider!)) {\n        return;\n      }\n    }\n\n    if (this.viewOptions.animate && !this.viewOptions.animateOnMove) {\n      if (this.moving) {\n        this.sliderElementAnimateClass = false;\n      }\n    }\n\n    this.moving = true;\n\n    const newPos: number = !ValueHelper.isNullOrUndefined(touchForThisSlider!)\n      ? this.getEventPosition(event, touchForThisSlider!.identifier)\n      : this.getEventPosition(event);\n    let newValue: number;\n    const ceilValue: number = this.viewOptions.rightToLeft\n      ? this.viewOptions.floor!\n      : this.viewOptions.ceil!;\n    const floorValue: number = this.viewOptions.rightToLeft ? this.viewOptions.ceil! : this.viewOptions.floor!;\n\n    if (newPos <= 0) {\n      newValue = floorValue;\n    } else if (newPos >= this.maxHandlePosition) {\n      newValue = ceilValue;\n    } else {\n      newValue = this.positionToValue(newPos);\n      if (fromTick && !ValueHelper.isNullOrUndefined(this.viewOptions.tickStep)) {\n        newValue = this.roundStep(newValue, this.viewOptions.tickStep);\n      } else {\n        newValue = this.roundStep(newValue);\n      }\n    }\n    this.positionTrackingHandle(newValue);\n  }\n\n  private onEnd(event: MouseEvent | TouchEvent): void {\n    if (CompatibilityHelper.isTouchEvent(event)) {\n      const changedTouches: TouchList = (event as TouchEvent).changedTouches;\n      if (changedTouches[0].identifier !== this.touchId) {\n        return;\n      }\n    }\n\n    this.moving = false;\n    if (this.viewOptions.animate) {\n      this.sliderElementAnimateClass = true;\n    }\n\n    this.touchId = undefined;\n\n    if (!this.viewOptions.keyboardSupport) {\n      this.minHandleElement!.active = false;\n      this.maxHandleElement!.active = false;\n      this.currentTrackingPointer = undefined;\n    }\n    this.dragging.active = false;\n\n    this.unsubscribeOnMove();\n    this.unsubscribeOnEnd();\n\n    this.userChangeEnd.emit(this.getChangeContext());\n  }\n\n  private onPointerFocus(pointerType: PointerType): void {\n    const pointerElement: SliderHandleDirective = this.getPointerElement(pointerType)!;\n    pointerElement.on('blur', (): void => this.onPointerBlur(pointerElement));\n    pointerElement.on('keydown', (event: KeyboardEvent): void => this.onKeyboardEvent(event));\n    pointerElement.on('keyup', (): void => this.onKeyUp());\n    pointerElement.active = true;\n\n    this.currentTrackingPointer = pointerType;\n    this.currentFocusPointer = pointerType;\n    this.firstKeyDown = true;\n  }\n\n  private onKeyUp(): void {\n    this.firstKeyDown = true;\n    this.userChangeEnd.emit(this.getChangeContext());\n  }\n\n  private onPointerBlur(pointer: SliderHandleDirective): void {\n    pointer.off('blur');\n    pointer.off('keydown');\n    pointer.off('keyup');\n    pointer.active = false;\n    if (ValueHelper.isNullOrUndefined(this.touchId)) {\n      this.currentTrackingPointer = undefined;\n      this.currentFocusPointer = undefined;\n    }\n  }\n\n  private getKeyActions(currentValue: number): { [key: string]: number } {\n    const valueRange: number = this.viewOptions.ceil! - this.viewOptions.floor!;\n\n    let increaseStep: number = currentValue + this.viewOptions.step!;\n    let decreaseStep: number = currentValue - this.viewOptions.step!;\n    let increasePage: number = currentValue + valueRange / 10;\n    let decreasePage: number = currentValue - valueRange / 10;\n\n    if (this.viewOptions.reversedControls) {\n      increaseStep = currentValue - this.viewOptions.step!;\n      decreaseStep = currentValue + this.viewOptions.step!;\n      increasePage = currentValue - valueRange / 10;\n      decreasePage = currentValue + valueRange / 10;\n    }\n\n    // Left to right default actions\n    const actions: { [key: string]: number } = {\n      UP: increaseStep,\n      DOWN: decreaseStep,\n      LEFT: decreaseStep,\n      RIGHT: increaseStep,\n      PAGEUP: increasePage,\n      PAGEDOWN: decreasePage,\n      HOME: this.viewOptions.reversedControls ? this.viewOptions.ceil! : this.viewOptions.floor!,\n      END: this.viewOptions.reversedControls ? this.viewOptions.floor! : this.viewOptions.ceil!\n    };\n    // right to left means swapping right and left arrows\n    if (this.viewOptions.rightToLeft) {\n      actions['LEFT'] = increaseStep;\n      actions['RIGHT'] = decreaseStep;\n      // right to left and vertical means we also swap up and down\n      if (this.viewOptions.vertical || this.viewOptions.rotate !== 0) {\n        actions['UP'] = decreaseStep;\n        actions['DOWN'] = increaseStep;\n      }\n    }\n    return actions;\n  }\n\n  private onKeyboardEvent(event: KeyboardEvent): void {\n    const currentValue = this.getCurrentTrackingValue()!;\n    const keyCode = !ValueHelper.isNullOrUndefined(event.keyCode)\n      ? event.keyCode\n      : event.which;\n    const keys: { [keyCode: number]: string } = {\n      38: 'UP',\n      40: 'DOWN',\n      37: 'LEFT',\n      39: 'RIGHT',\n      33: 'PAGEUP',\n      34: 'PAGEDOWN',\n      36: 'HOME',\n      35: 'END'\n    };\n    const actions: { [key: string]: number } = this.getKeyActions(currentValue);\n    const key: string = keys[keyCode];\n    const action: number = actions[key];\n\n    if (ValueHelper.isNullOrUndefined(action) || ValueHelper.isNullOrUndefined(this.currentTrackingPointer)) {\n      return;\n    }\n    event.preventDefault();\n\n    if (this.firstKeyDown) {\n      this.firstKeyDown = false;\n      this.userChangeStart.emit(this.getChangeContext());\n    }\n\n    const actionValue: number = MathHelper.clampToRange(action, this.viewOptions.floor!, this.viewOptions.ceil!);\n    const newValue: number = this.roundStep(actionValue);\n    if (!this.viewOptions.draggableRangeOnly) {\n      this.positionTrackingHandle(newValue);\n    } else {\n      const difference = this.viewHighValue! - this.viewLowValue!;\n      let newMinValue: number;\n      let newMaxValue: number;\n\n      if (this.currentTrackingPointer === PointerType.Min) {\n        newMinValue = newValue;\n        newMaxValue = newValue + difference;\n        if (newMaxValue > this.viewOptions.ceil!) {\n          newMaxValue = this.viewOptions.ceil!;\n          newMinValue = newMaxValue - difference;\n        }\n      } else if (this.currentTrackingPointer === PointerType.Max) {\n        newMaxValue = newValue;\n        newMinValue = newValue - difference;\n        if (newMinValue < this.viewOptions.floor!) {\n          newMinValue = this.viewOptions.floor!;\n          newMaxValue = newMinValue + difference;\n        }\n      }\n      this.positionTrackingBar(newMinValue!, newMaxValue!);\n    }\n  }\n\n  // onDragStart event handler, handles dragging of the middle bar\n  private onDragStart(event: MouseEvent | TouchEvent,\n    bindMove: boolean, bindEnd: boolean, pointerType?: PointerType): void {\n    const position: number = this.getEventPosition(event);\n\n    this.dragging = new Dragging();\n    this.dragging.active = true;\n    this.dragging.value = this.positionToValue(position);\n    this.dragging.difference = this.viewHighValue! - this.viewLowValue!;\n    this.dragging.lowLimit = this.viewOptions.rightToLeft\n      ? this.minHandleElement!.position - position\n      : position - this.minHandleElement!.position;\n    this.dragging.highLimit = this.viewOptions.rightToLeft\n      ? position - this.maxHandleElement!.position\n      : this.maxHandleElement!.position - position;\n\n    this.onStart(event, bindMove, bindEnd, pointerType);\n  }\n\n  /** Get min value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */\n  private getMinValue(newPos: number, outOfBounds: boolean, isAbove: boolean): number {\n    const isRTL = this.viewOptions.rightToLeft!;\n    let value: number;\n\n    if (outOfBounds) {\n      if (isAbove) {\n        value = isRTL\n          ? this.viewOptions.floor!\n          : this.viewOptions.ceil! - this.dragging.difference;\n      } else {\n        value = isRTL\n          ? this.viewOptions.ceil! - this.dragging.difference\n          : this.viewOptions.floor!;\n      }\n    } else {\n      value = isRTL\n        ? this.positionToValue(newPos + this.dragging.lowLimit)\n        : this.positionToValue(newPos - this.dragging.lowLimit);\n    }\n    return this.roundStep(value);\n  }\n\n  /** Get max value depending on whether the newPos is outOfBounds above or below the bar and rightToLeft */\n  private getMaxValue(newPos: number, outOfBounds: boolean, isAbove: boolean): number {\n    const isRTL = this.viewOptions.rightToLeft!;\n    let value: number;\n\n    if (outOfBounds) {\n      if (isAbove) {\n        value = isRTL\n          ? this.viewOptions.floor! + this.dragging.difference\n          : this.viewOptions.ceil!;\n      } else {\n        value = isRTL\n          ? this.viewOptions.ceil!\n          : this.viewOptions.floor! + this.dragging.difference;\n      }\n    } else {\n      if (isRTL) {\n        value =\n          this.positionToValue(newPos + this.dragging.lowLimit) +\n          this.dragging.difference;\n      } else {\n        value =\n          this.positionToValue(newPos - this.dragging.lowLimit) +\n          this.dragging.difference;\n      }\n    }\n\n    return this.roundStep(value);\n  }\n\n  private onDragMove(event?: MouseEvent | TouchEvent): void {\n    const newPos: number = this.getEventPosition(event!);\n\n    if (this.viewOptions.animate && !this.viewOptions.animateOnMove) {\n      if (this.moving) {\n        this.sliderElementAnimateClass = false;\n      }\n    }\n\n    this.moving = true;\n\n    let ceilLimit: number,\n      floorLimit: number,\n      floorHandleElement: SliderHandleDirective,\n      ceilHandleElement: SliderHandleDirective;\n    if (this.viewOptions.rightToLeft) {\n      ceilLimit = this.dragging.lowLimit;\n      floorLimit = this.dragging.highLimit;\n      floorHandleElement = this.maxHandleElement!;\n      ceilHandleElement = this.minHandleElement!;\n    } else {\n      ceilLimit = this.dragging.highLimit;\n      floorLimit = this.dragging.lowLimit;\n      floorHandleElement = this.minHandleElement!;\n      ceilHandleElement = this.maxHandleElement!;\n    }\n\n    const isUnderFloorLimit: boolean = (newPos <= floorLimit);\n    const isOverCeilLimit: boolean = (newPos >= this.maxHandlePosition - ceilLimit);\n\n    let newMinValue: number;\n    let newMaxValue: number;\n    if (isUnderFloorLimit) {\n      if (floorHandleElement.position === 0) {\n        return;\n      }\n      newMinValue = this.getMinValue(newPos, true, false);\n      newMaxValue = this.getMaxValue(newPos, true, false);\n    } else if (isOverCeilLimit) {\n      if (ceilHandleElement.position === this.maxHandlePosition) {\n        return;\n      }\n      newMaxValue = this.getMaxValue(newPos, true, true);\n      newMinValue = this.getMinValue(newPos, true, true);\n    } else {\n      newMinValue = this.getMinValue(newPos, false, false);\n      newMaxValue = this.getMaxValue(newPos, false, false);\n    }\n\n    this.positionTrackingBar(newMinValue, newMaxValue);\n  }\n\n  // Set the new value and position for the entire bar\n  private positionTrackingBar(newMinValue: number, newMaxValue: number): void {\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.minLimit) &&\n      newMinValue < this.viewOptions.minLimit!) {\n      newMinValue = this.viewOptions.minLimit!;\n      newMaxValue = MathHelper.roundToPrecisionLimit(newMinValue + this.dragging.difference, this.viewOptions.precisionLimit!);\n    }\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxLimit) &&\n      newMaxValue > this.viewOptions.maxLimit!) {\n      newMaxValue = this.viewOptions.maxLimit!;\n      newMinValue = MathHelper.roundToPrecisionLimit(newMaxValue - this.dragging.difference, this.viewOptions.precisionLimit!);\n    }\n\n    this.viewLowValue = newMinValue;\n    this.viewHighValue = newMaxValue;\n    this.applyViewChange();\n    this.updateHandles(PointerType.Min, this.valueToPosition(newMinValue));\n    this.updateHandles(PointerType.Max, this.valueToPosition(newMaxValue));\n  }\n\n  // Set the new value and position to the current tracking handle\n  private positionTrackingHandle(newValue: number): void {\n    newValue = this.applyMinMaxLimit(newValue);\n    if (this.range) {\n      if (this.viewOptions.pushRange) {\n        newValue = this.applyPushRange(newValue);\n      } else {\n        if (this.viewOptions.noSwitching) {\n          if (this.currentTrackingPointer === PointerType.Min &&\n            newValue > this.viewHighValue!) {\n            newValue = this.applyMinMaxRange(this.viewHighValue!);\n          } else if (this.currentTrackingPointer === PointerType.Max &&\n            newValue < this.viewLowValue!) {\n            newValue = this.applyMinMaxRange(this.viewLowValue!);\n          }\n        }\n        newValue = this.applyMinMaxRange(newValue);\n        /* This is to check if we need to switch the min and max handles */\n        if (this.currentTrackingPointer === PointerType.Min && newValue > this.viewHighValue!) {\n          this.viewLowValue = this.viewHighValue;\n          this.applyViewChange();\n          this.updateHandles(PointerType.Min, this.maxHandleElement!.position);\n          this.updateAriaAttributes();\n          this.currentTrackingPointer = PointerType.Max;\n          this.minHandleElement!.active = false;\n          this.maxHandleElement!.active = true;\n          if (this.viewOptions.keyboardSupport) {\n            this.maxHandleElement!.focus();\n          }\n        } else if (this.currentTrackingPointer === PointerType.Max &&\n          newValue < this.viewLowValue!) {\n          this.viewHighValue = this.viewLowValue;\n          this.applyViewChange();\n          this.updateHandles(PointerType.Max, this.minHandleElement!.position);\n          this.updateAriaAttributes();\n          this.currentTrackingPointer = PointerType.Min;\n          this.maxHandleElement!.active = false;\n          this.minHandleElement!.active = true;\n          if (this.viewOptions.keyboardSupport) {\n            this.minHandleElement!.focus();\n          }\n        }\n      }\n    }\n\n    if (this.getCurrentTrackingValue() !== newValue) {\n      if (this.currentTrackingPointer === PointerType.Min) {\n        this.viewLowValue = newValue;\n        this.applyViewChange();\n      } else if (this.currentTrackingPointer === PointerType.Max) {\n        this.viewHighValue = newValue;\n        this.applyViewChange();\n      }\n      this.updateHandles(this.currentTrackingPointer!, this.valueToPosition(newValue));\n      this.updateAriaAttributes();\n    }\n  }\n\n  private applyMinMaxLimit(newValue: number): number {\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.minLimit) && newValue < this.viewOptions.minLimit!) {\n      return this.viewOptions.minLimit!;\n    }\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxLimit) && newValue > this.viewOptions.maxLimit!) {\n      return this.viewOptions.maxLimit!;\n    }\n    return newValue;\n  }\n\n  private applyMinMaxRange(newValue: number): number {\n    const oppositeValue = (this.currentTrackingPointer === PointerType.Min)\n      ? this.viewHighValue\n      : this.viewLowValue;\n    const difference: number = Math.abs(newValue - oppositeValue!);\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.minRange)) {\n      if (difference < this.viewOptions.minRange!) {\n        if (this.currentTrackingPointer === PointerType.Min) {\n          return MathHelper.roundToPrecisionLimit(this.viewHighValue! - this.viewOptions.minRange!, this.viewOptions.precisionLimit!);\n        } else if (this.currentTrackingPointer === PointerType.Max) {\n          return MathHelper.roundToPrecisionLimit(this.viewLowValue! + this.viewOptions.minRange!, this.viewOptions.precisionLimit!);\n        }\n      }\n    }\n    if (!ValueHelper.isNullOrUndefined(this.viewOptions.maxRange)) {\n      if (difference > this.viewOptions.maxRange!) {\n        if (this.currentTrackingPointer === PointerType.Min) {\n          return MathHelper.roundToPrecisionLimit(this.viewHighValue! - this.viewOptions.maxRange!, this.viewOptions.precisionLimit!);\n        } else if (this.currentTrackingPointer === PointerType.Max) {\n          return MathHelper.roundToPrecisionLimit(this.viewLowValue! + this.viewOptions.maxRange!, this.viewOptions.precisionLimit!);\n        }\n      }\n    }\n    return newValue;\n  }\n\n  private applyPushRange(newValue: number): number {\n    const difference: number = (this.currentTrackingPointer === PointerType.Min)\n      ? this.viewHighValue! - newValue\n      : newValue - this.viewLowValue!;\n    const minRange = (!ValueHelper.isNullOrUndefined(this.viewOptions.minRange))\n      ? this.viewOptions.minRange!\n      : this.viewOptions.step!;\n    const maxRange = this.viewOptions.maxRange!;\n    // if smaller than minRange\n    if (difference < minRange) {\n      if (this.currentTrackingPointer === PointerType.Min) {\n        this.viewHighValue = MathHelper.roundToPrecisionLimit(\n          Math.min(newValue + minRange, this.viewOptions.ceil!), this.viewOptions.precisionLimit!);\n        newValue = MathHelper.roundToPrecisionLimit(this.viewHighValue - minRange, this.viewOptions.precisionLimit!);\n        this.applyViewChange();\n        this.updateHandles(PointerType.Max, this.valueToPosition(this.viewHighValue));\n      } else if (this.currentTrackingPointer === PointerType.Max) {\n        this.viewLowValue = MathHelper.roundToPrecisionLimit(\n          Math.max(newValue - minRange, this.viewOptions.floor!), this.viewOptions.precisionLimit!);\n        newValue = MathHelper.roundToPrecisionLimit(this.viewLowValue + minRange, this.viewOptions.precisionLimit!);\n        this.applyViewChange();\n        this.updateHandles(PointerType.Min, this.valueToPosition(this.viewLowValue));\n      }\n      this.updateAriaAttributes();\n    } else if (!ValueHelper.isNullOrUndefined(maxRange) && difference > maxRange) {\n      // if greater than maxRange\n      if (this.currentTrackingPointer === PointerType.Min) {\n        this.viewHighValue = MathHelper.roundToPrecisionLimit(newValue + maxRange, this.viewOptions.precisionLimit!);\n        this.applyViewChange();\n        this.updateHandles(PointerType.Max, this.valueToPosition(this.viewHighValue)\n        );\n      } else if (this.currentTrackingPointer === PointerType.Max) {\n        this.viewLowValue = MathHelper.roundToPrecisionLimit(newValue - maxRange, this.viewOptions.precisionLimit!);\n        this.applyViewChange();\n        this.updateHandles(PointerType.Min, this.valueToPosition(this.viewLowValue));\n      }\n      this.updateAriaAttributes();\n    }\n    return newValue;\n  }\n\n  private getChangeContext(): ChangeContext {\n    const changeContext: ChangeContext = new ChangeContext();\n    changeContext.pointerType = this.currentTrackingPointer;\n    changeContext.value = +this.value!;\n    if (this.range) {\n      changeContext.highValue = +this.highValue!;\n    }\n    return changeContext;\n  }\n}","<!-- // 0 Left selection bar outside two handles -->\n<span ngxSliderElement #leftOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-left-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 1 Right selection bar outside two handles -->\n<span ngxSliderElement #rightOuterSelectionBar class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-right-out-selection\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 2 The whole slider bar -->\n<span ngxSliderElement #fullBar [class.ngx-slider-transparent]=\"fullBarTransparentClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-full-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar\"></span>\n</span>\n<!-- // 3 Selection bar between two handles -->\n<span ngxSliderElement #selectionBar [class.ngx-slider-draggable]=\"selectionBarDraggableClass\" class=\"ngx-slider-span ngx-slider-bar-wrapper ngx-slider-selection-bar\">\n  <span class=\"ngx-slider-span ngx-slider-bar ngx-slider-selection\" [ngStyle]=\"barStyle\"></span>\n</span>\n<!-- // 4 Low slider handle -->\n<span ngxSliderHandle #minHandle class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-min\" [ngStyle]=minPointerStyle></span>\n<!-- // 5 High slider handle -->\n<span ngxSliderHandle #maxHandle [style.display]=\"range ? 'inherit' : 'none'\" class=\"ngx-slider-span ngx-slider-pointer ngx-slider-pointer-max\" [ngStyle]=maxPointerStyle></span>\n<!-- // 6 Floor label -->\n<span ngxSliderLabel #floorLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-floor\"></span>\n<!-- // 7 Ceiling label -->\n<span ngxSliderLabel #ceilLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-limit ngx-slider-ceil\"></span>\n<!-- // 8 Label above the low slider handle -->\n<span ngxSliderLabel #minHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-value\"></span>\n<!-- // 9 Label above the high slider handle -->\n<span ngxSliderLabel #maxHandleLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-model-high\"></span>\n<!-- // 10 Combined range label when the slider handles are close ex. 15 - 17 -->\n<span ngxSliderLabel #combinedLabel class=\"ngx-slider-span ngx-slider-bubble ngx-slider-combined\"></span>\n<!-- // 11 The ticks -->\n<span ngxSliderElement #ticksElement [hidden]=\"!showTicks\" [class.ngx-slider-ticks-values-under]=\"ticksUnderValuesClass\" class=\"ngx-slider-ticks\">\n  <span *ngFor=\"let t of ticks\" class=\"ngx-slider-tick\" [ngClass]=\"{'ngx-slider-selected': t.selected}\" [ngStyle]=\"t.style\">\n    <ngx-slider-tooltip-wrapper [template]=\"tooltipTemplate\" [tooltip]=\"t.tooltip\" [placement]=\"t.tooltipPlacement\"></ngx-slider-tooltip-wrapper>\n    <ngx-slider-tooltip-wrapper *ngIf=\"t.value !== null\" class=\"ngx-slider-span ngx-slider-tick-value\"\n        [template]=\"tooltipTemplate\" [tooltip]=\"t.valueTooltip\" [placement]=\"t.valueTooltipPlacement\" [content]=\"t.value\"></ngx-slider-tooltip-wrapper>\n    <span *ngIf=\"t.legend !== null\" class=\"ngx-slider-span ngx-slider-tick-legend\" [innerHTML]=\"t.legend\"></span>\n  </span>\n</span>"]}