diff --git a/website/packages/lightweight-charts/types.d.ts b/website/packages/lightweight-charts/types.d.ts
index a15bd5132..4da1bc23b 100644
--- a/website/packages/lightweight-charts/types.d.ts
+++ b/website/packages/lightweight-charts/types.d.ts
@@ -12,7 +12,7 @@ import {
   ISeriesApi,
   BaselineData,
 } from "./v4.2.0/types";
-import { Color } from "../../scripts/types/self";
+import { Color, ValuedCandlestickData } from "../../scripts/types/self";
 
 interface BaseSeriesBlueprint {
   title: string;
@@ -69,11 +69,13 @@ interface BaseSeries {
 }
 interface SingleSeries extends BaseSeries {
   iseries: ISeriesApi<any>;
+  dataset: Accessor<(SingleValueData | ValuedCandlestickData)[] | null>;
 }
 interface SplitSeries extends BaseSeries {
   chunks: Array<Accessor<ISeriesApi<SeriesType> | undefined>>;
   dataset: ResourceDataset<TimeScale, number>;
 }
+type AnySeries = SingleSeries | SplitSeries;
 
 interface CreateSingleSeriesParameters {
   blueprint: SingleSeriesBlueprint;
@@ -85,7 +87,6 @@ interface CreateSplitSeriesParameters<S extends TimeScale> {
   blueprint: SplitSeriesBlueprint;
   id: string;
   index: number;
-  setMinMaxMarkersWhenIdle: VoidFunction;
   disabled?: Accessor<boolean>;
 }
 
@@ -98,6 +99,8 @@ type ChartPane = IChartApi & {
   createSplitSeries: <S extends TimeScale>(
     a: CreateSplitSeriesParameters<S>,
   ) => SplitSeries;
+  anySeries: AnySeries[];
+  singleSeries: SingleSeries[];
   splitSeries: SplitSeries[];
 };
 
@@ -118,5 +121,5 @@ interface Marker {
 
 interface HoveredLegend {
   label: HTMLLabelElement;
-  series: SingleSeries | SplitSeries;
+  series: AnySeries;
 }
diff --git a/website/packages/lightweight-charts/wrapper.js b/website/packages/lightweight-charts/wrapper.js
index 1a6722496..9e55d6bcd 100644
--- a/website/packages/lightweight-charts/wrapper.js
+++ b/website/packages/lightweight-charts/wrapper.js
@@ -393,10 +393,10 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
 
       if (urlFrom && urlTo) {
         if (scale === "date" && urlFrom.includes("-") && urlTo.includes("-")) {
-          console.log({
-            from: new Date(urlFrom).toJSON().split("T")[0],
-            to: new Date(urlTo).toJSON().split("T")[0],
-          });
+          // console.log({
+          //   from: new Date(urlFrom).toJSON().split("T")[0],
+          //   to: new Date(urlTo).toJSON().split("T")[0],
+          // });
           return {
             from: new Date(urlFrom).toJSON().split("T")[0],
             to: new Date(urlTo).toJSON().split("T")[0],
@@ -405,10 +405,10 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
           scale === "height" &&
           (!urlFrom.includes("-") || !urlTo.includes("-"))
         ) {
-          console.log({
-            from: Number(urlFrom),
-            to: Number(urlTo),
-          });
+          // console.log({
+          //   from: Number(urlFrom),
+          //   to: Number(urlTo),
+          // });
           return {
             from: Number(urlFrom),
             to: Number(urlTo),
@@ -426,7 +426,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
 
       const savedTimeRange = getSavedTimeRange();
 
-      console.log(savedTimeRange);
+      // console.log(savedTimeRange);
 
       if (savedTimeRange) {
         return savedTimeRange;
@@ -527,7 +527,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
     const notHoveredLegendTransparency = "66";
     /**
      * @param {Object} args
-     * @param {SingleSeries | SplitSeries} args.series
+     * @param {AnySeries} args.series
      * @param {string} [args.extraName]
      */
     function createLegend({ series, extraName }) {
@@ -694,7 +694,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
       }
       createHoverEffect();
 
-      if ("dataset" in series) {
+      if ("dataset" in series && "url" in series.dataset) {
         const anchor = window.document.createElement("a");
         anchor.href = series.dataset.url;
         anchor.target = "_blank";
@@ -730,9 +730,6 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
       chartDiv.classList.add("lightweight-chart");
       chartWrapper.append(chartDiv);
 
-      /** @type {SplitSeries[]} */
-      const paneSplitSeries = [];
-
       options = { ...options };
       if (kind === "static") {
         options.handleScale = false;
@@ -928,15 +925,17 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
               utils.url.removeParam(paramKey);
               utils.storage.remove(storageKey);
             }
+
+            setMinMaxMarkersWhenIdle();
           },
         );
 
         return series;
       }
 
-      const chartPane = /** @type {ChartPane} */ (_chart);
+      const pane = /** @type {ChartPane} */ (_chart);
 
-      chartPane.createSingleSeries = function ({ blueprint, id }) {
+      pane.createSingleSeries = function ({ blueprint, id }) {
         /** @type {ISeriesApi<SeriesType>} */
         let s;
 
@@ -965,6 +964,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
             defaultActive: blueprint.defaultActive,
           }),
           iseries: s,
+          dataset: blueprint.data || (() => /** @type {any} */ ([])),
         };
 
         signals.createEffect(series.visible, (visible) => {
@@ -975,13 +975,15 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
 
         createLegend({ series });
 
+        pane.singleSeries.push(series);
+        pane.anySeries.push(series);
+
         return series;
       };
-      chartPane.createSplitSeries = function ({
+      pane.createSplitSeries = function ({
         id,
         index: seriesIndex,
         disabled,
-        setMinMaxMarkersWhenIdle,
         dataset,
         blueprint,
       }) {
@@ -998,7 +1000,8 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
           chunks: new Array(dataset.fetchedJSONs.length),
         };
 
-        paneSplitSeries.push(series);
+        pane.splitSeries.push(series);
+        pane.anySeries.push(series);
         chartSplitSeries.unshift(series);
 
         dataset.fetchedJSONs.forEach((json, index) => {
@@ -1011,7 +1014,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
           const isMyTurn = signals.createMemo(() => {
             if (seriesIndex <= 0) return true;
 
-            const previousSeriesChunk = paneSplitSeries.at(seriesIndex - 1)
+            const previousSeriesChunk = pane.splitSeries.at(seriesIndex - 1)
               ?.chunks[index];
             const isPreviousSeriesOnChart = previousSeriesChunk?.();
 
@@ -1139,30 +1142,38 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
 
         return series;
       };
-      chartPane.hidden = () => {
+      pane.hidden = () => {
         return chartWrapper.hidden;
       };
-      chartPane.setHidden = (b) => {
+      pane.setHidden = (b) => {
         chartWrapper.hidden = b;
       };
-      chartPane.splitSeries = paneSplitSeries;
-      chartPane.setInitialVisibleTimeRange = () => {
+      pane.splitSeries = [];
+      pane.singleSeries = [];
+      pane.anySeries = [];
+      pane.setInitialVisibleTimeRange = function () {
         const range = visibleTimeRange();
 
         if (range) {
-          chartPane.timeScale().setVisibleRange(/** @type {any} */ (range));
+          pane.timeScale().setVisibleRange(/** @type {any} */ (range));
 
           // On small screen it doesn't it might not set it  in time
           setTimeout(() => {
             try {
-              chartPane.timeScale().setVisibleRange(/** @type {any} */ (range));
+              pane.timeScale().setVisibleRange(/** @type {any} */ (range));
             } catch {}
           }, 50);
         }
       };
+      pane.remove = function () {
+        _chart.remove();
+        pane.splitSeries.length = 0;
+        pane.singleSeries.length = 0;
+        pane.anySeries.length = 0;
+      };
 
       if (whitespace) {
-        chartPane.whitespace = setWhitespace({ chart: _chart, scale, utils });
+        pane.whitespace = setWhitespace({ chart: _chart, scale, utils });
       }
 
       function createUnitAndModeElements() {
@@ -1206,23 +1217,32 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
       switch (kind) {
         case "static": {
           config?.forEach((params) => {
-            chartPane.createSingleSeries({
+            pane.createSingleSeries({
               id: utils.stringToId(params.title),
               blueprint: params,
             });
           });
 
-          chartPane.timeScale().fitContent();
+          pane.timeScale().fitContent();
+
+          if (!paneIndex) {
+            setTimeout(() => {
+              pane.timeScale().subscribeVisibleTimeRangeChange((range) => {
+                if (!range) return;
+                visibleTimeRange.set(range);
+              });
+            });
+          }
 
           break;
         }
         case "moveable": {
-          chartPane.setInitialVisibleTimeRange();
+          pane.setInitialVisibleTimeRange();
           updateVisibleDatasetIds();
 
           if (!paneIndex) {
             setTimeout(() => {
-              chartPane.timeScale().subscribeVisibleTimeRangeChange((range) => {
+              pane.timeScale().subscribeVisibleTimeRangeChange((range) => {
                 if (!range) return;
                 visibleTimeRange.set(range);
                 debouncedUpdateVisibleDatasetIds();
@@ -1235,9 +1255,231 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
         }
       }
 
-      panes.push(chartPane);
+      panes.push(pane);
 
-      return chartPane;
+      pane.subscribeCrosshairMove(({ time, sourceEvent }) => {
+        // Don't override crosshair position from scroll event
+        if (time && !sourceEvent) return;
+
+        for (
+          let otherChartIndex = 0;
+          otherChartIndex < panes.length;
+          otherChartIndex++
+        ) {
+          const otherPane = panes[otherChartIndex];
+
+          if (otherPane && paneIndex !== otherChartIndex) {
+            if (time) {
+              otherPane.setCrosshairPosition(NaN, time, otherPane.whitespace);
+            } else {
+              // No time when mouse goes outside the chart
+              otherPane.clearCrosshairPosition();
+            }
+          }
+        }
+      });
+
+      const chartVisible = signals.createMemo(() =>
+        pane.anySeries.some((series) => series.visible()),
+      );
+
+      function createChartVisibilityEffect() {
+        signals.createEffect(chartVisible, (chartVisible) => {
+          pane.setHidden(!chartVisible);
+        });
+      }
+      createChartVisibilityEffect();
+
+      function createTimeScaleVisibilityEffect() {
+        signals.createEffect(chartVisible, (chartVisible) => {
+          let i = paneIndex || 0;
+          const last = i === panes.length - 1;
+          const visible = last && chartVisible;
+
+          pane.timeScale().applyOptions({
+            visible,
+          });
+
+          if (i > 0 && last) {
+            panes.slice(0, -1).forEach((pane) =>
+              pane.timeScale().applyOptions({
+                visible: !visible,
+              }),
+            );
+          }
+        });
+      }
+      createTimeScaleVisibilityEffect();
+
+      pane.timeScale().subscribeVisibleLogicalRangeChange((logicalRange) => {
+        if (!logicalRange) return;
+        for (let i = 0; i < panes.length; i++) {
+          if (paneIndex !== i) {
+            panes[i].timeScale().setVisibleLogicalRange(logicalRange);
+          }
+        }
+      });
+
+      function setMinMaxMarkers() {
+        try {
+          const { from, to } = visibleTimeRange();
+
+          const dateFrom = new Date(String(from));
+          const dateTo = new Date(String(to));
+
+          let max = /** @type {Marker | undefined} */ (undefined);
+          let min = /** @type {Marker | undefined} */ (undefined);
+
+          /** @type {(SeriesMarker<Time> & Weighted) | undefined} */
+          let minMarker;
+          /** @type {(SeriesMarker<Time> & Weighted) | undefined} */
+          let maxMarker;
+
+          const ids = visibleDatasetIds();
+
+          /**
+           *
+           * @param {ISeriesApi<SeriesType> | undefined} series
+           * @param {SingleValueData<Time>[] | null | undefined} vec
+           * @returns
+           */
+          function parseSeriesValues(series, vec) {
+            if (!series || !series?.options().visible) return;
+
+            series.setMarkers([]);
+
+            const isCandlestick = series.seriesType() === "Candlestick";
+
+            if (!vec) return;
+
+            for (let k = 0; k < vec.length; k++) {
+              const data = vec[k];
+
+              let number;
+
+              if (scale === "date") {
+                const date = utils.date.fromTime(data.time);
+
+                number = date.getTime();
+
+                if (date <= dateFrom || date >= dateTo) {
+                  continue;
+                }
+              } else {
+                const height = data.time;
+
+                number = /** @type {number} */ (height);
+
+                if (height <= from || height >= to) {
+                  continue;
+                }
+              }
+
+              // @ts-ignore
+              const high = isCandlestick ? data["high"] : data.value;
+              // @ts-ignore
+              const low = isCandlestick ? data["low"] : data.value;
+
+              if (!max || high > max.value) {
+                max = {
+                  weight: number,
+                  time: data.time,
+                  value: high,
+                  seriesChunk: series,
+                };
+              }
+              if (!min || low < min.value) {
+                min = {
+                  weight: number,
+                  time: data.time,
+                  value: low,
+                  seriesChunk: series,
+                };
+              }
+            }
+          }
+
+          for (let i = 0; i < pane.singleSeries.length; i++) {
+            const series = pane.singleSeries[i];
+            parseSeriesValues(series.iseries, series.dataset());
+          }
+
+          for (let i = 0; i < pane.splitSeries.length; i++) {
+            const { chunks, dataset } = pane.splitSeries[i];
+
+            for (let j = 0; j < ids.length; j++) {
+              const id = ids[j];
+
+              const chunkIndex = utils.chunkIdToIndex(scale, id);
+
+              const chunk = chunks.at(chunkIndex)?.();
+
+              const vec = dataset.fetchedJSONs.at(chunkIndex)?.vec();
+
+              parseSeriesValues(chunk, vec);
+            }
+          }
+
+          if (min) {
+            minMarker = {
+              weight: min.weight,
+              time: min.time,
+              color: colors.default(),
+              position: "belowBar",
+              shape: "arrowUp",
+              size: 0,
+              text: utils.locale.numberToShortUSFormat(min.value),
+            };
+          }
+
+          if (max) {
+            maxMarker = {
+              weight: max.weight,
+              time: max.time,
+              color: colors.default(),
+              position: "aboveBar",
+              shape: "arrowDown",
+              size: 0,
+              text: utils.locale.numberToShortUSFormat(max.value),
+            };
+          }
+
+          if (
+            min &&
+            max &&
+            min.seriesChunk === max.seriesChunk &&
+            minMarker &&
+            maxMarker
+          ) {
+            min.seriesChunk.setMarkers(
+              [minMarker, maxMarker].sort((a, b) => a.weight - b.weight),
+            );
+          } else {
+            if (min && minMarker) {
+              min.seriesChunk.setMarkers([minMarker]);
+            }
+
+            if (max && maxMarker) {
+              max.seriesChunk.setMarkers([maxMarker]);
+            }
+          }
+        } catch (e) {}
+      }
+
+      const setMinMaxMarkersWhenIdle = () =>
+        utils.runWhenIdle(
+          () => {
+            setMinMaxMarkers();
+          },
+          pane.anySeries.length * 5 + scale === "date" ? 50 : 100,
+        );
+
+      signals.createEffect(
+        () => [visibleTimeRange(), colors.default()],
+        setMinMaxMarkersWhenIdle,
+      );
+
+      return pane;
     }
 
     config?.forEach((params) => {
@@ -1255,6 +1497,7 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
       owner = _owner;
       panes.forEach((pane) => pane.remove());
       panes.length = 0;
+      chartSplitSeries.length = 0;
       legendElement.innerHTML = "";
       panesElement.innerHTML = "";
     }
@@ -1300,23 +1543,12 @@ export default import("./v4.2.0/script.js").then((lightweightCharts) => {
     }
 
     return {
-      legendElement,
-      panesElement,
       createPane,
-      hoveredLegend,
-      createLegend,
-      panes,
       reset,
       visibleTimeRange,
       visibleDatasetIds,
-      lastVisibleDatasetIndex,
       getInitialVisibleTimeRange,
-      updateVisibleDatasetIds,
-      debouncedUpdateVisibleDatasetIds,
-      saveVisibleRange,
       getTicksToWidthRatio,
-      debouncedSaveVisibleRange,
-      splitSeries: chartSplitSeries,
     };
   }
 
diff --git a/website/scripts/chart.js b/website/scripts/chart.js
index 8e19dc2ba..26edef8f6 100644
--- a/website/scripts/chart.js
+++ b/website/scripts/chart.js
@@ -106,16 +106,10 @@ export function init({
   /**
    * @param {Object} args
    * @param {PriceSeriesType} args.type
-   * @param {VoidFunction} args.setMinMaxMarkersWhenIdle
    * @param {Option} args.option
    * @param {ChartPane} args.chartPane
    */
-  function createPriceSeries({
-    type,
-    setMinMaxMarkersWhenIdle,
-    option,
-    chartPane,
-  }) {
+  function createPriceSeries({ type, option, chartPane }) {
     const s = scale();
 
     /** @type {AnyDatasetPath} */
@@ -153,7 +147,6 @@ export function init({
       id: option.id,
       index: -1,
       disabled,
-      setMinMaxMarkersWhenIdle,
     });
 
     function createLiveCandleUpdateEffect() {
@@ -188,9 +181,6 @@ export function init({
       return s;
     });
 
-    const chartCount = 1 + (option.bottom?.length ? 1 : 0);
-    const blueprintCount =
-      1 + (option.top?.length || 0) + (option.bottom?.length || 0);
     const chartsBlueprints = [option.top || [], option.bottom].flatMap(
       (list) => (list ? [list] : []),
     );
@@ -202,166 +192,27 @@ export function init({
         whitespace: true,
       });
 
-      function setMinMaxMarkers() {
-        try {
-          const { from, to } = chart.visibleTimeRange();
-
-          const dateFrom = new Date(String(from));
-          const dateTo = new Date(String(to));
-
-          /** @type {Marker | undefined} */
-          let max = undefined;
-          /** @type {Marker | undefined} */
-          let min = undefined;
-
-          const ids = chart.visibleDatasetIds();
-
-          for (let i = 0; i < chartPane.splitSeries.length; i++) {
-            const { chunks, dataset } = chartPane.splitSeries[i];
-
-            for (let j = 0; j < ids.length; j++) {
-              const id = ids[j];
-
-              const chunkIndex = utils.chunkIdToIndex(scale, id);
-
-              const chunk = chunks.at(chunkIndex)?.();
-
-              if (!chunk || !chunk?.options().visible) continue;
-
-              chunk.setMarkers([]);
-
-              const isCandlestick = chunk.seriesType() === "Candlestick";
-
-              const vec = dataset.fetchedJSONs.at(chunkIndex)?.vec();
-
-              if (!vec) return;
-
-              for (let k = 0; k < vec.length; k++) {
-                const data = vec[k];
-
-                let number;
-
-                if (scale === "date") {
-                  const date = utils.date.fromTime(data.time);
-
-                  number = date.getTime();
-
-                  if (date <= dateFrom || date >= dateTo) {
-                    continue;
-                  }
-                } else {
-                  const height = data.time;
-
-                  number = /** @type {number} */ (height);
-
-                  if (height <= from || height >= to) {
-                    continue;
-                  }
-                }
-
-                // @ts-ignore
-                const high = isCandlestick ? data["high"] : data.value;
-                // @ts-ignore
-                const low = isCandlestick ? data["low"] : data.value;
-
-                if (!max || high > max.value) {
-                  max = {
-                    weight: number,
-                    time: data.time,
-                    value: high,
-                    seriesChunk: chunk,
-                  };
-                }
-                if (!min || low < min.value) {
-                  min = {
-                    weight: number,
-                    time: data.time,
-                    value: low,
-                    seriesChunk: chunk,
-                  };
-                }
-              }
-            }
-          }
-
-          /** @type {(SeriesMarker<Time> & Weighted) | undefined} */
-          let minMarker;
-          /** @type {(SeriesMarker<Time> & Weighted) | undefined} */
-          let maxMarker;
-
-          if (min) {
-            minMarker = {
-              weight: min.weight,
-              time: min.time,
-              color: colors.default(),
-              position: "belowBar",
-              shape: "arrowUp",
-              size: 0,
-              text: utils.locale.numberToShortUSFormat(min.value),
-            };
-          }
-
-          if (max) {
-            maxMarker = {
-              weight: max.weight,
-              time: max.time,
-              color: colors.default(),
-              position: "aboveBar",
-              shape: "arrowDown",
-              size: 0,
-              text: utils.locale.numberToShortUSFormat(max.value),
-            };
-          }
-
-          if (
-            min &&
-            max &&
-            min.seriesChunk === max.seriesChunk &&
-            minMarker &&
-            maxMarker
-          ) {
-            min.seriesChunk.setMarkers(
-              [minMarker, maxMarker].sort((a, b) => a.weight - b.weight),
-            );
-          } else {
-            if (min && minMarker) {
-              min.seriesChunk.setMarkers([minMarker]);
-            }
-
-            if (max && maxMarker) {
-              max.seriesChunk.setMarkers([maxMarker]);
-            }
-          }
-        } catch (e) {}
-      }
-
-      const setMinMaxMarkersWhenIdle = () =>
-        utils.runWhenIdle(
-          () => {
-            setMinMaxMarkers();
-          },
-          blueprintCount * 10 + scale === "date" ? 50 : 100,
-        );
-
-      function createSetMinMaxMarkersWhenIdleEffect() {
-        signals.createEffect(
-          () => [chart.visibleTimeRange(), dark()],
-          setMinMaxMarkersWhenIdle,
-        );
-      }
-      createSetMinMaxMarkersWhenIdleEffect();
-
       if (!paneIndex) {
         updateVisiblePriceSeriesType({
           visibleTimeRange: chart.visibleTimeRange(),
         });
 
+        chartPane
+          .timeScale()
+          .subscribeVisibleLogicalRangeChange((logicalRange) => {
+            if (!logicalRange) return;
+
+            // Must be the chart with the visible timeScale
+            debouncedUpdateVisiblePriceSeriesType({
+              visibleLogicalRange: logicalRange,
+            });
+          });
+
         /** @param {PriceSeriesType} type */
         function _createPriceSeries(type) {
           return createPriceSeries({
             chartPane,
             option,
-            setMinMaxMarkersWhenIdle,
             type,
           });
         }
@@ -391,96 +242,12 @@ export function init({
           index,
           blueprint,
           id: option.id,
-          setMinMaxMarkersWhenIdle,
           dataset,
         });
       });
 
-      setMinMaxMarkers();
-
       activeDatasets.set((s) => s);
 
-      chartPane.splitSeries.forEach((series) => {
-        signals.createEffect(series.active, () => {
-          setMinMaxMarkersWhenIdle();
-        });
-      });
-
-      const chartVisible = signals.createMemo(() =>
-        chartPane.splitSeries.some((series) => series.visible()),
-      );
-
-      function createChartVisibilityEffect() {
-        signals.createEffect(chartVisible, (chartVisible) => {
-          chartPane.setHidden(!chartVisible);
-        });
-      }
-      createChartVisibilityEffect();
-
-      function createTimeScaleVisibilityEffect() {
-        signals.createEffect(chartVisible, (chartVisible) => {
-          const visible = paneIndex === chartCount - 1 && chartVisible;
-
-          chartPane.timeScale().applyOptions({
-            visible,
-          });
-
-          if (paneIndex === 1) {
-            chart.panes[0].timeScale().applyOptions({
-              visible: !visible,
-            });
-          }
-        });
-      }
-      createTimeScaleVisibilityEffect();
-
-      chartPane
-        .timeScale()
-        .subscribeVisibleLogicalRangeChange((logicalRange) => {
-          if (!logicalRange) return;
-
-          // Must be the chart with the visible timeScale
-          if (paneIndex === chartCount - 1) {
-            debouncedUpdateVisiblePriceSeriesType({
-              visibleLogicalRange: logicalRange,
-            });
-          }
-
-          for (
-            let otherChartIndex = 0;
-            otherChartIndex <= chartCount - 1;
-            otherChartIndex++
-          ) {
-            if (paneIndex !== otherChartIndex) {
-              chart.panes[otherChartIndex]
-                .timeScale()
-                .setVisibleLogicalRange(logicalRange);
-            }
-          }
-        });
-
-      chartPane.subscribeCrosshairMove(({ time, sourceEvent }) => {
-        // Don't override crosshair position from scroll event
-        if (time && !sourceEvent) return;
-
-        for (
-          let otherChartIndex = 0;
-          otherChartIndex <= chartCount - 1;
-          otherChartIndex++
-        ) {
-          const otherChart = chart.panes[otherChartIndex];
-
-          if (otherChart && paneIndex !== otherChartIndex) {
-            if (time) {
-              otherChart.setCrosshairPosition(NaN, time, otherChart.whitespace);
-            } else {
-              // No time when mouse goes outside the chart
-              otherChart.clearCrosshairPosition();
-            }
-          }
-        }
-      });
-
       return chart;
     });
   }
diff --git a/website/scripts/main.js b/website/scripts/main.js
index ec5765f04..6a6bcf0d4 100644
--- a/website/scripts/main.js
+++ b/website/scripts/main.js
@@ -3,7 +3,7 @@
 /**
  * @import { Option, ResourceDataset, TimeScale, TimeRange, Unit, Weighted, DatasetPath, OHLC, FetchedJSON, DatasetValue, FetchedResult, AnyDatasetPath, Color, DatasetCandlestickData, PartialChartOption, ChartOption, AnyPartialOption, ProcessedOptionAddons, OptionsTree, AnyPath, SimulationOption, Frequency, LastValues } from "./types/self"
  * @import {createChart as CreateClassicChart, createChartEx as CreateCustomChart, LineStyleOptions } from "../packages/lightweight-charts/v4.2.0/types";
- * @import { Marker,  CreatePaneParameters,  HoveredLegend, ChartPane, SplitSeries, SingleSeries, CreateSplitSeriesParameters, LineSeriesBlueprint, CandlestickSeriesBlueprint, BaselineSeriesBlueprint, CreateBaseSeriesParameters, BaseSeries, RemoveSeriesBlueprintFluff, SplitSeriesBlueprint } from "../packages/lightweight-charts/types";
+ * @import { Marker,  CreatePaneParameters,  HoveredLegend, ChartPane, SplitSeries, SingleSeries, CreateSplitSeriesParameters, LineSeriesBlueprint, CandlestickSeriesBlueprint, BaselineSeriesBlueprint, CreateBaseSeriesParameters, BaseSeries, RemoveSeriesBlueprintFluff, SplitSeriesBlueprint, AnySeries } from "../packages/lightweight-charts/types";
  * @import * as _ from "../packages/ufuzzy/v1.0.14/types"
  * @import { DeepPartial, ChartOptions, IChartApi, IHorzScaleBehavior, WhitespaceData, SingleValueData, ISeriesApi, Time, LineData, LogicalRange, SeriesMarker, CandlestickData, SeriesType, BaselineStyleOptions, SeriesOptionsCommon } from "../packages/lightweight-charts/v4.2.0/types"
  * @import { DatePath, HeightPath, LastPath } from "./types/paths";
diff --git a/website/scripts/types/self.d.ts b/website/scripts/types/self.d.ts
index 2c33d27a6..fed6f9b4f 100644
--- a/website/scripts/types/self.d.ts
+++ b/website/scripts/types/self.d.ts
@@ -199,11 +199,9 @@ type ValuedCandlestickData = CandlestickData & Valued;
 interface FetchedResult<
   Scale extends TimeScale,
   Type extends number | OHLC,
-  Value extends DatasetValue<
-    SingleValueData | ValuedCandlestickData
-  > = DatasetValue<
-    Type extends number ? SingleValueData : ValuedCandlestickData
-  >,
+  Value extends SingleValueData | ValuedCandlestickData = Type extends number
+    ? SingleValueData
+    : ValuedCandlestickData,
 > {
   at: Date | null;
   json: Signal<FetchedJSON<Scale, Type> | null>;