jqtree 1.8.10 → 1.8.11

package/tree.jquery.debug.js

@@ -1,7 +1,7 @@
 /*
-JqTree 1.8.10
+JqTree 1.8.11
 
-Copyright 2025 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;
@@ -153,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);
@@ -186,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();
@@ -365,25 +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,
-          openFolderDelay,
-          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;
@@ -641,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;
@@ -771,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);
@@ -880,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;
@@ -993,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;
@@ -1258,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;
@@ -1369,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 = {};
@@ -1397,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 {
@@ -1417,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) {
@@ -1848,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;
@@ -1876,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) {
@@ -1907,16 +1889,15 @@ var jqtree = (function (exports) {
     }
 
     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,
@@ -1995,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;
@@ -2183,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;
       }
@@ -2197,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);
@@ -2226,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) {
@@ -2291,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;
@@ -2374,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";
@@ -2385,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;
       }
     }
 
@@ -2447,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;
@@ -2476,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();
@@ -2552,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;
@@ -2625,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") {
@@ -2633,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 {
@@ -2675,12 +2591,12 @@ var jqtree = (function (exports) {
       }
     }
 
-    const version = "1.8.10";
+    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,
@@ -2725,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) {
@@ -2792,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;
         }
@@ -2833,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();
       }
@@ -2918,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();
@@ -2994,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);
         }
@@ -3177,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;
@@ -3423,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();
@@ -3433,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);
@@ -3478,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;