@pipsend/charts 2.3.4 → 2.3.11

package/dist/pipsend-charts.standalone.development.mjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.4
+ * Pipsend Charts v2.3.11
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -2483,14 +2483,8 @@ class SeriesBarColorer {
         return this._private__styleGetter(this._private__findBar, this._private__series._internal_options(), barIndex, precomputedBars);
     }
     /**
-     * Like `barStyle`, but returns null instead of throwing when the bar is
-     * gone.
-     *
-     * Recolouring walks items that were laid out against the data as it was. A
-     * bar that has since disappeared is not an error there: the view is about
-     * to be rebuilt from the new data anyway. Letting it throw took down
-     * whatever asked for the repaint — including `setData`, which left the
-     * series without its data and the pane empty until the page was reloaded.
+     * Like `barStyle`, but null instead of throwing when the bar is gone, which
+     * a recolour of items laid out against older data can hit.
      */
     _internal_barStyleOrNull(barIndex, precomputedBars) {
         if (precomputedBars === undefined && this._private__series._internal_bars()._internal_valueAt(barIndex) === null) {
@@ -2892,7 +2886,10 @@ class SeriesPrimitivePriceAxisViewWrapper extends PriceAxisView {
         commonRendererData._internal_additionalPaddingTop = additionalPadding;
         commonRendererData._internal_additionalPaddingBottom = additionalPadding;
         commonRendererData._internal_coordinate = data._internal_coordinate;
-        commonRendererData._internal_fixedCoordinate = data._internal_fixedCoordinate;
+        // Re-runs at draw time, after the axis has moved the label clear of overlaps.
+        if (data._internal_fixedCoordinate !== undefined) {
+            commonRendererData._internal_fixedCoordinate = data._internal_fixedCoordinate;
+        }
         axisRendererData._internal_text = data._internal_text;
         axisRendererData._internal_visible = data._internal_visible;
         axisRendererData._internal_tickVisible = data._internal_tickVisible;
@@ -3769,7 +3766,6 @@ class PriceTickSpanCalculator {
     }
 }
 
-const TICK_DENSITY = 2.5;
 class PriceTickMarkBuilder {
     constructor(priceScale, base, coordinateToLogicalFunc, logicalToCoordinateFunc) {
         this._private__marks = [];
@@ -3830,7 +3826,7 @@ class PriceTickMarkBuilder {
         return this._private__priceScale._internal_fontSize();
     }
     _private__tickMarkHeight() {
-        return Math.ceil(this._private__fontHeight() * TICK_DENSITY);
+        return Math.max(1, Math.ceil(this._private__fontHeight() * this._private__priceScale._internal_options().tickMarkSpacing));
     }
     _private__updateMarks(firstValue, span, high, low, minCoord, maxCoord) {
         const marks = this._private__marks;
@@ -3995,6 +3991,9 @@ class PriceScale {
             this._private__invalidateInternalHeightCache();
             this._private__marksCache = null;
         }
+        if (options.tickMarkSpacing !== undefined) {
+            this._private__marksCache = null;
+        }
     }
     _internal_isAutoScale() {
         return this._private__options.autoScale;
@@ -5172,6 +5171,9 @@ class TickMarks {
         this._private__uniformDistribution = val;
         this._private__cache = null;
     }
+    _internal_invalidate() {
+        this._private__cache = null;
+    }
     _internal_setTimeScalePoints(newPoints, firstChangedPointIndex) {
         this._private__removeMarksSinceIndex(firstChangedPointIndex);
         this._private__cache = null;
@@ -5190,7 +5192,7 @@ class TickMarks {
             });
         }
     }
-    _internal_build(spacing, maxWidth, checkIndicesForData, indicesWithDataMap, indicesWithDataId) {
+    _internal_build(spacing, maxWidth, checkIndicesForData, indicesWithDataMap, indicesWithDataId, allows = () => true) {
         const maxIndexesPerMark = Math.ceil(maxWidth / spacing);
         if (this._private__cache === null ||
             this._private__cache._internal_maxIndexesPerMark !== maxIndexesPerMark ||
@@ -5199,7 +5201,7 @@ class TickMarks {
             this._private__cache = {
                 _internal_indicesWithDataId: indicesWithDataId,
                 _internal_checkIndicesForData: checkIndicesForData,
-                _internal_marks: this._private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap),
+                _internal_marks: this._private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap, allows),
                 _internal_maxIndexesPerMark: maxIndexesPerMark,
             };
         }
@@ -5223,7 +5225,7 @@ class TickMarks {
             this._private__marksByWeight.delete(weight);
         }
     }
-    _private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap) {
+    _private__buildMarksImpl(maxIndexesPerMark, checkIndicesForData, indicesWithDataMap, allows) {
         let marks = [];
         const canBeIncluded = (mark) => !checkIndicesForData || indicesWithDataMap.has(mark.index);
         for (const weight of Array.from(this._private__marksByWeight.keys()).sort((a, b) => b - a)) {
@@ -5241,6 +5243,11 @@ class TickMarks {
             let leftIndex = -Infinity;
             for (let i = 0; i < currentWeightLength; i++) {
                 const mark = currentWeight[i];
+                // Skipped before the fit check: a rejected mark must not count as one
+                // that did not fit, which with uniform distribution drops its whole weight.
+                if (!allows(mark, maxIndexesPerMark)) {
+                    continue;
+                }
                 const currentIndex = mark.index;
                 // Determine indexes with which current index will be compared
                 // All marks to the right is moved to new array
@@ -5547,7 +5554,7 @@ class TimeScale {
         const visibleBars = ensureNotNull(this._internal_visibleStrictRange());
         const firstBar = Math.max(visibleBars._internal_left(), visibleBars._internal_left() - indexPerLabel);
         const lastBar = Math.max(visibleBars._internal_right(), visibleBars._internal_right() - indexPerLabel);
-        const items = this._private__tickMarks._internal_build(spacing, maxLabelWidth, this._private__options.ignoreWhitespaceIndices, this._private__indicesWithData, this._private__indicesWithDataUpdateId);
+        const items = this._private__tickMarks._internal_build(spacing, maxLabelWidth, this._private__options.ignoreWhitespaceIndices, this._private__indicesWithData, this._private__indicesWithDataUpdateId, (mark, barsPerMark) => this._private__horzScaleBehavior.allowsTickMark?.(mark, barsPerMark) ?? true);
         // according to indexPerLabel value this value means "earliest index which _might be_ used as the second label on time scale"
         const earliestIndexOfSecondLabel = this._private__firstIndex() + indexPerLabel;
         // according to indexPerLabel value this value means "earliest index which _might be_ used as the second last label on time scale"
@@ -5925,6 +5932,7 @@ class TimeScale {
     _private__invalidateTickMarks() {
         this._private__resetTimeMarksCache();
         this._private__formattedByWeight.clear();
+        this._private__tickMarks._internal_invalidate();
     }
     _private__updateDateTimeFormatter() {
         this._private__horzScaleBehavior.updateFormatter(this._private__localizationOptions);
@@ -7039,6 +7047,14 @@ class HorzScaleBehaviorTime {
         const tp = item;
         return this._private__dateTimeFormatter._internal_format(new Date(tp._internal_timestamp * 1000));
     }
+    allowsTickMark(tickMark, barsPerMark) {
+        const filter = this._private__options.timeScale.tickMarkFilter;
+        if (filter === undefined) {
+            return true;
+        }
+        const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
+        return filter(tickMark.originalTime, tickMarkType, barsPerMark);
+    }
     formatTickmark(tickMark, localizationOptions) {
         const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
         const options = this._private__options.timeScale;
@@ -11443,9 +11459,6 @@ class SeriesPaneViewBase {
     _internal__updateOptions() {
         const colorer = this._internal__series._internal_barColorer();
         this._internal__items = this._internal__items.map((item) => {
-            // An item whose bar is gone keeps the colour it had. Throwing here
-            // took down whatever asked for the repaint — `setData` among them,
-            // which left the series without its data and the pane empty.
             const style = colorer._internal_barStyleOrNull(item._internal_time);
             return style === null ? item : { ...item, ...style };
         });
@@ -11748,6 +11761,7 @@ const priceScaleOptionsDefaults = {
     },
     minimumWidth: 0,
     ensureEdgeTickMarksVisible: false,
+    tickMarkSpacing: 2.5,
 };
 
 const timeScaleOptionsDefaults = {
@@ -12843,8 +12857,6 @@ class LinePaneViewBase extends SeriesPaneViewBase {
         const colorer = this._internal__series._internal_barColorer();
         this._internal__items = this._internal__series._internal_bars()._internal_rows().map((row) => {
             const value = row._internal_value[3 /* PlotRowValueIndex.Close */];
-            // The row travels with the point: without it the colorer looks it up
-            // again by index, and that lookup could fail and take the repaint down.
             return this._internal__createRawItem(row._internal_index, value, colorer, row);
         });
     }
@@ -12867,10 +12879,10 @@ styleGetter) {
         if (point) {
             const style = styleGetter(renderingScope, point);
             if (style !== prevStyle) {
-                context.beginPath();
                 if (prevStyle !== null) {
                     context.fill();
                 }
+                context.beginPath();
                 context.fillStyle = style;
                 prevStyle = style;
             }
@@ -13809,9 +13821,6 @@ class BarsPaneViewBase extends SeriesPaneViewBase {
     }
     _internal__fillRawPoints() {
         const colorer = this._internal__series._internal_barColorer();
-        // The row goes to the colorer as it is. Asking for the style by index
-        // alone made it look the row up again, and that second lookup could come
-        // back empty and throw, taking the whole repaint down with it.
         this._internal__items = this._internal__series._internal_bars()._internal_rows().map((row) => this._internal__createRawItem(row._internal_index, row, colorer));
     }
 }
@@ -17882,7 +17891,7 @@ function applyHeikinAshi(series, chart, options = {}) {
         hideSource: options.hideSource ?? true,
     };
     const sourceOptions = series.options();
-    // Same price scale and the same formatting as the source: the candles are a
+    // Same price scale, formatting and axis labels as the source: the candles are a
     // restatement of that series, not a second instrument, so they must not
     // autoscale on their own axis or round to a different precision.
     const haSeries = chart.addSeries(candlestickSeries, {
@@ -17896,6 +17905,8 @@ function applyHeikinAshi(series, chart, options = {}) {
         wickDownColor: resolved.wickDownColor,
         priceScaleId: sourceOptions.priceScaleId,
         priceFormat: sourceOptions.priceFormat,
+        lastValueVisible: sourceOptions.lastValueVisible,
+        priceLineVisible: sourceOptions.priceLineVisible,
     }, resolved.paneIndex);
     let restoreSourcePaint = null;
     const blankSource = (blank) => {
@@ -18097,12 +18108,14 @@ function applyMACD(series, chart, options = {}) {
     const macdSeries = chart.addSeries(lineSeries, {
         color: resolved.colorMACD,
     }, paneIndex);
+    // An index past the last pane opens a new one, so the rest follow MACD to where it landed.
+    const macdPane = paneIndexOf(chart, macdSeries, paneIndex);
     const signalSeries = chart.addSeries(lineSeries, {
         color: resolved.colorSignal,
-    }, paneIndex);
+    }, macdPane);
     const histogramSeries$1 = chart.addSeries(histogramSeries, {
         color: resolved.colorHistogramUp,
-    }, paneIndex);
+    }, macdPane);
     // Calculate EMA
     const calculateEMA = (prices, period) => {
         const ema = [];
@@ -18234,13 +18247,13 @@ function applyStochastic(series, chart, options = {}) {
         // Stochastic is bounded to 0-100; pinning it keeps the pane readable
         autoscaleInfoProvider: boundedScale,
     }, paneIndex);
+    // An index past the last pane opens a new one, so %D follows %K to where it landed.
+    const scalePane = paneIndexOf(chart, kSeries, paneIndex);
     // Create %D line (slow - signal)
     const dSeries = chart.addSeries(lineSeries, {
         color: resolved.colorD,
         autoscaleInfoProvider: boundedScale,
-    }, paneIndex);
-    // The pane the series landed in, which is not always the one asked for.
-    const scalePane = paneIndexOf(chart, kSeries, paneIndex);
+    }, scalePane);
     chart.priceScale(kSeries.options().priceScaleId ?? 'right', scalePane).applyOptions({
         scaleMargins: {
             top: 0.1,
@@ -18582,15 +18595,16 @@ function applyADX(series, chart, options = {}) {
         color: resolved.colorADX,
         autoscaleInfoProvider: boundedScale,
     }, paneIndex);
+    // An index past the last pane opens a new one, so the DI lines follow ADX to where it landed.
+    const scalePane = paneIndexOf(chart, adxSeries, paneIndex);
     const plusSeries = chart.addSeries(lineSeries, {
         color: resolved.colorPlusDI,
         autoscaleInfoProvider: boundedScale,
-    }, paneIndex);
+    }, scalePane);
     const minusSeries = chart.addSeries(lineSeries, {
         color: resolved.colorMinusDI,
         autoscaleInfoProvider: boundedScale,
-    }, paneIndex);
-    const scalePane = paneIndexOf(chart, adxSeries, paneIndex);
+    }, scalePane);
     chart.priceScale(adxSeries.options().priceScaleId ?? 'right', scalePane).applyOptions({
         scaleMargins: {
             top: 0.1,
@@ -19706,6 +19720,8 @@ class TradingLineController {
         this._private__pointerId = null;
         this._private__pressOrigin = null;
         this._private__pressedLine = null;
+        /** Whether the gesture in flight came from a finger rather than a mouse. */
+        this._private__pressWasTouch = false;
         /** Distance from the pointer to the dragged line when the press landed. */
         this._private__grabOffset = 0;
         /** Latest pointer position in pane coordinates, or null when off the panes. */
@@ -19770,8 +19786,18 @@ class TradingLineController {
         this._private__applyCursor();
     }
     _private__onPointerDown(event) {
-        const line = this._private__hoveredId === null ? null : this._private__lines.get(this._private__hoveredId) ?? null;
+        // Hover belongs to the mouse. Touch leaves whatever the last press marked
+        // still marked, so trusting it here grabbed that line again wherever the
+        // next tap landed: every press resolves itself instead.
+        this._private__pressWasTouch = event.pointerType !== 'mouse';
+        let line = this._private__pressWasTouch || this._private__hoveredId === null
+            ? null
+            : this._private__lines.get(this._private__hoveredId) ?? null;
+        if (line === null) {
+            line = this._private__resolveHitAt(event);
+        }
         if (!line) {
+            this._private__clearTouchHover();
             return;
         }
         this._private__pressOrigin = { _internal_x: event.clientX, _internal_y: event.clientY };
@@ -19810,6 +19836,7 @@ class TradingLineController {
     }
     _private__onPointerUp(event) {
         const dragged = this._private__dragging;
+        const wasTouch = this._private__pressWasTouch;
         const pressed = this._private__pressedLine;
         const origin = this._private__pressOrigin;
         this._private__releasePointer();
@@ -19831,12 +19858,24 @@ class TradingLineController {
                     dragged.click();
                 }
             }
+            this._private__clearTouchHover(wasTouch);
             this._private__applyCursor();
             return;
         }
         if (pressed !== null && !moved && pressed.isClickable()) {
             pressed.click();
         }
+        this._private__clearTouchHover(wasTouch);
+    }
+    /** A finger leaves nothing hovered behind it, the way lifting a mouse does. */
+    _private__clearTouchHover(wasTouch = this._private__pressWasTouch) {
+        if (!wasTouch || this._private__hoveredId === null) {
+            return;
+        }
+        const line = this._private__lines.get(this._private__hoveredId) ?? null;
+        this._private__setHovered(null);
+        this._private__setHoveredPart(line, null);
+        this._private__applyCursor();
     }
     /**
      * Abort an in-flight gesture: the line goes back to where it was and no
@@ -19882,9 +19921,38 @@ class TradingLineController {
         return paneY === null ? null : line.priceAt(paneY - this._private__grabOffset);
     }
     /** The pointer's position inside the line's pane, in pane coordinates. */
-    _private__paneY(line, event) {
+    /**
+     * The hovered id comes from the crosshair, which touch never moves before it
+     * presses, so the press resolves the target itself.
+     */
+    _private__resolveHitAt(event) {
+        for (const line of this._private__lines.values()) {
+            if (!line.hitTestAt) {
+                continue;
+            }
+            const paneElement = this._private__paneElementOf(line);
+            if (paneElement === null) {
+                continue;
+            }
+            const rect = paneElement.getBoundingClientRect();
+            // A fingertip is far coarser than a pointer, so its targets are widened.
+            const slop = event.pointerType === 'mouse' ? 0 : 12 /* Constants.TouchSlopPx */;
+            const hit = this._private__splitHit(line.hitTestAt(event.clientX - rect.left, event.clientY - rect.top, slop));
+            if (hit === null) {
+                continue;
+            }
+            this._private__setHovered(line.id());
+            this._private__setHoveredPart(line, hit._internal_part);
+            return line;
+        }
+        return null;
+    }
+    _private__paneElementOf(line) {
         const pane = this._private__chart.panes()[line.paneIndex()];
-        const paneElement = pane ? pane.getHTMLElement() : null;
+        return pane ? pane.getHTMLElement() : null;
+    }
+    _private__paneY(line, event) {
+        const paneElement = this._private__paneElementOf(line);
         if (paneElement) {
             return event.clientY - paneElement.getBoundingClientRect().top;
         }
@@ -20001,6 +20069,7 @@ let nextLineId = 0;
  * line. Hit testing comes from the engine — the line's id travels as the price
  * line's `externalId` — so the hit area matches what is drawn.
  */
+const HIT_TOLERANCE_PX$1 = 8;
 class DraggablePriceLine {
     constructor(chart, series, options) {
         this._private__priceLine = null;
@@ -20053,6 +20122,14 @@ class DraggablePriceLine {
             color: hovered ? this._private__options.hoverColor : this._private__originalColor,
         });
     }
+    /**
+     * The engine draws this one, so there is no pane view to ask: a press within
+     * the line's own grab strip counts as a hit.
+     */
+    hitTestAt(x, y, slop = 0) {
+        const coord = this._private__series.priceToCoordinate(this._private__options.price);
+        return coord !== null && Math.abs(y - coord) <= HIT_TOLERANCE_PX$1 + slop ? this._private__id : null;
+    }
     priceAt(paneY) {
         const price = this._private__series.coordinateToPrice(paneY);
         return price === null ? null : price;
@@ -20595,22 +20672,27 @@ class PositionLineRenderer {
     _internal_setData(data) {
         this._private__data = data;
     }
-    _internal_hitTest(x, y) {
+    /**
+     * `slop` widens every target by the same amount, for input coarser than a
+     * mouse pointer.
+     */
+    _internal_hitTest(x, y, slop = 0) {
         // The close button sits on top of the label, which sits on top of the
         // line, so the narrowest target is tested first.
         for (const layout of this._private__layouts) {
-            if (layout._internal_closable && x >= layout._internal_closeLeft && x <= layout._internal_closeRight &&
-                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2) {
+            if (layout._internal_closable && x >= layout._internal_closeLeft - slop && x <= layout._internal_closeRight + slop &&
+                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2 + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'close' };
             }
         }
         for (const layout of this._private__layouts) {
-            if (x >= layout._internal_pillLeft && x <= layout._internal_pillRight && Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2) {
+            if (x >= layout._internal_pillLeft - slop && x <= layout._internal_pillRight + slop &&
+                Math.abs(y - layout._internal_labelY) <= layout._internal_height / 2 + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'body' };
             }
         }
         for (const layout of this._private__layouts) {
-            if (Math.abs(y - layout._internal_y) <= 8 /* Constants.LineHitTolerance */) {
+            if (Math.abs(y - layout._internal_y) <= 8 /* Constants.LineHitTolerance */ + slop) {
                 return { _internal_level: layout._internal_level, _internal_part: 'line' };
             }
         }
@@ -20847,8 +20929,8 @@ class PositionLinePaneView {
     zOrder() {
         return 'top';
     }
-    _internal_hitTest(x, y) {
-        return this._private__data === null ? null : this._private__renderer._internal_hitTest(x, y);
+    _internal_hitTest(x, y, slop = 0) {
+        return this._private__data === null ? null : this._private__renderer._internal_hitTest(x, y, slop);
     }
 }
 
@@ -20999,6 +21081,13 @@ class PositionLine {
      * of jumping to sit under it — which matters most when the label has been
      * fanned away from its own line.
      */
+    hitTestAt(x, y, slop = 0) {
+        const hit = this._private__paneView._internal_hitTest(x, y, slop);
+        if (hit === null) {
+            return null;
+        }
+        return this._private__levelOptions(hit._internal_level) === null ? null : `${this._private__id}#${hit._internal_level}:${hit._internal_part}`;
+    }
     dragAnchorY() {
         if (this._private__dragLevel === null) {
             return null;
@@ -30069,6 +30158,7 @@ class DrawingToolsManager {
         this._private__mouseMoveHandler = null;
         this._private__pointerDownHandler = null;
         this._private__pointerUpHandler = null;
+        this._private__pointerMoveHandler = null;
         this._private__pointerCancelHandler = null;
         this._private__lostCaptureHandler = null;
         this._private__windowPointerUpHandler = null;
@@ -30643,10 +30733,12 @@ class DrawingToolsManager {
         if (chartElement) {
             this._private__pointerDownHandler = (event) => this._private__handlePointerDown(event);
             this._private__pointerUpHandler = (event) => this._private__handlePointerUp(event);
+            this._private__pointerMoveHandler = (event) => this._private__handlePointerMove(event);
             this._private__pointerCancelHandler = (event) => this._private__handlePointerUp(event);
             this._private__lostCaptureHandler = (event) => this._private__handleLostPointerCapture(event);
             chartElement.addEventListener('pointerdown', this._private__pointerDownHandler);
             chartElement.addEventListener('pointerup', this._private__pointerUpHandler);
+            chartElement.addEventListener('pointermove', this._private__pointerMoveHandler);
             chartElement.addEventListener('pointercancel', this._private__pointerCancelHandler);
             chartElement.addEventListener('lostpointercapture', this._private__lostCaptureHandler);
         }
@@ -30681,6 +30773,10 @@ class DrawingToolsManager {
                 chartElement.removeEventListener('pointerup', this._private__pointerUpHandler);
                 this._private__pointerUpHandler = null;
             }
+            if (this._private__pointerMoveHandler) {
+                chartElement.removeEventListener('pointermove', this._private__pointerMoveHandler);
+                this._private__pointerMoveHandler = null;
+            }
             if (this._private__pointerCancelHandler) {
                 chartElement.removeEventListener('pointercancel', this._private__pointerCancelHandler);
                 this._private__pointerCancelHandler = null;
@@ -30830,6 +30926,36 @@ class DrawingToolsManager {
         // mouse events, and those are what drive the crosshair the drag reads.
         this._private__disableChartInteractions();
     }
+    /**
+     * The drag reads the crosshair, which touch never moves: its move handler
+     * only tries to pan, and the drag has just turned panning off. So touch is
+     * driven straight from the pointer instead.
+     */
+    _private__handlePointerMove(event) {
+        if (!this._private__isDragging || this._private__draggedToolId === null || event.pointerType === 'mouse') {
+            return;
+        }
+        if (this._private__pointerId !== null && event.pointerId !== this._private__pointerId) {
+            return;
+        }
+        const tool = this._private__tools.get(this._private__draggedToolId);
+        if (!tool) {
+            return;
+        }
+        const paneElement = this._private__paneElementOf(tool);
+        if (paneElement === null) {
+            return;
+        }
+        const rect = paneElement.getBoundingClientRect();
+        const series = tool.series();
+        const price = series.coordinateToPrice((event.clientY - rect.top));
+        const time = timeFromCoordinate(this._private__chart, series, event.clientX - rect.left);
+        if (price === null || time === null) {
+            return;
+        }
+        tool.updateDrag(time, price);
+        event.preventDefault();
+    }
     _private__handlePointerUp(event) {
         if (!this._private__isDragging || this._private__draggedToolId === null) {
             return;
@@ -31003,7 +31129,7 @@ const customSeriesDefaultOptions = {
  * Returns the current version as a string. For example `'1.0.0'`.
  */
 function version() {
-    return "2.3.4";
+    return "2.3.11";
 }
 
 export { areaSeries as AreaSeries, ArrowTool, barSeries as BarSeries, baselineSeries as BaselineSeries, BrushTool, candlestickSeries as CandlestickSeries, CircleTool, ColorType, CrossLineTool, CrosshairMode, DEFAULT_SESSIONS, DraggablePriceLine, DrawingToolsManager, EXTENDED_FIBONACCI_RATIOS, FibonacciCalculator, FibonacciExtensionTool, FibonacciFanTool, FibonacciTool, GanttTool, histogramSeries as HistogramSeries, HorizontalLineTool, InteractiveLineManager, LastPriceAnimationMode, lineSeries as LineSeries, LineStyle, LineType, MismatchDirection, ParallelChannelTool, PitchforkTool, PolygonTool, PositionCalculator, PositionLine, PositionMarkersManager, PositionTool, PriceLineSource, PriceScaleMode, RectangleTool, RulerCalculator, RulerTool, STANDARD_FIBONACCI_RATIOS, TextTool, TickMarkType, TrackingModeExitMode, TradingSessionsIndicator, TrendLineTool, VerticalLineTool, VolumeProfileIndicator, applyADX, applyATR, applyBollingerBands, applyCCI, applyDonchianChannels, applyEMA, applyHeikinAshi, applyIchimoku, applyKeltnerChannels, applyMACD, applyMFI, applyOBV, applyParabolicSAR, applyPivotPoints, applyRSI, applySMA, applyStochastic, applySuperTrend, applyVWAP, applyVolume, applyWMA, applyWilliamsR, calculateHeikinAshi, calculatePipConfig, coordinateFromTime, createArrowTool, createBrushTool, createChart, createChartEx, createCircleTool, createCrossLineTool, createFibonacciExtensionTool, createFibonacciFanTool, createFibonacciTool, createGanttTool, createHorizontalLineTool, createImageWatermark, createInteractiveLineManager, createOptionsChart, createParallelChannelTool, createPitchforkTool, createPolygonTool, createPositionLine, createPositionMarkers, createPositionTool, createRectangleTool, createRulerTool, createSeriesMarkers, createTextTool, createTextWatermark, createTradingLine, createTradingSessionsIndicator, createTrendLineTool, createUpDownMarkers, createVerticalLineTool, createVolumeProfileIndicator, createYieldCurveChart, customSeriesDefaultOptions, defaultHorzScaleBehavior, getPipConfig, hideSeriesPaint, isBusinessDay, isUTCTimestamp, setSeriesVolumes, setVolumeProfileData, timeFromCoordinate, version };