edytor 1.0.0-rc.3 → 2.0.0

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/count-events-for-safari.js

@@ -0,0 +1,104 @@
+import { bindAll } from '../../../bind-event-listener/index.js';
+import { isSafari } from '../is-safari.js';
+
+/* For "dragenter" events, the browser should set `relatedTarget` to the previous element.
+ * For external drag operations, our first "dragenter" event should have a `event.relatedTarget` of `null`.
+ *
+ *  Unfortunately in Safari `event.relatedTarget` is *always* set to `null`
+ *  Safari bug: https://bugs.webkit.org/show_bug.cgi?id=242627
+ *  To work around this we count "dragenter" and "dragleave" events */
+// Using symbols for event properties so we don't clash with
+// anything on the `event` object
+export const symbols = {
+  isLeavingWindow: Symbol('leaving'),
+  isEnteringWindow: Symbol('entering')
+};
+(function fixSafari() {
+  // Don't do anything when server side rendering
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  // rather than checking the userAgent for "jsdom" we can do this check
+  // so that the check will be removed completely in production code
+  if (process.env.NODE_ENV === 'test') {
+    return;
+  }
+  if (!isSafari()) {
+    return;
+  }
+  function getInitialState() {
+    return {
+      enterCount: 0,
+      isOverWindow: false
+    };
+  }
+  let state = getInitialState();
+  function resetState() {
+    state = getInitialState();
+  }
+
+  // These event listeners are bound _forever_ and _never_ removed
+  // We don't bother cleaning up these event listeners (for now)
+  // as this workaround is only for Safari
+
+  // This is how the event count works:
+  //
+  // lift (+1 enterCount)
+  // - dragstart(draggable) [enterCount: 0]
+  // - dragenter(draggable) [enterCount: 1]
+  // leaving draggable (+0 enterCount)
+  // - dragenter(document.body) [enterCount: 2]
+  // - dragleave(draggable) [enterCount: 1]
+  // leaving window (-1 enterCount)
+  // - dragleave(document.body) [enterCount: 0] {leaving the window}
+
+  // Things to note:
+  // - dragenter and dragleave bubble
+  // - the first dragenter when entering a window might not be on `window`
+  //   - it could be on an element that is pressed up against the window
+  //   - (so we cannot rely on `event.target` values)
+
+  bindAll(window, [{
+    type: 'dragstart',
+    listener: () => {
+      state.enterCount = 0;
+      // drag start occurs in the source window
+      state.isOverWindow = true;
+      // When a drag first starts it will also trigger a "dragenter" on the draggable element
+    }
+  }, {
+    type: 'drop',
+    listener: resetState
+  }, {
+    type: 'dragend',
+    listener: resetState
+  }, {
+    type: 'dragenter',
+    listener: event => {
+      if (!state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object
+        // The `event` object is shared with all event listeners for the event
+        event[symbols.isEnteringWindow] = true;
+      }
+      state.isOverWindow = true;
+      state.enterCount++;
+    }
+  }, {
+    type: 'dragleave',
+    listener: event => {
+      state.enterCount--;
+      if (state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object as it is shared with all event listeners
+        // The `event` object is shared with all event listeners for the event
+        event[symbols.isLeavingWindow] = true;
+        state.isOverWindow = false;
+      }
+    }
+  }],
+  // using `capture: true` so that adding event listeners
+  // in bubble phase will have the correct symbols
+  {
+    capture: true
+  });
+})();

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/is-from-another-window.js

