handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/core/clone.mjs

@@ -1,4 +1,5 @@
-import Event from '../event.mjs';
+import Event, { createEventDeps } from '../event.mjs';
+import { createTableDeps } from '../table/baseTable.mjs';
 import CoreAbstract from './_base.mjs';
 class Clone extends CoreAbstract {
     /**
@@ -6,14 +7,18 @@ class Clone extends CoreAbstract {
    * @param {SettingsPure|Settings} settings The Walkontable settings.
    * @param {WalkontableCloneOptions} clone Clone data.
    */ constructor(table, settings, clone){
-        super(table, settings);
-        const facadeGetter = this.wtSettings.getSetting('facade', this);
+        // Share the master's geometry reader instead of creating a new one, so a single reader serves
+        // the master and all overlay clones.
+        super(table, settings, clone.geometryReader);
         this.cloneSource = clone.source;
         this.cloneOverlay = clone.overlay;
-        this.wtTable = this.cloneOverlay.createTable(this.getTableDao(), facadeGetter, this.domBindings, this.wtSettings);
+        this.wtTable = this.cloneOverlay.createTable(createTableDeps(this.engineContext));
         this.wtViewport = clone.viewport;
         this.selectionManager = clone.selectionManager;
-        this.wtEvent = new Event(facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable, this.selectionManager, clone.event);
+        // Event deps resolve `getWtTable()`/`getSelectionManager()` off this clone's context, so they
+        // read the clone's own table and selection manager (set just above). The parent Event is the
+        // per-instance link back to the master, kept as a separate argument.
+        this.wtEvent = new Event(createEventDeps(this.engineContext), clone.event);
         this.findOriginalHeaders();
     }
 }

package/3rdparty/walkontable/src/core/core.d.ts

@@ -1,5 +1,5 @@
 import CoreAbstract from './_base';
-import type { Overlay } from '../overlay/_base';
+import type { Overlay } from '../overlay/regions/_base';
 /**
  * @class Walkontable
  */
@@ -24,8 +24,4 @@ export default class Walkontable extends CoreAbstract {
      * @returns {Overlay | null}
      */
     getOverlayByName(overlayName: string): Overlay | null;
-    /**
-     * @returns {Record<string, unknown>}
-     */
-    getViewportDao(): Record<string, unknown>;
 }

package/3rdparty/walkontable/src/core/core.js

@@ -8,12 +8,13 @@ Object.defineProperty(exports, "default", {
         return Walkontable;
     }
 });
-const _event = /*#__PURE__*/ _interop_require_default(require("../event"));
-const _overlays = /*#__PURE__*/ _interop_require_default(require("../overlays"));
+const _event = /*#__PURE__*/ _interop_require_wildcard(require("../event"));
+const _overlays = /*#__PURE__*/ _interop_require_wildcard(require("../overlay/overlays"));
 const _overlay = require("../overlay");
 const _settings = /*#__PURE__*/ _interop_require_default(require("../settings"));
-const _master = /*#__PURE__*/ _interop_require_default(require("../table/master"));
-const _viewport = /*#__PURE__*/ _interop_require_default(require("../viewport"));
+const _masterTable = /*#__PURE__*/ _interop_require_default(require("../table/regions/masterTable"));
+const _baseTable = require("../table/baseTable");
+const _viewport = /*#__PURE__*/ _interop_require_wildcard(require("../viewport/viewport"));
 const _base = /*#__PURE__*/ _interop_require_default(require("./_base"));
 const _manager = require("../selection/manager");
 const _object = require("../../../../helpers/object");
