@parca/profile 0.19.140 → 0.19.142

package/dist/ProfileFlameGraph/FlameGraphArrow/useVisibleNodes.js

@@ -1,3 +1,7 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { c as _c } from "react-compiler-runtime";
 // Copyright 2022 The Parca Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -10,33 +14,62 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 import { useMemo, useRef } from 'react';
 import { RowHeight } from './FlameGraphNodes';
 import { FIELD_CUMULATIVE, FIELD_DEPTH, FIELD_VALUE_OFFSET } from './index';
 import { getMaxDepth } from './utils';
+
 /**
  * This function groups rows by their depth level.
  * Instead of scanning all rows to find depth matches, we pre-compute
  * buckets so viewport rendering only examines depth ranges that are relevant.
  */
-const useDepthBuckets = (table) => {
-    return useMemo(() => {
-        if (table === undefined)
-            return [];
-        const depthColumn = table.getChild(FIELD_DEPTH);
-        if (depthColumn === null)
-            return [];
-        // Find max depth
-        const maxDepth = getMaxDepth(depthColumn);
-        // Create buckets for each depth level
-        const buckets = Array.from({ length: maxDepth + 1 }, () => []);
-        // Populate buckets with row indices
-        for (let row = 0; row < table.numRows; row++) {
-            const depth = depthColumn.get(row) ?? 0;
-            buckets[depth].push(row);
+var useDepthBuckets = function useDepthBuckets(table) {
+  var $ = _c(4);
+  var t0;
+  if ($[0] !== table) {
+    bb0: {
+      if (table === undefined) {
+        var t1;
+        if ($[2] === Symbol["for"]("react.memo_cache_sentinel")) {
+          t1 = [];
+          $[2] = t1;
+        } else {
+          t1 = $[2];
         }
-        return buckets;
-    }, [table]);
+        t0 = t1;
+        break bb0;
+      }
+      var depthColumn = table.getChild(FIELD_DEPTH);
+      if (depthColumn === null) {
+        var _t;
+        if ($[3] === Symbol["for"]("react.memo_cache_sentinel")) {
+          _t = [];
+          $[3] = _t;
+        } else {
+          _t = $[3];
+        }
+        t0 = _t;
+        break bb0;
+      }
+      var maxDepth = getMaxDepth(depthColumn);
+      var buckets = Array.from({
+        length: maxDepth + 1
+      }, _temp);
+      for (var row = 0; row < table.numRows; row++) {
+        var _depthColumn$get;
+        var depth = (_depthColumn$get = depthColumn.get(row)) !== null && _depthColumn$get !== void 0 ? _depthColumn$get : 0;
+        buckets[depth].push(row);
+      }
+      t0 = buckets;
+    }
+    $[0] = table;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
 };
 /**
  * useVisibleNodes returns row indices visible in the current viewport through multi-stage culling.
@@ -50,88 +83,117 @@ const useDepthBuckets = (table) => {
  * Critical for maintaining 60fps performance on large flamegraphs where
  * rendering all nodes would freeze the browser.
  */
-export const useVisibleNodes = ({ table, viewport, total, width, selectedRow, effectiveDepth, }) => {
-    const depthBuckets = useDepthBuckets(table);
-    const lastResultRef = useRef({ key: '', result: [] });
-    const renderedRangeRef = useRef({
+export var useVisibleNodes = function useVisibleNodes(_ref) {
+  var table = _ref.table,
+    viewport = _ref.viewport,
+    total = _ref.total,
+    width = _ref.width,
+    selectedRow = _ref.selectedRow,
+    effectiveDepth = _ref.effectiveDepth;
+  var depthBuckets = useDepthBuckets(table);
+  var lastResultRef = useRef({
+    key: '',
+    result: []
+  });
+  var renderedRangeRef = useRef({
+    minDepth: Infinity,
+    maxDepth: -Infinity,
+    table: null
+  });
+  return useMemo(function () {
+    // This happens when the continer is scrolled off screen, in this case we return all previously rendered nodes
+    // to avoid trimming the rendered nodes to zero which would cause jank when scrolling back into view
+    if (viewport.containerHeight === 0 && lastResultRef.current.result.length > 0) {
+      return lastResultRef.current.result;
+    }
+
+    // Create a stable key for memoization to prevent unnecessary recalculations
+    var memoKey = "".concat(viewport.scrollTop, "-").concat(viewport.containerHeight, "-").concat(selectedRow, "-").concat(effectiveDepth, "-").concat(width, "-").concat(Number(total), "-").concat(table.numRows);
+
+    // Return cached result if viewport hasn't meaningfully changed
+    if (lastResultRef.current.key === memoKey) {
+      return lastResultRef.current.result;
+    }
+    if (table === null) return [];
+    var visibleRows = [];
+    var scrollTop = viewport.scrollTop,
+      containerHeight = viewport.containerHeight;
+
+    // Viewport Culling Algorithm:
+    // 1. Calculate visible depth range based on scroll position and container height
+    // 2. Add 5-row buffer above/below for smooth scrolling experience
+    // Note: We never shrink the rendered range to avoid back and forth node removals (and in turn additions when scrolled down again) to the dom.
+
+    var BUFFER = 15; // Buffer for smoother scrolling
+
+    var visibleStartDepth = Math.max(0, Math.floor(scrollTop / RowHeight) - BUFFER);
+    var visibleDepths = Math.ceil(containerHeight / RowHeight);
+    var visibleEndDepth = Math.min(effectiveDepth, visibleStartDepth + visibleDepths + BUFFER);
+
+    // Reset range if table changed (new data loaded) as this is new data
+    if (renderedRangeRef.current.table !== table) {
+      renderedRangeRef.current = {
         minDepth: Infinity,
         maxDepth: -Infinity,
-        table: null,
-    });
-    return useMemo(() => {
-        // This happens when the continer is scrolled off screen, in this case we return all previously rendered nodes
-        // to avoid trimming the rendered nodes to zero which would cause jank when scrolling back into view
-        if (viewport.containerHeight === 0 && lastResultRef.current.result.length > 0) {
-            return lastResultRef.current.result;
-        }
-        // Create a stable key for memoization to prevent unnecessary recalculations
-        const memoKey = `${viewport.scrollTop}-${viewport.containerHeight}-${selectedRow}-${effectiveDepth}-${width}-${Number(total)}-${table.numRows}`;
-        // Return cached result if viewport hasn't meaningfully changed
-        if (lastResultRef.current.key === memoKey) {
-            return lastResultRef.current.result;
-        }
-        if (table === null)
-            return [];
-        const visibleRows = [];
-        const { scrollTop, containerHeight } = viewport;
-        // Viewport Culling Algorithm:
-        // 1. Calculate visible depth range based on scroll position and container height
-        // 2. Add 5-row buffer above/below for smooth scrolling experience
-        // Note: We never shrink the rendered range to avoid back and forth node removals (and in turn additions when scrolled down again) to the dom.
-        const BUFFER = 15; // Buffer for smoother scrolling
-        const visibleStartDepth = Math.max(0, Math.floor(scrollTop / RowHeight) - BUFFER);
-        const visibleDepths = Math.ceil(containerHeight / RowHeight);
-        const visibleEndDepth = Math.min(effectiveDepth, visibleStartDepth + visibleDepths + BUFFER);
-        // Reset range if table changed (new data loaded) as this is new data
-        if (renderedRangeRef.current.table !== table) {
-            renderedRangeRef.current = {
-                minDepth: Infinity,
-                maxDepth: -Infinity,
-                table,
-            };
-        }
-        // Expand the rendered range (never shrink when scrolling up/down)
-        renderedRangeRef.current.minDepth = Math.min(renderedRangeRef.current.minDepth, visibleStartDepth);
-        renderedRangeRef.current.maxDepth = Math.max(renderedRangeRef.current.maxDepth, visibleEndDepth);
-        const startDepth = renderedRangeRef.current.minDepth;
-        const endDepth = renderedRangeRef.current.maxDepth;
-        const cumulativeColumn = table.getChild(FIELD_CUMULATIVE);
-        const valueOffsetColumn = table.getChild(FIELD_VALUE_OFFSET);
-        const selectionOffset = valueOffsetColumn?.get(selectedRow) !== null &&
-            valueOffsetColumn?.get(selectedRow) !== undefined
-            ? BigInt(valueOffsetColumn?.get(selectedRow))
-            : 0n;
-        const selectionCumulative = cumulativeColumn?.get(selectedRow) != null ? BigInt(cumulativeColumn?.get(selectedRow)) : 0n;
-        const totalNumber = Number(total);
-        const selectionOffsetNumber = Number(selectionOffset);
-        const selectionCumulativeNumber = Number(selectionCumulative);
-        // Iterate only through visible depth range instead of all rows
-        for (let depth = startDepth; depth <= endDepth && depth < depthBuckets.length; depth++) {
-            // Skip if depth is beyond effective depth limit
-            if (effectiveDepth !== undefined && depth > effectiveDepth) {
-                continue;
-            }
-            const rowsAtDepth = depthBuckets[depth];
-            for (const row of rowsAtDepth) {
-                const cumulative = cumulativeColumn?.get(row) != null ? Number(cumulativeColumn?.get(row)) : 0;
-                const valueOffset = valueOffsetColumn?.get(row) !== null && valueOffsetColumn?.get(row) !== undefined
-                    ? Number(valueOffsetColumn?.get(row))
-                    : 0;
-                // Horizontal culling: Skip nodes outside selection bounds
-                if (valueOffset + cumulative <= selectionOffsetNumber ||
-                    valueOffset >= selectionOffsetNumber + selectionCumulativeNumber) {
-                    continue;
-                }
-                // Size culling: Skip nodes too small to be visible (< 1px width)
-                const computedWidth = (cumulative / totalNumber) * width;
-                if (computedWidth <= 1) {
-                    continue;
-                }
-                visibleRows.push(row);
-            }
+        table: table
+      };
+    }
+
+    // Expand the rendered range (never shrink when scrolling up/down)
+    renderedRangeRef.current.minDepth = Math.min(renderedRangeRef.current.minDepth, visibleStartDepth);
+    renderedRangeRef.current.maxDepth = Math.max(renderedRangeRef.current.maxDepth, visibleEndDepth);
+    var startDepth = renderedRangeRef.current.minDepth;
+    var endDepth = renderedRangeRef.current.maxDepth;
+    var cumulativeColumn = table.getChild(FIELD_CUMULATIVE);
+    var valueOffsetColumn = table.getChild(FIELD_VALUE_OFFSET);
+    var selectionOffset = (valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(selectedRow)) !== null && (valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(selectedRow)) !== undefined ? BigInt(valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(selectedRow)) : 0n;
+    var selectionCumulative = (cumulativeColumn === null || cumulativeColumn === void 0 ? void 0 : cumulativeColumn.get(selectedRow)) != null ? BigInt(cumulativeColumn === null || cumulativeColumn === void 0 ? void 0 : cumulativeColumn.get(selectedRow)) : 0n;
+    var totalNumber = Number(total);
+    var selectionOffsetNumber = Number(selectionOffset);
+    var selectionCumulativeNumber = Number(selectionCumulative);
+
+    // Iterate only through visible depth range instead of all rows
+    for (var depth = startDepth; depth <= endDepth && depth < depthBuckets.length; depth++) {
+      // Skip if depth is beyond effective depth limit
+      if (effectiveDepth !== undefined && depth > effectiveDepth) {
+        continue;
+      }
+      var rowsAtDepth = depthBuckets[depth];
+      var _iterator = _createForOfIteratorHelper(rowsAtDepth),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var row = _step.value;
+          var cumulative = (cumulativeColumn === null || cumulativeColumn === void 0 ? void 0 : cumulativeColumn.get(row)) != null ? Number(cumulativeColumn === null || cumulativeColumn === void 0 ? void 0 : cumulativeColumn.get(row)) : 0;
+          var valueOffset = (valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(row)) !== null && (valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(row)) !== undefined ? Number(valueOffsetColumn === null || valueOffsetColumn === void 0 ? void 0 : valueOffsetColumn.get(row)) : 0;
+
+          // Horizontal culling: Skip nodes outside selection bounds
+          if (valueOffset + cumulative <= selectionOffsetNumber || valueOffset >= selectionOffsetNumber + selectionCumulativeNumber) {
+            continue;
+          }
+
+          // Size culling: Skip nodes too small to be visible (< 1px width)
+          var computedWidth = cumulative / totalNumber * width;
+          if (computedWidth <= 1) {
+            continue;
+          }
+          visibleRows.push(row);
         }
-        // Cache the result with the current key
-        lastResultRef.current = { key: memoKey, result: visibleRows };
-        return visibleRows;
-    }, [depthBuckets, viewport, total, width, selectedRow, effectiveDepth, table]);
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    // Cache the result with the current key
+    lastResultRef.current = {
+      key: memoKey,
+      result: visibleRows
+    };
+    return visibleRows;
+  }, [depthBuckets, viewport, total, width, selectedRow, effectiveDepth, table]);
 };
+function _temp() {
+  return [];
+}

package/dist/ProfileFlameGraph/FlameGraphArrow/useZoom.js

@@ -1,3 +1,10 @@
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+import { c as _c } from "react-compiler-runtime";
 // Copyright 2022 The Parca Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -10,120 +17,233 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { flushSync } from 'react-dom';
-const MIN_ZOOM = 1.0;
-export const MAX_ZOOM = 100.0;
-const BUTTON_ZOOM_STEP = 1.5;
+var MIN_ZOOM = 1.0;
+export var MAX_ZOOM = 100.0;
+var BUTTON_ZOOM_STEP = 1.5;
 // Sensitivity for trackpad/wheel zoom - smaller = smoother
-const WHEEL_ZOOM_SENSITIVITY = 0.01;
-const clampZoom = (zoom) => {
-    return Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, zoom));
+var WHEEL_ZOOM_SENSITIVITY = 0.01;
+var clampZoom = function clampZoom(zoom) {
+  return Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, zoom));
 };
-export const useZoom = (containerRef) => {
-    const [zoomLevel, setZoomLevel] = useState(MIN_ZOOM);
-    const zoomLevelRef = useRef(MIN_ZOOM);
-    const scrollLeftRef = useRef(0);
-    // Keep scrollLeftRef in sync with actual scroll position during regular scrolling
-    useEffect(() => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const onScroll = () => {
-            scrollLeftRef.current = container.scrollLeft;
-        };
-        container.addEventListener('scroll', onScroll, { passive: true });
-        return () => container.removeEventListener('scroll', onScroll);
-    }, [containerRef]);
-    // Apply a new zoom level around a focal point
-    const applyZoom = useCallback((newZoom, focalX) => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const oldZoom = zoomLevelRef.current;
-        if (newZoom === oldZoom)
-            return;
-        // Pre-compute intended scrollLeft BEFORE flushSync so MiniMap reads correct value during render
-        const contentX = container.scrollLeft + focalX;
-        const ratio = contentX / oldZoom;
-        const newScrollLeft = ratio * newZoom - focalX;
-        scrollLeftRef.current = newScrollLeft;
-        zoomLevelRef.current = newZoom;
-        flushSync(() => setZoomLevel(newZoom));
-        // Apply scroll to DOM after render (content is now wide enough)
-        container.scrollLeft = newScrollLeft;
-    }, [containerRef]);
-    const zoomIn = useCallback(() => {
-        const newZoom = clampZoom(zoomLevelRef.current * BUTTON_ZOOM_STEP);
-        const container = containerRef.current;
-        applyZoom(newZoom, container !== null ? container.clientWidth / 2 : 0);
-    }, [containerRef, applyZoom]);
-    const zoomOut = useCallback(() => {
-        const newZoom = clampZoom(zoomLevelRef.current / BUTTON_ZOOM_STEP);
-        const container = containerRef.current;
-        applyZoom(newZoom, container !== null ? container.clientWidth / 2 : 0);
-    }, [containerRef, applyZoom]);
-    const resetZoom = useCallback(() => {
-        zoomLevelRef.current = MIN_ZOOM;
-        scrollLeftRef.current = 0;
-        setZoomLevel(MIN_ZOOM);
-        const container = containerRef.current;
-        if (container !== null) {
-            container.scrollLeft = 0;
+export var useZoom = function useZoom(containerRef) {
+  var $ = _c(28);
+  var _useState = useState(MIN_ZOOM),
+    _useState2 = _slicedToArray(_useState, 2),
+    zoomLevel = _useState2[0],
+    setZoomLevel = _useState2[1];
+  var zoomLevelRef = useRef(MIN_ZOOM);
+  var scrollLeftRef = useRef(0);
+  var t0;
+  var t1;
+  if ($[0] !== containerRef) {
+    t0 = function t0() {
+      var container = containerRef.current;
+      if (container === null) {
+        return;
+      }
+      var onScroll = function onScroll() {
+        scrollLeftRef.current = container.scrollLeft;
+      };
+      container.addEventListener("scroll", onScroll, {
+        passive: true
+      });
+      return function () {
+        return container.removeEventListener("scroll", onScroll);
+      };
+    };
+    t1 = [containerRef];
+    $[0] = containerRef;
+    $[1] = t0;
+    $[2] = t1;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+  }
+  useEffect(t0, t1);
+  var t2;
+  if ($[3] !== containerRef) {
+    t2 = function t2(newZoom, focalX) {
+      var container_0 = containerRef.current;
+      if (container_0 === null) {
+        return;
+      }
+      var oldZoom = zoomLevelRef.current;
+      if (newZoom === oldZoom) {
+        return;
+      }
+      var contentX = container_0.scrollLeft + focalX;
+      var ratio = contentX / oldZoom;
+      var newScrollLeft = ratio * newZoom - focalX;
+      scrollLeftRef.current = newScrollLeft;
+      zoomLevelRef.current = newZoom;
+      flushSync(function () {
+        return setZoomLevel(newZoom);
+      });
+      container_0.scrollLeft = newScrollLeft;
+    };
+    $[3] = containerRef;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  var applyZoom = t2;
+  var t3;
+  if ($[5] !== applyZoom || $[6] !== containerRef) {
+    t3 = function t3() {
+      var newZoom_0 = clampZoom(zoomLevelRef.current * BUTTON_ZOOM_STEP);
+      var container_1 = containerRef.current;
+      applyZoom(newZoom_0, container_1 !== null ? container_1.clientWidth / 2 : 0);
+    };
+    $[5] = applyZoom;
+    $[6] = containerRef;
+    $[7] = t3;
+  } else {
+    t3 = $[7];
+  }
+  var zoomIn = t3;
+  var t4;
+  if ($[8] !== applyZoom || $[9] !== containerRef) {
+    t4 = function t4() {
+      var newZoom_1 = clampZoom(zoomLevelRef.current / BUTTON_ZOOM_STEP);
+      var container_2 = containerRef.current;
+      applyZoom(newZoom_1, container_2 !== null ? container_2.clientWidth / 2 : 0);
+    };
+    $[8] = applyZoom;
+    $[9] = containerRef;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  var zoomOut = t4;
+  var t5;
+  if ($[11] !== containerRef) {
+    t5 = function t5() {
+      zoomLevelRef.current = MIN_ZOOM;
+      scrollLeftRef.current = 0;
+      setZoomLevel(MIN_ZOOM);
+      var container_3 = containerRef.current;
+      if (container_3 !== null) {
+        container_3.scrollLeft = 0;
+      }
+    };
+    $[11] = containerRef;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  var resetZoom = t5;
+  var t6;
+  var t7;
+  if ($[13] !== applyZoom || $[14] !== containerRef) {
+    t6 = function t6() {
+      var container_4 = containerRef.current;
+      if (container_4 === null) {
+        return;
+      }
+      var handleWheel = function handleWheel(e) {
+        if (!e.ctrlKey && !e.metaKey) {
+          return;
         }
-    }, [containerRef]);
-    useEffect(() => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const handleWheel = (e) => {
-            if (!e.ctrlKey && !e.metaKey)
-                return;
-            e.preventDefault();
-            let delta = e.deltaY;
-            if (e.deltaMode === 1) {
-                delta *= 20;
-            }
-            // Limiting the max zoom step per event to 15%, so to fix the huge jumps in Linux OS.
-            const MAX_FACTOR = 0.15;
-            const rawFactor = -delta * WHEEL_ZOOM_SENSITIVITY;
-            const zoomFactor = 1 + Math.max(-MAX_FACTOR, Math.min(MAX_FACTOR, rawFactor));
-            const newZoom = clampZoom(zoomLevelRef.current * zoomFactor);
-            applyZoom(newZoom, e.clientX - container.getBoundingClientRect().left);
-        };
-        container.addEventListener('wheel', handleWheel, { passive: false });
-        return () => {
-            container.removeEventListener('wheel', handleWheel);
-        };
-    }, [containerRef, applyZoom]);
-    const zoomToPosition = useCallback((normalizedX, targetZoom) => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const newZoom = clampZoom(targetZoom);
-        if (newZoom === zoomLevelRef.current)
-            return;
-        const containerWidth = container.clientWidth;
-        const contentWidth = containerWidth * newZoom;
-        const targetScrollLeft = Math.max(0, Math.min(normalizedX * contentWidth - containerWidth / 2, contentWidth - containerWidth));
-        // Pre-set scrollLeftRef before flushSync so MiniMap reads correct value during render
-        scrollLeftRef.current = targetScrollLeft;
-        zoomLevelRef.current = newZoom;
-        flushSync(() => setZoomLevel(newZoom));
-        container.scrollLeft = targetScrollLeft;
-    }, [containerRef]);
-    const setZoomWithScroll = useCallback((zoom, newScrollLeft) => {
-        const container = containerRef.current;
-        if (container === null)
-            return;
-        const clamped = clampZoom(zoom);
-        const contentWidth = container.clientWidth * clamped;
-        const clampedScroll = Math.max(0, Math.min(newScrollLeft, contentWidth - container.clientWidth));
-        // Pre-set scrollLeftRef before flushSync so MiniMap reads correct value during render
-        scrollLeftRef.current = clampedScroll;
-        zoomLevelRef.current = clamped;
-        flushSync(() => setZoomLevel(clamped));
-        container.scrollLeft = clampedScroll;
-    }, [containerRef]);
-    return { zoomLevel, zoomIn, zoomOut, resetZoom, zoomToPosition, setZoomWithScroll, scrollLeftRef };
-};
+        e.preventDefault();
+        var delta = e.deltaY;
+        if (e.deltaMode === 1) {
+          delta = delta * 20;
+        }
+        var rawFactor = -delta * WHEEL_ZOOM_SENSITIVITY;
+        var zoomFactor = 1 + Math.max(-0.15, Math.min(0.15, rawFactor));
+        var newZoom_2 = clampZoom(zoomLevelRef.current * zoomFactor);
+        applyZoom(newZoom_2, e.clientX - container_4.getBoundingClientRect().left);
+      };
+      container_4.addEventListener("wheel", handleWheel, {
+        passive: false
+      });
+      return function () {
+        container_4.removeEventListener("wheel", handleWheel);
+      };
+    };
+    t7 = [containerRef, applyZoom];
+    $[13] = applyZoom;
+    $[14] = containerRef;
+    $[15] = t6;
+    $[16] = t7;
+  } else {
+    t6 = $[15];
+    t7 = $[16];
+  }
+  useEffect(t6, t7);
+  var t8;
+  if ($[17] !== containerRef) {
+    t8 = function t8(normalizedX, targetZoom) {
+      var container_5 = containerRef.current;
+      if (container_5 === null) {
+        return;
+      }
+      var newZoom_3 = clampZoom(targetZoom);
+      if (newZoom_3 === zoomLevelRef.current) {
+        return;
+      }
+      var containerWidth = container_5.clientWidth;
+      var contentWidth = containerWidth * newZoom_3;
+      var targetScrollLeft = Math.max(0, Math.min(normalizedX * contentWidth - containerWidth / 2, contentWidth - containerWidth));
+      scrollLeftRef.current = targetScrollLeft;
+      zoomLevelRef.current = newZoom_3;
+      flushSync(function () {
+        return setZoomLevel(newZoom_3);
+      });
+      container_5.scrollLeft = targetScrollLeft;
+    };
+    $[17] = containerRef;
+    $[18] = t8;
+  } else {
+    t8 = $[18];
+  }
+  var zoomToPosition = t8;
+  var t9;
+  if ($[19] !== containerRef) {
+    t9 = function t9(zoom, newScrollLeft_0) {
+      var container_6 = containerRef.current;
+      if (container_6 === null) {
+        return;
+      }
+      var clamped = clampZoom(zoom);
+      var contentWidth_0 = container_6.clientWidth * clamped;
+      var clampedScroll = Math.max(0, Math.min(newScrollLeft_0, contentWidth_0 - container_6.clientWidth));
+      scrollLeftRef.current = clampedScroll;
+      zoomLevelRef.current = clamped;
+      flushSync(function () {
+        return setZoomLevel(clamped);
+      });
+      container_6.scrollLeft = clampedScroll;
+    };
+    $[19] = containerRef;
+    $[20] = t9;
+  } else {
+    t9 = $[20];
+  }
+  var setZoomWithScroll = t9;
+  var t10;
+  if ($[21] !== resetZoom || $[22] !== setZoomWithScroll || $[23] !== zoomIn || $[24] !== zoomLevel || $[25] !== zoomOut || $[26] !== zoomToPosition) {
+    t10 = {
+      zoomLevel: zoomLevel,
+      zoomIn: zoomIn,
+      zoomOut: zoomOut,
+      resetZoom: resetZoom,
+      zoomToPosition: zoomToPosition,
+      setZoomWithScroll: setZoomWithScroll,
+      scrollLeftRef: scrollLeftRef
+    };
+    $[21] = resetZoom;
+    $[22] = setZoomWithScroll;
+    $[23] = zoomIn;
+    $[24] = zoomLevel;
+    $[25] = zoomOut;
+    $[26] = zoomToPosition;
+    $[27] = t10;
+  } else {
+    t10 = $[27];
+  }
+  return t10;
+};