wunderbaum 0.12.1 → 0.14.0

package/dist/wunderbaum.umd.js

@@ -7,7 +7,7 @@
     /*!
      * Wunderbaum - debounce.ts
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /*
      * debounce & throttle, taken from https://github.com/lodash/lodash v4.17.21
@@ -299,7 +299,7 @@
     /*!
      * Wunderbaum - util
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /** @module util */
     /** Readable names for `MouseEvent.button` */
@@ -449,7 +449,7 @@
         }
         return obj;
     }
-    /** Shortcut for `throw new Error(msg)`.*/
+    /** Shortcut for `throw new Error(msg)`. */
     function error(msg) {
         throw new Error(msg);
     }
@@ -682,18 +682,6 @@
         }
         return obj;
     }
-    // /** Return a EventTarget from selector or cast an existing element. */
-    // export function eventTargetFromSelector(
-    //   obj: string | EventTarget
-    // ): EventTarget | null {
-    //   if (!obj) {
-    //     return null;
-    //   }
-    //   if (typeof obj === "string") {
-    //     return document.querySelector(obj) as EventTarget;
-    //   }
-    //   return obj as EventTarget;
-    // }
     /**
      * Return a canonical descriptive string for a keyboard or mouse event.
      *
@@ -976,6 +964,10 @@
         }
         throw new Error(`Expected a string like '123px': ${defaults}`);
     }
+    /** Cast any value to <T>. */
+    function unsafeCast(value) {
+        return value;
+    }
     /** Return the the boolean value of the first non-null element.
      * Example:
      * ```js
@@ -1049,7 +1041,7 @@
         const throttledFn = (...args) => {
             if (waiting) {
                 pendingArgs = args;
-                // console.log(`adaptiveThrottle() queing request #${waiting}...`, args);
+                // console.log(`adaptiveThrottle() queueing request #${waiting}...`, args);
                 waiting += 1;
             }
             else {
@@ -1104,6 +1096,60 @@
         };
         return throttledFn;
     }
+    /**
+     * MurmurHash3 implementation for strings.
+     * @param key The input string to hash.
+     * @param asString Optional convert result to zero-padded string of 8 characters.
+     * @param seed Optional seed value.
+     * @returns A 32-bit hash as a number or string.
+     */
+    function murmurHash3(key, asString = true, seed = 0) {
+        let h1 = seed;
+        const remainder = key.length & 3; // key.length % 4
+        const bytes = key.length - remainder;
+        const c1 = 0xcc9e2d51;
+        const c2 = 0x1b873593;
+        let i = 0;
+        while (i < bytes) {
+            let k1 = (key.charCodeAt(i) & 0xff) |
+                ((key.charCodeAt(++i) & 0xff) << 8) |
+                ((key.charCodeAt(++i) & 0xff) << 16) |
+                ((key.charCodeAt(++i) & 0xff) << 24);
+            ++i;
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+            h1 = (h1 << 13) | (h1 >>> 19);
+            h1 = Math.imul(h1, 5) + 0xe6546b64;
+        }
+        let k1 = 0;
+        switch (remainder) {
+            case 3:
+                k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+            // fall through
+            case 2:
+                k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+            // fall through
+            case 1:
+                k1 ^= key.charCodeAt(i) & 0xff;
+                k1 = Math.imul(k1, c1);
+                k1 = (k1 << 15) | (k1 >>> 17);
+                k1 = Math.imul(k1, c2);
+                h1 ^= k1;
+        }
+        h1 ^= key.length;
+        h1 ^= h1 >>> 16;
+        h1 = Math.imul(h1, 0x85ebca6b);
+        h1 ^= h1 >>> 13;
+        h1 = Math.imul(h1, 0xc2b2ae35);
+        h1 ^= h1 >>> 16;
+        if (asString) {
+            // Convert to 8 digit hex string
+            return (h1 >>> 0).toString(16).padStart(8, "0");
+        }
+        return h1 >>> 0; // Convert to unsigned 32-bit integer
+    }
 
     var util = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -1134,6 +1180,7 @@
         isFunction: isFunction,
         isMac: isMac,
         isPlainObject: isPlainObject,
+        murmurHash3: murmurHash3,
         noop: noop,
         onEvent: onEvent,
         overrideMethod: overrideMethod,
@@ -1147,13 +1194,14 @@
         toPixel: toPixel,
         toSet: toSet,
         toggleCheckbox: toggleCheckbox,
-        type: type
+        type: type,
+        unsafeCast: unsafeCast
     });
 
     /*!
      * Wunderbaum - types
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /**
      * Possible values for {@link WunderbaumNode.update} and {@link Wunderbaum.update}.
@@ -1221,7 +1269,7 @@
     /*!
      * Wunderbaum - wb_extension_base
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     class WunderbaumExtension {
         constructor(tree, id, defaults) {
@@ -1280,7 +1328,7 @@
     /*!
      * Wunderbaum - ext-filter
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     const START_MARKER = "\uFFF7";
     const END_MARKER = "\uFFF8";
@@ -1292,7 +1340,7 @@
                 autoApply: true, // Re-apply last filter if lazy data is loaded
                 autoExpand: false, // Expand all branches that contain matches while filtered
                 matchBranch: false, // Whether to implicitly match all children of matched nodes
-                connectInput: null, // Element or selector of an input control for filter query strings
+                connect: null, // Element or selector of an input control for filter query strings
                 fuzzy: false, // Match single characters in order, e.g. 'fb' will match 'FooBar'
                 hideExpanders: false, // Hide expanders if all child nodes are hidden by filter
                 highlight: true, // Highlight matches by wrapping inside <mark> tags
@@ -1300,36 +1348,117 @@
                 mode: "dim", // Grayout unmatched nodes (pass "hide" to remove unmatched node instead)
                 noData: true, // Display a 'no data' status node if result is empty
             });
+            this.queryInput = null;
+            this.prevButton = null;
+            this.nextButton = null;
+            this.modeButton = null;
+            this.matchInfoElem = null;
             this.lastFilterArgs = null;
         }
         init() {
             super.init();
-            const connectInput = this.getPluginOption("connectInput");
-            if (connectInput) {
-                this.queryInput = elemFromSelector(connectInput);
-                assert(this.queryInput, `Invalid 'filter.connectInput' option: ${connectInput}.`);
-                onEvent(this.queryInput, "input", debounce((e) => {
-                    // this.tree.log("query", e);
-                    this.filterNodes(this.queryInput.value.trim(), {});
-                }, 700));
+            const connect = this.getPluginOption("connect");
+            if (connect) {
+                this._connectControls();
             }
         }
         setPluginOption(name, value) {
-            // alert("filter opt=" + name + ", " + value)
             super.setPluginOption(name, value);
             switch (name) {
                 case "mode":
-                    this.tree.filterMode = value === "hide" ? "hide" : "dim";
+                    this.tree.filterMode =
+                        value === "hide" ? "hide" : value === "mark" ? "mark" : "dim";
                     this.tree.updateFilter();
                     break;
             }
         }
+        _updatedConnectedControls() {
+            var _a;
+            const filterActive = this.tree.filterMode !== null;
+            const activeNode = this.tree.getActiveNode();
+            const matchCount = filterActive ? this.countMatches() : 0;
+            const strings = this.treeOpts.strings;
+            let matchIdx = "?";
+            if (this.matchInfoElem) {
+                if (filterActive) {
+                    let info;
+                    if (matchCount === 0) {
+                        info = strings.noMatch;
+                    }
+                    else if (activeNode && activeNode.match >= 1) {
+                        matchIdx = (_a = activeNode.match) !== null && _a !== void 0 ? _a : "?";
+                        info = strings.matchIndex;
+                    }
+                    else {
+                        info = strings.queryResult;
+                    }
+                    info = info
+                        .replace("${count}", this.tree.count().toLocaleString())
+                        .replace("${match}", "" + matchIdx)
+                        .replace("${matches}", matchCount.toLocaleString());
+                    this.matchInfoElem.textContent = info;
+                }
+                else {
+                    this.matchInfoElem.textContent = "";
+                }
+            }
+            if (this.nextButton instanceof HTMLButtonElement) {
+                this.nextButton.disabled = !matchCount;
+            }
+            if (this.prevButton instanceof HTMLButtonElement) {
+                this.prevButton.disabled = !matchCount;
+            }
+            if (this.modeButton) {
+                this.modeButton.disabled = !filterActive;
+                this.modeButton.classList.toggle("wb-filter-hide", this.tree.filterMode === "hide");
+            }
+        }
+        _connectControls() {
+            const tree = this.tree;
+            const connect = this.getPluginOption("connect");
+            if (!connect) {
+                return;
+            }
+            this.queryInput = elemFromSelector(connect.inputElem);
+            if (!this.queryInput) {
+                throw new Error(`Invalid 'filter.connect' option: ${connect.inputElem}.`);
+            }
+            this.prevButton = elemFromSelector(connect.prevButton);
+            this.nextButton = elemFromSelector(connect.nextButton);
+            this.modeButton = elemFromSelector(connect.modeButton);
+            this.matchInfoElem = elemFromSelector(connect.matchInfoElem);
+            if (this.prevButton) {
+                onEvent(this.prevButton, "click", () => {
+                    tree.findRelatedNode(tree.getActiveNode() || tree.getFirstChild(), "prevMatch");
+                    this._updatedConnectedControls();
+                });
+            }
+            if (this.nextButton) {
+                onEvent(this.nextButton, "click", () => {
+                    tree.findRelatedNode(tree.getActiveNode() || tree.getFirstChild(), "nextMatch");
+                    this._updatedConnectedControls();
+                });
+            }
+            if (this.modeButton) {
+                onEvent(this.modeButton, "click", (e) => {
+                    if (!this.tree.filterMode) {
+                        return;
+                    }
+                    this.setPluginOption("mode", tree.filterMode === "dim" ? "hide" : "dim");
+                });
+            }
+            onEvent(this.queryInput, "input", debounce((e) => {
+                this.filterNodes(this.queryInput.value.trim(), {});
+            }, 700));
+            this._updatedConnectedControls();
+        }
         _applyFilterNoUpdate(filter, _opts) {
             return this.tree.runWithDeferredUpdate(() => {
                 return this._applyFilterImpl(filter, _opts);
             });
         }
         _applyFilterImpl(filter, _opts) {
+            var _a;
             let //temp,
             count = 0;
             const start = Date.now();
@@ -1411,11 +1540,11 @@
                     return !!res;
                 };
             }
-            tree.filterMode = opts.mode;
+            tree.filterMode = (_a = opts.mode) !== null && _a !== void 0 ? _a : "dim";
             // eslint-disable-next-line prefer-rest-params
             this.lastFilterArgs = arguments;
             tree.element.classList.toggle("wb-ext-filter-hide", !!hideMode);
-            tree.element.classList.toggle("wb-ext-filter-dim", !hideMode);
+            tree.element.classList.toggle("wb-ext-filter-dim", opts.mode === "dim");
             tree.element.classList.toggle("wb-ext-filter-hide-expanders", !!opts.hideExpanders);
             // Reset current filter
             tree.root.subMatchCount = 0;
@@ -1424,10 +1553,6 @@
                 delete node.titleWithHighlight;
                 node.subMatchCount = 0;
             });
-            // statusNode = tree.root.findDirectChild(KEY_NODATA);
-            // if (statusNode) {
-            //   statusNode.remove();
-            // }
             tree.setStatus(NodeStatusType.ok);
             // Adjust node.hide, .match, and .subMatchCount properties
             treeOpts.autoCollapse = false; // #528
@@ -1438,7 +1563,7 @@
                 let res = filter(node);
                 if (res === "skip") {
                     node.visit(function (c) {
-                        c.match = false;
+                        c.match = undefined;
                     }, true);
                     return "skip";
                 }
@@ -1449,7 +1574,7 @@
                 }
                 if (res) {
                     count++;
-                    node.match = true;
+                    node.match = count;
                     node.visitParents((p) => {
                         if (p !== node) {
                             p.subMatchCount += 1;
@@ -1476,6 +1601,7 @@
             }
             // Redraw whole tree
             tree.logDebug(`Filter '${filter}' found ${count} nodes in ${Date.now() - start} ms.`);
+            this._updatedConnectedControls();
             return count;
         }
         /**
@@ -1490,6 +1616,10 @@
          */
         filterBranches(filter, options) {
             assert(options.matchBranch === undefined, "filterBranches() is deprecated.");
+            this.tree.logDeprecate("filterBranches()", {
+                since: "0.9.0",
+                hint: "Use `filterNodes` instead and set `options.matchBranch: true`",
+            });
             options.matchBranch = true;
             return this._applyFilterNoUpdate(filter, options);
         }