@@ -0,0 +1,16 @@
+/**
+ * Does the `EventTarget` look like a `Node` based on "duck typing".
+ *
+ * Helpful when the `Node` might be outside of the current document
+ * so we cannot to an `target instanceof Node` check.
+ */
+function isNodeLike(target) {
+  return 'nodeName' in target;
+}
+
+/**
+ * Is an `EventTarget` a `Node` from another `window`?
+ */
+export function isFromAnotherWindow(eventTarget) {
+  return isNodeLike(eventTarget) && eventTarget.ownerDocument !== document;
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/is-leaving-window-in-safari.js

@@ -0,0 +1,12 @@
+import { isSafari } from '../is-safari.js';
+import { symbols } from './count-events-for-safari.js';
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function isLeavingWindowInSafari({
+  dragLeave
+}) {
+  if (!isSafari()) {
+    return false;
+  }
+  return dragLeave.hasOwnProperty(symbols.isLeavingWindow);
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/is-leaving-window.js

@@ -0,0 +1,55 @@
+import { isFirefox } from '../is-firefox.js';
+import { isSafari } from '../is-safari.js';
+import { isFromAnotherWindow } from './is-from-another-window.js';
+import { isLeavingWindowInSafari } from './is-leaving-window-in-safari.js';
+export function isLeavingWindow({
+  dragLeave
+}) {
+  const {
+    type,
+    relatedTarget
+  } = dragLeave;
+  if (type !== 'dragleave') {
+    return false;
+  }
+  if (isSafari()) {
+    return isLeavingWindowInSafari({
+      dragLeave
+    });
+  }
+
+  // Standard check: if going to `null` we are leaving the `window`
+  if (relatedTarget == null) {
+    return true;
+  }
+
+  /**
+   * 🦊 Exception: `iframe` in Firefox (`125.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `dragLeave.relatedTarget` is element _inside_ the child `iframe`
+   * (foreign element)
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
+   * (foreign element)
+   */
+
+  if (isFirefox()) {
+    return isFromAnotherWindow(relatedTarget);
+  }
+
+  /**
+   * 🌏 Exception: `iframe` in Chrome (`124.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `dragLeave.relatedTarget` is `null` *(standard check)*
+   */
+
+  // Case 2
+  // Using `instanceof` check as the element will be in the same `window`
+  return relatedTarget instanceof HTMLIFrameElement;
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/detect-broken-drag.js

@@ -0,0 +1,48 @@
+export function getBindingsForBrokenDrags({
+  onDragEnd
+}) {
+  return [
+  // ## Detecting drag ending for removed draggables
+  //
+  // If a draggable element is removed during a drag and the user drops:
+  // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+  // 2. if not over a valid drop target (or cancelled): we get nothing
+  // The "dragend" event will not fire on the source draggable if it has been
+  // removed from the DOM.
+  // So we need to figure out if a drag operation has finished by looking at other events
+  // We can do this by looking at other events
+
+  // ### First detection: "pointermove" events
+
+  // 1. "pointermove" events cannot fire during a drag and drop operation
+  // according to the spec. So if we get a "pointermove" it means that
+  // the drag and drop operations has finished. So if we get a "pointermove"
+  // we know that the drag is over
+  // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+  // other pointer events. However, firefox will allow a few
+  // pointer event to get through after a drag starts.
+  // The most I've seen is 3
+  {
+    type: 'pointermove',
+    listener: (() => {
+      let callCount = 0;
+      return function listener() {
+        // Using 20 as it is far bigger than the most observed (3)
+        if (callCount < 20) {
+          callCount++;
+          return;
+        }
+        onDragEnd();
+      };
+    })()
+  },
+  // ### Second detection: "pointerdown" events
+
+  // If we receive this event then we know that a drag operation has finished
+  // and potentially another one is about to start.
+  // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+  {
+    type: 'pointerdown',
+    listener: onDragEnd
+  }];
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/get-input.js

@@ -0,0 +1,14 @@
+export function getInput(event) {
+  return {
+    altKey: event.altKey,
+    button: event.button,
+    buttons: event.buttons,
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey,
+    shiftKey: event.shiftKey,
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pageX: event.pageX,
+    pageY: event.pageY
+  };
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/is-firefox.js

@@ -0,0 +1,13 @@
+import { once } from '../public-utils/once.js';
+
+// using `cache` as our `isFirefox()` result will not change in a browser
+
+/**
+ * Returns `true` if a `Firefox` browser
+ * */
+export const isFirefox = once(function isFirefox() {
+  if (process.env.NODE_ENV === 'test') {
+    return false;
+  }
+  return navigator.userAgent.includes('Firefox');
+});

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/is-safari.js

@@ -0,0 +1,19 @@
+import { once } from '../public-utils/once.js';
+
+// using `cache` as our `isSafari()` result will not change in a browser
+
+/**
+ * Returns `true` if a `Safari` browser.
+ * Returns `true` if the browser is running on iOS (they are all Safari).
+ *
+ * Use `isSafariOnIOS` if you want to check if something is Safari + iOS
+ * */
+export const isSafari = once(function isSafari() {
+  if (process.env.NODE_ENV === 'test') {
+    return false;
+  }
+  const {
+    userAgent
+  } = navigator;
+  return userAgent.includes('AppleWebKit') && !userAgent.includes('Chrome');
+});

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/max-z-index.js

@@ -0,0 +1,3 @@
+// Maximum possible z-index
+// https://stackoverflow.com/questions/491052/minimum-and-maximum-value-of-z-index
+export const maxZIndex = 2147483647;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/media-types/text-media-type.js

@@ -0,0 +1,6 @@
+// Why we put the media types in their own files:
+//
+// - we are not putting them all in one file as not all adapters need all types
+// - we are not putting them in the external helpers as some things just need the
+//   types and not the external functions code
+export const textMediaType = 'text/plain';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/media-types/url-media-type.js

@@ -0,0 +1,6 @@
+// Why we put the media types in their own files:
+//
+// - we are not putting them all in one file as not all adapters need all types
+// - we are not putting them in the external helpers as some things just need the
+//   types and not the external functions code
+export const URLMediaType = 'text/uri-list';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/popover-reset-styles.js

@@ -0,0 +1,40 @@
+/**
+ * Resets user agent styles for `[popover]` elements.
+ *
+ * Browsers apply these defaults to popovers (per the WHATWG HTML spec rendering section):
+ * - `inset: 0` + `margin: auto` → centers the popover in the viewport
+ * - `border: solid` → visible border
+ * - `padding: 0.25em` → internal spacing
+ * - `overflow: auto` → scrollbars when content overflows
+ * - `color: CanvasText` + `background-color: Canvas` → system theme colors
+ *
+ * This object neutralizes those defaults so the popover behaves like a plain
+ * positioned `<div>`, matching the sizing of the legacy (non-popover)
+ * fallback container exactly.
+ *
+ * **Width and height (`auto`)**
+ *
+ * `width` and `height` override the spec user agent value of `fit-content`
+ * with `auto`.
+ *
+ * _Why?_
+ *
+ * - When a `[popover]` is sized with `fit-content` and contains a flex
+ *   container, Safari collapses any flex item that uses `overflow: auto`
+ *   to `0px`.
+ * - Setting the popover's `width` and `height` to `auto` skips the `fit-content`
+ *   pass and avoids the bug in Safari
+ * - Chromium and Firefox tolerate `fit-content` here, but `auto` is safe
+ *   everywhere and matches our non-popover path
+ */
+export const popoverResetUserAgentStyles = {
+  inset: 'unset',
+  border: 'none',
+  padding: 0,
+  margin: 0,
+  overflow: 'visible',
+  color: 'inherit',
+  background: 'transparent',
+  width: 'auto',
+  height: 'auto'
+};

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/supports-popover.js

@@ -0,0 +1,16 @@
+import { once } from '../public-utils/once.js';
+
+// Using `once` as the value won't change in a browser
+
+/**
+ * Returns `true` if the browser supports the Popover API (top-layer).
+ *
+ * When supported, elements with `popover="manual"` can be promoted to the
+ * browser's top layer via `element.showPopover()`, which is more reliable
+ * than `z-index` for ensuring an element renders above everything else.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Popover_API
+ */
+export const supportsPopover = once(function supportsPopover() {
+  return typeof HTMLElement !== 'undefined' && typeof HTMLElement.prototype.showPopover === 'function';
+});

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, 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.

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/element.d.ts

@@ -0,0 +1,4 @@
+import type { ElementDragType, CleanupFn } from '../../pragmatic-drag-and-drop/entry-point/types.js';
+import type { ElementAutoScrollArgs, WindowAutoScrollArgs } from '../internal-types.js';
+export declare const autoScrollForElements: (args: ElementAutoScrollArgs<ElementDragType>) => CleanupFn;
+export declare const autoScrollWindowForElements: (args?: WindowAutoScrollArgs<ElementDragType>) => CleanupFn;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/element.js

@@ -0,0 +1,8 @@
+import { monitorForElements } from '../../pragmatic-drag-and-drop/adapter/element-adapter.js';
+import { makeApi } from '../over-element/make-api.js';
+const api = makeApi({
+  monitor: monitorForElements
+});
+export const autoScrollForElements = api.autoScroll;
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export const autoScrollWindowForElements = api.autoScrollWindow;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/internal-types.d.ts

@@ -0,0 +1,50 @@
+import type { AllDragTypes, Input } from '../pragmatic-drag-and-drop/entry-point/types.js';
+export type ElementGetFeedbackArgs<DragType extends AllDragTypes> = {
+    /**
+     * The users _current_ input
+     */
+    input: Input;
+    /**
+     * The data associated with the entity being dragged
+     */
+    source: DragType['payload'];
+    /**
+     * The element trying to be scrolled
+     */
+    element: Element;
+};
+export type WindowGetFeedbackArgs<DragType extends AllDragTypes> = Omit<ElementGetFeedbackArgs<DragType>, 'element'>;
+export type Spacing = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type Edge = keyof Spacing;
+export type EngagementHistoryEntry = {
+    timeOfEngagementStart: number;
+};
+export type InternalConfig = {
+    startHitboxAtPercentageRemainingOfElement: Spacing;
+    maxScrollAtPercentageRemainingOfHitbox: Spacing;
+    maxPixelScrollPerSecond: number;
+    timeDampeningDurationMs: number;
+    maxMainAxisHitboxSize: number;
+};
+export type PublicConfig = Partial<{
+    maxScrollSpeed: 'standard' | 'fast';
+}>;
+export type ElementAutoScrollArgs<DragType extends AllDragTypes> = {
+    element: Element;
+    canScroll?: (args: ElementGetFeedbackArgs<DragType>) => boolean;
+    getAllowedAxis?: (args: ElementGetFeedbackArgs<DragType>) => AllowedAxis;
+    getConfiguration?: (args: ElementGetFeedbackArgs<DragType>) => PublicConfig;
+};
+export type WindowAutoScrollArgs<DragType extends AllDragTypes> = {
+    canScroll?: (args: WindowGetFeedbackArgs<DragType>) => boolean;
+    getAllowedAxis?: (args: WindowGetFeedbackArgs<DragType>) => AllowedAxis;
+    getConfiguration?: (args: WindowGetFeedbackArgs<DragType>) => PublicConfig;
+};
+export type Side = 'start' | 'end';
+export type Axis = 'vertical' | 'horizontal';
+export type AllowedAxis = Axis | 'all';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/over-element/data-attributes.js

@@ -0,0 +1,9 @@
+export const dataAttribute = 'data-auto-scrollable';
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export const selector = `[${dataAttribute}="true"]`;
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function addScrollableAttribute(element) {
+  element.setAttribute(dataAttribute, 'true');
+  return () => element.removeAttribute(dataAttribute);
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/over-element/get-scroll-by.js

@@ -0,0 +1,117 @@
+import { canScrollOnEdge } from '../shared/can-scroll-on-edge.js';
+import { edgeAxisLookup, edges } from '../shared/edges.js';
+import { getOverElementHitbox } from '../shared/get-over-element-hitbox.js';
+import { getScrollChange } from '../shared/get-scroll-change.js';
+import { isAxisAllowed } from '../shared/is-axis-allowed.js';
+import { isWithin } from '../shared/is-within.js';
+function getRectDefault(element) {
+  return element.getBoundingClientRect();
+}
+export function getScrollBy({
+  element,
+  input,
+  timeSinceLastFrame,
+  engagement,
+  config,
+  allowedAxis,
+  getRect = getRectDefault
+}) {
+  const client = {
+    x: input.clientX,
+    y: input.clientY
+  };
+  const clientRect = getRect(element);
+  const scrollableEdges = edges.reduce((map, edge) => {
+    const hitbox = getOverElementHitbox[edge]({
+      clientRect,
+      config
+    });
+    const axis = edgeAxisLookup[edge];
+
+    // Note: changing the allowed axis during a drag will not
+    // reset time dampening. It was decided it would be too
+    // complex to implement initially, and we can add it
+    // later if needed.
+    if (!isAxisAllowed(axis, allowedAxis)) {
+      return map;
+    }
+    if (!isWithin({
+      client,
+      clientRect: hitbox
+    })) {
+      return map;
+    }
+    if (!canScrollOnEdge[edge](element)) {
+      return map;
+    }
+    map.set(edge, {
+      edge,
+      hitbox
+    });
+    return map;
+  }, new Map());
+  const left = (() => {
+    const axis = 'horizontal';
+    const leftEdge = scrollableEdges.get('left');
+    if (leftEdge) {
+      return getScrollChange({
+        client,
+        edge: leftEdge.edge,
+        hitbox: leftEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    const rightEdge = scrollableEdges.get('right');
+    if (rightEdge) {
+      return getScrollChange({
+        client,
+        edge: rightEdge.edge,
+        hitbox: rightEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    return 0;
+  })();
+  const top = (() => {
+    const axis = 'vertical';
+    const bottomEdge = scrollableEdges.get('bottom');
+    if (bottomEdge) {
+      return getScrollChange({
+        client,
+        edge: bottomEdge.edge,
+        hitbox: bottomEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    const topEdge = scrollableEdges.get('top');
+    if (topEdge) {
+      return getScrollChange({
+        client,
+        edge: topEdge.edge,
+        hitbox: topEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    return 0;
+  })();
+  return {
+    left,
+    top
+  };
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/over-element/make-api.js

@@ -0,0 +1,90 @@
+import { combine } from '../../pragmatic-drag-and-drop/public-utils/combine.js';
+import { once } from '../../pragmatic-drag-and-drop/public-utils/once.js';
+import { getScheduler } from '../shared/scheduler.js';
+import { addScrollableAttribute } from './data-attributes.js';
+import { tryScroll } from './try-scroll.js';
+export function makeApi({
+  monitor
+}) {
+  const elementRegistry = new Map();
+  const windowRegistry = new Set();
+  function autoScroll(args) {
+    // Warn during development if trying to add auto scroll to an element
+    // that is not scrollable.
+    // Note: this can produce a false positive when a scroll container is not
+    // scrollable initially, but becomes scrollable during a drag.
+    // I thought of adding the warning as I think it would be a more common pitfall
+    // to accidentally register auto scrolling on the wrong element
+    // If requested, we could provide a mechanism to opt out of this warning
+    if (process.env.NODE_ENV !== 'production') {
+      const {
+        overflowX,
+        overflowY
+      } = window.getComputedStyle(args.element);
+      const isScrollable = overflowX === 'auto' || overflowX === 'scroll' || overflowY === 'auto' || overflowY === 'scroll';
+      if (!isScrollable) {
+        // eslint-disable-next-line no-console
+        console.warn('Auto scrolling has been attached to an element that appears not to be scrollable', {
+          element: args.element,
+          overflowX,
+          overflowY
+        });
+      }
+    }
+
+    // Warn if there is an existing registration
+    if (process.env.NODE_ENV !== 'production') {
+      const existing = elementRegistry.get(args.element);
+      if (existing) {
+        // eslint-disable-next-line no-console
+        console.warn('You have already registered autoScrolling on the same element', {
+          existing,
+          proposed: args
+        });
+      }
+    }
+    elementRegistry.set(args.element, args);
+    const cleanup = combine(addScrollableAttribute(args.element), () => elementRegistry.delete(args.element));
+    return once(cleanup);
+  }
+  function autoScrollWindow(args = {}) {
+    // Putting `args` in a unique object so that
+    // each call will create a unique entry, even if a consumer
+    // shares the `args` object between calls.
+    // Just being safe here.
+    const unique = {
+      ...args
+    };
+    windowRegistry.add(unique);
+    function cleanup() {
+      windowRegistry.delete(unique);
+    }
+    return once(cleanup);
+  }
+  function findEntry(element) {
+    var _elementRegistry$get;
+    return (_elementRegistry$get = elementRegistry.get(element)) !== null && _elementRegistry$get !== void 0 ? _elementRegistry$get : null;
+  }
+  function getWindowScrollEntries() {
+    return Array.from(windowRegistry);
+  }
+  function onFrame({
+    latestArgs,
+    underUsersPointer,
+    timeSinceLastFrame
+  }) {
+    tryScroll({
+      input: latestArgs.location.current.input,
+      source: latestArgs.source,
+      findEntry,
+      underUsersPointer,
+      timeSinceLastFrame,
+      getWindowScrollEntries
+    });
+  }
+  getScheduler(monitor).onFrame(onFrame);
+  return {
+    autoScroll,
+    autoScrollWindow
+  };
+}