jqtree 1.8.9 → 1.8.11

package/tree.jquery.debug.js

@@ -1,7 +1,7 @@
 /*
-JqTree 1.8.8
+JqTree 1.8.11
 
-Copyright 2024 Marco Braak
+Copyright 2026 Marco Braak
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -21,15 +21,14 @@ var jqtree = (function (exports) {
     'use strict';
 
     class DataLoader {
-      constructor(_ref) {
-        let {
-          dataFilter,
-          loadData,
-          onLoadFailed,
-          onLoading,
-          treeElement,
-          triggerEvent
-        } = _ref;
+      constructor({
+        dataFilter,
+        loadData,
+        onLoadFailed,
+        onLoading,
+        treeElement,
+        triggerEvent
+      }) {
         this.dataFilter = dataFilter;
         this.loadData = loadData;
         this.onLoadFailed = onLoadFailed;
@@ -119,31 +118,6 @@ var jqtree = (function (exports) {
       }
     }
 
-    let Position = /*#__PURE__*/function (Position) {
-      Position[Position["Before"] = 1] = "Before";
-      Position[Position["After"] = 2] = "After";
-      Position[Position["Inside"] = 3] = "Inside";
-      Position[Position["None"] = 4] = "None";
-      return Position;
-    }({});
-    const positionNames = {
-      after: Position.After,
-      before: Position.Before,
-      inside: Position.Inside,
-      none: Position.None
-    };
-    const getPositionName = position => {
-      for (const name in positionNames) {
-        if (Object.prototype.hasOwnProperty.call(positionNames, name)) {
-          if (positionNames[name] === position) {
-            return name;
-          }
-        }
-      }
-      return "";
-    };
-    const getPosition = name => positionNames[name];
-
     const isInt = n => typeof n === "number" && n % 1 === 0;
     const isFunction = v => typeof v === "function";
     const getBoolString = value => value ? "true" : "false";