@@ -1520,34 +1650,22 @@
             else {
                 tree.logWarn("updateFilter(): no filter active.");
             }
+            this._updatedConnectedControls();
         }
         /**
          * [ext-filter] Reset the filter.
          */
         clearFilter() {
             const tree = this.tree;
-            // statusNode = tree.root.findDirectChild(KEY_NODATA),
-            // escapeTitles = tree.options.escapeTitles;
             tree.enableUpdate(false);
-            // if (statusNode) {
-            //   statusNode.remove();
-            // }
             tree.setStatus(NodeStatusType.ok);
             // we also counted root node's subMatchCount
             delete tree.root.match;
             delete tree.root.subMatchCount;
             tree.visit((node) => {
-                // if (node.match && node._rowElem) {
-                //   let titleElem = node._rowElem.querySelector("span.wb-title")!;
-                //   node._callEvent("enhanceTitle", { titleElem: titleElem });
-                // }
                 delete node.match;
                 delete node.subMatchCount;
                 delete node.titleWithHighlight;
-                // if (node.subMatchBadge) {
-                //   node.subMatchBadge.remove();
-                //   delete node.subMatchBadge;
-                // }
                 if (node._filterAutoExpanded && node.expanded) {
                     node.setExpanded(false, {
                         noAnimation: true,
@@ -1561,12 +1679,12 @@
             tree.element.classList.remove(
             // "wb-ext-filter",
             "wb-ext-filter-dim", "wb-ext-filter-hide");
-            // tree._callHook("treeStructureChanged", this, "clearFilter");
+            this._updatedConnectedControls();
             tree.enableUpdate(true);
         }
     }
     /**
-     * @description Marks the matching charecters of `text` either by `mark` or
+     * @description Marks the matching characters of `text` either by `mark` or
      * by exotic*Chars (if `escapeTitles` is `true`) based on `matches`
      * which is an array of matching groups.
      * @param {string} text
@@ -1605,7 +1723,7 @@
     /*!
      * Wunderbaum - ext-keynav
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     const QUICKSEARCH_DELAY = 500;
     class KeynavExtension extends WunderbaumExtension {
@@ -1969,7 +2087,7 @@
     /*!
      * Wunderbaum - ext-logger
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     class LoggerExtension extends WunderbaumExtension {
         constructor(tree) {
@@ -2011,7 +2129,7 @@
     /*!
      * Wunderbaum - ext-dnd
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     const nodeMimeType = "application/x-wunderbaum-node";
     class DndExtension extends WunderbaumExtension {
@@ -2247,7 +2365,6 @@
          */
         onDragEvent(e) {
             var _a;
-            // const tree = this.tree;
             const dndOpts = this.treeOpts.dnd;
             const srcNode = Wunderbaum.getNode(e);
             if (!srcNode) {
@@ -2273,7 +2390,7 @@
                     return false;
                 }
                 const nodeData = srcNode.toDict(true, (n) => {
-                    // We don't want to re-use the key on drop:
+                    // We don't want to reuse the key on drop:
                     n._orgKey = n.key;
                     delete n.key;
                 });
@@ -2335,6 +2452,7 @@
             };
             if (!targetNode) {
                 this._leaveNode();
+                e.preventDefault(); // Don't open file in browser when dropped in empty area
                 return;
             }
             if (["drop"].includes(e.type)) {
@@ -2440,19 +2558,20 @@
                 nodeData = nodeData ? JSON.parse(nodeData) : null;
                 const srcNode = this.srcNode;
                 const lastDropEffect = this.lastDropEffect;
-                setTimeout(() => {
-                    // Decouple this call, because drop actions may prevent the dragend event
-                    // from being fired on some browsers
-                    targetNode._callEvent("dnd.drop", {
-                        event: e,
-                        region: region,
-                        suggestedDropMode: region === "over" ? "appendChild" : region,
-                        suggestedDropEffect: lastDropEffect,
-                        // suggestedDropEffect: e.dataTransfer?.dropEffect,
-                        sourceNode: srcNode,
-                        sourceNodeData: nodeData,
-                    });
-                }, 10);
+                /* Before v0.14.0, we decoupled `_callEvent` like so:
+                     Decouple this call, because drop actions may prevent the dragend
+                     event from being fired on some browsers.
+                     setTimeout(() => {...}, 10);
+                  however this made e.dataTransfer.items inaccessible */
+                targetNode._callEvent("dnd.drop", {
+                    event: e,
+                    region: region,
+                    suggestedDropMode: region === "over" ? "appendChild" : region,
+                    suggestedDropEffect: lastDropEffect,
+                    sourceNode: srcNode,
+                    sourceNodeData: nodeData,
+                    dataTransfer: e.dataTransfer,
+                });
             }
             return false;
         }
@@ -2461,7 +2580,7 @@
     /*!
      * Wunderbaum - drag_observer
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /**
      * Convert mouse- and touch events to 'dragstart', 'drag', and 'dragstop'.
@@ -2610,7 +2729,7 @@
     /*!
      * Wunderbaum - common
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     const DEFAULT_DEBUGLEVEL = 3; // Replaced by rollup script
     /**
@@ -2630,12 +2749,18 @@
     const RENDER_MAX_PREFETCH = 5;
     /** Minimum column width if not set otherwise. */
     const DEFAULT_MIN_COL_WIDTH = 4;
+    /**
+     * A value for `node.type` that by convention may be used to mark a node as directory.
+     * It may be used to sort 'directories' to the top.
+     */
+    const NODE_TYPE_FOLDER = "folder";
     /** Regular expression to detect if a string describes an image URL (in contrast
      * to a class name). Strings are considered image urls if they contain '.' or '/'.
+     * `<` is ignored, because it is probably an html tag.
      */
-    const TEST_IMG = new RegExp(/\.|\//);
-    // export const RECURSIVE_REQUEST_ERROR = "$recursive_request";
-    // export const INVALID_REQUEST_TARGET_ERROR = "$request_target_invalid";
+    const TEST_FILE_PATH = /^(?!.*<).*[/.]/;
+    /** Regular expression to detect if a string describes an HTML element. */
+    const TEST_HTML = /</;
     /**
      * Default node icons for icon libraries
      *
@@ -2643,7 +2768,7 @@
      *  - 'fontawesome6' {@link https://fontawesome.com/icons}
      *
      */
-    const iconMaps = {
+    const defaultIconMaps = {
         bootstrap: {
             error: "bi bi-exclamation-triangle",
             // loading: "bi bi-hourglass-split wb-busy",
@@ -2691,7 +2816,7 @@
             radioChecked: "fa-solid fa-circle",
             radioUnchecked: "fa-regular fa-circle",
             radioUnknown: "fa-regular fa-circle-question",
-            folder: "fa-solid fa-folder-closed",
+            folder: "fa-regular fa-folder-closed",
             folderOpen: "fa-regular fa-folder-open",
             folderLazy: "fa-solid fa-folder-plus",
             doc: "fa-regular fa-file",
@@ -2723,29 +2848,20 @@
     //   "Escape",
     // ]);
     /** Map `KeyEvent.key` to navigation action. */
-    const KEY_TO_ACTION_DICT = {
-        " ": "toggleSelect",
-        "+": "expand",
-        Add: "expand",
+    const KEY_TO_NAVIGATION_MAP = {
         ArrowDown: "down",
         ArrowLeft: "left",
         ArrowRight: "right",
         ArrowUp: "up",
         Backspace: "parent",
-        "/": "collapseAll",
-        Divide: "collapseAll",
         End: "lastCol",
         Home: "firstCol",
         "Control+End": "last",
         "Control+Home": "first",
         "Meta+ArrowDown": "last", // macOs
         "Meta+ArrowUp": "first", // macOs
-        "*": "expandAll",
-        Multiply: "expandAll",
         PageDown: "pageDown",
         PageUp: "pageUp",
-        "-": "collapse",
-        Subtract: "collapse",
     };
     /** Return a callback that returns true if the node title matches the string
      * or regular expression.
@@ -2773,12 +2889,20 @@
             return reMatch.test(node.title);
         };
     }
-    /** Compare two nodes by title (case-insensitive). */
+    /** Compare two nodes by title (case-insensitive).
+     * @deprecated Use `key` option instead of `cmp` in sort methods.
+     */
     function nodeTitleSorter(a, b) {
         const x = a.title.toLowerCase();
         const y = b.title.toLowerCase();
         return x === y ? 0 : x > y ? 1 : -1;
     }
+    // /** Compare nodes by title (case-insensitive). */
+    // export function nodeTitleKeyGetter(
+    //   node: WunderbaumNode
+    // ): string | number | Array<any> {
+    //   return node.title.toLowerCase();
+    // }
     /**
      * Convert 'flat' to 'nested' format.
      *
@@ -2969,7 +3093,7 @@
     /*!
      * Wunderbaum - ext-grid
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     class GridExtension extends WunderbaumExtension {
         constructor(tree) {
@@ -3029,7 +3153,7 @@
             super.init();
         }
         /**
-         * Hanldes drag and sragstop events for column resizing.
+         * Handles drag and sragstop events for column resizing.
          */
         handleDrag(e) {
             const custom = e.customData;
@@ -3060,7 +3184,7 @@
     /*!
      * Wunderbaum - deferred
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /**
      * Implement a ES6 Promise, that exposes a resolve() and reject() method.
@@ -3113,7 +3237,7 @@
     /*!
      * Wunderbaum - wunderbaum_node
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     /** WunderbaumNode properties that can be passed with source data.
      * (Any other source properties will be stored as `node.data.PROP`.)
@@ -3164,7 +3288,7 @@
      */
     class WunderbaumNode {
         constructor(tree, parent, data) {
-            var _a, _b;
+            var _a;
             /** Reference key. Unlike {@link key}, a `refKey` may occur multiple
              * times within a tree (in this case we have 'clone nodes').
              * @see Use {@link setKey} to modify.
@@ -3194,8 +3318,8 @@
             assert(!data.children, "'children' not allowed here");
             this.tree = tree;
             this.parent = parent;
-            this.key = "" + ((_a = data.key) !== null && _a !== void 0 ? _a : ++WunderbaumNode.sequence);
-            this.title = "" + ((_b = data.title) !== null && _b !== void 0 ? _b : "<" + this.key + ">");
+            this.key = tree._calculateKey(data, parent);
+            this.title = "" + ((_a = data.title) !== null && _a !== void 0 ? _a : "<" + this.key + ">");
             this.expanded = !!data.expanded;
             this.lazy = !!data.lazy;
             // We set the following node properties only if a matching data value is
@@ -3316,8 +3440,14 @@
                 const forceExpand = applyMinExpanLevel && _level < tree.options.minExpandLevel;
                 for (const child of nodeData) {
                     const subChildren = child.children;
+                    // Remove children property from source data because it should not be
+                    // passed to the constructor of WunderbaumNode:
                     delete child.children;
                     const n = new WunderbaumNode(tree, this, child);
+                    // Set `children` property again, so it can be used in `reload()`
+                    if (subChildren != null) {
+                        child.children = subChildren;
+                    }
                     if (forceExpand && !n.isUnloaded()) {
                         n.expanded = true;
                     }
@@ -3733,15 +3863,12 @@
             }
             return l;
         }
-        /** Return a string representing the hierachical node path, e.g. "a/b/c".
+        /** Return a string representing the hierarchical node path, e.g. "a/b/c".
          * @param includeSelf
          * @param part property name or callback
          * @param separator
          */
         getPath(includeSelf = true, part = "title", separator = "/") {
-            // includeSelf = includeSelf !== false;
-            // part = part || "title";
-            // separator = separator || "/";
             let val;
             const path = [];
             const isFunc = typeof part === "function";
@@ -3756,7 +3883,7 @@
             }, includeSelf);
             return path.join(separator);
         }
-        /** Return the preceeding node (under the same parent) or null. */
+        /** Return the preceding node (under the same parent) or null. */
         getPrevSibling() {
             const ac = this.parent.children;
             const idx = ac.indexOf(this);
@@ -3785,7 +3912,7 @@
         hasClass(className) {
             return this.classes ? this.classes.has(className) : false;
         }
-        /** Return true if node ist the currently focused node. @since 0.9.0 */
+        /** Return true if node is the currently focused node. @since 0.9.0 */
         hasFocus() {
             return this.tree.focusNode === this;
         }
@@ -3840,7 +3967,7 @@
          * an expand operation is currently possible.
          */
         isExpandable(andCollapsed = false) {
-            // `false` is never expandable (unoffical)
+            // `false` is never expandable (unofficial)
             if ((andCollapsed && this.expanded) || this.children === false) {
                 return false;
             }
@@ -3895,7 +4022,7 @@
         isParentOf(other) {
             return other && other.parent === this;
         }
-        /** (experimental) Return true if this node is partially loaded. */
+        /** Return true if this node is partially loaded. @experimental  */
         isPartload() {
             return !!this._partload;
         }
@@ -3903,11 +4030,11 @@
         isPartsel() {
             return !this.selected && !!this._partsel;
         }
-        /** Return true if this node has DOM representaion, i.e. is displayed in the viewport. */
+        /** Return true if this node has DOM representation, i.e. is displayed in the viewport. */
         isRadio() {
             return !!this.parent.radiogroup || this.getOption("checkbox") === "radio";
         }
-        /** Return true if this node has DOM representaion, i.e. is displayed in the viewport. */
+        /** Return true if this node has DOM representation, i.e. is displayed in the viewport. */
         isRendered() {
             return !!this._rowElem;
         }
@@ -4353,10 +4480,11 @@
          * @param options
          */
         async navigate(where, options) {
+            var _a;
             // Allow to pass 'ArrowLeft' instead of 'left'
-            where = KEY_TO_ACTION_DICT[where] || where;
+            const navType = ((_a = KEY_TO_NAVIGATION_MAP[where]) !== null && _a !== void 0 ? _a : where);
             // Otherwise activate or focus the related node
-            const node = this.findRelatedNode(where);
+            const node = this.findRelatedNode(navType);
             if (!node) {
                 this.logWarn(`Could not find related node '${where}'.`);
                 return Promise.resolve(this);
@@ -4453,86 +4581,17 @@
                 renderColInfosById: renderColInfosById,
             };
         }
-        _createIcon(iconMap, parentElem, replaceChild, showLoading) {
-            let iconSpan;
-            let icon = this.getOption("icon");
-            if (this._errorInfo) {
-                icon = iconMap.error;
-            }
-            else if (this._isLoading && showLoading) {
-                // Status nodes, or nodes without expander (< minExpandLevel) should
-                // display the 'loading' status with the i.wb-icon span
-                icon = iconMap.loading;
-            }
-            if (icon === false) {
-                return null; // explicitly disabled: don't try default icons
-            }
-            if (typeof icon === "string") ;
-            else if (this.statusNodeType) {
-                icon = iconMap[this.statusNodeType];
-            }
-            else if (this.expanded) {
-                icon = iconMap.folderOpen;
-            }
-            else if (this.children) {
-                icon = iconMap.folder;
-            }
-            else if (this.lazy) {
-                icon = iconMap.folderLazy;
-            }
-            else {
-                icon = iconMap.doc;
-            }
-            // this.log("_createIcon: " + icon);
-            if (!icon) {
-                iconSpan = document.createElement("i");
-                iconSpan.className = "wb-icon";
-            }
-            else if (icon.indexOf("<") >= 0) {
-                // HTML
-                iconSpan = elemFromHtml(icon);
-            }
-            else if (TEST_IMG.test(icon)) {
-                // Image URL
-                iconSpan = elemFromHtml(`<i class="wb-icon" style="background-image: url('${icon}');">`);
-            }
-            else {
-                // Class name
-                iconSpan = document.createElement("i");
-                iconSpan.className = "wb-icon " + icon;
-            }
-            if (replaceChild) {
-                parentElem.replaceChild(iconSpan, replaceChild);
-            }
-            else {
-                parentElem.appendChild(iconSpan);
-            }
-            // Event handler `tree.iconBadge` can return a badge text or HTMLSpanElement
-            const cbRes = this._callEvent("iconBadge", { iconSpan: iconSpan });
-            let badge = null;
-            if (cbRes != null && cbRes !== false) {
-                let classes = "";
-                let tooltip = "";
-                if (isPlainObject(cbRes)) {
-                    badge = "" + cbRes.badge;
-                    classes = cbRes.badgeClass ? " " + cbRes.badgeClass : "";
-                    tooltip = cbRes.badgeTooltip ? ` title="${cbRes.badgeTooltip}"` : "";
-                }
-                else if (typeof cbRes === "number") {
-                    badge = "" + cbRes;
+        _createIcon(parentElem, replaceChild, showLoading) {
+            const iconElem = this.tree._createNodeIcon(this, showLoading, true);
+            if (iconElem) {
+                if (replaceChild) {
+                    parentElem.replaceChild(iconElem, replaceChild);
                 }
                 else {
-                    badge = cbRes; // string or HTMLSpanElement
-                }
-                if (typeof badge === "string") {
-                    badge = elemFromHtml(`<span class="wb-badge${classes}"${tooltip}>${escapeHtml(badge)}</span>`);
-                }
-                if (badge) {
-                    iconSpan.append(badge);
+                    parentElem.appendChild(iconElem);
                 }
             }
-            // this.log("_createIcon: ", iconSpan);
-            return iconSpan;
+            return iconElem;
         }
         /**
          * Create a whole new `<div class="wb-row">` element.
@@ -4587,7 +4646,7 @@
             }
             // Render the icon (show a 'loading' icon if we do not have an expander that
             // we would prefer).
-            const iconSpan = this._createIcon(tree.iconMap, nodeElem, null, !expanderSpan);
+            const iconSpan = this._createIcon(nodeElem, null, !expanderSpan);
             if (iconSpan) {
                 ofsTitlePx += ICON_WIDTH;
             }
@@ -4730,9 +4789,9 @@
             const typeInfo = this.type ? tree.types[this.type] : null;
             const rowDiv = this._rowElem;
             // Row markup already exists
-            const nodeElem = rowDiv.querySelector("span.wb-node");
-            const expanderSpan = nodeElem.querySelector("i.wb-expander");
-            const checkboxSpan = nodeElem.querySelector("i.wb-checkbox");
+            const nodeSpan = rowDiv.querySelector("span.wb-node");
+            const expanderElem = nodeSpan.querySelector("i.wb-expander");
+            const checkboxElem = nodeSpan.querySelector("i.wb-checkbox");
             const rowClasses = ["wb-row"];
             this.expanded ? rowClasses.push("wb-expanded") : 0;
             this.lazy ? rowClasses.push("wb-lazy") : 0;
@@ -4757,7 +4816,7 @@
             if (typeInfo && typeInfo.classes) {
                 rowDiv.classList.add(...typeInfo.classes);
             }
-            if (expanderSpan) {
+            if (expanderElem) {
                 let image = null;
                 if (this._isLoading) {
                     image = iconMap.loading;
@@ -4774,16 +4833,20 @@
                     image = iconMap.expanderLazy;
                 }
                 if (image == null) {
-                    expanderSpan.classList.add("wb-indent");
+                    expanderElem.className = "wb-expander";
+                    expanderElem.classList.add("wb-indent");
+                }
+                else if (TEST_HTML.test(image)) {
+                    expanderElem.replaceWith(elemFromHtml(image));
                 }
-                else if (TEST_IMG.test(image)) {
-                    expanderSpan.style.backgroundImage = `url('${image}')`;
+                else if (TEST_FILE_PATH.test(image)) {
+                    expanderElem.style.backgroundImage = `url('${image}')`;
                 }
                 else {
-                    expanderSpan.className = "wb-expander " + image;
+                    expanderElem.className = "wb-expander " + image;
                 }
             }
-            if (checkboxSpan) {
+            if (checkboxElem) {
                 let cbclass = "wb-checkbox ";
                 if (this.isRadio()) {
                     cbclass += "wb-radio ";
@@ -4807,7 +4870,7 @@
                         cbclass += iconMap.checkUnchecked;
                     }
                 }
-                checkboxSpan.className = cbclass;
+                checkboxElem.className = cbclass;
             }
             // Fix active cell in cell-nav mode
             if (!opts.isNew) {
@@ -4817,9 +4880,9 @@
                     colSpan.classList.remove("wb-error", "wb-invalid");
                 }
                 // Update icon (if not opts.isNew, which would rebuild markup anyway)
-                const iconSpan = nodeElem.querySelector("i.wb-icon");
+                const iconSpan = nodeSpan.querySelector("i.wb-icon");
                 if (iconSpan) {
-                    this._createIcon(tree.iconMap, nodeElem, iconSpan, !expanderSpan);
+                    this._createIcon(nodeSpan, iconSpan, !expanderElem);
                 }
             }
             // Adjust column width
@@ -5124,6 +5187,32 @@
         setKey(key, refKey) {
             throw new Error("Not yet implemented");
         }
+        // /**
+        //  * Calculate a *stable*, unique key for this node from its refKey (or title).
+        //  * We also add information from the parent, because a refKey may occur multiple
+        //  * times in a tree.
+        //  */
+        // calcUniqueKey() {
+        //   // Assuming that the parent's key was calculated the same way, we implicitly
+        //   // involve the whole refKey-path:
+        //   const s = this.key + (this.refKey || this.title);
+        //   // 32-bit has a high probability of collisions, so we pump up to 64-bit
+        //   // https://security.stackexchange.com/q/209882/207588
+        //   const h1 = util.murmurHash3(s, true);
+        //   return "id_" + h1 + util.murmurHash3(h1 + s, true);
+        //   // const l = [];
+        //   // // eslint-disable-next-line  @typescript-eslint/no-this-alias
+        //   // let node: WunderbaumNode = this;
+        //   // while (node.parent) {
+        //   //   l.unshift(node.refKey || node.key);
+        //   //   node = node.parent;
+        //   // }
+        //   // const path = l.join("/");
+        //   // 32-bit has a high probability of collisions, so we pump up to 64-bit
+        //   // https://security.stackexchange.com/q/209882/207588
+        //   // const h1 = util.murmurHash3(path, true);
+        //   // return "id_" + h1 + util.murmurHash3(h1 + path, true);
+        // }
         /**
          * Trigger a repaint, typically after a status or data change.
          *
@@ -5155,6 +5244,23 @@
             });
             return nodeList;
         }
+        /**
+         * Return an array of refKey values.
+         *
+         * RefKeys are unique identifiers for a node data, and are used to identify
+         * clones.
+         * If more than one node has the same refKey, it is only returned once.
+         * @param selected if true, only return refKeys of selected nodes.
+         */
+        getRefKeys(selected = false) {
+            const refKeys = new Set();
+            this.visit((node) => {
+                if (node.refKey != null && (!selected || node.selected)) {
+                    refKeys.add(node.refKey);
+                }
+            });
+            return Array.from(refKeys);
+        }
         /** Toggle the check/uncheck state. */
         toggleSelected(options) {
             let flag = this.isSelected();
@@ -5334,9 +5440,11 @@
                     if (selectMode === "hier") {
                         this.fixSelection3AfterClick();
                     }
-                    else if (selectMode === "single") {
+                    else if (selectMode === "single" && flag) {
                         tree.visit((n) => {
-                            n.selected = false;
+                            if (n !== this) {
+                                n.selected = false;
+                            }
                         });
                     }
                 }
@@ -5368,7 +5476,7 @@
                 assert(data.statusNodeType, "Not a status node");
                 assert(!firstChild || !firstChild.isStatusNode(), "Child must not be a status node");
                 statusNode = this.addNode(data, "prependChild");
-                statusNode.match = true;
+                statusNode.match = -1; // Mark as 'match' to avoid hiding
                 tree.update(ChangeType.structure);
                 return statusNode;
             };
@@ -5438,30 +5546,16 @@
             this.tooltip = tooltip;
             this.update();
         }
-        _sortChildren(cmp, deep) {
-            const cl = this.children;
-            if (!cl) {
-                return;
-            }
-            cl.sort(cmp);
-            if (deep) {
-                for (let i = 0, l = cl.length; i < l; i++) {
-                    if (cl[i].children) {
-                        cl[i]._sortChildren(cmp, deep);
-                    }
-                }
-            }
-        }
         /**
          * Sort child list by title or custom criteria.
          * @param {function} cmp custom compare function(a, b) that returns -1, 0, or 1
          *    (defaults to sorting by title).
          * @param {boolean} deep pass true to sort all descendant nodes recursively
+         * @deprecated use {@link sort}
          */
         sortChildren(cmp = nodeTitleSorter, deep = false) {
-            this._sortChildren(cmp || nodeTitleSorter, deep);
-            this.tree.update(ChangeType.structure);
-            // this.triggerModify("sort"); // TODO
+            this.tree.logDeprecate("node.sortChildren()", { since: "0.14.0" });
+            return this.sort({ cmp: cmp ? cmp : undefined, deep: deep });
         }
         /**
          * Renumber nodes `_nativeIndex`. This is useful to allow to restore the
@@ -5483,74 +5577,142 @@
         /**
          * Convenience method to implement column sorting.
          * @since 0.11.0
+         * @deprecated use {@link sort}
          */
         sortByProperty(options) {
-            var _a, _b, _c;
-            const { caseInsensitive = true, deep = true, nativeOrderPropName = "_nativeIndex", updateColInfo = false, } = options;
-            let order;
-            let colDef;
+            this.tree.logDeprecate("node.sortByProperty()", { since: "0.14.0" });
+            return this.sort(options);
+        }
+        /**
+         * Implement column sorting.
+         * @since 0.14.0
+         */
+        sort(options) {
+            const tree = this.tree;
+            let { propName = undefined, deep = true, key = undefined, order = undefined, caseInsensitive = true, cmp = undefined, 
+            // Support click on column sort header:
+            updateColInfo = false, nativeOrderPropName = "_nativeIndex", colId = undefined, } = options;
+            propName !== null && propName !== void 0 ? propName : (propName = colId);
+            if (propName === "*") {
+                propName = "title";
+            }
+            const isFolder = tree.options.sortFoldersFirst === true
+                ? (node) => node.hasChildren() !== false || node.type === NODE_TYPE_FOLDER
+                : tree.options.sortFoldersFirst;
             if (updateColInfo) {
-                colDef = this.tree["_columnsById"][options.colId];
+                const colDef = this.tree["_columnsById"][options.colId];
                 assert(colDef, `Invalid colId specified: ${options.colId}`);
-                order =
-                    (_a = options.order) !== null && _a !== void 0 ? _a : rotate(colDef.sortOrder, ["asc", "desc", undefined]);
+                order !== null && order !== void 0 ? order : (order = rotate(colDef.sortOrder, ["asc", "desc", undefined]));
                 for (const col of this.tree.columns) {
                     col.sortOrder = col === colDef ? order : undefined;
                 }
+                if (order === undefined) {
+                    propName = nativeOrderPropName;
+                    order = "asc";
+                }
                 this.tree.update(ChangeType.colStructure);
             }
             else {
-                order = (_b = options.order) !== null && _b !== void 0 ? _b : "asc";
+                propName !== null && propName !== void 0 ? propName : (propName = "title");
+                order !== null && order !== void 0 ? order : (order = "asc");
+            }
+            this.logDebug(`sort(), propName=${propName}, ${order}`, options);
+            assert(propName || cmp || key, "No `propName` or `key` specified");
+            // Define a key callback from the parameters we have
+            if (key == null && cmp == null) {
+                key = (node) => {
+                    let val;
+                    if (NODE_DICT_PROPS.has(propName)) {
+                        val = node[propName];
+                    }
+                    else {
+                        val = node.data[propName];
+                    }
+                    if (caseInsensitive && typeof val === "string") {
+                        val = val.toLowerCase();
+                    }
+                    return val;
+                };
             }
-            let propName = (_c = options.propName) !== null && _c !== void 0 ? _c : (options.colId || "");
-            if (propName === "*") {
-                propName = "title";
+            // Define a compare callback that uses the key callback
+            if (cmp) {
+                assert(!key, "`key` and `cmp` are mutually exclusive");
+                tree.logDeprecate("SortOptions.cmp", {
+                    since: "0.14.0",
+                    hint: "use the `key` callback instead",
+                });
             }
-            if (order == null) {
-                propName = nativeOrderPropName;
-                order = "asc";
+            else {
+                if (options.propName || options.caseInsensitive) {
+                    tree.logWarn("sort(): ignoring propName, caseInsensitive");
+                }
+                cmp = (a, b) => {
+                    if (isFolder) {
+                        const isFolderA = isFolder(a);
+                        if (isFolderA !== isFolder(b)) {
+                            return isFolderA ? -1 : 1;
+                        }
+                    }
+                    let x = key(a);
+                    let y = key(b);
+                    // Assure we have reasonable comparisons with null values:
+                    if (x == null) {
+                        x = typeof y === "string" ? "" : 0;
+                    }
+                    else if (typeof x === "boolean") {
+                        x = x ? 1 : 0;
+                    }
+                    if (y == null) {
+                        y = typeof x === "string" ? "" : 0;
+                    }
+                    else if (typeof y === "boolean") {
+                        y = y ? 1 : 0;
+                    }
+                    if (order === "desc") {
+                        return x === y ? 0 : x > y ? -1 : 1;
+                    }
+                    return x === y ? 0 : x > y ? 1 : -1;
+                };
             }
-            this.logDebug(`sortByProperty(), propName=${propName}, ${order}`, options);
-            assert(propName, "No property name specified");
-            const cmp = (a, b) => {
-                let av, bv;
-                if (NODE_DICT_PROPS.has(propName)) {
-                    av = a[propName];
-                    bv = b[propName];
-                }
-                else {
-                    av = a.data[propName];
-                    bv = b.data[propName];
-                }
-                if (av == null && bv == null) {
-                    return 0;
-                }
-                if (av == null) {
-                    av = typeof bv === "string" ? "" : 0;
-                }
-                else if (typeof av === "boolean") {
-                    av = av ? 1 : 0;
-                }
-                if (bv == null) {
-                    bv = typeof av === "string" ? "" : 0;
-                }
-                else if (typeof bv === "boolean") {
-                    bv = bv ? 1 : 0;
+            function _sortChildren(cl) {
+                if (!cl) {
+                    return;
                 }
-                if (caseInsensitive) {
-                    if (typeof av === "string") {
-                        av = av.toLowerCase();
-                    }
-                    if (typeof bv === "string") {
-                        bv = bv.toLowerCase();
+                cl.sort(cmp);
+                if (deep) {
+                    for (let i = 0, l = cl.length; i < l; i++) {
+                        if (cl[i].children) {
+                            _sortChildren(cl[i].children);
+                        }
                     }
                 }
-                if (order === "desc") {
-                    return av === bv ? 0 : av > bv ? -1 : 1;
+            }
+            if (this.children) {
+                _sortChildren(this.children);
+            }
+            this.tree.update(ChangeType.structure);
+            // this.triggerModify("sort"); // TODO
+        }
+        /**
+         * Re-apply current sorting if any (use after lazy load).
+         * Example:
+         * ```js
+         * load: function (e) {
+         *   // Whe loading a lazy branch, apply current sort order if any
+         *   e.node.resort();
+         * },
+         * ```
+         * @since 0.14.0
+         */
+        resort(options = {}) {
+            for (const colDef of this.tree.columns) {
+                if (colDef.sortOrder) {
+                    options.colId = colDef.id;
+                    options.order = colDef.sortOrder;
+                    this.sort(options);
+                    break;
                 }
-                return av === bv ? 0 : av > bv ? 1 : -1;
-            };
-            return this.sortChildren(cmp, deep);
+            }
         }
         /**
          * Trigger `modifyChild` event on a parent to signal that a child was modified.
@@ -5587,7 +5749,8 @@
          * @param {function} callback the callback function.
          *     Return false to stop iteration, return "skip" to skip this node and
          *     its children only.
-         * @see {@link IterableIterator<WunderbaumNode>}, {@link Wunderbaum.visit}.
+         * @see `wb_node.WunderbaumNode.IterableIterator<WunderbaumNode>`
+         * @see {@link Wunderbaum.visit}.
          */
         visit(callback, includeSelf = false) {
             let res = true;
@@ -5660,7 +5823,7 @@
     /*!
      * Wunderbaum - ext-edit
      * Copyright (c) 2021-2025, Martin Wendt. Released under the MIT license.
-     * v0.12.1, Sat, 22 Feb 2025 22:59:20 GMT (https://github.com/mar10/wunderbaum)
+     * v0.14.0, Fri, 20 Mar 2026 16:58:31 GMT (https://github.com/mar10/wunderbaum)
      */
     // const START_MARKER = "\uFFF7";
     class EditExtension extends WunderbaumExtension {
@@ -5895,7 +6058,7 @@
                 newValue = newValue.trim();
             }
             if (!node) {
-                this.tree.logDebug("stopEditTitle: not in edit mode.");
+                // this.tree.logDebug("stopEditTitle: not in edit mode.");
                 return;
             }
             node.logDebug(`stopEditTitle(${apply})`, options, focusElem, newValue);
@@ -5979,7 +6142,7 @@
             newNode.setClass("wb-edit-new");
             this.relatedNode = node;
             // Don't filter new nodes:
-            newNode.match = true;
+            newNode.match = -1;
             newNode.makeVisible({ noAnimation: true }).then(() => {
                 this.startEditTitle(newNode);
             });
@@ -5995,8 +6158,8 @@
      * https://github.com/mar10/wunderbaum
      *
      * Released under the MIT license.
-     * @version v0.12.1
-     * @date Sat, 22 Feb 2025 22:59:20 GMT
+     * @version v0.14.0
+     * @date Fri, 20 Mar 2026 16:58:31 GMT
      */
     // import "./wunderbaum.scss";
     class WbSystemRoot extends WunderbaumNode {
@@ -6045,18 +6208,21 @@
             this._disableUpdateIgnoreCount = 0;
             this._activeNode = null;
             this._focusNode = null;
+            this._initialSource = null;
             /** Shared properties, referenced by `node.type`. */
             this.types = {};
             /** List of column definitions. */
-            this.columns = []; // any[] = [];
+            this.columns = [];
             this._columnsById = {};
             // Modification Status
             this.pendingChangeTypes = new Set();
             /** Expose some useful methods of the util.ts module as `tree._util`. */
             this._util = util;
             // --- SELECT ---
-            // /** @internal */
             // public selectRangeAnchor: WunderbaumNode | null = null;
+            // --- BREADCRUMB ---
+            /** Filter options (used as defaults for calls to {@link Wunderbaum.filterNodes} ) */
+            this.breadcrumb = null;
             // --- FILTER ---
             /** Filter options (used as defaults for calls to {@link Wunderbaum.filterNodes} ) */
             this.filterMode = null;
@@ -6071,45 +6237,57 @@
             this.lastQuicksearchTerm = "";
             // --- EDIT ---
             this.lastClickTime = 0;
-            const opts = (this.options = extend({
-                id: null,
-                source: null, // URL for GET/PUT, Ajax options, or callback
-                element: null, // <div class="wunderbaum">
+            // Set default options and merge with user options
+            const initOptions = Object.assign({
+                id: undefined,
+                source: [], // URL for GET/PUT, Ajax options, or callback
+                element: unsafeCast(null),
                 debugLevel: DEFAULT_DEBUGLEVEL, // 0:quiet, 1:errors, 2:warnings, 3:info, 4:verbose
                 header: null, // Show/hide header (pass bool or string)
-                // headerHeightPx: ROW_HEIGHT,
                 rowHeightPx: DEFAULT_ROW_HEIGHT,
                 iconMap: "bootstrap",
-                columns: null,
-                types: null,
-                // escapeTitles: true,
+                columns: [], //util.unsafeCast<ColumnDefinitionList>(null),
+                types: {},
                 enabled: true,
                 fixedCol: false,
                 showSpinner: false,
                 checkbox: false,
                 minExpandLevel: 0,
                 emptyChildListExpandable: false,
-                // updateThrottleWait: 200,
                 skeleton: false,
-                connectTopBreadcrumb: null, // HTMLElement that receives the top nodes breadcrumb
+                autoCollapse: false,
+                adjustHeight: true,
+                connectTopBreadcrumb: null,
+                columnsFilterable: false,
+                columnsMenu: false,
+                columnsResizable: false,
+                columnsSortable: false,
                 selectMode: "multi", // SelectModeType
+                scrollIntoViewOnExpandClick: true,
+                // --- Extensions (actually set by exensions on init)
+                dnd: unsafeCast(null),
+                edit: unsafeCast(null),
+                filter: unsafeCast(null),
                 // --- KeyNav ---
-                navigationModeOption: null, // NavModeEnum.startRow,
+                navigationModeOption: unsafeCast(null),
                 quicksearch: true,
                 // --- Events ---
-                iconBadge: null,
-                change: null,
-                // enhanceTitle: null,
-                error: null,
-                receive: null,
+                // iconBadge: null,
+                // change: null,
+                // ...
                 // --- Strings ---
                 strings: {
                     loadError: "Error",
                     loading: "Loading...",
-                    // loading: "Loading&hellip;",
                     noData: "No data",
+                    breadcrumbDelimiter: " » ",
+                    queryResult: "Found ${matches} of ${count}",
+                    noMatch: "No results",
+                    matchIndex: "${match} of ${matches}",
                 },
-            }, options));
+            }, options);
+            const opts = initOptions;
+            this.options = opts;
             const readyDeferred = new Deferred();
             this.ready = readyDeferred.promise();
             let readyOk = false;
@@ -6136,7 +6314,8 @@
                     this._callEvent("init", { error: err });
                 }
             });
-            this.id = opts.id || "wb_" + ++Wunderbaum.sequence;
+            this.id = initOptions.id || "wb_" + ++Wunderbaum.sequence;
+            delete initOptions.id;
             this.root = new WbSystemRoot(this);
             this._registerExtension(new KeynavExtension(this));
             this._registerExtension(new EditExtension(this));
@@ -6146,19 +6325,20 @@
             this._registerExtension(new LoggerExtension(this));
             this._updateViewportThrottled = adaptiveThrottle(this._updateViewportImmediately.bind(this), {});
             // --- Evaluate options
-            this.columns = opts.columns;
-            delete opts.columns;
+            this.columns = initOptions.columns || [];
+            delete initOptions.columns;
             if (!this.columns || !this.columns.length) {
                 const title = typeof opts.header === "string" ? opts.header : this.id;
                 this.columns = [{ id: "*", title: title, width: "*" }];
             }
-            if (opts.types) {
-                this.setTypes(opts.types, true);
+            if (initOptions.types) {
+                this.setTypes(initOptions.types, true);
             }
-            delete opts.types;
+            delete initOptions.types;
             // --- Create Markup
-            this.element = elemFromSelector(opts.element);
-            assert(!!this.element, `Invalid 'element' option: ${opts.element}`);
+            this.element = elemFromSelector(initOptions.element);
+            assert(!!this.element, `Invalid 'element' option: ${initOptions.element}`);
+            delete initOptions.element;
             this.element.classList.add("wunderbaum");
             if (!this.element.getAttribute("tabindex")) {
                 this.element.tabIndex = 0;
@@ -6213,6 +6393,19 @@
             this.headerElement =
                 this.element.querySelector("div.wb-header");
             this.element.classList.toggle("wb-grid", this.columns.length > 1);
+            if (this.options.connectTopBreadcrumb) {
+                this.breadcrumb = elemFromSelector(this.options.connectTopBreadcrumb);
+                assert(!this.breadcrumb || this.breadcrumb.innerHTML != null, `Invalid 'connectTopBreadcrumb' option: ${this.breadcrumb}.`);
+                this.breadcrumb.addEventListener("click", (e) => {
+                    // const node = Wunderbaum.getNode(e)!;
+                    const elem = e.target;
+                    if (elem && elem.matches("a.wb-breadcrumb")) {
+                        const node = this.keyMap.get(elem.dataset.key);
+                        node === null || node === void 0 ? void 0 : node.setActive();
+                        e.preventDefault();
+                    }
+                });
+            }
             this._initExtensions();
             // --- apply initial options
             ["enabled", "fixedCol"].forEach((optName) => {
@@ -6221,11 +6414,11 @@
                 }
             });
             // --- Load initial data
-            if (opts.source) {
+            if (initOptions.source) {
                 if (opts.showSpinner) {
                     this.nodeListElement.innerHTML = `<progress class='spinner'>${opts.strings.loading}</progress>`;
                 }
-                this.load(opts.source)
+                this.load(initOptions.source)
                     .then(() => {
                     // The source may have defined columns, so we may adjust the nav mode
                     if (opts.navigationModeOption == null) {
@@ -6258,15 +6451,18 @@
             // has a wrong value at start???
             this.update(ChangeType.any);
             // --- Bind listeners
-            this.element.addEventListener("scroll", (e) => {
-                // this.log(`scroll, scrollTop:${e.target.scrollTop}`, e);
-                this.update(ChangeType.scroll);
-            });
+            this._registerEventHandlers();
             this.resizeObserver = new ResizeObserver((entries) => {
                 // this.log("ResizeObserver: Size changed", entries);
                 this.update(ChangeType.resize);
             });
             this.resizeObserver.observe(this.element);
+        }
+        _registerEventHandlers() {
+            this.element.addEventListener("scroll", (e) => {
+                // this.log(`scroll, scrollTop:${e.target.scrollTop}`, e);
+                this.update(ChangeType.scroll);
+            });
             onEvent(this.element, "click", ".wb-button,.wb-col-icon", (e) => {
                 var _a, _b;
                 const info = Wunderbaum.getEventInfo(e);
@@ -6282,9 +6478,6 @@
                 const node = info.node;
                 const mouseEvent = e;
                 // this.log("click", info);
-                // if (this._selectRange(info) === false) {
-                //   return;
-                // }
                 if (this._callEvent("click", { event: e, node: node, info: info }) === false) {
                     this.lastClickTime = Date.now();
                     return false;
@@ -6303,20 +6496,22 @@
                         (!slowClickDelay || Date.now() - this.lastClickTime < slowClickDelay)) {
                         node.startEditTitle();
                     }
-                    if (info.colIdx >= 0) {
-                        node.setActive(true, { colIdx: info.colIdx, event: e });
-                    }
-                    else {
-                        node.setActive(true, { event: e });
-                    }
                     if (info.region === NodeRegion.expander) {
                         node.setExpanded(!node.isExpanded(), {
-                            scrollIntoView: options.scrollIntoViewOnExpandClick !== false,
+                            scrollIntoView: this.options.scrollIntoViewOnExpandClick !== false,
                         });
                     }
                     else if (info.region === NodeRegion.checkbox) {
                         node.toggleSelected();
                     }
+                    else {
+                        if (info.colIdx >= 0) {
+                            node.setActive(true, { colIdx: info.colIdx, event: e });
+                        }
+                        else {
+                            node.setActive(true, { event: e });
+                        }
+                    }
                 }
                 this.lastClickTime = Date.now();
             });
@@ -6352,7 +6547,7 @@
                 const targetNode = Wunderbaum.getNode(e);
                 this._callEvent("focus", { flag: flag, event: e });
                 if (flag && this.isRowNav() && !this.isEditingTitle()) {
-                    if (opts.navigationModeOption === NavModeEnum.row) {
+                    if (this.options.navigationModeOption === NavModeEnum.row) {
                         targetNode === null || targetNode === void 0 ? void 0 : targetNode.setActive();
                     }
                     else {
@@ -6419,11 +6614,12 @@
         }
         /**
          * Return the icon-function -> icon-definition mapping.
+         * @deprecated Use {@link Wunderbaum.iconMaps}
          */
         get iconMap() {
             const map = this.options.iconMap;
             if (typeof map === "string") {
-                return iconMaps[map];
+                return defaultIconMaps[map];
             }
             return map;
         }
@@ -6476,7 +6672,38 @@
                 ext.init();
             }
         }
-        /** Add node to tree's bookkeeping data structures. */
+        /**
+         * Calculate a *stable*, unique key for a node from its refKey (or title).
+         * We also add information from the parent, because a refKey may occur multiple
+         * times in a tree (but not as child of the same parent).
+         * @internal
+         */
+        _calculateKey(data, parent) {
+            if (data.key) {
+                // Always use an explicitly passed key
+                return data.key;
+            }
+            // Auto-keys are optional, use a monotonic counter by default:
+            if (!this.options.autoKeys) {
+                return "" + ++WunderbaumNode.sequence;
+            }
+            // Add the parent's key to the hash. Assuming this was generated by the
+            // same algorithm, this should incorporate the whole path:
+            const s = (parent ? parent.key : "") + (data.refKey || data.title);
+            // 32-bit has a high probability of collisions, so we pump up to 64-bit
+            // https://security.stackexchange.com/q/209882/207588
+            const h1 = murmurHash3(s, true);
+            let key = "id_" + h1 + murmurHash3(h1 + s, true);
+            // Check for collisions
+            // (Most likely if the same title occurs multiple in the same parent).
+            const existingNode = this.keyMap.get(key);
+            if (existingNode) {
+                key += "." + ++Wunderbaum.sequence;
+                this.logWarn(`Node with existing key: '${existingNode}', using ${key}.`, data);
+            }
+            return key;
+        }
+        /** Add node to tree's bookkeeping data structures. @internal */
         _registerNode(node) {
             const key = node.key;
             assert(key != null, `Missing key: '${node}'.`);
@@ -6493,7 +6720,7 @@
                 }
             }
         }
-        /** Remove node from tree's bookkeeping data structures. */
+        /** Remove node from tree's bookkeeping data structures. @internal  */
         _unregisterNode(node) {
             // Remove refKey reference from map (if any)
             const rk = node.refKey;
@@ -6576,7 +6803,10 @@
             });
             return node;
         }
-        /** Return the topmost visible node in the viewport. */
+        /** Return the topmost visible node in the viewport.
+         * @param complete If `false`, the node is considered visible if at least one
+         * pixel is visible.
+         */
         getTopmostVpNode(complete = true) {
             const rowHeight = this.options.rowHeightPx;
             const gracePx = 1; // ignore subpixel scrolling
@@ -6609,7 +6839,7 @@
             bottomIdx = Math.min(bottomIdx, this.count(true) - 1);
             return this._getNodeByRowIdx(bottomIdx);
         }
-        /** Return preceeding visible node in the viewport. */
+        /** Return preceding visible node in the viewport. */
         _getPrevNodeInView(node, ofs = 1) {
             this.visitRows((n) => {
                 node = n;
@@ -6620,13 +6850,18 @@
             return node;
         }
         /** Return following visible node in the viewport. */
-        _getNextNodeInView(node, ofs = 1) {
+        _getNextNodeInView(node, options) {
+            let ofs = (options === null || options === void 0 ? void 0 : options.ofs) || 1;
+            const reverse = !!(options === null || options === void 0 ? void 0 : options.reverse);
             this.visitRows((n) => {
                 node = n;
+                if ((options === null || options === void 0 ? void 0 : options.cb) && options.cb(n)) {
+                    return false;
+                }
                 if (ofs-- <= 0) {
                     return false;
                 }
-            }, { reverse: false, start: node || this.getActiveNode() });
+            }, { reverse: reverse, start: node || this.getActiveNode() });
             return node;
         }
         /**
@@ -6746,9 +6981,11 @@
                 case "first":
                 case "last":
                 case "left":
+                case "nextMatch":
                 case "pageDown":
                 case "pageUp":
                 case "parent":
+                case "prevMatch":
                 case "right":
                 case "up":
                     return node.navigate(cmd);
@@ -6863,22 +7100,39 @@
         /** Run code, but defer rendering of viewport until done.
          *
          * ```js
-         * tree.runWithDeferredUpdate(() => {
-         *   return someFuncThatWouldUpdateManyNodes();
+         * const res = tree.runWithDeferredUpdate(() => {
+         *   return someFunctionThatWouldUpdateManyNodes();
          * });
          * ```
          */
-        runWithDeferredUpdate(func, hint = null) {
+        runWithDeferredUpdate(func) {
             try {
                 this.enableUpdate(false);
                 const res = func();
-                assert(!(res instanceof Promise), `Promise return not allowed: ${res}`);
+                assert(!(res instanceof Promise), `Promise return not allowed (see 'runWithDeferredUpdateAsync()'): ${res}`);
                 return res;
             }
             finally {
                 this.enableUpdate(true);
             }
         }
+        /** Run code, but defer rendering of viewport until done.
+         *
+         * ```js
+         * const res = await tree.runWithDeferredUpdate(async () => {
+         *   return someAsyncFunctionThatWouldUpdateManyNodes();
+         * });
+         * ```
+         */
+        async runWithDeferredUpdateAsync(func) {
+            try {
+                this.enableUpdate(false);
+                return await func();
+            }
+            finally {
+                this.enableUpdate(true);
+            }
+        }
         /** Recursively expand all expandable nodes (triggers lazy load if needed). */
         async expandAll(flag = true, options) {
             await this.root.expandAll(flag, options);
@@ -6898,6 +7152,17 @@
         getSelectedNodes(stopOnParents = false) {
             return this.root.getSelectedNodes(stopOnParents);
         }
+        /**
+         * Return an array of refKey values.
+         *
+         * RefKeys are unique identifiers for a node data, and are used to identify
+         * clones.
+         * If more than one node has the same refKey, it is only returned once.
+         * @param selected if true, only return refKeys of selected nodes.
+         */
+        getRefKeys(selected = false) {
+            return this.root.getRefKeys(selected);
+        }
         /*
          * Return an array of selected nodes.
          */
@@ -6940,6 +7205,11 @@
         count(visible = false) {
             return visible ? this.treeRowCount : this.keyMap.size;
         }
+        /** Return the number of *unique* nodes in the data model, i.e. unique `node.refKey`.
+         */
+        countUnique() {
+            return this.refKeyMap.size;
+        }
         /** @internal sanity check. */
         _check() {
             let i = 0;
@@ -6998,12 +7268,14 @@
          * and wrap-around at the end.
          * Used by quicksearch and keyboard navigation.
          */
-        findNextNode(match, startNode) {
+        findNextNode(match, startNode, reverse = false) {
             //, visibleOnly) {
             let res = null;
             const firstNode = this.getFirstChild();
+            // Last visible node (calculation is expensive, so do only if we need it):
+            const lastNode = reverse ? this.findRelatedNode(firstNode, "last") : null;
             const matcher = typeof match === "string" ? makeNodeTitleStartMatcher(match) : match;
-            startNode = startNode || firstNode;
+            startNode = startNode || (reverse ? lastNode : firstNode);
             function _checkNode(n) {
                 // console.log("_check " + n)
                 if (matcher(n)) {
@@ -7016,12 +7288,14 @@
             this.visitRows(_checkNode, {
                 start: startNode,
                 includeSelf: false,
+                reverse: reverse,
             });
             // Wrap around search
             if (!res && startNode !== firstNode) {
                 this.visitRows(_checkNode, {
-                    start: firstNode,
+                    start: reverse ? lastNode : firstNode,
                     includeSelf: true,
+                    reverse: reverse,
                 });
             }
             return res;
@@ -7088,7 +7362,7 @@
                     // }
                     break;
                 case "up":
-                    res = this._getPrevNodeInView(node);
+                    res = this._getNextNodeInView(node, { reverse: true });
                     break;
                 case "down":
                     res = this._getNextNodeInView(node);
@@ -7101,7 +7375,10 @@
                             res = bottomNode;
                         }
                         else {
-                            res = this._getNextNodeInView(node, pageSize);
+                            res = this._getNextNodeInView(node, {
+                                reverse: false,
+                                ofs: pageSize,
+                            });
                         }
                     }
                     break;
@@ -7116,10 +7393,23 @@
                             res = topNode;
                         }
                         else {
-                            res = this._getPrevNodeInView(node, pageSize);
+                            res = this._getNextNodeInView(node, {
+                                reverse: true,
+                                ofs: pageSize,
+                            });
                         }
                     }
                     break;
+                case "prevMatch":
+                // fallthrough
+                case "nextMatch":
+                    if (!this.isFilterActive) {
+                        this.logWarn(`${where}: Filter is not active.`);
+                        break;
+                    }
+                    res = this.findNextNode((n) => n.isMatched(), node, where === "prevMatch");
+                    res === null || res === void 0 ? void 0 : res.setActive();
+                    break;
                 default:
                     this.logWarn("Unknown relation '" + where + "'.");
             }
@@ -7154,6 +7444,18 @@
         format(name_cb, connectors) {
             return this.root.format(name_cb, connectors);
         }
+        /**
+         * Always returns null (so a tree instance behaves as `tree.root`).
+         */
+        get parent() {
+            return null;
+        }
+        /**
+         * Return a list of top-level nodes.
+         */
+        get children() {
+            return this.root.children || [];
+        }
         /**
          * Return the active cell (`span.wb-col`) of the currently active node or null.
          */
@@ -7181,6 +7483,12 @@
         getFirstChild() {
             return this.root.getFirstChild();
         }
+        /**
+         * Return the last top level node if any (not the invisible root node).
+         */
+        getLastChild() {
+            return this.root.getLastChild();
+        }
         /**
          * Return the node that currently has keyboard focus or null.
          * Alias for {@link Wunderbaum.focusNode}.
@@ -7266,7 +7574,7 @@
         }
         /** Return true if any node title or grid cell is currently beeing edited.
          *
-         * See also {@link Wunderbaum.isEditingTitle}.
+         * See also {@link isEditingTitle}.
          */
         isEditing() {
             const focusElem = this.nodeListElement.querySelector("input:focus,select:focus");
@@ -7274,7 +7582,7 @@
         }
         /** Return true if any node is currently in edit-title mode.
          *
-         * See also {@link WunderbaumNode.isEditingTitle} and {@link Wunderbaum.isEditing}.
+         * See also {@link WunderbaumNode.isEditingTitle} and {@link isEditing}.
          */
         isEditingTitle() {
             return this._callMethod("edit.isEditingTitle");
@@ -7294,7 +7602,7 @@
             return res;
         }
         /** Write to `console.log` with tree name as prefix if opts.debugLevel >= 4.
-         * @see {@link Wunderbaum.logDebug}
+         * @see {@link logDebug}
          */
         log(...args) {
             if (this.options.debugLevel >= 4) {
@@ -7303,7 +7611,7 @@
         }
         /** Write to `console.debug`  with tree name as prefix if opts.debugLevel >= 4.
          * and browser console level includes debug/verbose messages.
-         * @see {@link Wunderbaum.log}
+         * @see {@link log}
          */
         logDebug(...args) {
             if (this.options.debugLevel >= 4) {
@@ -7341,6 +7649,19 @@
                 console.warn(this.toString(), ...args); // eslint-disable-line no-console
             }
         }
+        /** Emit a warning for deprecated methods. @internal */
+        logDeprecate(method, options) {
+            if (this.options.debugLevel >= 2) {
+                let msg = `${this}: ${method} is deprecated`;
+                if (options === null || options === void 0 ? void 0 : options.since) {
+                    msg += ` since ${options.since}`;
+                }
+                if (options === null || options === void 0 ? void 0 : options.hint) {
+                    msg += ` (${options.since})`;
+                }
+                console.warn(msg + "."); // eslint-disable-line no-console
+            }
+        }
         /** Reset column widths to default. @since 0.10.0 */
         resetColumns() {
             this.columns.forEach((col) => {
@@ -7508,6 +7829,69 @@
         _setFocusNode(node) {
             this._focusNode = node;
         }
+        /** Return the current selection/expansion/activation status. @experimental */
+        getState(options = {}) {
+            var _a, _b;
+            const { activeKey = true, expandedKeys = false, selectedKeys = false, } = options;
+            const expandSet = new Set();
+            if (expandedKeys) {
+                for (const node of this) {
+                    if (node.isExpanded() && node.hasChildren()) {
+                        expandSet.add(node.key);
+                    }
+                }
+            }
+            // Parents of active node are always expanded
+            if (activeKey && this.activeNode) {
+                this.activeNode.visitParents((n) => {
+                    if (n.parent) {
+                        expandSet.add(n.key);
+                    }
+                }, false);
+            }
+            const state = {
+                expandedKeys: expandSet.size ? Array.from(expandSet) : undefined,
+                activeKey: (_b = (_a = this.activeNode) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : null,
+                activeColIdx: this.activeColIdx,
+                selectedKeys: selectedKeys
+                    ? this.getSelectedNodes().flatMap((n) => n.key)
+                    : undefined,
+            };
+            return state;
+        }
+        /** Apply selection/expansion/activation status. @experimental */
+        async setState(state, options = {}) {
+            const { expandLazy = true } = options;
+            return this.runWithDeferredUpdateAsync(async () => {
+                var _a, _b;
+                if (state.expandedKeys && state.expandedKeys.length) {
+                    if (expandLazy) {
+                        // Expand all keys recursively, even if they are not in the tree yet
+                        await this._loadLazyNodes(state.expandedKeys, {
+                            expand: true,
+                            noEvents: true,
+                        });
+                    }
+                    else {
+                        for (const key of state.expandedKeys) {
+                            (_a = this.findKey(key)) === null || _a === void 0 ? void 0 : _a.setExpanded(true);
+                        }
+                    }
+                }
+                if (state.activeKey) {
+                    this.setActiveNode(state.activeKey);
+                }
+                if (state.selectedKeys) {
+                    this.selectAll(false);
+                    for (const key of state.selectedKeys) {
+                        (_b = this.findKey(key)) === null || _b === void 0 ? void 0 : _b.setSelected(true);
+                    }
+                }
+                if (this.isCellNav() && state.activeColIdx != null) {
+                    this.setColumn(state.activeColIdx);
+                }
+            });
+        }
         update(change, node, options) {
             // this.log(`update(${change}) node=${node}`);
             if (!(node instanceof WunderbaumNode)) {
@@ -7664,18 +8048,33 @@
          * @param {function} cmp custom compare function(a, b) that returns -1, 0, or 1
          *    (defaults to sorting by title).
          * @param {boolean} deep pass true to sort all descendant nodes recursively
+         * @deprecated use {@link sort}
          */
         sortChildren(cmp = nodeTitleSorter, deep = false) {
-            this.root.sortChildren(cmp, deep);
+            this.logDeprecate("sortChildren()", { since: "0.14.0" });
+            return this.sort({
+                cmp: cmp ? cmp : undefined,
+                deep: deep,
+                propName: "title",
+            });
         }
         /**
          * Convenience method to implement column sorting.
          * @see {@link WunderbaumNode.sortByProperty}.
          * @since 0.11.0
+         * @deprecated use {@link sort}
          */
         sortByProperty(options) {
+            this.logDeprecate("sortByProperty()", { since: "0.14.0" });
             this.root.sortByProperty(options);
         }
+        /**
+         * Sort nodes list by title or custom criteria.
+         * @since 0.14.0
+         */
+        sort(options) {
+            this.root.sort(options);
+        }
         /** Convert tree to an array of plain objects.
          *
          * @param callback is called for every node, in order to allow
@@ -7789,11 +8188,11 @@
             // }
             return modified;
         }
-        _insertIcon(icon, elem) {
-            const iconElem = document.createElement("i");
-            iconElem.className = icon;
-            elem.appendChild(iconElem);
-        }
+        // protected _insertIcon(icon: string, elem: HTMLElement) {
+        //   const iconElem = document.createElement("i");
+        //   iconElem.className = icon;
+        //   elem.appendChild(iconElem);
+        // }
         /** Create/update header markup from `this.columns` definition.
          * @internal
          */
@@ -7891,6 +8290,102 @@
                 this._updateViewportImmediately();
             }
         }
+        /** @internal */
+        _createNodeIcon(node, showLoading, showBadge) {
+            const iconMap = this.iconMap;
+            let iconElem;
+            let icon = node.getOption("icon");
+            if (node._errorInfo) {
+                icon = iconMap.error;
+            }
+            else if (node._isLoading && showLoading) {
+                // Status nodes, or nodes without expander (< minExpandLevel) should
+                // display the 'loading' status with the i.wb-icon span
+                icon = iconMap.loading;
+            }
+            if (icon === false) {
+                return null; // explicitly disabled: don't try default icons
+            }
+            if (typeof icon === "string") ;
+            else if (node.statusNodeType) {
+                icon = iconMap[node.statusNodeType];
+            }
+            else if (node.expanded) {
+                icon = iconMap.folderOpen;
+            }
+            else if (node.children) {
+                icon = iconMap.folder;
+            }
+            else if (node.lazy) {
+                icon = iconMap.folderLazy;
+            }
+            else {
+                icon = iconMap.doc;
+            }
+            if (!icon) {
+                iconElem = document.createElement("i");
+                iconElem.className = "wb-icon";
+            }
+            else if (TEST_HTML.test(icon)) {
+                iconElem = elemFromHtml(icon);
+            }
+            else if (TEST_FILE_PATH.test(icon)) {
+                iconElem = elemFromHtml(`<i class="wb-icon" style="background-image: url('${icon}');">`);
+            }
+            else {
+                // Class name
+                iconElem = document.createElement("i");
+                iconElem.className = "wb-icon " + icon;
+            }
+            // Event handler `tree.iconBadge` can return a badge text or HTMLSpanElement
+            const cbRes = showBadge && node._callEvent("iconBadge", { iconSpan: iconElem });
+            let badge = null;
+            if (cbRes != null && cbRes !== false) {
+                let classes = "";
+                let tooltip = "";
+                if (isPlainObject(cbRes)) {
+                    badge = "" + cbRes.badge;
+                    classes = cbRes.badgeClass ? " " + cbRes.badgeClass : "";
+                    tooltip = cbRes.badgeTooltip ? ` title="${cbRes.badgeTooltip}"` : "";
+                }
+                else if (typeof cbRes === "number") {
+                    badge = "" + cbRes;
+                }
+                else {
+                    badge = cbRes; // string or HTMLSpanElement
+                }
+                if (typeof badge === "string") {
+                    badge = elemFromHtml(`<span class="wb-badge${classes}"${tooltip}>${escapeHtml(badge)}</span>`);
+                }
+                if (badge) {
+                    iconElem.append(badge);
+                }
+            }
+            return iconElem;
+        }
+        _updateTopBreadcrumb() {
+            const breadcrumb = this.breadcrumb;
+            const topmost = this.getTopmostVpNode(true);
+            const parentList = topmost === null || topmost === void 0 ? void 0 : topmost.getParentList(false, false);
+            if (parentList === null || parentList === void 0 ? void 0 : parentList.length) {
+                breadcrumb.innerHTML = "";
+                for (const n of topmost.getParentList(false, false)) {
+                    const icon = this._createNodeIcon(n, false, false);
+                    if (icon) {
+                        breadcrumb.append(icon, " ");
+                    }
+                    const part = document.createElement("a");
+                    part.textContent = n.title;
+                    part.href = "#";
+                    part.classList.add("wb-breadcrumb");
+                    part.dataset.key = n.key;
+                    breadcrumb.append(part, this.options.strings.breadcrumbDelimiter);
+                }
+            }
+            else {
+                breadcrumb.innerHTML = "&nbsp;";
+            }
+        }
         /**
          * This is the actual update method, which is wrapped inside a throttle method.
          * It calls `updateColumns()` and `_updateRows()`.
@@ -7901,7 +8396,6 @@
          * @internal
          */
         _updateViewportImmediately() {
-            var _a;
             if (this._disableUpdateCount) {
                 this.log(`_updateViewportImmediately() IGNORED (disable level: ${this._disableUpdateCount}).`);
                 this._disableUpdateIgnoreCount++;
@@ -7948,11 +8442,8 @@
                 this._updateRows();
                 // console.profileEnd(`_updateViewportImmediately()`)
             }
-            if (this.options.connectTopBreadcrumb) {
-                assert(this.options.connectTopBreadcrumb.textContent != null, `Invalid 'connectTopBreadcrumb' option (input element expected).`);
-                let path = (_a = this.getTopmostVpNode(true)) === null || _a === void 0 ? void 0 : _a.getPath(false, "title", " > ");
-                path = path ? path + " >" : "";
-                this.options.connectTopBreadcrumb.textContent = path;
+            if (this.breadcrumb) {
+                this._updateTopBreadcrumb();
             }
             this._callEvent("update");
         }
@@ -8076,7 +8567,8 @@
         }
         /**
          * Call `callback(node)` for all nodes in hierarchical order (depth-first, pre-order).
-         * @see {@link IterableIterator<WunderbaumNode>}, {@link WunderbaumNode.visit}.
+         * @see `wb_node.WunderbaumNode.IterableIterator<WunderbaumNode>`
+         * @see {@link WunderbaumNode.visit}.
          *
          * @param {function} callback the callback function.
          *     Return false to stop iteration, return "skip" to skip this node and
@@ -8219,11 +8711,71 @@
          *
          * Previous data is cleared. Note that also column- and type defintions may
          * be passed with the `source` object.
+         * @see {@link Wunderbaum.reload} for a shortcut to reload the last ajax request
+         * and restore the previous state.
          */
-        load(source) {
+        async load(source) {
             this.clear();
+            this._initialSource = source;
             return this.root.load(source);
         }
+        /** Reload the tree and optionally restore state.
+         * Source defaults to last ajax url if any.
+         * Restoring the active node requires stable keys
+         * @see {@link WunderbaumOptions.autoKeys}
+         * @see {@link Wunderbaum.load}
+         * @experimental
+         */
+        async reload(options = {}) {
+            const { source = this._initialSource, reactivate = true } = options;
+            if (!source) {
+                this.logWarn("No previous ajax source to reload.");
+                return;
+            }
+            if (!reactivate) {
+                return this.load(source);
+            }
+            const state = this.getState();
+            await this.load(source);
+            return this.setState(state);
+        }
+        /**
+         * Make sure that all nodes in the given keyList are accessible.
+         * This may include loading lazy parent nodes.
+         * Recursively load (and optionally expand) all requested node paths.
+         */
+        async _loadLazyNodes(keyList, options = {}) {
+            const { expand = true } = options;
+            const keySet = new Set(keyList);
+            // Make sure that all parent nodes are loaded (and expand if requested)
+            while (keySet.size > 0) {
+                const pendingNodes = [];
+                const curSet = new Set(keySet);
+                for (const key of curSet) {
+                    const node = this.findKey(key);
+                    if (!node) {
+                        continue; // key not yet found (need to load lazy parent?)
+                    }
+                    keySet.delete(key);
+                    if (expand) {
+                        pendingNodes.push(node.setExpanded(true));
+                    }
+                    else if (node.isUnloaded()) {
+                        pendingNodes.push(node.loadLazy());
+                    }
+                    if (node._rowElem) {
+                        node._render(); // show spinner even is update is suppressed
+                    }
+                }
+                if (pendingNodes.length === 0) {
+                    // will not load any more nodes, so if if there are still keys
+                    // left in the set, we will never find them
+                    this.logWarn(`Could not expand ${keySet.size} nodes:`, keySet);
+                    break;
+                }
+                await Promise.allSettled(pendingNodes);
+            }
+        }
         /**
          * Disable render requests during operations that would trigger many updates.
          *
@@ -8321,9 +8873,21 @@
     }
     Wunderbaum.sequence = 0;
     /** Wunderbaum release version number "MAJOR.MINOR.PATCH". */
-    Wunderbaum.version = "v0.12.1"; // Set to semver by 'grunt release'
+    Wunderbaum.version = "v0.14.0"; // Set to semver by 'grunt release'
     /** Expose some useful methods of the util.ts module as `Wunderbaum.util`. */
     Wunderbaum.util = util;
+    /** A map of default iconMaps.
+     * May be used as default, when passing partial icon definition maps:
+     * ```js
+     * const tree = new mar10.Wunderbaum({
+     *   ...
+     *   iconMap: Object.assign(Wunderbaum.iconMaps.bootstrap, {
+     *     folder: "bi bi-archive",
+     *   }),
+     * });
+     * ```
+     */
+    Wunderbaum.iconMaps = defaultIconMaps;
 
     exports.Wunderbaum = Wunderbaum;