handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/overlay/resizeMonitor.mjs

@@ -0,0 +1,153 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+import { requestAnimationFrame } from '../../../../helpers/feature.mjs';
+import { warn } from '../../../../helpers/console.mjs';
+/**
+ * Assembles the ResizeMonitor's dependencies from the engine composition context. It needs only the
+ * settings accessor (to fire the `onContainerElementResize` setting) and the master table (for the
+ * wrapper element it observes) — no callback back into the owning Overlays coordinator.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @returns {object} The ResizeMonitor dependency set.
+ */ export function createResizeMonitorDeps(ctx) {
+    return {
+        wtSettings: ctx.wtSettings,
+        wtTable: ctx.getWtTable()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * The amount of times the ResizeObserver callback was fired in direct succession.
+   *
+   * @type {number}
+   */ _containerDomResizeCount = /*#__PURE__*/ new WeakMap(), /**
+   * The timeout ID for the ResizeObserver endless-loop-blocking logic.
+   *
+   * @type {number}
+   */ _containerDomResizeCountTimeout = /*#__PURE__*/ new WeakMap(), /**
+   * The instance of the ResizeObserver that observes the size of the Walkontable wrapper element.
+   * In case of the size change detection the `onContainerElementResize` is fired.
+   *
+   * @type {ResizeObserver}
+   */ _resizeObserver = /*#__PURE__*/ new WeakMap();
+/**
+ * Watches the Walkontable wrapper's parent element for size changes and fires the
+ * `onContainerElementResize` setting when one is detected.
+ *
+ * The class owns the `ResizeObserver` plus the endless-loop guard: a dynamic parent size (for example
+ * `dvh` units) can make the observer callback re-trigger itself indefinitely, so a rolling count with
+ * a short reset window disconnects the observer once the callback fires too many times in direct
+ * succession. Extracted from the Overlays coordinator so the loop-guard lifecycle stays self-contained.
+ *
+ * @class ResizeMonitor
+ */ export class ResizeMonitor {
+    /**
+   * Starts observing the Walkontable wrapper's parent element for size changes. No-op when the
+   * wrapper has no parent element.
+   */ observe() {
+        const parentElement = _class_private_field_get(this, _deps).wtTable.wtRootElement.parentElement;
+        if (parentElement) {
+            _class_private_field_get(this, _resizeObserver).observe(parentElement);
+        }
+    }
+    /**
+   * Resets the direct-succession resize counter. Called when a window resize accounts for the size
+   * change, so it is excluded from the endless-loop-blocking logic.
+   */ resetResizeCount() {
+        _class_private_field_set(this, _containerDomResizeCount, 0);
+    }
+    /**
+   * Cleans up on destroy: clears the pending reset timeout and disconnects the observer.
+   */ destroy() {
+        if (_class_private_field_get(this, _containerDomResizeCountTimeout) !== null) {
+            clearTimeout(_class_private_field_get(this, _containerDomResizeCountTimeout));
+            _class_private_field_set(this, _containerDomResizeCountTimeout, null);
+        }
+        _class_private_field_get(this, _resizeObserver).disconnect();
+    }
+    /**
+   * @param {ResizeMonitorDeps} deps The ResizeMonitor dependencies.
+   */ constructor(deps){
+        /**
+   * The ResizeMonitor dependencies.
+   *
+   * @type {ResizeMonitorDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _containerDomResizeCount, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _containerDomResizeCountTimeout, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _resizeObserver, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _containerDomResizeCount, 0);
+        _class_private_field_set(this, _containerDomResizeCountTimeout, null);
+        _class_private_field_set(this, _resizeObserver, new ResizeObserver((entries)=>{
+            requestAnimationFrame(()=>{
+                if (!Array.isArray(entries) || !entries.length) {
+                    return;
+                }
+                _class_private_field_set(this, _containerDomResizeCount, _class_private_field_get(this, _containerDomResizeCount) + 1);
+                if (_class_private_field_get(this, _containerDomResizeCount) === 300) {
+                    warn('The ResizeObserver callback was fired too many times in direct succession.' + '\nThis may be due to an infinite loop caused by setting a dynamic height/width (for example, ' + 'with the `dvh` units) to a Handsontable container\'s parent. ' + '\nThe observer will be disconnected.');
+                    _class_private_field_get(this, _resizeObserver).disconnect();
+                }
+                // This logic is required to prevent an endless loop of the ResizeObserver callback.
+                // https://github.com/handsontable/dev-handsontable/issues/1898#issuecomment-2154794817
+                if (_class_private_field_get(this, _containerDomResizeCountTimeout) !== null) {
+                    clearTimeout(_class_private_field_get(this, _containerDomResizeCountTimeout));
+                }
+                _class_private_field_set(this, _containerDomResizeCountTimeout, setTimeout(()=>{
+                    _class_private_field_set(this, _containerDomResizeCount, 0);
+                }, 100));
+                _class_private_field_get(this, _deps).wtSettings.getSetting('onContainerElementResize');
+            });
+        }));
+        _class_private_field_set(this, _deps, deps);
+    }
+}

package/3rdparty/walkontable/src/overlay/scroll/nativeScrollInput.d.mts

@@ -0,0 +1 @@
+export * from './nativeScrollInput.js';

package/3rdparty/walkontable/src/overlay/scroll/nativeScrollInput.d.ts

@@ -0,0 +1,62 @@
+import type { EngineContext } from '../../wire';
+import type { default as Overlays } from '../overlays';
+import type { StickyScrollStrategy } from '../strategies/stickyScrollStrategy';
+import type { ResizeMonitor } from '../resizeMonitor';
+/**
+ * Assembles the NativeScrollInput's dependencies. The overlays are resolved off the owning
+ * coordinator (its own fields set by `initOverlays`), and the sticky-scroll strategy + resize monitor
+ * are passed as the already-built instances so their listener hooks can be re-registered from here.
+ * ScrollSync's `syncScrollPositions` and the coordinator's scrollable element are reached via
+ * callbacks, so this module type-imports Overlays/StickyScrollStrategy/ResizeMonitor only.
+ *
+ * @param {EngineContext} ctx The engine composition context.
+ * @param {Overlays} overlays The owning Overlays coordinator.
+ * @param {StickyScrollStrategy} stickyScroll The overlays' sticky-scroll strategy.
+ * @param {ResizeMonitor} resizeMonitor The overlays' container-resize monitor.
+ * @returns {object} The NativeScrollInput dependency set.
+ */
+export declare function createNativeScrollInputDeps(ctx: EngineContext, overlays: Overlays, stickyScroll: StickyScrollStrategy, resizeMonitor: ResizeMonitor): {
+    wtSettings: import("../../settings").default;
+    rootDocument: Document;
+    rootWindow: Window;
+    geometryReader: import("../../domMeasure/geometryReader").GeometryReader;
+    wtTable: import("../../table/baseTable").default;
+    eventManager: import("../../../../../eventManager").default;
+    getTopOverlay: () => import("..").Overlay;
+    getInlineStartOverlay: () => import("..").Overlay;
+    getCloneableOverlays: () => import("..").Overlay[];
+    getScrollableElement: () => HTMLElement | Window;
+    syncScrollPositions: () => void;
+    scrollVertically: (delta: number) => boolean;
+    scrollHorizontally: (delta: number) => boolean;
+    registerStickyScrollListeners: () => void;
+    resetResizeCount: () => void;
+    observeResize: () => void;
+};
+/**
+ * The NativeScrollInput dependencies, inferred from `createNativeScrollInputDeps`.
+ */
+export type NativeScrollInputDeps = ReturnType<typeof createNativeScrollInputDeps>;
+/**
+ * Binds the native DOM input listeners (scroll, wheel, keydown/keyup, window resize) and translates
+ * them into the engine's scroll actions: a scroll event syncs the master/clone positions, a wheel
+ * event over a clone is turned into a scroll of the master scrollable element, and arrow-key presses
+ * flip a flag so a keyboard-driven render only syncs master -> overlay.
+ *
+ * Extracted from the Overlays coordinator so the native-input lifecycle is self-contained; the
+ * coordinator keeps a thin public `registerListeners` delegate because ScrollSync re-registers the
+ * listeners when the scrollable element changes.
+ *
+ * @class NativeScrollInput
+ */
+export declare class NativeScrollInput {
+    #private;
+    /**
+     * @param {NativeScrollInputDeps} deps The NativeScrollInput dependencies.
+     */
+    constructor(deps: NativeScrollInputDeps);
+    /**
+     * Register all necessary event listeners.
+     */
+    registerListeners(): void;
+}

package/3rdparty/walkontable/src/overlay/scroll/nativeScrollInput.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get NativeScrollInput () {
+        return NativeScrollInput;
+    },
+    get createNativeScrollInputDeps () {
+        return createNativeScrollInputDeps;
+    }
+});
+const _unicode = require("../../../../../helpers/unicode");
+const _element = require("../../../../../helpers/dom/element");
+const _feature = require("../../../../../helpers/feature");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+/**
+ * Type predicate that checks whether a WheelEvent carries the legacy
+ * non-standard `wheelDeltaX`/`wheelDeltaY` properties emitted by older browsers.
+ *
+ * @param {WheelEvent} event The wheel event to test.
+ * @returns {boolean}
+ */ function isWheelEventWithLegacyDelta(event) {
+    return 'wheelDeltaY' in event || 'wheelDeltaX' in event;
+}
+function createNativeScrollInputDeps(ctx, overlays, stickyScroll, resizeMonitor) {
+    return {
+        wtSettings: ctx.wtSettings,
+        rootDocument: ctx.rootDocument,
+        rootWindow: ctx.rootWindow,
+        geometryReader: ctx.geometryReader,
+        wtTable: ctx.getWtTable(),
+        eventManager: overlays.eventManager,
+        getTopOverlay: ()=>overlays.topOverlay,
+        getInlineStartOverlay: ()=>overlays.inlineStartOverlay,
+        getCloneableOverlays: ()=>[
+                overlays.topOverlay,
+                overlays.bottomOverlay,
+                overlays.inlineStartOverlay,
+                overlays.topInlineStartCornerOverlay,
+                overlays.bottomInlineStartCornerOverlay
+            ],
+        getScrollableElement: ()=>overlays.scrollableElement,
+        syncScrollPositions: ()=>overlays.syncScrollPositions(),
+        scrollVertically: (delta)=>overlays.scrollVertically(delta),
+        scrollHorizontally: (delta)=>overlays.scrollHorizontally(delta),
+        registerStickyScrollListeners: ()=>stickyScroll.registerListeners(),
+        resetResizeCount: ()=>resizeMonitor.resetResizeCount(),
+        observeResize: ()=>resizeMonitor.observe()
+    };
+}
+var _deps = /*#__PURE__*/ new WeakMap(), /**
+   * Whether an arrow key is currently pressed.
+   *
+   * @type {boolean}
+   */ _keyPressed = /*#__PURE__*/ new WeakMap(), /**
+   * The browser's line height, used to convert line-based wheel deltas into pixels.
+   *
+   * @type {number}
+   */ _browserLineHeight = /*#__PURE__*/ new WeakMap(), /**
+   * Scroll listener.
+   *
+   * @param {Event} event The mouse event object.
+   */ _onTableScroll = /*#__PURE__*/ new WeakSet(), /**
+   * Wheel listener for cloned overlays.
+   *
+   * @param {Event} event The mouse event object.
+   * @param {boolean} preventDefault If `true`, the `preventDefault` will be called on event object.
+   */ _onCloneWheel = /*#__PURE__*/ new WeakSet(), /**
+   * Key down listener.
+   *
+   * @param {KeyboardEvent} event The keyboard event object.
+   */ _onKeyDown = /*#__PURE__*/ new WeakSet(), /**
+   * Key up listener.
+   */ _onKeyUp = /*#__PURE__*/ new WeakSet(), /**
+   * Translate wheel event into scroll event and sync scroll overlays position.
+   *
+   * @param {WheelEvent} event The mouse event object.
+   * @returns {boolean}
+   */ _translateMouseWheelToScroll = /*#__PURE__*/ new WeakSet(), /**
+   * Retrieve the browser line height, used to convert line-based wheel deltas into pixels.
+   *
+   * @returns {number}
+   */ _computeBrowserLineHeight = /*#__PURE__*/ new WeakSet();
+class NativeScrollInput {
+    /**
+   * Register all necessary event listeners.
+   */ registerListeners() {
+        const { rootDocument, rootWindow, wtTable, wtSettings, eventManager } = _class_private_field_get(this, _deps);
+        const topOverlay = _class_private_field_get(this, _deps).getTopOverlay();
+        const inlineStartOverlay = _class_private_field_get(this, _deps).getInlineStartOverlay();
+        const { mainTableScrollableElement: topOverlayScrollableElement } = topOverlay;
+        const { mainTableScrollableElement: inlineStartOverlayScrollableElement } = inlineStartOverlay;
+        eventManager.addEventListener(rootDocument.documentElement, 'keydown', (event)=>_class_private_method_get(this, _onKeyDown, onKeyDown).call(this, event));
+        eventManager.addEventListener(rootDocument.documentElement, 'keyup', ()=>_class_private_method_get(this, _onKeyUp, onKeyUp).call(this));
+        eventManager.addEventListener(rootDocument, 'visibilitychange', ()=>_class_private_method_get(this, _onKeyUp, onKeyUp).call(this));
+        _class_private_field_get(this, _deps).registerStickyScrollListeners();
+        eventManager.addEventListener(topOverlayScrollableElement, 'scroll', (event)=>_class_private_method_get(this, _onTableScroll, onTableScroll).call(this, event), {
+            passive: true
+        });
+        if (topOverlayScrollableElement !== inlineStartOverlayScrollableElement) {
+            eventManager.addEventListener(inlineStartOverlayScrollableElement, 'scroll', (event)=>_class_private_method_get(this, _onTableScroll, onTableScroll).call(this, event), {
+                passive: true
+            });
+        }
+        const isScrollOnWindow = _class_private_field_get(this, _deps).getScrollableElement() === rootWindow;
+        const preventWheel = wtSettings.getSetting('preventWheel');
+        const wheelEventOptions = {
+            passive: isScrollOnWindow
+        };
+        eventManager.addEventListener(wtTable.wtRootElement, 'wheel', (event)=>_class_private_method_get(this, _onCloneWheel, onCloneWheel).call(this, event, preventWheel), wheelEventOptions);
+        _class_private_field_get(this, _deps).getCloneableOverlays().forEach((overlay)=>{
+            if (!overlay.clone) {
+                return;
+            }
+            eventManager.addEventListener(overlay.clone.wtTable.holder, 'wheel', (event)=>_class_private_method_get(this, _onCloneWheel, onCloneWheel).call(this, event, preventWheel), wheelEventOptions);
+        });
+        let resizeTimeout;
+        eventManager.addEventListener(rootWindow, 'resize', ()=>{
+            (0, _feature.requestAnimationFrame)(()=>{
+                clearTimeout(resizeTimeout);
+                wtSettings.getSetting('onWindowResize');
+                resizeTimeout = setTimeout(()=>{
+                    // Remove resizing the window from the ResizeObserver's endless-loop-blocking logic.
+                    _class_private_field_get(this, _deps).resetResizeCount();
+                }, 200);
+            });
+        });
+        if (!isScrollOnWindow) {
+            _class_private_field_get(this, _deps).observeResize();
+        }
+    }
+    /**
+   * @param {NativeScrollInputDeps} deps The NativeScrollInput dependencies.
+   */ constructor(deps){
+        _class_private_method_init(this, _onTableScroll);
+        _class_private_method_init(this, _onCloneWheel);
+        _class_private_method_init(this, _onKeyDown);
+        _class_private_method_init(this, _onKeyUp);
+        _class_private_method_init(this, _translateMouseWheelToScroll);
+        _class_private_method_init(this, _computeBrowserLineHeight);
+        /**
+   * The NativeScrollInput dependencies.
+   *
+   * @type {NativeScrollInputDeps}
+   */ _class_private_field_init(this, _deps, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _keyPressed, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _browserLineHeight, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _keyPressed, false);
+        _class_private_field_set(this, _deps, deps);
+        _class_private_field_set(this, _browserLineHeight, _class_private_method_get(this, _computeBrowserLineHeight, computeBrowserLineHeight).call(this));
+    }
+}
+function onTableScroll(event) {
+    // There was if statement which controlled flow of this function. It avoided the execution of the next lines
+    // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
+    const { rootWindow } = _class_private_field_get(this, _deps);
+    const masterHorizontal = _class_private_field_get(this, _deps).getInlineStartOverlay().mainTableScrollableElement;
+    const masterVertical = _class_private_field_get(this, _deps).getTopOverlay().mainTableScrollableElement;
+    const target = event.target;
+    // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
+    // by hot.refreshBorder
+    if (_class_private_field_get(this, _keyPressed)) {
+        if (masterVertical !== rootWindow && target !== rootWindow && !(masterVertical instanceof HTMLElement && (0, _element.eventTargetEl)(event).contains(masterVertical)) || masterHorizontal !== rootWindow && target !== rootWindow && !(masterHorizontal instanceof HTMLElement && (0, _element.eventTargetEl)(event).contains(masterHorizontal))) {
+            return;
+        }
+    }
+    _class_private_field_get(this, _deps).syncScrollPositions();
+}
+function onCloneWheel(event, preventDefault) {
+    // Fix for Windows OS, where the ctrl key is used to zoom the page (issue #dev-2405).
+    if (event.ctrlKey) {
+        return;
+    }
+    const { rootWindow } = _class_private_field_get(this, _deps);
+    // There was if statement which controlled flow of this function. It avoided the execution of the next lines
+    // on mobile devices. It was changed. Broader description of this case is included within issue #4856.
+    const masterHorizontal = _class_private_field_get(this, _deps).getInlineStartOverlay().mainTableScrollableElement;
+    const masterVertical = _class_private_field_get(this, _deps).getTopOverlay().mainTableScrollableElement;
+    const target = event.target;
+    // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered
+    // by hot.refreshBorder
+    const shouldNotWheelVertically = masterVertical !== rootWindow && target !== rootWindow && !(target instanceof Node && masterVertical instanceof HTMLElement && target.contains(masterVertical));
+    const shouldNotWheelHorizontally = masterHorizontal !== rootWindow && target !== rootWindow && !(target instanceof Node && masterHorizontal instanceof HTMLElement && target.contains(masterHorizontal));
+    if (_class_private_field_get(this, _keyPressed) && (shouldNotWheelVertically || shouldNotWheelHorizontally) || _class_private_field_get(this, _deps).getScrollableElement() === rootWindow) {
+        return;
+    }
+    const isScrollPossible = _class_private_method_get(this, _translateMouseWheelToScroll, translateMouseWheelToScroll).call(this, event);
+    if (preventDefault || _class_private_field_get(this, _deps).getScrollableElement() !== rootWindow && isScrollPossible) {
+        event.preventDefault();
+    }
+}
+function onKeyDown(event) {
+    _class_private_field_set(this, _keyPressed, (0, _unicode.isKey)(event.keyCode, 'ARROW_UP|ARROW_RIGHT|ARROW_DOWN|ARROW_LEFT'));
+}
+function onKeyUp() {
+    _class_private_field_set(this, _keyPressed, false);
+}
+function translateMouseWheelToScroll(event) {
+    let deltaY;
+    let deltaX;
+    if (isWheelEventWithLegacyDelta(event)) {
+        deltaY = isNaN(event.deltaY) ? -1 * (event.wheelDeltaY ?? 0) : event.deltaY;
+        deltaX = isNaN(event.deltaX) ? -1 * (event.wheelDeltaX ?? 0) : event.deltaX;
+    } else {
+        deltaY = event.deltaY;
+        deltaX = event.deltaX;
+    }
+    if (event.deltaMode === 1) {
+        deltaX += deltaX * _class_private_field_get(this, _browserLineHeight);
+        deltaY += deltaY * _class_private_field_get(this, _browserLineHeight);
+    }
+    const isScrollVerticallyPossible = _class_private_field_get(this, _deps).scrollVertically(deltaY);
+    const isScrollHorizontallyPossible = _class_private_field_get(this, _deps).scrollHorizontally(deltaX);
+    return isScrollVerticallyPossible || isScrollHorizontallyPossible;
+}
+function computeBrowserLineHeight() {
+    const { rootDocument, geometryReader } = _class_private_field_get(this, _deps);
+    const computedStyle = geometryReader.getComputedStyle(rootDocument.body);
+    /**
+     * Sometimes `line-height` might be set to 'normal'. In that case, a default `font-size` should be multiplied by roughly 1.2.
+     * Https://developer.mozilla.org/pl/docs/Web/CSS/line-height#Values.
+     */ const lineHeight = parseInt(computedStyle.lineHeight, 10);
+    const lineHeightFalback = parseInt(computedStyle.fontSize, 10) * 1.2;
+    return lineHeight || lineHeightFalback;
+}