@pipsend/charts 2.3.10 → 2.3.12

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.10
+ * Pipsend Charts v2.3.12
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -19705,6 +19705,12 @@
     }
 
     const CLICK_TOLERANCE_PX = 4;
+    /**
+     * A fingertip never holds still: every tap travels further than a pointer
+     * does, and judging it by the mouse's few pixels turned each one into a tiny
+     * drag, so the tap never arrived.
+     */
+    const TOUCH_CLICK_TOLERANCE_PX = 12;
     /**
      * Single input owner for every trading line on a chart.
      *
@@ -19723,6 +19729,8 @@
             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. */
@@ -19787,8 +19795,18 @@
             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 };
@@ -19827,14 +19845,16 @@
         }
         _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();
             this._private__pressedLine = null;
             this._private__pressOrigin = null;
+            const tolerance = wasTouch ? TOUCH_CLICK_TOLERANCE_PX : CLICK_TOLERANCE_PX;
             const moved = origin !== null &&
-                (Math.abs(event.clientX - origin._internal_x) > CLICK_TOLERANCE_PX ||
-                    Math.abs(event.clientY - origin._internal_y) > CLICK_TOLERANCE_PX);
+                (Math.abs(event.clientX - origin._internal_x) > tolerance ||
+                    Math.abs(event.clientY - origin._internal_y) > tolerance);
             if (dragged !== null) {
                 this._private__dragging = null;
                 this._private__grabOffset = 0;
@@ -19848,12 +19868,24 @@
                         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
@@ -19899,9 +19931,38 @@
             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;
             }
@@ -20018,6 +20079,7 @@
      * 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;
@@ -20070,6 +20132,14 @@
                 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;
@@ -20612,22 +20682,27 @@
         _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' };
                 }
             }
@@ -20864,8 +20939,8 @@
         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);
         }
     }
 
@@ -21016,6 +21091,13 @@
          * 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;
@@ -30086,6 +30168,7 @@
             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;
@@ -30660,10 +30743,12 @@
             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);
             }
@@ -30698,6 +30783,10 @@
                     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;
@@ -30847,6 +30936,36 @@
             // 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;
@@ -31020,7 +31139,7 @@
      * Returns the current version as a string. For example `'1.0.0'`.
      */
     function version() {
-        return "2.3.10";
+        return "2.3.12";
     }
 
     var PipsendChartsModule = /*#__PURE__*/Object.freeze({

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

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.10
+ * Pipsend Charts v2.3.12
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -19702,6 +19702,12 @@ function setVolumeProfileData(indicator, data) {
 }
 
 const CLICK_TOLERANCE_PX = 4;
+/**
+ * A fingertip never holds still: every tap travels further than a pointer
+ * does, and judging it by the mouse's few pixels turned each one into a tiny
+ * drag, so the tap never arrived.
+ */
+const TOUCH_CLICK_TOLERANCE_PX = 12;
 /**
  * Single input owner for every trading line on a chart.
  *
@@ -19720,6 +19726,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. */
@@ -19784,8 +19792,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 };
@@ -19824,14 +19842,16 @@ 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();
         this._private__pressedLine = null;
         this._private__pressOrigin = null;
+        const tolerance = wasTouch ? TOUCH_CLICK_TOLERANCE_PX : CLICK_TOLERANCE_PX;
         const moved = origin !== null &&
-            (Math.abs(event.clientX - origin._internal_x) > CLICK_TOLERANCE_PX ||
-                Math.abs(event.clientY - origin._internal_y) > CLICK_TOLERANCE_PX);
+            (Math.abs(event.clientX - origin._internal_x) > tolerance ||
+                Math.abs(event.clientY - origin._internal_y) > tolerance);
         if (dragged !== null) {
             this._private__dragging = null;
             this._private__grabOffset = 0;
@@ -19845,12 +19865,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
@@ -19896,9 +19928,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;
         }
@@ -20015,6 +20076,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;
@@ -20067,6 +20129,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;
@@ -20609,22 +20679,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' };
             }
         }
@@ -20861,8 +20936,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);
     }
 }
 
@@ -21013,6 +21088,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;
@@ -30083,6 +30165,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;
@@ -30657,10 +30740,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);
         }
@@ -30695,6 +30780,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;
@@ -30844,6 +30933,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;
@@ -31017,7 +31136,7 @@ const customSeriesDefaultOptions = {
  * Returns the current version as a string. For example `'1.0.0'`.
  */
 function version() {
-    return "2.3.10";
+    return "2.3.12";
 }
 
 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 };