@pipsend/charts 2.3.18 → 2.3.20

package/dist/pipsend-charts.development.mjs

@@ -1,6 +1,6 @@
 /*!
  * @license
- * Pipsend Charts v2.3.18-dev+202610170141
+ * Pipsend Charts v2.3.20-dev+202610211649
  * Copyright (c) 2026 Pipsend
  * Licensed under MIT License
  * Built on TradingView Lightweight Charts™ (Apache 2.0)
@@ -5554,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, (mark, barsPerMark) => this._private__horzScaleBehavior.allowsTickMark?.(mark, barsPerMark) ?? true);
+        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, this._private__points[mark.index - 1]) ?? 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"
@@ -6828,6 +6828,75 @@ function defaultTickMarkFormatter(timePoint, tickMarkType, locale) {
     return localDateFromUtc.toLocaleString(locale, formatOptions);
 }
 
+const DAY = 86400;
+const QUARTER_HOUR = 900;
+const zones = new Map();
+function zoneCache(timeZone) {
+    let cache = zones.get(timeZone);
+    if (cache === undefined) {
+        let format = null;
+        try {
+            format = new Intl.DateTimeFormat('en-US', {
+                timeZone,
+                hourCycle: 'h23',
+                year: 'numeric',
+                month: 'numeric',
+                day: 'numeric',
+                hour: 'numeric',
+                minute: 'numeric',
+                second: 'numeric',
+            });
+        }
+        catch (error) {
+            format = null;
+        }
+        cache = { _internal_format: format, _internal_days: new Map(), _internal_quarters: new Map() };
+        zones.set(timeZone, cache);
+    }
+    return cache;
+}
+function exactOffset(format, time) {
+    const parts = format.formatToParts(new Date(time * 1000));
+    const part = (type) => Number(parts.find((p) => p.type === type)?.value ?? 0);
+    const wallClock = Date.UTC(part('year'), part('month') - 1, part('day'), part('hour') % 24, part('minute'), part('second'));
+    return Math.round(wallClock / 1000 - time);
+}
+/**
+ * Offset of `timeZone` from UTC at `time`, in seconds. Undefined, `'UTC'` and
+ * unknown zones are 0.
+ *
+ * Resolved once per UTC day, and to the quarter hour only on days with a
+ * transition: asking `Intl` for every bar is too slow for a whole series.
+ */
+function timeZoneOffset(timeZone, time) {
+    if (timeZone === undefined || timeZone === 'UTC') {
+        return 0;
+    }
+    const cache = zoneCache(timeZone);
+    const format = cache._internal_format;
+    if (format === null) {
+        return 0;
+    }
+    const day = Math.floor(time / DAY);
+    let wholeDay = cache._internal_days.get(day);
+    if (wholeDay === undefined) {
+        const start = exactOffset(format, day * DAY);
+        const end = exactOffset(format, (day + 1) * DAY - 1);
+        wholeDay = start === end ? start : null;
+        cache._internal_days.set(day, wholeDay);
+    }
+    if (wholeDay !== null) {
+        return wholeDay;
+    }
+    const quarter = Math.floor(time / QUARTER_HOUR);
+    let offset = cache._internal_quarters.get(quarter);
+    if (offset === undefined) {
+        offset = exactOffset(format, quarter * QUARTER_HOUR);
+        cache._internal_quarters.set(quarter, offset);
+    }
+    return offset;
+}
+
 function hours(count) {
     return count * 60 * 60 * 1000;
 }