@@ -178,14 +152,13 @@ var jqtree = (function (exports) {
     }
 
     class DragElement {
-      constructor(_ref) {
-        let {
-          autoEscape,
-          nodeName,
-          offsetX,
-          offsetY,
-          treeElement
-        } = _ref;
+      constructor({
+        autoEscape,
+        nodeName,
+        offsetX,
+        offsetY,
+        treeElement
+      }) {
         this.offsetX = offsetX;
         this.offsetY = offsetY;
         this.element = this.createElement(nodeName, autoEscape);
@@ -211,14 +184,13 @@ var jqtree = (function (exports) {
       }
     }
 
-    const iterateVisibleNodes = (tree, _ref) => {
-      let {
-        handleAfterOpenFolder,
-        handleClosedFolder,
-        handleFirstNode,
-        handleNode,
-        handleOpenFolder
-      } = _ref;
+    const iterateVisibleNodes = (tree, {
+      handleAfterOpenFolder,
+      handleClosedFolder,
+      handleFirstNode,
+      handleNode,
+      handleOpenFolder
+    }) => {
       let isFirstNode = true;
       const iterate = (node, nextNode) => {
         let mustIterateInside = (node.is_open || !node.element) && node.hasChildren();
@@ -278,43 +250,43 @@ var jqtree = (function (exports) {
       const handleAfterOpenFolder = (node, nextNode) => {
         if (node === currentNode || nextNode === currentNode) {
           // Cannot move before or after current item
-          addHitPosition(node, Position.None, lastTop);
+          addHitPosition(node, null, lastTop);
         } else {
-          addHitPosition(node, Position.After, lastTop);
+          addHitPosition(node, "after", lastTop);
         }
       };
       const handleClosedFolder = (node, nextNode, element) => {
         const top = getOffsetTop(element);
         if (node === currentNode) {
           // Cannot move after current item
-          addHitPosition(node, Position.None, top);
+          addHitPosition(node, null, top);
         } else {
-          addHitPosition(node, Position.Inside, top);
+          addHitPosition(node, "inside", top);
 
           // Cannot move before current item
           if (nextNode !== currentNode) {
-            addHitPosition(node, Position.After, top);
+            addHitPosition(node, "after", top);
           }
         }
       };
       const handleFirstNode = node => {
         if (node !== currentNode && node.element) {
-          addHitPosition(node, Position.Before, getOffsetTop(node.element));
+          addHitPosition(node, "before", getOffsetTop(node.element));
         }
       };
       const handleNode = (node, nextNode, element) => {
         const top = getOffsetTop(element);
         if (node === currentNode) {
           // Cannot move inside current item
-          addHitPosition(node, Position.None, top);
+          addHitPosition(node, null, top);
         } else {
-          addHitPosition(node, Position.Inside, top);
+          addHitPosition(node, "inside", top);
         }
         if (nextNode === currentNode || node === currentNode) {
           // Cannot move before or after current item
-          addHitPosition(node, Position.None, top);
+          addHitPosition(node, null, top);
         } else {
-          addHitPosition(node, Position.After, top);
+          addHitPosition(node, "after", top);
         }
       };
       const handleOpenFolder = (node, element) => {
@@ -324,10 +296,10 @@ var jqtree = (function (exports) {
           // Dnd over the current element is not possible: add a position with type None for the top and the bottom.
           const top = getOffsetTop(element);
           const height = element.clientHeight;
-          addHitPosition(node, Position.None, top);
+          addHitPosition(node, null, top);
           if (height > 5) {
             // Subtract 5 pixels to allow more space for the next element.
-            addHitPosition(node, Position.None, top + height - 5);
+            addHitPosition(node, null, top + height - 5);
           }
 
           // Stop iterating
@@ -336,7 +308,7 @@ var jqtree = (function (exports) {
 
         // Cannot move before current item
         if (node.children[0] !== currentNode) {
-          addHitPosition(node, Position.Inside, getOffsetTop(element));
+          addHitPosition(node, "inside", getOffsetTop(element));
         }
 
         // Continue iterating
@@ -358,7 +330,7 @@ var jqtree = (function (exports) {
       let areaTop = top;
       for (let i = 0; i < positionCount; i++) {
         const position = positionsInGroup[i];
-        if (position.position !== Position.None) {
+        if (position.position) {
           hitAreas.push({
             bottom: areaTop + areaHeight,
             node: position.node,
@@ -390,24 +362,24 @@ var jqtree = (function (exports) {
     const generateHitAreas = (tree, currentNode, treeBottom) => generateHitAreasFromPositions(generateHitPositions(tree, currentNode), treeBottom);
 
     class DragAndDropHandler {
-      constructor(_ref) {
-        let {
-          autoEscape,
-          getNodeElement,
-          getNodeElementForNode,
-          getScrollLeft,
-          getTree,
-          onCanMove,
-          onCanMoveTo,
-          onDragMove,
-          onDragStop,
-          onIsMoveHandle,
-          openNode,
-          refreshElements,
-          slide,
-          treeElement,
-          triggerEvent
-        } = _ref;
+      constructor({
+        autoEscape,
+        getNodeElement,
+        getNodeElementForNode,
+        getScrollLeft,
+        getTree,
+        onCanMove,
+        onCanMoveTo,
+        onDragMove,
+        onDragStop,
+        onIsMoveHandle,
+        openFolderDelay,
+        openNode,
+        refreshElements,
+        slide,
+        treeElement,
+        triggerEvent
+      }) {
         this.autoEscape = autoEscape;
         this.getNodeElement = getNodeElement;
         this.getNodeElementForNode = getNodeElementForNode;
@@ -418,6 +390,7 @@ var jqtree = (function (exports) {
         this.onDragMove = onDragMove;
         this.onDragStop = onDragStop;
         this.onIsMoveHandle = onIsMoveHandle;
+        this.openFolderDelay = openFolderDelay;
         this.openNode = openNode;
         this.refreshElements = refreshElements;
         this.slide = slide;
@@ -533,8 +506,7 @@ var jqtree = (function (exports) {
         if (!this.onCanMoveTo) {
           return true;
         }
-        const positionName = getPositionName(area.position);
-        return this.onCanMoveTo(currentItem.node, area.node, positionName);
+        return this.onCanMoveTo(currentItem.node, area.node, area.position);
       }
       clear() {
         if (this.dragElement) {
@@ -581,12 +553,12 @@ var jqtree = (function (exports) {
 
       /* Move the dragged node to the selected position in the tree. */
       moveItem(positionInfo) {
-        if (this.currentItem && this.hoveredArea && this.hoveredArea.position !== Position.None && this.canMoveToArea(this.hoveredArea, this.currentItem)) {
+        if (this.currentItem && this.hoveredArea?.position && this.canMoveToArea(this.hoveredArea, this.currentItem)) {
           const movedNode = this.currentItem.node;
           const targetNode = this.hoveredArea.node;
           const position = this.hoveredArea.position;
           const previousParent = movedNode.parent;
-          if (position === Position.Inside) {
+          if (position === "inside") {
             this.hoveredArea.node.is_open = true;
           }
           const doMove = () => {
@@ -602,7 +574,7 @@ var jqtree = (function (exports) {
               do_move: doMove,
               moved_node: movedNode,
               original_event: positionInfo.originalEvent,
-              position: getPositionName(position),
+              position,
               previous_parent: previousParent,
               target_node: targetNode
             }
@@ -618,7 +590,7 @@ var jqtree = (function (exports) {
       }
       mustOpenFolderTimer(area) {
         const node = area.node;
-        return node.isFolder() && !node.is_open && area.position === Position.Inside;
+        return node.isFolder() && !node.is_open && area.position === "inside";
       }
       removeDropHint() {
         if (this.previousGhost) {
@@ -665,21 +637,20 @@ var jqtree = (function (exports) {
     }
 
     class ElementsRenderer {
-      constructor(_ref) {
-        let {
-          $element,
-          autoEscape,
-          buttonLeft,
-          closedIcon,
-          dragAndDrop,
-          getTree,
-          isNodeSelected,
-          onCreateLi,
-          openedIcon,
-          rtl,
-          showEmptyFolder,
-          tabIndex
-        } = _ref;
+      constructor({
+        $element,
+        autoEscape,
+        buttonLeft,
+        closedIcon,
+        dragAndDrop,
+        getTree,
+        isNodeSelected,
+        onCreateLi,
+        openedIcon,
+        rtl,
+        showEmptyFolder,
+        tabIndex
+      }) {
         this.autoEscape = autoEscape;
         this.buttonLeft = buttonLeft;
         this.dragAndDrop = dragAndDrop;
@@ -795,7 +766,7 @@ var jqtree = (function (exports) {
        * Call onCreateLi
        */
       createLi(node, level) {
-        const isSelected = Boolean(this.isNodeSelected(node));
+        const isSelected = this.isNodeSelected(node);
         const mustShowFolder = node.isFolder() || node.isEmptyFolder && this.showEmptyFolder;
         const li = mustShowFolder ? this.createFolderLi(node, level, isSelected) : this.createNodeLi(node, level, isSelected);
         this.attachNodeData(node, li);
@@ -904,15 +875,14 @@ var jqtree = (function (exports) {
     }
 
     class KeyHandler {
-      constructor(_ref) {
-        let {
-          closeNode,
-          getSelectedNode,
-          isFocusOnTree,
-          keyboardSupport,
-          openNode,
-          selectNode
-        } = _ref;
+      constructor({
+        closeNode,
+        getSelectedNode,
+        isFocusOnTree,
+        keyboardSupport,
+        openNode,
+        selectNode
+      }) {
         this.closeNode = closeNode;
         this.getSelectedNode = getSelectedNode;
         this.isFocusOnTree = isFocusOnTree;
@@ -1017,20 +987,19 @@ var jqtree = (function (exports) {
     });
 
     class MouseHandler {
-      constructor(_ref) {
-        let {
-          element,
-          getMouseDelay,
-          getNode,
-          onClickButton,
-          onClickTitle,
-          onMouseCapture,
-          onMouseDrag,
-          onMouseStart,
-          onMouseStop,
-          triggerEvent,
-          useContextMenu
-        } = _ref;
+      constructor({
+        element,
+        getMouseDelay,
+        getNode,
+        onClickButton,
+        onClickTitle,
+        onMouseCapture,
+        onMouseDrag,
+        onMouseStart,
+        onMouseStop,
+        triggerEvent,
+        useContextMenu
+      }) {
         this.element = element;
         this.getMouseDelay = getMouseDelay;
         this.getNode = getNode;
@@ -1282,10 +1251,7 @@ var jqtree = (function (exports) {
     const isNodeRecordWithChildren = data => typeof data === "object" && "children" in data && data.children instanceof Array;
 
     class Node {
-      constructor() {
-        let nodeData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-        let isRoot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-        let nodeClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Node;
+      constructor(nodeData = null, isRoot = false, nodeClass = Node) {
         this.name = "";
         this.load_on_demand = false;
         this.isEmptyFolder = nodeData != null && isNodeRecordWithChildren(nodeData) && nodeData.children.length === 0;
@@ -1393,8 +1359,7 @@ var jqtree = (function (exports) {
       /*
       Get the tree as data.
       */
-      getData() {
-        let includeParent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      getData(includeParent = false) {
         const getDataFromNodes = nodes => {
           return nodes.map(node => {
             const tmpNode = {};
@@ -1421,9 +1386,6 @@ var jqtree = (function (exports) {
           return null;
         } else {
           const lastChild = this.children[this.children.length - 1];
-          if (!lastChild) {
-            return null;
-          }
           if (!(lastChild.hasChildren() && lastChild.is_open)) {
             return lastChild;
           } else {
@@ -1441,8 +1403,7 @@ var jqtree = (function (exports) {
         }
         return level;
       }
-      getNextNode() {
-        let includeChildren = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      getNextNode(includeChildren = true) {
         if (includeChildren && this.hasChildren()) {
           return this.children[0] ?? null;
         } else if (!this.parent) {
@@ -1678,7 +1639,7 @@ var jqtree = (function (exports) {
         } else {
           movedNode.parent.doRemoveChild(movedNode);
           switch (position) {
-            case Position.After:
+            case "after":
               {
                 if (targetNode.parent) {
                   targetNode.parent.addChildAtPosition(movedNode, targetNode.parent.getChildIndex(targetNode) + 1);
@@ -1686,7 +1647,7 @@ var jqtree = (function (exports) {
                 }
                 return false;
               }
-            case Position.Before:
+            case "before":
               {
                 if (targetNode.parent) {
                   targetNode.parent.addChildAtPosition(movedNode, targetNode.parent.getChildIndex(targetNode));
@@ -1694,14 +1655,12 @@ var jqtree = (function (exports) {
                 }
                 return false;
               }
-            case Position.Inside:
+            case "inside":
               {
                 // move inside as first child
                 targetNode.addChildAtPosition(movedNode, 0);
                 return true;
               }
-            default:
-              return false;
           }
         }
       }
@@ -1825,13 +1784,13 @@ var jqtree = (function (exports) {
         this.node = node;
         this.ghost = this.createGhostElement();
         switch (position) {
-          case Position.After:
+          case "after":
             this.moveAfter();
             break;
-          case Position.Before:
+          case "before":
             this.moveBefore();
             break;
-          case Position.Inside:
+          case "inside":
             {
               if (node.isFolder() && node.is_open) {
                 this.moveInsideOpenFolder();
@@ -1874,13 +1833,12 @@ var jqtree = (function (exports) {
     }
 
     class NodeElement {
-      constructor(_ref) {
-        let {
-          getScrollLeft,
-          node,
-          tabIndex,
-          treeElement
-        } = _ref;
+      constructor({
+        getScrollLeft,
+        node,
+        tabIndex,
+        treeElement
+      }) {
         this.getScrollLeft = getScrollLeft;
         this.tabIndex = tabIndex;
         this.treeElement = treeElement;
@@ -1902,9 +1860,7 @@ var jqtree = (function (exports) {
       }
       init(node) {
         this.node = node;
-        if (!node.element) {
-          node.element = this.treeElement;
-        }
+        node.element ??= this.treeElement;
         this.element = node.element;
       }
       select(mustSetFocus) {
@@ -1928,21 +1884,20 @@ var jqtree = (function (exports) {
         return this.element.querySelector(":scope > ul");
       }
       mustShowBorderDropHint(position) {
-        return position === Position.Inside;
+        return position === "inside";
       }
     }
 
     class FolderElement extends NodeElement {
-      constructor(_ref) {
-        let {
-          closedIconElement,
-          getScrollLeft,
-          node,
-          openedIconElement,
-          tabIndex,
-          treeElement,
-          triggerEvent
-        } = _ref;
+      constructor({
+        closedIconElement,
+        getScrollLeft,
+        node,
+        openedIconElement,
+        tabIndex,
+        treeElement,
+        triggerEvent
+      }) {
         super({
           getScrollLeft,
           node,
@@ -2013,7 +1968,7 @@ var jqtree = (function (exports) {
         }
       }
       mustShowBorderDropHint(position) {
-        return !this.node.is_open && position === Position.Inside;
+        return !this.node.is_open && position === "inside";
       }
       getButton() {
         return this.element.querySelector(":scope > .jqtree-element > a.jqtree-toggler");
@@ -2021,19 +1976,18 @@ var jqtree = (function (exports) {
     }
 
     class SaveStateHandler {
-      constructor(_ref) {
-        let {
-          addToSelection,
-          getNodeById,
-          getSelectedNodes,
-          getTree,
-          onGetStateFromStorage,
-          onSetStateFromStorage,
-          openNode,
-          refreshElements,
-          removeFromSelection,
-          saveState
-        } = _ref;
+      constructor({
+        addToSelection,
+        getNodeById,
+        getSelectedNodes,
+        getTree,
+        onGetStateFromStorage,
+        onSetStateFromStorage,
+        openNode,
+        refreshElements,
+        removeFromSelection,
+        saveState
+      }) {
         this.addToSelection = addToSelection;
         this.getNodeById = getNodeById;
         this.getSelectedNodes = getSelectedNodes;
@@ -2209,12 +2163,11 @@ var jqtree = (function (exports) {
       }
     }
 
-    class ContainerScrollParent {
-      constructor(_ref) {
-        let {
-          container,
-          refreshHitAreas
-        } = _ref;
+    class ScrollParent {
+      constructor({
+        container,
+        refreshHitAreas
+      }) {
         this.container = container;
         this.refreshHitAreas = refreshHitAreas;
       }
@@ -2223,7 +2176,7 @@ var jqtree = (function (exports) {
         if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
           this.horizontalScrollDirection = newHorizontalScrollDirection;
           if (this.horizontalScrollTimeout != null) {
-            window.clearTimeout(this.verticalScrollTimeout);
+            window.clearTimeout(this.horizontalScrollTimeout);
           }
           if (newHorizontalScrollDirection) {
             this.horizontalScrollTimeout = window.setTimeout(this.scrollHorizontally.bind(this), 40);
@@ -2252,42 +2205,6 @@ var jqtree = (function (exports) {
       stopScrolling() {
         this.horizontalScrollDirection = undefined;
         this.verticalScrollDirection = undefined;
-        this.scrollParentTop = undefined;
-        this.scrollParentBottom = undefined;
-      }
-      getNewHorizontalScrollDirection(pageX) {
-        const scrollParentOffset = getElementPosition(this.container);
-        const rightEdge = scrollParentOffset.left + this.container.clientWidth;
-        const leftEdge = scrollParentOffset.left;
-        const isNearRightEdge = pageX > rightEdge - 20;
-        const isNearLeftEdge = pageX < leftEdge + 20;
-        if (isNearRightEdge) {
-          return "right";
-        } else if (isNearLeftEdge) {
-          return "left";
-        }
-        return undefined;
-      }
-      getNewVerticalScrollDirection(pageY) {
-        if (pageY < this.getScrollParentTop()) {
-          return "top";
-        }
-        if (pageY > this.getScrollParentBottom()) {
-          return "bottom";
-        }
-        return undefined;
-      }
-      getScrollParentBottom() {
-        if (this.scrollParentBottom == null) {
-          this.scrollParentBottom = this.getScrollParentTop() + this.container.clientHeight;
-        }
-        return this.scrollParentBottom;
-      }
-      getScrollParentTop() {
-        if (this.scrollParentTop == null) {
-          this.scrollParentTop = getOffsetTop(this.container);
-        }
-        return this.scrollParentTop;
       }
       scrollHorizontally() {
         if (!this.horizontalScrollDirection) {
@@ -2317,77 +2234,70 @@ var jqtree = (function (exports) {
       }
     }
 
-    class DocumentScrollParent {
-      constructor(_ref) {
-        let {
-          refreshHitAreas,
-          treeElement
-        } = _ref;
-        this.refreshHitAreas = refreshHitAreas;
-        this.treeElement = treeElement;
+    class ContainerScrollParent extends ScrollParent {
+      stopScrolling() {
+        super.stopScrolling();
+        this.horizontalScrollDirection = undefined;
+        this.verticalScrollDirection = undefined;
       }
-      checkHorizontalScrolling(pageX) {
-        const newHorizontalScrollDirection = this.getNewHorizontalScrollDirection(pageX);
-        if (this.horizontalScrollDirection !== newHorizontalScrollDirection) {
-          this.horizontalScrollDirection = newHorizontalScrollDirection;
-          if (this.horizontalScrollTimeout != null) {
-            window.clearTimeout(this.horizontalScrollTimeout);
-          }
-          if (newHorizontalScrollDirection) {
-            this.horizontalScrollTimeout = window.setTimeout(this.scrollHorizontally.bind(this), 40);
-          }
+      getNewHorizontalScrollDirection(pageX) {
+        const scrollParentOffset = getElementPosition(this.container);
+        const containerWidth = this.container.getBoundingClientRect().width;
+        const rightEdge = scrollParentOffset.left + containerWidth;
+        const leftEdge = scrollParentOffset.left;
+        const isNearRightEdge = pageX > rightEdge - 20;
+        const isNearLeftEdge = pageX < leftEdge + 20;
+        if (isNearRightEdge) {
+          return "right";
+        } else if (isNearLeftEdge) {
+          return "left";
         }
+        return undefined;
       }
-      checkVerticalScrolling(pageY) {
-        const newVerticalScrollDirection = this.getNewVerticalScrollDirection(pageY);
-        if (this.verticalScrollDirection !== newVerticalScrollDirection) {
-          this.verticalScrollDirection = newVerticalScrollDirection;
-          if (this.verticalScrollTimeout != null) {
-            window.clearTimeout(this.verticalScrollTimeout);
-            this.verticalScrollTimeout = undefined;
-          }
-          if (newVerticalScrollDirection) {
-            this.verticalScrollTimeout = window.setTimeout(this.scrollVertically.bind(this), 40);
-          }
+      getNewVerticalScrollDirection(pageY) {
+        if (pageY < this.getScrollParentTop()) {
+          return "top";
         }
+        if (pageY > this.getScrollParentBottom()) {
+          return "bottom";
+        }
+        return undefined;
       }
-      getScrollLeft() {
-        return document.documentElement.scrollLeft;
+      getScrollParentBottom() {
+        if (this.scrollParentBottom == null) {
+          const containerHeight = this.container.getBoundingClientRect().height;
+          this.scrollParentBottom = this.getScrollParentTop() + containerHeight;
+        }
+        return this.scrollParentBottom;
+      }
+      getScrollParentTop() {
+        this.scrollParentTop ??= getOffsetTop(this.container);
+        return this.scrollParentTop;
+      }
+    }
+
+    class DocumentScrollParent extends ScrollParent {
+      constructor({
+        refreshHitAreas,
+        treeElement
+      }) {
+        super({
+          container: document.documentElement,
+          refreshHitAreas
+        });
+        this.treeElement = treeElement;
       }
       scrollToY(top) {
         const treeTop = getOffsetTop(this.treeElement);
-        document.documentElement.scrollTop = top + treeTop;
+        super.scrollToY(top + treeTop);
       }
       stopScrolling() {
-        this.horizontalScrollDirection = undefined;
-        this.verticalScrollDirection = undefined;
+        super.stopScrolling();
         this.documentScrollHeight = undefined;
         this.documentScrollWidth = undefined;
       }
-      canScrollDown() {
-        const documentElement = document.documentElement;
-        return documentElement.scrollTop + documentElement.clientHeight < this.getDocumentScrollHeight();
-      }
-      canScrollRight() {
-        const documentElement = document.documentElement;
-        return documentElement.scrollLeft + documentElement.clientWidth < this.getDocumentScrollWidth();
-      }
-      getDocumentScrollHeight() {
-        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
-        if (this.documentScrollHeight == null) {
-          this.documentScrollHeight = document.documentElement.scrollHeight;
-        }
-        return this.documentScrollHeight;
-      }
-      getDocumentScrollWidth() {
-        // Store the original scroll width because the scroll width can increase when the drag element is moved beyond the scroll width.
-        if (this.documentScrollWidth == null) {
-          this.documentScrollWidth = document.documentElement.scrollWidth;
-        }
-        return this.documentScrollWidth;
-      }
       getNewHorizontalScrollDirection(pageX) {
-        const scrollLeft = document.documentElement.scrollLeft;
+        const scrollLeft = this.container.scrollLeft;
         const windowWidth = window.innerWidth;
         const isNearRightEdge = pageX > windowWidth - 20;
         const isNearLeftEdge = pageX - scrollLeft < 20;
@@ -2400,7 +2310,7 @@ var jqtree = (function (exports) {
         return undefined;
       }
       getNewVerticalScrollDirection(pageY) {
-        const scrollTop = jQuery(document).scrollTop() ?? 0;
+        const scrollTop = this.container.scrollTop;
         const distanceTop = pageY - scrollTop;
         if (distanceTop < 20) {
           return "top";
@@ -2411,31 +2321,21 @@ var jqtree = (function (exports) {
         }
         return undefined;
       }
-      scrollHorizontally() {
-        if (!this.horizontalScrollDirection) {
-          return;
-        }
-        const distance = this.horizontalScrollDirection === "left" ? -20 : 20;
-        window.scrollBy({
-          behavior: "instant",
-          left: distance,
-          top: 0
-        });
-        this.refreshHitAreas();
-        setTimeout(this.scrollHorizontally.bind(this), 40);
+      canScrollDown() {
+        return this.container.scrollTop + this.container.clientHeight < this.getDocumentScrollHeight();
       }
-      scrollVertically() {
-        if (!this.verticalScrollDirection) {
-          return;
-        }
-        const distance = this.verticalScrollDirection === "top" ? -20 : 20;
-        window.scrollBy({
-          behavior: "instant",
-          left: 0,
-          top: distance
-        });
-        this.refreshHitAreas();
-        setTimeout(this.scrollVertically.bind(this), 40);
+      canScrollRight() {
+        return this.container.scrollLeft + this.container.clientWidth < this.getDocumentScrollWidth();
+      }
+      getDocumentScrollHeight() {
+        // Store the original scroll height because the scroll height can increase when the drag element is moved beyond the scroll height.
+        this.documentScrollHeight ??= this.container.scrollHeight;
+        return this.documentScrollHeight;
+      }
+      getDocumentScrollWidth() {
+        // Store the original scroll width because the scroll width can increase when the drag element is moved beyond the scroll width.
+        this.documentScrollWidth ??= this.container.scrollWidth;
+        return this.documentScrollWidth;
       }
     }
 
@@ -2473,11 +2373,10 @@ var jqtree = (function (exports) {
     };
 
     class ScrollHandler {
-      constructor(_ref) {
-        let {
-          refreshHitAreas,
-          treeElement
-        } = _ref;
+      constructor({
+        refreshHitAreas,
+        treeElement
+      }) {
         this.refreshHitAreas = refreshHitAreas;
         this.scrollParent = undefined;
         this.treeElement = treeElement;
@@ -2502,18 +2401,15 @@ var jqtree = (function (exports) {
         this.getScrollParent().checkVerticalScrolling(positionInfo.pageY);
       }
       getScrollParent() {
-        if (!this.scrollParent) {
-          this.scrollParent = createScrollParent(this.treeElement, this.refreshHitAreas);
-        }
+        this.scrollParent ??= createScrollParent(this.treeElement, this.refreshHitAreas);
         return this.scrollParent;
       }
     }
 
     class SelectNodeHandler {
-      constructor(_ref) {
-        let {
-          getNodeById
-        } = _ref;
+      constructor({
+        getNodeById
+      }) {
         this.getNodeById = getNodeById;
         this.selectedNodes = new Set();
         this.clear();
@@ -2578,8 +2474,7 @@ var jqtree = (function (exports) {
           return false;
         }
       }
-      removeFromSelection(node) {
-        let includeChildren = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      removeFromSelection(node, includeChildren = false) {
         if (node.id == null) {
           if (this.selectedSingleNode && node.element === this.selectedSingleNode.element) {
             this.selectedSingleNode = null;
@@ -2651,7 +2546,7 @@ var jqtree = (function (exports) {
       };
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      jQuery.fn[widgetName] = function (argument1) {
+      jQuery.fn[widgetName] = function (argument1, ...args) {
         if (!argument1) {
           return createWidget(this, null);
         } else if (typeof argument1 === "object") {
@@ -2659,15 +2554,10 @@ var jqtree = (function (exports) {
           return createWidget(this, options);
         } else if (typeof argument1 === "string" && argument1[0] !== "_") {
           const functionName = argument1;
-          if (functionName === "destroy") {
+          if (argument1 === "destroy") {
             destroyWidget(this);
             return undefined;
-          } else if (functionName === "get_widget_class") {
-            return widgetClass;
           } else {
-            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-              args[_key - 1] = arguments[_key];
-            }
             return callFunction(this, functionName, args);
           }
         } else {
@@ -2701,12 +2591,12 @@ var jqtree = (function (exports) {
       }
     }
 
-    const version = "1.8.8";
+    const version = "1.8.11";
 
     const NODE_PARAM_IS_EMPTY = "Node parameter is empty";
     const PARAM_IS_EMPTY = "Parameter is empty: ";
     class JqTreeWidget extends SimpleWidget {
-      static defaults = (() => ({
+      static defaults = {
         animationSpeed: "fast",
         autoEscape: true,
         autoOpen: false,
@@ -2751,7 +2641,7 @@ var jqtree = (function (exports) {
         // The delay for starting dnd (in milliseconds)
         tabIndex: 0,
         useContextMenu: true
-      }))();
+      };
       addNodeAfter(newNodeInfo, existingNode) {
         const newNode = existingNode.addAfter(newNodeInfo);
         if (newNode) {
@@ -2818,7 +2708,7 @@ var jqtree = (function (exports) {
         return this.tree.getNodeByCallback(callback);
       }
       getNodeByHtmlElement(inputElement) {
-        const element = inputElement instanceof HTMLElement ? inputElement : inputElement[0];
+        const element = inputElement instanceof HTMLElement ? inputElement : inputElement.get(0);
         if (!element) {
           return null;
         }
@@ -2859,9 +2749,7 @@ var jqtree = (function (exports) {
         this.element = this.$el;
         this.isInitialized = false;
         this.options.rtl = this.getRtlOption();
-        if (this.options.closedIcon == null) {
-          this.options.closedIcon = this.getDefaultClosedIcon();
-        }
+        this.options.closedIcon ??= this.getDefaultClosedIcon();
         this.connectHandlers();
         this.initData();
       }
@@ -2919,11 +2807,8 @@ var jqtree = (function (exports) {
         if (!position) {
           throw Error(PARAM_IS_EMPTY + "position");
         }
-        const positionIndex = getPosition(position);
-        if (positionIndex !== undefined) {
-          this.tree.moveNode(node, targetNode, positionIndex);
-          this.refreshElements(null);
-        }
+        this.tree.moveNode(node, targetNode, position);
+        this.refreshElements(null);
         return this.element;
       }
       moveUp() {
@@ -2947,9 +2832,7 @@ var jqtree = (function (exports) {
             slide = param1;
             onFinished = param2;
           }
-          if (slide == null) {
-            slide = this.options.slide;
-          }
+          slide ??= this.options.slide;
           return [slide, onFinished];
         };
         const [slide, onFinished] = parseParams();
@@ -3023,8 +2906,7 @@ var jqtree = (function (exports) {
         }
         return this.element;
       }
-      toggle(node) {
-        let slideParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      toggle(node, slideParam = null) {
         if (!node) {
           throw Error(NODE_PARAM_IS_EMPTY);
         }
@@ -3206,7 +3088,7 @@ var jqtree = (function (exports) {
       }
       containsElement(element) {
         const node = this.getNode(element);
-        return node != null && node.tree === this.tree;
+        return node?.tree === this.tree;
       }
       createFolderElement(node) {
         const closedIconElement = this.renderer.closedIconElement;
@@ -3452,7 +3334,7 @@ var jqtree = (function (exports) {
       }
       isFocusOnTree() {
         const activeElement = document.activeElement;
-        return Boolean(activeElement && activeElement.tagName === "SPAN" && this.containsElement(activeElement));
+        return activeElement?.tagName === "SPAN" && this.containsElement(activeElement);
       }
       isSelectedNodeInSubtree(subtree) {
         const selectedNode = this.getSelectedNode();
@@ -3462,9 +3344,7 @@ var jqtree = (function (exports) {
           return subtree === selectedNode || subtree.isParentOf(selectedNode);
         }
       }
-      loadFolderOnDemand(node) {
-        let slide = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-        let onFinished = arguments.length > 2 ? arguments[2] : undefined;
+      loadFolderOnDemand(node, slide = true, onFinished) {
         node.is_loading = true;
         this.doLoadDataFromUrl(null, node, () => {
           this.openNodeInternal(node, slide, onFinished);
@@ -3507,9 +3387,7 @@ var jqtree = (function (exports) {
           return false;
         }
       }
-      openNodeInternal(node) {
-        let slide = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-        let onFinished = arguments.length > 2 ? arguments[2] : undefined;
+      openNodeInternal(node, slide = true, onFinished) {
         const doOpenNode = (_node, _slide, _onFinished) => {
           if (!node.children.length) {
             return;