@@ -23,6 +24,47 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 class Walkontable extends _base.default {
     /**
    * Export settings as class names added to the parent element of the table.
@@ -61,54 +103,17 @@ class Walkontable extends _base.default {
         return this.wtOverlays[`${camelCaseOverlay}Overlay`] ?? null;
     }
     /**
-   * @returns {Record<string, unknown>}
-   */ getViewportDao() {
-        return ((instance)=>({
-                get wot () {
-                    return instance;
-                },
-                get topOverlayTrimmingContainer () {
-                    return instance.wtOverlays.topOverlay.trimmingContainer;
-                },
-                get inlineStartOverlayTrimmingContainer () {
-                    return instance.wtOverlays.inlineStartOverlay.trimmingContainer;
-                },
-                get topScrollPosition () {
-                    return instance.wtOverlays.topOverlay.getScrollPosition();
-                },
-                get topParentOffset () {
-                    return instance.wtOverlays.topOverlay.getTableParentOffset();
-                },
-                get inlineStartScrollPosition () {
-                    return instance.wtOverlays.inlineStartOverlay.getScrollPosition();
-                },
-                get inlineStartParentOffset () {
-                    return instance.wtOverlays.inlineStartOverlay.getTableParentOffset();
-                },
-                get topOverlay () {
-                    return instance.wtOverlays.topOverlay; // TODO refactoring: move outside dao, use IOC
-                },
-                get inlineStartOverlay () {
-                    return instance.wtOverlays.inlineStartOverlay; // TODO refactoring: move outside dao, use IOC
-                },
-                get bottomOverlay () {
-                    return instance.wtOverlays.bottomOverlay; // TODO refactoring: move outside dao, use IOC
-                }
-            }))(this);
-    }
-    /**
    * @param {HTMLTableElement} table Main table.
    * @param {SettingsPure} settings The Walkontable settings.
    */ constructor(table, settings){
         super(table, new _settings.default(settings));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const facadeGetter = this.wtSettings.getSetting('facade', this); // todo rethink. I would like to have no access to facade from the internal scope.
-        this.wtTable = new _master.default(this.getTableDao(), facadeGetter, this.domBindings, this.wtSettings);
-        this.wtViewport = new _viewport.default(this.getViewportDao(), this.domBindings, this.wtSettings, this.eventManager, this.wtTable);
+        this.wtTable = new _masterTable.default((0, _baseTable.createTableDeps)(this.engineContext));
+        // Built after the master table exists (the deps resolve `getWtTable()` concretely); the overlays
+        // are still late-bound and come through as thunks in the deps.
+        this.wtViewport = new _viewport.default((0, _viewport.createViewportDeps)(this.engineContext));
         this.selectionManager = new _manager.SelectionManager(this.wtSettings.getSetting('selections'));
-        this.wtEvent = new _event.default(facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable, this.selectionManager);
-        this.wtOverlays = new _overlays.default(// TODO create DAO and remove reference to the Walkontable instance.
-        this, facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable);
+        this.wtEvent = new _event.default((0, _event.createEventDeps)(this.engineContext));
+        this.wtOverlays = new _overlays.default((0, _overlays.createOverlaysDeps)(this.engineContext));
         this.exportSettingsAsClassNames();
         this.findOriginalHeaders();
     }

package/3rdparty/walkontable/src/core/core.mjs

@@ -1,9 +1,10 @@
-import Event from '../event.mjs';
-import Overlays from '../overlays.mjs';
+import Event, { createEventDeps } from '../event.mjs';
+import Overlays, { createOverlaysDeps } from '../overlay/overlays.mjs';
 import { CLONE_TYPES } from '../overlay/index.mjs';
-import Settings from '../settings.mjs';
-import MasterTable from '../table/master.mjs';
-import Viewport from '../viewport.mjs';
+import Settings from '../settings/index.mjs';
+import MasterTable from '../table/regions/masterTable.mjs';
+import { createTableDeps } from '../table/baseTable.mjs';
+import Viewport, { createViewportDeps } from '../viewport/viewport.mjs';
 import CoreAbstract from './_base.mjs';
 import { SelectionManager } from '../selection/manager.mjs';
 import { objectEach } from '../../../../helpers/object.mjs';
@@ -46,54 +47,17 @@ class Walkontable extends CoreAbstract {
         return this.wtOverlays[`${camelCaseOverlay}Overlay`] ?? null;
     }
     /**
-   * @returns {Record<string, unknown>}
-   */ getViewportDao() {
-        return ((instance)=>({
-                get wot () {
-                    return instance;
-                },
-                get topOverlayTrimmingContainer () {
-                    return instance.wtOverlays.topOverlay.trimmingContainer;
-                },
-                get inlineStartOverlayTrimmingContainer () {
-                    return instance.wtOverlays.inlineStartOverlay.trimmingContainer;
-                },
-                get topScrollPosition () {
-                    return instance.wtOverlays.topOverlay.getScrollPosition();
-                },
-                get topParentOffset () {
-                    return instance.wtOverlays.topOverlay.getTableParentOffset();
-                },
-                get inlineStartScrollPosition () {
-                    return instance.wtOverlays.inlineStartOverlay.getScrollPosition();
-                },
-                get inlineStartParentOffset () {
-                    return instance.wtOverlays.inlineStartOverlay.getTableParentOffset();
-                },
-                get topOverlay () {
-                    return instance.wtOverlays.topOverlay; // TODO refactoring: move outside dao, use IOC
-                },
-                get inlineStartOverlay () {
-                    return instance.wtOverlays.inlineStartOverlay; // TODO refactoring: move outside dao, use IOC
-                },
-                get bottomOverlay () {
-                    return instance.wtOverlays.bottomOverlay; // TODO refactoring: move outside dao, use IOC
-                }
-            }))(this);
-    }
-    /**
    * @param {HTMLTableElement} table Main table.
    * @param {SettingsPure} settings The Walkontable settings.
    */ constructor(table, settings){
         super(table, new Settings(settings));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const facadeGetter = this.wtSettings.getSetting('facade', this); // todo rethink. I would like to have no access to facade from the internal scope.
-        this.wtTable = new MasterTable(this.getTableDao(), facadeGetter, this.domBindings, this.wtSettings);
-        this.wtViewport = new Viewport(this.getViewportDao(), this.domBindings, this.wtSettings, this.eventManager, this.wtTable);
+        this.wtTable = new MasterTable(createTableDeps(this.engineContext));
+        // Built after the master table exists (the deps resolve `getWtTable()` concretely); the overlays
+        // are still late-bound and come through as thunks in the deps.
+        this.wtViewport = new Viewport(createViewportDeps(this.engineContext));
         this.selectionManager = new SelectionManager(this.wtSettings.getSetting('selections'));
-        this.wtEvent = new Event(facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable, this.selectionManager);
-        this.wtOverlays = new Overlays(// TODO create DAO and remove reference to the Walkontable instance.
-        this, facadeGetter, this.domBindings, this.wtSettings, this.eventManager, this.wtTable);
+        this.wtEvent = new Event(createEventDeps(this.engineContext));
+        this.wtOverlays = new Overlays(createOverlaysDeps(this.engineContext));
         this.exportSettingsAsClassNames();
         this.findOriginalHeaders();
     }

package/3rdparty/walkontable/src/domMeasure/geometryReader.d.mts

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

package/3rdparty/walkontable/src/domMeasure/geometryReader.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Reads geometric measurements from the DOM.
+ *
+ * Every layout-forcing DOM read in the rendering engine goes through this port instead of reading
+ * element properties (`clientHeight`, `offsetWidth`, …) directly. Centralizing the reads here is the
+ * seam a caching layer can later slot into: a future adapter can memoize measurements per draw
+ * without changing any call site.
+ *
+ * The only adapter today is `LiveGeometryReader` — a stateless pass-through that reads straight from
+ * the DOM and holds no cache, so it introduces no behavior change.
+ *
+ * The contract currently covers the reads used by the viewport calculations. It grows as more
+ * modules are routed through the port; only methods matched to a real call site are declared.
+ *
+ * @interface GeometryReader
+ */
+export interface GeometryReader {
+    /**
+     * Reads `element.clientWidth`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    clientWidth(element: HTMLElement): number;
+    /**
+     * Reads `element.clientHeight`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    clientHeight(element: HTMLElement): number;
+    /**
+     * Reads `element.offsetWidth`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetWidth(element: HTMLElement): number;
+    /**
+     * Reads `element.offsetHeight`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetHeight(element: HTMLElement): number;
+    /**
+     * Reads `element.offsetTop`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetTop(element: HTMLElement): number;
+    /**
+     * Reads `element.offsetLeft`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetLeft(element: HTMLElement): number;
+    /**
+     * Reads `element.offsetParent`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {HTMLElement | null}
+     */
+    offsetParent(element: HTMLElement): HTMLElement | null;
+    /**
+     * Checks whether the element takes part in the layout, so that its own and its ancestors' styles
+     * describe where it is rendered.
+     *
+     * @param {HTMLElement} element The element to check.
+     * @returns {boolean}
+     */
+    isRendered(element: HTMLElement): boolean;
+    /**
+     * Reads `element.scrollWidth`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    scrollWidth(element: HTMLElement): number;
+    /**
+     * Reads `element.scrollHeight`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    scrollHeight(element: HTMLElement): number;
+    /**
+     * Reads `element.getBoundingClientRect()`.
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {DOMRect}
+     */
+    getBoundingClientRect(element: HTMLElement): DOMRect;
+    /**
+     * Returns the element width including borders (the `outerWidth` DOM helper).
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    outerWidth(element: HTMLElement): number;
+    /**
+     * Returns the element height including borders (the `outerHeight` DOM helper).
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    outerHeight(element: HTMLElement): number;
+    /**
+     * Returns the element height without borders (the `innerHeight` DOM helper).
+     *
+     * @param {HTMLElement | Window} element The element (or window) to measure.
+     * @returns {number}
+     */
+    innerHeight(element: HTMLElement | Window): number;
+    /**
+     * Returns the element width without borders (the `innerWidth` DOM helper).
+     *
+     * @param {HTMLElement | Window} element The element (or window) to measure.
+     * @returns {number}
+     */
+    innerWidth(element: HTMLElement | Window): number;
+    /**
+     * Returns the element offset relative to the document (the `offset` DOM helper).
+     *
+     * @param {HTMLElement} element The element to measure.
+     * @returns {{ left: number, top: number }}
+     */
+    offset(element: HTMLElement): {
+        left: number;
+        top: number;
+    };
+    /**
+     * Returns the browser scrollbar width (the `getScrollbarWidth` DOM helper). The document argument
+     * is optional and forwarded verbatim so existing call sites keep their exact behavior — some pass
+     * the root document, some rely on the helper's default.
+     *
+     * @param {Document} [rootDocument] The document used to measure the scrollbar.
+     * @returns {number}
+     */
+    getScrollbarWidth(rootDocument?: Document): number;
+    /**
+     * Returns the element's resolved computed style (`rootWindow.getComputedStyle`).
+     *
+     * @param {Element} element The element to read.
+     * @returns {CSSStyleDeclaration}
+     */
+    getComputedStyle(element: Element): CSSStyleDeclaration;
+    /**
+     * Returns a single resolved computed-style property (the `getStyle` DOM helper).
+     *
+     * @param {HTMLElement} element The element to read.
+     * @param {string} property The CSS property name.
+     * @returns {string | undefined}
+     */
+    getStyle(element: HTMLElement, property: string): string | undefined;
+    /**
+     * Returns the element's maximum vertical scroll offset (the `getMaximumScrollTop` DOM helper).
+     *
+     * @param {HTMLElement} element The element to read.
+     * @returns {number}
+     */
+    getMaximumScrollTop(element: HTMLElement): number;
+    /**
+     * Returns the element's maximum horizontal scroll offset (the `getMaximumScrollLeft` DOM helper).
+     *
+     * @param {HTMLElement} element The element to read.
+     * @returns {number}
+     */
+    getMaximumScrollLeft(element: HTMLElement): number;
+}

package/3rdparty/walkontable/src/domMeasure/geometryReader.js

@@ -0,0 +1,19 @@
+/**
+ * Reads geometric measurements from the DOM.
+ *
+ * Every layout-forcing DOM read in the rendering engine goes through this port instead of reading
+ * element properties (`clientHeight`, `offsetWidth`, …) directly. Centralizing the reads here is the
+ * seam a caching layer can later slot into: a future adapter can memoize measurements per draw
+ * without changing any call site.
+ *
+ * The only adapter today is `LiveGeometryReader` — a stateless pass-through that reads straight from
+ * the DOM and holds no cache, so it introduces no behavior change.
+ *
+ * The contract currently covers the reads used by the viewport calculations. It grows as more
+ * modules are routed through the port; only methods matched to a real call site are declared.
+ *
+ * @interface GeometryReader
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/3rdparty/walkontable/src/domMeasure/geometryReader.mjs

@@ -0,0 +1,16 @@
+/**
+ * Reads geometric measurements from the DOM.
+ *
+ * Every layout-forcing DOM read in the rendering engine goes through this port instead of reading
+ * element properties (`clientHeight`, `offsetWidth`, …) directly. Centralizing the reads here is the
+ * seam a caching layer can later slot into: a future adapter can memoize measurements per draw
+ * without changing any call site.
+ *
+ * The only adapter today is `LiveGeometryReader` — a stateless pass-through that reads straight from
+ * the DOM and holds no cache, so it introduces no behavior change.
+ *
+ * The contract currently covers the reads used by the viewport calculations. It grows as more
+ * modules are routed through the port; only methods matched to a real call site are declared.
+ *
+ * @interface GeometryReader
+ */ export { };

package/3rdparty/walkontable/src/domMeasure/liveGeometryReader.d.mts

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

package/3rdparty/walkontable/src/domMeasure/liveGeometryReader.d.ts

@@ -0,0 +1,134 @@
+import type { GeometryReader } from './geometryReader';
+/**
+ * The live (uncached) implementation of {@link GeometryReader}.
+ *
+ * Element-property reads return the property directly; measurement reads delegate to the shared
+ * `helpers/dom/element` functions. The class is stateless and holds no cache, so it reads the same
+ * values at the same time as the previous inline reads — it changes structure, not behavior.
+ *
+ * @class LiveGeometryReader
+ */
+export declare class LiveGeometryReader implements GeometryReader {
+    #private;
+    /**
+     * @param {Window} rootWindow The window used to resolve computed styles.
+     */
+    constructor(rootWindow: Window);
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    clientWidth(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    clientHeight(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetWidth(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetHeight(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetTop(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    offsetLeft(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {HTMLElement | null}
+     */
+    offsetParent(element: HTMLElement): HTMLElement | null;
+    /**
+     * A box test, deliberately not a style test: `display: none` and `content-visibility: hidden`
+     * generate no boxes yet read their styles correctly, and this asks whether the geometry can be
+     * measured. Whether the styles resolve is `StylesHandler`'s question. See the unrendered-table
+     * section of `walkontable/AGENTS.md`.
+     *
+     * @param {HTMLElement} element The element to check.
+     * @returns {boolean}
+     */
+    isRendered(element: HTMLElement): boolean;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    scrollWidth(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    scrollHeight(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {DOMRect}
+     */
+    getBoundingClientRect(element: HTMLElement): DOMRect;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    outerWidth(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {number}
+     */
+    outerHeight(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement | Window} element The element (or window) to measure.
+     * @returns {number}
+     */
+    innerHeight(element: HTMLElement | Window): number;
+    /**
+     * @param {HTMLElement | Window} element The element (or window) to measure.
+     * @returns {number}
+     */
+    innerWidth(element: HTMLElement | Window): number;
+    /**
+     * @param {HTMLElement} element The element to measure.
+     * @returns {{ left: number, top: number }}
+     */
+    offset(element: HTMLElement): {
+        left: number;
+        top: number;
+    };
+    /**
+     * Forwards the optional document argument verbatim to preserve the exact behavior of each call
+     * site (some pass the root document, some rely on the helper's default global document).
+     *
+     * @param {Document} [rootDocument] The document used to measure the scrollbar.
+     * @returns {number}
+     */
+    getScrollbarWidth(rootDocument?: Document): number;
+    /**
+     * @param {HTMLElement} element The element to read.
+     * @returns {CSSStyleDeclaration}
+     */
+    getComputedStyle(element: HTMLElement): CSSStyleDeclaration;
+    /**
+     * @param {HTMLElement} element The element to read.
+     * @param {string} property The CSS property name.
+     * @returns {string | undefined}
+     */
+    getStyle(element: HTMLElement, property: string): string | undefined;
+    /**
+     * @param {HTMLElement} element The element to read.
+     * @returns {number}
+     */
+    getMaximumScrollTop(element: HTMLElement): number;
+    /**
+     * @param {HTMLElement} element The element to read.
+     * @returns {number}
+     */
+    getMaximumScrollLeft(element: HTMLElement): number;
+}