@@ -6867,29 +6936,36 @@ function weightByTime(currentDate, prevDate) {
 function cast(t) {
     return t;
 }
-function fillWeightsForPoints(sortedTimePoints, startIndex = 0) {
+// Business days are dates, not instants: never shifted
+function zonedTimestamp(point, timeZone) {
+    const time = cast(point.time);
+    return time._internal_businessDay === undefined ? time._internal_timestamp + timeZoneOffset(timeZone, time._internal_timestamp) : time._internal_timestamp;
+}
+function fillWeightsForPoints(sortedTimePoints, startIndex = 0, timeZone) {
     if (sortedTimePoints.length === 0) {
         return;
     }
-    let prevTime = startIndex === 0 ? null : cast(sortedTimePoints[startIndex - 1].time)._internal_timestamp;
+    let prevTime = startIndex === 0 ? null : zonedTimestamp(sortedTimePoints[startIndex - 1], timeZone);
     let prevDate = prevTime !== null ? new Date(prevTime * 1000) : null;
     let totalTimeDiff = 0;
     for (let index = startIndex; index < sortedTimePoints.length; ++index) {
         const currentPoint = sortedTimePoints[index];
-        const currentDate = new Date(cast(currentPoint.time)._internal_timestamp * 1000);
+        const currentTime = zonedTimestamp(currentPoint, timeZone);
+        const currentDate = new Date(currentTime * 1000);
         if (prevDate !== null) {
             currentPoint.timeWeight = weightByTime(currentDate, prevDate);
         }
-        totalTimeDiff += cast(currentPoint.time)._internal_timestamp - (prevTime || cast(currentPoint.time)._internal_timestamp);
-        prevTime = cast(currentPoint.time)._internal_timestamp;
+        totalTimeDiff += currentTime - (prevTime || currentTime);
+        prevTime = currentTime;
         prevDate = currentDate;
     }
     if (startIndex === 0 && sortedTimePoints.length > 1) {
         // let's guess a weight for the first point
         // let's say the previous point was average time back in the history
         const averageTimeDiff = Math.ceil(totalTimeDiff / (sortedTimePoints.length - 1));
-        const approxPrevDate = new Date((cast(sortedTimePoints[0].time)._internal_timestamp - averageTimeDiff) * 1000);
-        sortedTimePoints[0].timeWeight = weightByTime(new Date(cast(sortedTimePoints[0].time)._internal_timestamp * 1000), approxPrevDate);
+        const firstTime = zonedTimestamp(sortedTimePoints[0], timeZone);
+        const approxPrevDate = new Date((firstTime - averageTimeDiff) * 1000);
+        sortedTimePoints[0].timeWeight = weightByTime(new Date(firstTime * 1000), approxPrevDate);
     }
 }
 
@@ -7044,16 +7120,15 @@ class HorzScaleBehaviorTime {
         }
     }
     formatHorzItem(item) {
-        const tp = item;
-        return this._private__dateTimeFormatter._internal_format(new Date(tp._internal_timestamp * 1000));
+        return this._private__dateTimeFormatter._internal_format(new Date(this._private__zonedTimePoint(item)._internal_timestamp * 1000));
     }
-    allowsTickMark(tickMark, barsPerMark) {
+    allowsTickMark(tickMark, barsPerMark, previous) {
         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);
+        return filter(tickMark.originalTime, tickMarkType, barsPerMark, previous === undefined ? null : previous.originalTime);
     }
     formatTickmark(tickMark, localizationOptions) {
         const tickMarkType = weightToTickMarkType(tickMark.weight, this._private__options.timeScale.timeVisible, this._private__options.timeScale.secondsVisible);
@@ -7064,7 +7139,7 @@ class HorzScaleBehaviorTime {
                 return tickMarkString;
             }
         }
-        return defaultTickMarkFormatter(tickMark.time, tickMarkType, localizationOptions.locale);
+        return defaultTickMarkFormatter(this._private__zonedTimePoint(tickMark.time), tickMarkType, localizationOptions.locale);
     }
     maxTickMarkWeight(tickMarks) {
         let maxWeight = tickMarks.reduce(markWithGreaterWeight$2, tickMarks[0]).weight;
@@ -7076,7 +7151,17 @@ class HorzScaleBehaviorTime {
         return maxWeight;
     }
     fillWeightsForPoints(sortedTimePoints, startIndex) {
-        fillWeightsForPoints(sortedTimePoints, startIndex);
+        fillWeightsForPoints(sortedTimePoints, startIndex, this._private__timeZone());
+    }
+    _private__timeZone() {
+        return this._private__options?.localization.timeZone;
+    }
+    _private__zonedTimePoint(timePoint) {
+        if (timePoint._internal_businessDay !== undefined) {
+            return timePoint;
+        }
+        const offset = timeZoneOffset(this._private__timeZone(), timePoint._internal_timestamp);
+        return offset === 0 ? timePoint : { _internal_timestamp: (timePoint._internal_timestamp + offset) };
     }
     static _internal_applyDefaults(options) {
         return merge({ localization: { dateFormat: 'dd MMM \'yy' } }, options ?? {});
@@ -10683,6 +10768,10 @@ class DataLayer {
         this._private__sortedTimePoints = [];
         this._private__horzScaleBehavior = horzScaleBehavior;
     }
+    _internal_refillTimeWeights() {
+        this._private__horzScaleBehavior.fillWeightsForPoints(this._private__sortedTimePoints, 0);
+        return this._private__sortedTimePoints;
+    }
     _internal_destroy() {
         this._private__pointDataByTimePoint.clear();
         this._private__seriesRowsBySeries.clear();
@@ -12187,7 +12276,13 @@ class ChartApi {
                 throw new Error(`colorParsers option should not be changed once the chart has been created.`);
             }
         }
+        const timeZone = this.options().localization.timeZone;
         this._private__chartWidget._internal_applyOptions(toInternalOptions(options));
+        if (this.options().localization.timeZone !== timeZone) {
+            const model = this._private__chartWidget._internal_model();
+            model._internal_timeScale()._internal_update(this._private__dataLayer._internal_refillTimeWeights(), 0);
+            model._internal_fullUpdate();
+        }
     }
     options() {
         return this._private__chartWidget._internal_options();
@@ -18825,8 +18920,9 @@ class TradingSessionsPaneView {
 const DEFAULT_SESSIONS = [
     {
         name: 'Tokyo',
-        startHour: 0,
-        endHour: 9,
+        startHour: 9,
+        endHour: 18,
+        timeZone: 'Asia/Tokyo',
         color: '#FF6B00',
         opacity: 0.1,
     },
@@ -18834,13 +18930,15 @@ const DEFAULT_SESSIONS = [
         name: 'London',
         startHour: 8,
         endHour: 17,
+        timeZone: 'Europe/London',
         color: '#2962FF',
         opacity: 0.1,
     },
     {
         name: 'New York',
-        startHour: 13,
-        endHour: 22,
+        startHour: 8,
+        endHour: 17,
+        timeZone: 'America/New_York',
         color: '#089981',
         opacity: 0.1,
     },
@@ -18926,79 +19024,49 @@ class TradingSessionsIndicator {
         }
     }
     _private__highlightSession(session, data) {
-        let sessionStart = null;
-        let sessionData = [];
-        for (const point of data) {
-            const time = point.time;
-            const hour = this._private__getUTCHour(time);
-            const isInSession = this._private__isTimeInSession(hour, session.startHour, session.endHour);
-            if (isInSession) {
-                if (!sessionStart) {
-                    sessionStart = time;
-                }
-                sessionData.push(point);
-            }
-            else {
-                if (sessionStart && sessionData.length > 0) {
-                    // End of session, create highlight box
-                    this._private__createSessionBox(sessionStart, sessionData[sessionData.length - 1].time, session);
-                    sessionStart = null;
-                    sessionData = [];
-                }
-            }
-        }
-        // Handle case where session extends to end of visible range
-        if (sessionStart && sessionData.length > 0) {
-            this._private__createSessionBox(sessionStart, sessionData[sessionData.length - 1].time, session);
-        }
+        this._private__eachRun(data, (time) => this._private__inSession(time, session), (startTime, endTime) => this._private__createSessionBox(startTime, endTime, session));
     }
+    // Per bar, since each session reads the clock of its own zone
     _private__highlightOverlaps(data) {
-        // Find overlapping sessions
         const sessions = this._private__options.sessions;
         for (let i = 0; i < sessions.length; i++) {
             for (let j = i + 1; j < sessions.length; j++) {
-                const session1 = sessions[i];
-                const session2 = sessions[j];
-                // Check if sessions overlap
-                const overlap = this._private__getSessionOverlap(session1, session2);
-                if (overlap) {
-                    this._private__highlightOverlapPeriod(overlap, data);
-                }
+                this._private__eachRun(data, (time) => this._private__inSession(time, sessions[i]) && this._private__inSession(time, sessions[j]), (startTime, endTime) => this._private__createOverlapBox(startTime, endTime));
             }
         }
     }
-    _private__getSessionOverlap(session1, session2) {
-        const start = Math.max(session1.startHour, session2.startHour);
-        const end = Math.min(session1.endHour, session2.endHour);
-        if (start < end) {
-            return { _internal_start: start, _internal_end: end };
-        }
-        return null;
-    }
-    _private__highlightOverlapPeriod(overlap, data) {
-        let overlapStart = null;
-        let overlapData = [];
+    _private__eachRun(data, inside, emit) {
+        let runStart = null;
+        let runEnd = null;
         for (const point of data) {
-            const time = point.time;
-            const hour = this._private__getUTCHour(time);
-            const isInOverlap = hour >= overlap._internal_start && hour < overlap._internal_end;
-            if (isInOverlap) {
-                if (!overlapStart) {
-                    overlapStart = time;
-                }
-                overlapData.push(point);
+            if (inside(point.time)) {
+                runStart = runStart ?? point.time;
+                runEnd = point.time;
             }
-            else {
-                if (overlapStart && overlapData.length > 0) {
-                    this._private__createOverlapBox(overlapStart, overlapData[overlapData.length - 1].time);
-                    overlapStart = null;
-                    overlapData = [];
-                }
+            else if (runStart !== null && runEnd !== null) {
+                emit(runStart, runEnd);
+                runStart = null;
+                runEnd = null;
             }
         }
-        if (overlapStart && overlapData.length > 0) {
-            this._private__createOverlapBox(overlapStart, overlapData[overlapData.length - 1].time);
+        if (runStart !== null && runEnd !== null) {
+            emit(runStart, runEnd);
+        }
+    }
+    _private__inSession(time, session) {
+        const hour = this._private__hourIn(time, session.timeZone);
+        if (session.startHour < session.endHour) {
+            return hour >= session.startHour && hour < session.endHour;
         }
+        // Crosses midnight
+        return hour >= session.startHour || hour < session.endHour;
+    }
+    _private__hourIn(time, timeZone) {
+        const seconds = typeof time === 'number' ? time : typeof time === 'string' ? Date.parse(time) / 1000 : NaN;
+        if (!Number.isFinite(seconds)) {
+            return 0;
+        }
+        return new Date((seconds + timeZoneOffset(timeZone, seconds)) * 1000).getUTCHours();
     }
     _private__createSessionBox(startTime, endTime, session) {
         // Validate times
@@ -19028,29 +19096,6 @@ class TradingSessionsIndicator {
         };
         this._private__sessionBoxes.push(box);
     }
-    _private__isTimeInSession(hour, startHour, endHour) {
-        if (startHour < endHour) {
-            return hour >= startHour && hour < endHour;
-        }
-        else {
-            // Session crosses midnight
-            return hour >= startHour || hour < endHour;
-        }
-    }
-    _private__getUTCHour(time) {
-        // Convert time to UTC hour
-        if (typeof time === 'number') {
-            // Unix timestamp in seconds
-            const date = new Date(time * 1000);
-            return date.getUTCHours();
-        }
-        else if (typeof time === 'string') {
-            // ISO string
-            const date = new Date(time);
-            return date.getUTCHours();
-        }
-        return 0;
-    }
     _private__clearSessionBoxes() {
         // Clear all session boxes
         this._private__sessionBoxes = [];
@@ -27557,6 +27602,13 @@ class BrushTool extends DrawingToolBase {
     isDrawingModeActive() {
         return this._private__drawingModeActive;
     }
+    /**
+     * A brush armed for its next stroke is not a drawing yet: it stays out of the
+     * undo history, where restoring it would re-arm a brush the app does not hold.
+     */
+    isComplete() {
+        return (this._private__brushOptions.points ?? []).length > 0;
+    }
     _private__onPointerDown(event) {
         // A press over an existing drawing belongs to that drawing: it is how the
         // user grabs or selects one without putting the brush away first.
@@ -30196,6 +30248,14 @@ function createGanttTool(context, options) {
 
 /** Undo steps kept, each a full snapshot of every drawing. */
 const UNDO_HISTORY_LIMIT = 100;
+/**
+ * Points for a restored freehand tool. Built with bracket notation: a plain
+ * `{ time, price }` literal gets its keys renamed by the build, and the tool,
+ * which reads them by their public names, comes back drawing nothing.
+ */
+function restorePoints(points) {
+    return points.map((point) => makeSerializedPoint(readSerializedNumber(point, 'price') ?? 0, readSerializedTime(point)));
+}
 /**
  * Central manager for all drawing tools - TradingView style
  * Handles multiple tools, selection, deletion, and keyboard shortcuts
@@ -30430,7 +30490,22 @@ class DrawingToolsManager {
     _private__applySnapshot(snapshot) {
         this._private__restoring = true;
         try {
-            this.restoreAll({ chart: this._private__chart, series: this._private__series }, snapshot, true);
+            // The history only holds placed drawings, so a tool still being drawn
+            // stays: undoing with the brush armed must leave it armed.
+            this._private__applySelection(null);
+            for (const [id, tool] of Array.from(this._private__tools)) {
+                if (!tool.isComplete()) {
+                    continue;
+                }
+                tool.remove();
+                this._private__tools.delete(id);
+                this._private__pendingToolIds.delete(id);
+            }
+            // Annotated, or the build renames the keys the tools read
+            const context = { chart: this._private__chart, series: this._private__series };
+            for (const data of snapshot) {
+                this.restoreTool(context, data);
+            }
             this._private__committed = snapshot;
         }
         finally {
@@ -30660,16 +30735,8 @@ class DrawingToolsManager {
                     ...style,
                 });
             case 'polygon':
-                // Bracket notation on the way out too, not just on the way in: a
-                // plain `{ time, price }` literal here gets its keys renamed and
-                // the restored corners come back empty.
                 return createPolygonTool(context, {
-                    points: points.map((_, index) => {
-                        const vertex = {};
-                        vertex['time'] = pt(index)._internal_t;
-                        vertex['price'] = pt(index)._internal_p;
-                        return vertex;
-                    }),
+                    points: restorePoints(points),
                     ...style,
                 });
             case 'crossLine':
@@ -30735,12 +30802,12 @@ class DrawingToolsManager {
                 });
             case 'arrow':
                 return createArrowTool(context, {
-                    points: points.map((p) => ({ _internal_time: p['time'], _internal_price: p['price'] })),
+                    points: restorePoints(points),
                     ...style,
                 });
             case 'brush':
                 return createBrushTool(context, {
-                    points: points.map((p) => ({ _internal_time: p['time'], _internal_price: p['price'] })),
+                    points: restorePoints(points),
                     ...style,
                 });
             case 'text':
@@ -31038,6 +31105,8 @@ class DrawingToolsManager {
         event.preventDefault();
     }
     _private__handlePointerUp(event) {
+        // A brush stroke ends here, and no click follows it to run the check
+        this._private__scheduleCompletionCheck();
         if (!this._private__isDragging || this._private__draggedToolId === null) {
             return;
         }
@@ -31210,7 +31279,7 @@ const customSeriesDefaultOptions = {
  * Returns the current version as a string. For example `'1.0.0'`.
  */
 function version() {
-    return "2.3.18-dev+202610170141";
+    return "2.3.20-dev+202610211649";
 }
 
-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, createTimeLabels, createTradingLine, createTradingSessionsIndicator, createTrendLineTool, createUpDownMarkers, createVerticalLineTool, createVolumeProfileIndicator, createYieldCurveChart, customSeriesDefaultOptions, defaultHorzScaleBehavior, getPipConfig, hideSeriesPaint, isBusinessDay, isUTCTimestamp, setSeriesVolumes, setVolumeProfileData, timeFromCoordinate, version };
+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, createTimeLabels, createTradingLine, createTradingSessionsIndicator, createTrendLineTool, createUpDownMarkers, createVerticalLineTool, createVolumeProfileIndicator, createYieldCurveChart, customSeriesDefaultOptions, defaultHorzScaleBehavior, getPipConfig, hideSeriesPaint, isBusinessDay, isUTCTimestamp, setSeriesVolumes, setVolumeProfileData, timeFromCoordinate, timeZoneOffset, version };