wunderbaum 0.12.1 → 0.14.0

package/dist/wunderbaum.esm.js

@@ -1,7 +1,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
@@ -293,7 +293,7 @@ function throttle(func, wait = 0, options = {}) {
 /*!
  * 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` */
@@ -443,7 +443,7 @@ function each(obj, callback) {
     }
     return obj;
 }
-/** Shortcut for `throw new Error(msg)`.*/
+/** Shortcut for `throw new Error(msg)`. */
 function error(msg) {
     throw new Error(msg);
 }
@@ -676,18 +676,6 @@ function elemFromSelector(obj) {
     }
     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.
  *
@@ -970,6 +958,10 @@ function toPixel(...defaults) {
     }
     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
@@ -1043,7 +1035,7 @@ function adaptiveThrottle(callback, options) {
     const throttledFn = (...args) => {
         if (waiting) {
             pendingArgs = args;
-            // console.log(`adaptiveThrottle() queing request #${waiting}...`, args);
+            // console.log(`adaptiveThrottle() queueing request #${waiting}...`, args);
             waiting += 1;
         }
         else {
@@ -1098,6 +1090,60 @@ function adaptiveThrottle(callback, options) {
     };
     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,
@@ -1128,6 +1174,7 @@ var util = /*#__PURE__*/Object.freeze({
     isFunction: isFunction,
     isMac: isMac,
     isPlainObject: isPlainObject,
+    murmurHash3: murmurHash3,
     noop: noop,
     onEvent: onEvent,
     overrideMethod: overrideMethod,
@@ -1141,13 +1188,14 @@ var util = /*#__PURE__*/Object.freeze({
     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}.
@@ -1215,7 +1263,7 @@ var NavModeEnum;
 /*!
  * 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) {
@@ -1274,7 +1322,7 @@ class WunderbaumExtension {
 /*!
  * 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";
@@ -1286,7 +1334,7 @@ class FilterExtension extends WunderbaumExtension {
             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
@@ -1294,36 +1342,117 @@ class FilterExtension extends WunderbaumExtension {
             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();
@@ -1405,11 +1534,11 @@ class FilterExtension extends WunderbaumExtension {
                 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;
@@ -1418,10 +1547,6 @@ class FilterExtension extends WunderbaumExtension {
             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
@@ -1432,7 +1557,7 @@ class FilterExtension extends WunderbaumExtension {
             let res = filter(node);
             if (res === "skip") {
                 node.visit(function (c) {
-                    c.match = false;
+                    c.match = undefined;
                 }, true);
                 return "skip";
             }
@@ -1443,7 +1568,7 @@ class FilterExtension extends WunderbaumExtension {
             }
             if (res) {
                 count++;
-                node.match = true;
+                node.match = count;
                 node.visitParents((p) => {
                     if (p !== node) {
                         p.subMatchCount += 1;
@@ -1470,6 +1595,7 @@ class FilterExtension extends WunderbaumExtension {
         }
         // Redraw whole tree
         tree.logDebug(`Filter '${filter}' found ${count} nodes in ${Date.now() - start} ms.`);
+        this._updatedConnectedControls();
         return count;
     }
     /**
@@ -1484,6 +1610,10 @@ class FilterExtension extends WunderbaumExtension {
      */
     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);
     }
@@ -1514,34 +1644,22 @@ class FilterExtension extends WunderbaumExtension {
         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,
@@ -1555,12 +1673,12 @@ class FilterExtension extends WunderbaumExtension {
         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
@@ -1599,7 +1717,7 @@ function _markFuzzyMatchedChars(text, matches, escapeTitles = true) {
 /*!
  * 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 {
@@ -1963,7 +2081,7 @@ class KeynavExtension extends WunderbaumExtension {
 /*!
  * 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) {
@@ -2005,7 +2123,7 @@ class LoggerExtension extends WunderbaumExtension {
 /*!
  * 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 {
@@ -2241,7 +2359,6 @@ class DndExtension extends WunderbaumExtension {
      */
     onDragEvent(e) {
         var _a;
-        // const tree = this.tree;
         const dndOpts = this.treeOpts.dnd;
         const srcNode = Wunderbaum.getNode(e);
         if (!srcNode) {
@@ -2267,7 +2384,7 @@ class DndExtension extends WunderbaumExtension {
                 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;
             });
@@ -2329,6 +2446,7 @@ class DndExtension extends WunderbaumExtension {
         };
         if (!targetNode) {
             this._leaveNode();
+            e.preventDefault(); // Don't open file in browser when dropped in empty area
             return;
         }
         if (["drop"].includes(e.type)) {
@@ -2434,19 +2552,20 @@ class DndExtension extends WunderbaumExtension {
             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;
     }
@@ -2455,7 +2574,7 @@ class DndExtension extends WunderbaumExtension {
 /*!
  * 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'.
@@ -2604,7 +2723,7 @@ class DragObserver {
 /*!
  * 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
 /**
@@ -2624,12 +2743,18 @@ const TITLE_SPAN_PAD_Y = 7;
 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
  *
@@ -2637,7 +2762,7 @@ const TEST_IMG = new RegExp(/\.|\//);
  *  - 'fontawesome6' {@link https://fontawesome.com/icons}
  *
  */
-const iconMaps = {
+const defaultIconMaps = {
     bootstrap: {
         error: "bi bi-exclamation-triangle",
         // loading: "bi bi-hourglass-split wb-busy",
@@ -2685,7 +2810,7 @@ const iconMaps = {
         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",
@@ -2717,29 +2842,20 @@ const RESERVED_TREE_SOURCE_KEYS = new Set([
 //   "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.
@@ -2767,12 +2883,20 @@ function makeNodeTitleStartMatcher(s) {
         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.
  *
@@ -2963,7 +3087,7 @@ function decompressSourceData(source) {
 /*!
  * 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) {
@@ -3023,7 +3147,7 @@ class GridExtension extends WunderbaumExtension {
         super.init();
     }
     /**
-     * Hanldes drag and sragstop events for column resizing.
+     * Handles drag and sragstop events for column resizing.
      */
     handleDrag(e) {
         const custom = e.customData;
@@ -3054,7 +3178,7 @@ class GridExtension extends WunderbaumExtension {
 /*!
  * 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.
@@ -3107,7 +3231,7 @@ class Deferred {
 /*!
  * 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`.)
@@ -3158,7 +3282,7 @@ NODE_DICT_PROPS.delete("unselectable");
  */
 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.
@@ -3188,8 +3312,8 @@ class WunderbaumNode {
         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
@@ -3310,8 +3434,14 @@ class WunderbaumNode {
             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;
                 }
@@ -3727,15 +3857,12 @@ class WunderbaumNode {
         }
         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";
@@ -3750,7 +3877,7 @@ class WunderbaumNode {
         }, 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);
@@ -3779,7 +3906,7 @@ class WunderbaumNode {
     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;
     }
@@ -3834,7 +3961,7 @@ class WunderbaumNode {
      * 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;
         }
@@ -3889,7 +4016,7 @@ class WunderbaumNode {
     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;
     }
@@ -3897,11 +4024,11 @@ class WunderbaumNode {
     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;
     }
@@ -4347,10 +4474,11 @@ class WunderbaumNode {
      * @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);
@@ -4447,86 +4575,17 @@ class WunderbaumNode {
             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.
@@ -4581,7 +4640,7 @@ class WunderbaumNode {
         }
         // 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;
         }
@@ -4724,9 +4783,9 @@ class WunderbaumNode {
         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;
@@ -4751,7 +4810,7 @@ class WunderbaumNode {
         if (typeInfo && typeInfo.classes) {
             rowDiv.classList.add(...typeInfo.classes);
         }
-        if (expanderSpan) {
+        if (expanderElem) {
             let image = null;
             if (this._isLoading) {
                 image = iconMap.loading;
@@ -4768,16 +4827,20 @@ class WunderbaumNode {
                 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 ";
@@ -4801,7 +4864,7 @@ class WunderbaumNode {
                     cbclass += iconMap.checkUnchecked;
                 }
             }
-            checkboxSpan.className = cbclass;
+            checkboxElem.className = cbclass;
         }
         // Fix active cell in cell-nav mode
         if (!opts.isNew) {
@@ -4811,9 +4874,9 @@ class WunderbaumNode {
                 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
@@ -5118,6 +5181,32 @@ class WunderbaumNode {
     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.
      *
@@ -5149,6 +5238,23 @@ class WunderbaumNode {
         });
         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();
@@ -5328,9 +5434,11 @@ class WunderbaumNode {
                 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;
+                        }
                     });
                 }
             }
@@ -5362,7 +5470,7 @@ class WunderbaumNode {
             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;
         };
@@ -5432,30 +5540,16 @@ class WunderbaumNode {
         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
@@ -5477,74 +5571,142 @@ class WunderbaumNode {
     /**
      * 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.
@@ -5581,7 +5743,8 @@ class WunderbaumNode {
      * @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;
@@ -5654,7 +5817,7 @@ WunderbaumNode.sequence = 0;
 /*!
  * 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 {
@@ -5889,7 +6052,7 @@ class EditExtension extends WunderbaumExtension {
             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);
@@ -5973,7 +6136,7 @@ class EditExtension extends WunderbaumExtension {
         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);
         });
@@ -5989,8 +6152,8 @@ class EditExtension extends WunderbaumExtension {
  * 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 {
@@ -6039,18 +6202,21 @@ class Wunderbaum {
         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;
@@ -6065,45 +6231,57 @@ class Wunderbaum {
         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;
@@ -6130,7 +6308,8 @@ class Wunderbaum {
                 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));
@@ -6140,19 +6319,20 @@ class Wunderbaum {
         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;
@@ -6207,6 +6387,19 @@ class Wunderbaum {
         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) => {
@@ -6215,11 +6408,11 @@ class Wunderbaum {
             }
         });
         // --- 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) {
@@ -6252,15 +6445,18 @@ class Wunderbaum {
         // 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);
@@ -6276,9 +6472,6 @@ class Wunderbaum {
             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;
@@ -6297,20 +6490,22 @@ class Wunderbaum {
                     (!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();
         });
@@ -6346,7 +6541,7 @@ class Wunderbaum {
             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 {
@@ -6413,11 +6608,12 @@ class Wunderbaum {
     }
     /**
      * 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;
     }
@@ -6470,7 +6666,38 @@ class Wunderbaum {
             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}'.`);
@@ -6487,7 +6714,7 @@ class Wunderbaum {
             }
         }
     }
-    /** 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;
@@ -6570,7 +6797,10 @@ class Wunderbaum {
         });
         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
@@ -6603,7 +6833,7 @@ class Wunderbaum {
         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;
@@ -6614,13 +6844,18 @@ class Wunderbaum {
         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;
     }
     /**
@@ -6740,9 +6975,11 @@ class Wunderbaum {
             case "first":
             case "last":
             case "left":
+            case "nextMatch":
             case "pageDown":
             case "pageUp":
             case "parent":
+            case "prevMatch":
             case "right":
             case "up":
                 return node.navigate(cmd);
@@ -6857,22 +7094,39 @@ class Wunderbaum {
     /** 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);
@@ -6892,6 +7146,17 @@ class Wunderbaum {
     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.
      */
@@ -6934,6 +7199,11 @@ class Wunderbaum {
     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;
@@ -6992,12 +7262,14 @@ class Wunderbaum {
      * 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)) {
@@ -7010,12 +7282,14 @@ class Wunderbaum {
         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;
@@ -7082,7 +7356,7 @@ class Wunderbaum {
                 // }
                 break;
             case "up":
-                res = this._getPrevNodeInView(node);
+                res = this._getNextNodeInView(node, { reverse: true });
                 break;
             case "down":
                 res = this._getNextNodeInView(node);
@@ -7095,7 +7369,10 @@ class Wunderbaum {
                         res = bottomNode;
                     }
                     else {
-                        res = this._getNextNodeInView(node, pageSize);
+                        res = this._getNextNodeInView(node, {
+                            reverse: false,
+                            ofs: pageSize,
+                        });
                     }
                 }
                 break;
@@ -7110,10 +7387,23 @@ class Wunderbaum {
                         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 + "'.");
         }
@@ -7148,6 +7438,18 @@ class Wunderbaum {
     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.
      */
@@ -7175,6 +7477,12 @@ class Wunderbaum {
     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}.
@@ -7260,7 +7568,7 @@ class Wunderbaum {
     }
     /** 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");
@@ -7268,7 +7576,7 @@ class Wunderbaum {
     }
     /** 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");
@@ -7288,7 +7596,7 @@ class Wunderbaum {
         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) {
@@ -7297,7 +7605,7 @@ class Wunderbaum {
     }
     /** 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) {
@@ -7335,6 +7643,19 @@ class Wunderbaum {
             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) => {
@@ -7502,6 +7823,69 @@ class Wunderbaum {
     _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)) {
@@ -7658,18 +8042,33 @@ class Wunderbaum {
      * @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
@@ -7783,11 +8182,11 @@ class Wunderbaum {
         // }
         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
      */
@@ -7885,6 +8284,102 @@ class Wunderbaum {
             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()`.
@@ -7895,7 +8390,6 @@ class Wunderbaum {
      * @internal
      */
     _updateViewportImmediately() {
-        var _a;
         if (this._disableUpdateCount) {
             this.log(`_updateViewportImmediately() IGNORED (disable level: ${this._disableUpdateCount}).`);
             this._disableUpdateIgnoreCount++;
@@ -7942,11 +8436,8 @@ class Wunderbaum {
             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");
     }
@@ -8070,7 +8561,8 @@ class Wunderbaum {
     }
     /**
      * 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
@@ -8213,11 +8705,71 @@ class Wunderbaum {
      *
      * 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.
      *
@@ -8315,8 +8867,20 @@ class Wunderbaum {
 }
 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;
 
 export { Wunderbaum };