/*! jQuery Fancytree Plugin - 2.8.1 - 2015-03-01T20:28
 * https://github.com/mar10/fancytree
 * Copyright (c) 2015 Martin Wendt; Licensed MIT */
(function (factory) {
  if (typeof define === 'function' && define.amd) {
    define(['jquery'], factory);
  } else {
    factory(jQuery);
  }
})(function ($) {
  !(function (a, b, c, d) {
    'use strict';
    function e(b, c) {
      b || ((c = c ? ': ' + c : ''), a.error('Fancytree assertion failed' + c));
    }
    function f(a, c) {
      var d,
        e,
        f = b.console ? b.console[a] : null;
      if (f)
        try {
          f.apply(b.console, c);
        } catch (g) {
          for (e = '', d = 0; d < c.length; d++) e += c[d];
          f(e);
        }
    }
    function g(a) {
      return !(!a.tree || a.statusNodeType === d);
    }
    function h(b) {
      var c,
        d,
        e,
        f = a.map(a.trim(b).split('.'), function (a) {
          return parseInt(a, 10);
        }),
        g = a.map(Array.prototype.slice.call(arguments, 1), function (a) {
          return parseInt(a, 10);
        });
      for (c = 0; c < g.length; c++) if (((d = f[c] || 0), (e = g[c] || 0), d !== e)) return d > e;
      return !0;
    }
    function i(a, b, c, d, e) {
      var f = (function () {
        var c = b[a],
          f = d[a],
          g = b.ext[e],
          h = function () {
            return c.apply(b, arguments);
          },
          i = function (a) {
            return c.apply(b, a);
          };
        return function () {
          var a = b._local,
            c = b._super,
            d = b._superApply;
          try {
            return (b._local = g), (b._super = h), (b._superApply = i), f.apply(b, arguments);
          } finally {
            (b._local = a), (b._super = c), (b._superApply = d);
          }
        };
      })();
      return f;
    }
    function j(b, c, d, e) {
      for (var f in d)
        'function' == typeof d[f]
          ? 'function' == typeof b[f]
            ? (b[f] = i(f, b, c, d, e))
            : '_' === f.charAt(0)
              ? (b.ext[e][f] = i(f, b, c, d, e))
              : a.error(
                  'Could not override tree.' +
                    f +
                    ". Use prefix '_' to create tree." +
                    e +
                    '._' +
                    f,
                )
          : 'options' !== f && (b.ext[e][f] = d[f]);
    }
    function k(b, c) {
      return b === d
        ? a
            .Deferred(function () {
              this.resolve();
            })
            .promise()
        : a
            .Deferred(function () {
              this.resolveWith(b, c);
            })
            .promise();
    }
    function l(b, c) {
      return b === d
        ? a
            .Deferred(function () {
              this.reject();
            })
            .promise()
        : a
            .Deferred(function () {
              this.rejectWith(b, c);
            })
            .promise();
    }
    function m(a, b) {
      return function () {
        a.resolveWith(b);
      };
    }
    function n(b) {
      var c = a.extend({}, b.data()),
        d = c.json;
      return delete c.fancytree, d && (delete c.json, (c = a.extend(c, d))), c;
    }
    function o(a) {
      return (
        (a = a.toLowerCase()),
        function (b) {
          return b.title.toLowerCase().indexOf(a) >= 0;
        }
      );
    }
    function p(a) {
      var b = new RegExp('^' + a, 'i');
      return function (a) {
        return b.test(a.title);
      };
    }
    function q(b, c) {
      var d, f, g, h;
      for (
        this.parent = b,
          this.tree = b.tree,
          this.ul = null,
          this.li = null,
          this.statusNodeType = null,
          this._isLoading = !1,
          this._error = null,
          this.data = {},
          d = 0,
          f = A.length;
        f > d;
        d++
      )
        (g = A[d]), (this[g] = c[g]);
      c.data && a.extend(this.data, c.data);
      for (g in c) B[g] || a.isFunction(c[g]) || C[g] || (this.data[g] = c[g]);
      null == this.key
        ? this.tree.options.defaultKey
          ? ((this.key = this.tree.options.defaultKey(this)),
            e(this.key, 'defaultKey() must return a unique key'))
          : (this.key = '_' + t._nextNodeKey++)
        : (this.key = '' + this.key),
        c.active &&
          (e(null === this.tree.activeNode, 'only one active node allowed'),
          (this.tree.activeNode = this)),
        c.selected && (this.tree.lastSelectedNode = this),
        (this.children = null),
        (h = c.children),
        h && h.length && this._setChildren(h),
        this.tree._callHook('treeRegisterNode', this.tree, !0, this);
    }
    function r(b) {
      (this.widget = b),
        (this.$div = b.element),
        (this.options = b.options),
        this.options &&
          (a.isFunction(this.options.lazyload) &&
            !a.isFunction(this.options.lazyLoad) &&
            (this.options.lazyLoad = function () {
              return (
                t.warn(
                  "The 'lazyload' event is deprecated since 2014-02-25. Use 'lazyLoad' (with uppercase L) instead.",
                ),
                b.options.lazyload.apply(this, arguments)
              );
            }),
          a.isFunction(this.options.loaderror) &&
            a.error(
              "The 'loaderror' event was renamed since 2014-07-03. Use 'loadError' (with uppercase E) instead.",
            ),
          this.options.fx !== d &&
            t.warn("The 'fx' options was replaced by 'toggleEffect' since 2014-11-30.")),
        (this.ext = {}),
        (this.data = n(this.$div)),
        (this._id = a.ui.fancytree._nextId++),
        (this._ns = '.fancytree-' + this._id),
        (this.activeNode = null),
        (this.focusNode = null),
        (this._hasFocus = null),
        (this.lastSelectedNode = null),
        (this.systemFocusElement = null),
        (this.lastQuicksearchTerm = ''),
        (this.lastQuicksearchTime = 0),
        (this.statusClassPropName = 'span'),
        (this.ariaPropName = 'li'),
        (this.nodeContainerAttrName = 'li'),
        this.$div.find('>ul.fancytree-container').remove();
      var c,
        e = { tree: this };
      (this.rootNode = new q(e, {
        title: 'root',
        key: 'root_' + this._id,
        children: null,
        expanded: !0,
      })),
        (this.rootNode.parent = null),
        (c = a('<ul>', { class: 'ui-fancytree fancytree-container' }).appendTo(this.$div)),
        (this.$container = c),
        (this.rootNode.ul = c[0]),
        null == this.options.debugLevel && (this.options.debugLevel = t.debugLevel),
        this.$container.attr('tabindex', this.options.tabbable ? '0' : '-1'),
        this.options.aria && this.$container.attr('role', 'tree').attr('aria-multiselectable', !0);
    }
    if (a.ui && a.ui.fancytree)
      return void a.ui.fancytree.warn('Fancytree: ignored duplicate include');
    e(a.ui, 'Fancytree requires jQuery UI (http://jqueryui.com)');
    var s,
      t = null,
      u = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;', '/': '&#x2F;' },
      v = { 16: !0, 17: !0, 18: !0 },
      w = {
        8: 'backspace',
        9: 'tab',
        10: 'return',
        13: 'return',
        19: 'pause',
        20: 'capslock',
        27: 'esc',
        32: 'space',
        33: 'pageup',
        34: 'pagedown',
        35: 'end',
        36: 'home',
        37: 'left',
        38: 'up',
        39: 'right',
        40: 'down',
        45: 'insert',
        46: 'del',
        59: ';',
        61: '=',
        96: '0',
        97: '1',
        98: '2',
        99: '3',
        100: '4',
        101: '5',
        102: '6',
        103: '7',
        104: '8',
        105: '9',
        106: '*',
        107: '+',
        109: '-',
        110: '.',
        111: '/',
        112: 'f1',
        113: 'f2',
        114: 'f3',
        115: 'f4',
        116: 'f5',
        117: 'f6',
        118: 'f7',
        119: 'f8',
        120: 'f9',
        121: 'f10',
        122: 'f11',
        123: 'f12',
        144: 'numlock',
        145: 'scroll',
        173: '-',
        186: ';',
        187: '=',
        188: ',',
        189: '-',
        190: '.',
        191: '/',
        192: '`',
        219: '[',
        220: '\\',
        221: ']',
        222: "'",
      },
      x = { 0: '', 1: 'left', 2: 'middle', 3: 'right' },
      y = 'active expanded focus folder hideCheckbox lazy selected unselectable'.split(' '),
      z = {},
      A =
        'expanded extraClasses folder hideCheckbox key lazy refKey selected title tooltip unselectable'.split(
          ' ',
        ),
      B = {},
      C = { active: !0, children: !0, data: !0, focus: !0 };
    for (s = 0; s < y.length; s++) z[y[s]] = !0;
    for (s = 0; s < A.length; s++) B[A[s]] = !0;
    (q.prototype = {
      _findDirectChild: function (a) {
        var b,
          c,
          d = this.children;
        if (d)
          if ('string' == typeof a) {
            for (b = 0, c = d.length; c > b; b++) if (d[b].key === a) return d[b];
          } else {
            if ('number' == typeof a) return this.children[a];
            if (a.parent === this) return a;
          }
        return null;
      },
      _setChildren: function (a) {
        e(a && (!this.children || 0 === this.children.length), 'only init supported'),
          (this.children = []);
        for (var b = 0, c = a.length; c > b; b++) this.children.push(new q(this, a[b]));
      },
      addChildren: function (b, c) {
        var d,
          f,
          g,
          h = null,
          i = [];
        for (
          a.isPlainObject(b) && (b = [b]),
            this.children || (this.children = []),
            d = 0,
            f = b.length;
          f > d;
          d++
        )
          i.push(new q(this, b[d]));
        return (
          (h = i[0]),
          null == c
            ? (this.children = this.children.concat(i))
            : ((c = this._findDirectChild(c)),
              (g = a.inArray(c, this.children)),
              e(g >= 0, 'insertBefore must be an existing child'),
              this.children.splice.apply(this.children, [g, 0].concat(i))),
          (!this.parent || this.parent.ul || this.tr) && this.render(),
          3 === this.tree.options.selectMode && this.fixSelection3FromEndNodes(),
          h
        );
      },
      addNode: function (a, b) {
        switch (((b === d || 'over' === b) && (b = 'child'), b)) {
          case 'after':
            return this.getParent().addChildren(a, this.getNextSibling());
          case 'before':
            return this.getParent().addChildren(a, this);
          case 'firstChild':
            var c = this.children ? this.children[0] : null;
            return this.addChildren(a, c);
          case 'child':
          case 'over':
            return this.addChildren(a);
        }
        e(!1, 'Invalid mode: ' + b);
      },
      appendSibling: function (a) {
        return this.addNode(a, 'after');
      },
      applyPatch: function (b) {
        if (null === b) return this.remove(), k(this);
        var c,
          d,
          e,
          f = { children: !0, expanded: !0, parent: !0 };
        for (c in b)
          (e = b[c]), f[c] || a.isFunction(e) || (B[c] ? (this[c] = e) : (this.data[c] = e));
        return (
          b.hasOwnProperty('children') &&
            (this.removeChildren(), b.children && this._setChildren(b.children)),
          this.isVisible() && (this.renderTitle(), this.renderStatus()),
          (d = b.hasOwnProperty('expanded') ? this.setExpanded(b.expanded) : k(this))
        );
      },
      collapseSiblings: function () {
        return this.tree._callHook('nodeCollapseSiblings', this);
      },
      copyTo: function (a, b, c) {
        return a.addNode(this.toDict(!0, c), b);
      },
      countChildren: function (a) {
        var b,
          c,
          d,
          e = this.children;
        if (!e) return 0;
        if (((d = e.length), a !== !1)) for (b = 0, c = d; c > b; b++) d += e[b].countChildren();
        return d;
      },
      debug: function () {
        this.tree.options.debugLevel >= 2 &&
          (Array.prototype.unshift.call(arguments, this.toString()), f('log', arguments));
      },
      discard: function () {
        return (
          this.warn(
            'FancytreeNode.discard() is deprecated since 2014-02-16. Use .resetLazy() instead.',
          ),
          this.resetLazy()
        );
      },
      findAll: function (b) {
        b = a.isFunction(b) ? b : o(b);
        var c = [];
        return (
          this.visit(function (a) {
            b(a) && c.push(a);
          }),
          c
        );
      },
      findFirst: function (b) {
        b = a.isFunction(b) ? b : o(b);
        var c = null;
        return (
          this.visit(function (a) {
            return b(a) ? ((c = a), !1) : void 0;
          }),
          c
        );
      },
      _changeSelectStatusAttrs: function (a) {
        var b = !1;
        switch (a) {
          case !1:
            (b = this.selected || this.partsel), (this.selected = !1), (this.partsel = !1);
            break;
          case !0:
            (b = !this.selected || !this.partsel), (this.selected = !0), (this.partsel = !0);
            break;
          case d:
            (b = this.selected || !this.partsel), (this.selected = !1), (this.partsel = !0);
            break;
          default:
            e(!1, 'invalid state: ' + a);
        }
        return b && this.renderStatus(), b;
      },
      fixSelection3AfterClick: function () {
        var a = this.isSelected();
        this.visit(function (b) {
          b._changeSelectStatusAttrs(a);
        }),
          this.fixSelection3FromEndNodes();
      },
      fixSelection3FromEndNodes: function () {
        function a(b) {
          var c,
            e,
            f,
            g,
            h,
            i,
            j,
            k = b.children;
          if (k && k.length) {
            for (i = !0, j = !1, c = 0, e = k.length; e > c; c++)
              (f = k[c]), (g = a(f)), g !== !1 && (j = !0), g !== !0 && (i = !1);
            h = i ? !0 : j ? d : !1;
          } else h = !!b.selected;
          return b._changeSelectStatusAttrs(h), h;
        }
        e(3 === this.tree.options.selectMode, 'expected selectMode 3'),
          a(this),
          this.visitParents(function (a) {
            var b,
              c,
              e,
              f,
              g = a.children,
              h = !0,
              i = !1;
            for (b = 0, c = g.length; c > b; b++)
              (e = g[b]),
                (e.selected || e.partsel) && (i = !0),
                e.unselectable || e.selected || (h = !1);
            (f = h ? !0 : i ? d : !1), a._changeSelectStatusAttrs(f);
          });
      },
      fromDict: function (b) {
        for (var c in b)
          B[c]
            ? (this[c] = b[c])
            : 'data' === c
              ? a.extend(this.data, b.data)
              : a.isFunction(b[c]) || C[c] || (this.data[c] = b[c]);
        b.children && (this.removeChildren(), this.addChildren(b.children)), this.renderTitle();
      },
      getChildren: function () {
        return this.hasChildren() === d ? d : this.children;
      },
      getFirstChild: function () {
        return this.children ? this.children[0] : null;
      },
      getIndex: function () {
        return a.inArray(this, this.parent.children);
      },
      getIndexHier: function (b) {
        b = b || '.';
        var c = [];
        return (
          a.each(this.getParentList(!1, !0), function (a, b) {
            c.push(b.getIndex() + 1);
          }),
          c.join(b)
        );
      },
      getKeyPath: function (a) {
        var b = [],
          c = this.tree.options.keyPathSeparator;
        return (
          this.visitParents(function (a) {
            a.parent && b.unshift(a.key);
          }, !a),
          c + b.join(c)
        );
      },
      getLastChild: function () {
        return this.children ? this.children[this.children.length - 1] : null;
      },
      getLevel: function () {
        for (var a = 0, b = this.parent; b; ) a++, (b = b.parent);
        return a;
      },
      getNextSibling: function () {
        if (this.parent) {
          var a,
            b,
            c = this.parent.children;
          for (a = 0, b = c.length - 1; b > a; a++) if (c[a] === this) return c[a + 1];
        }
        return null;
      },
      getParent: function () {
        return this.parent;
      },
      getParentList: function (a, b) {
        for (var c = [], d = b ? this : this.parent; d; )
          (a || d.parent) && c.unshift(d), (d = d.parent);
        return c;
      },
      getPrevSibling: function () {
        if (this.parent) {
          var a,
            b,
            c = this.parent.children;
          for (a = 1, b = c.length; b > a; a++) if (c[a] === this) return c[a - 1];
        }
        return null;
      },
      hasChildren: function () {
        return this.lazy
          ? null == this.children
            ? d
            : 0 === this.children.length
              ? !1
              : 1 === this.children.length && this.children[0].isStatusNode()
                ? d
                : !0
          : !(!this.children || !this.children.length);
      },
      hasFocus: function () {
        return this.tree.hasFocus() && this.tree.focusNode === this;
      },
      info: function () {
        this.tree.options.debugLevel >= 1 &&
          (Array.prototype.unshift.call(arguments, this.toString()), f('info', arguments));
      },
      isActive: function () {
        return this.tree.activeNode === this;
      },
      isChildOf: function (a) {
        return this.parent && this.parent === a;
      },
      isDescendantOf: function (a) {
        if (!a || a.tree !== this.tree) return !1;
        for (var b = this.parent; b; ) {
          if (b === a) return !0;
          b = b.parent;
        }
        return !1;
      },
      isExpanded: function () {
        return !!this.expanded;
      },
      isFirstSibling: function () {
        var a = this.parent;
        return !a || a.children[0] === this;
      },
      isFolder: function () {
        return !!this.folder;
      },
      isLastSibling: function () {
        var a = this.parent;
        return !a || a.children[a.children.length - 1] === this;
      },
      isLazy: function () {
        return !!this.lazy;
      },
      isLoaded: function () {
        return !this.lazy || this.hasChildren() !== d;
      },
      isLoading: function () {
        return !!this._isLoading;
      },
      isRoot: function () {
        return this.isRootNode();
      },
      isRootNode: function () {
        return this.tree.rootNode === this;
      },
      isSelected: function () {
        return !!this.selected;
      },
      isStatusNode: function () {
        return !!this.statusNodeType;
      },
      isTopLevel: function () {
        return this.tree.rootNode === this.parent;
      },
      isUndefined: function () {
        return this.hasChildren() === d;
      },
      isVisible: function () {
        var a,
          b,
          c = this.getParentList(!1, !1);
        for (a = 0, b = c.length; b > a; a++) if (!c[a].expanded) return !1;
        return !0;
      },
      lazyLoad: function (a) {
        return (
          this.warn(
            'FancytreeNode.lazyLoad() is deprecated since 2014-02-16. Use .load() instead.',
          ),
          this.load(a)
        );
      },
      load: function (a) {
        var b,
          c,
          d = this;
        return (
          e(this.isLazy(), 'load() requires a lazy node'),
          a || this.isUndefined()
            ? (this.isLoaded() && this.resetLazy(),
              (c = this.tree._triggerNodeEvent('lazyLoad', this)),
              c === !1
                ? k(this)
                : (e('boolean' != typeof c, 'lazyLoad event must return source in data.result'),
                  (b = this.tree._callHook('nodeLoadChildren', this, c)),
                  this.expanded &&
                    b.always(function () {
                      d.render();
                    }),
                  b))
            : k(this)
        );
      },
      makeVisible: function (b) {
        var c,
          d = this,
          e = [],
          f = new a.Deferred(),
          g = this.getParentList(!1, !1),
          h = g.length,
          i = !(b && b.noAnimation === !0),
          j = !(b && b.scrollIntoView === !1);
        for (c = h - 1; c >= 0; c--) e.push(g[c].setExpanded(!0, b));
        return (
          a.when.apply(a, e).done(function () {
            j
              ? d.scrollIntoView(i).done(function () {
                  f.resolve();
                })
              : f.resolve();
          }),
          f.promise()
        );
      },
      moveTo: function (b, c, f) {
        (c === d || 'over' === c) && (c = 'child');
        var g,
          h = this.parent,
          i = 'child' === c ? b : b.parent;
        if (this !== b) {
          if (!this.parent) throw 'Cannot move system root';
          if (i.isDescendantOf(this)) throw 'Cannot move a node to its own descendant';
          if (1 === this.parent.children.length) {
            if (this.parent === i) return;
            (this.parent.children = this.parent.lazy ? [] : null), (this.parent.expanded = !1);
          } else
            (g = a.inArray(this, this.parent.children)),
              e(g >= 0),
              this.parent.children.splice(g, 1);
          if (((this.parent = i), i.hasChildren()))
            switch (c) {
              case 'child':
                i.children.push(this);
                break;
              case 'before':
                (g = a.inArray(b, i.children)), e(g >= 0), i.children.splice(g, 0, this);
                break;
              case 'after':
                (g = a.inArray(b, i.children)), e(g >= 0), i.children.splice(g + 1, 0, this);
                break;
              default:
                throw 'Invalid mode ' + c;
            }
          else i.children = [this];
          f && b.visit(f, !0),
            this.tree !== b.tree &&
              (this.warn('Cross-tree moveTo is experimantal!'),
              this.visit(function (a) {
                a.tree = b.tree;
              }, !0)),
            h.isDescendantOf(i) || h.render(),
            i.isDescendantOf(h) || i === h || i.render();
        }
      },
      navigate: function (b, c) {
        function d(d) {
          if (d) {
            try {
              d.makeVisible();
            } catch (e) {}
            return a(d.span).is(':visible')
              ? c === !1
                ? d.setFocus()
                : d.setActive()
              : (d.debug('Navigate: skipping hidden node'), void d.navigate(b, c));
          }
        }
        var e,
          f,
          g = !0,
          h = a.ui.keyCode,
          i = null;
        switch (b) {
          case h.BACKSPACE:
            this.parent && this.parent.parent && d(this.parent);
            break;
          case h.LEFT:
            this.expanded
              ? (this.setExpanded(!1), d(this))
              : this.parent && this.parent.parent && d(this.parent);
            break;
          case h.RIGHT:
            this.expanded || (!this.children && !this.lazy)
              ? this.children && this.children.length && d(this.children[0])
              : (this.setExpanded(), d(this));
            break;
          case h.UP:
            for (i = this.getPrevSibling(); i && !a(i.span).is(':visible'); )
              i = i.getPrevSibling();
            for (; i && i.expanded && i.children && i.children.length; )
              i = i.children[i.children.length - 1];
            !i && this.parent && this.parent.parent && (i = this.parent), d(i);
            break;
          case h.DOWN:
            if (this.expanded && this.children && this.children.length) i = this.children[0];
            else
              for (f = this.getParentList(!1, !0), e = f.length - 1; e >= 0; e--) {
                for (i = f[e].getNextSibling(); i && !a(i.span).is(':visible'); )
                  i = i.getNextSibling();
                if (i) break;
              }
            d(i);
            break;
          default:
            g = !1;
        }
      },
      remove: function () {
        return this.parent.removeChild(this);
      },
      removeChild: function (a) {
        return this.tree._callHook('nodeRemoveChild', this, a);
      },
      removeChildren: function () {
        return this.tree._callHook('nodeRemoveChildren', this);
      },
      render: function (a, b) {
        return this.tree._callHook('nodeRender', this, a, b);
      },
      renderTitle: function () {
        return this.tree._callHook('nodeRenderTitle', this);
      },
      renderStatus: function () {
        return this.tree._callHook('nodeRenderStatus', this);
      },
      resetLazy: function () {
        this.removeChildren(),
          (this.expanded = !1),
          (this.lazy = !0),
          (this.children = d),
          this.renderStatus();
      },
      scheduleAction: function (a, b) {
        this.tree.timer && clearTimeout(this.tree.timer), (this.tree.timer = null);
        var c = this;
        switch (a) {
          case 'cancel':
            break;
          case 'expand':
            this.tree.timer = setTimeout(function () {
              c.tree.debug('setTimeout: trigger expand'), c.setExpanded(!0);
            }, b);
            break;
          case 'activate':
            this.tree.timer = setTimeout(function () {
              c.tree.debug('setTimeout: trigger activate'), c.setActive(!0);
            }, b);
            break;
          default:
            throw 'Invalid mode ' + a;
        }
      },
      scrollIntoView: function (f, h) {
        h !== d &&
          g(h) &&
          (this.warn(
            "scrollIntoView() with 'topNode' option is deprecated since 2014-05-08. Use 'options.topNode' instead.",
          ),
          (h = { topNode: h }));
        var i,
          j,
          l,
          m,
          n = a.extend(
            {
              effects: f === !0 ? { duration: 200, queue: !1 } : f,
              scrollOfs: this.tree.options.scrollOfs,
              scrollParent: this.tree.options.scrollParent || this.tree.$container,
              topNode: null,
            },
            h,
          ),
          o = new a.Deferred(),
          p = this,
          q = a(this.span).height(),
          r = a(n.scrollParent),
          s = n.scrollOfs.top || 0,
          t = n.scrollOfs.bottom || 0,
          u = r.height(),
          v = r.scrollTop(),
          w = r,
          x = r[0] === b,
          y = n.topNode || null,
          z = null;
        return a(this.span).is(':visible')
          ? (x
              ? ((j = a(this.span).offset().top),
                (i = y && y.span ? a(y.span).offset().top : 0),
                (w = a('html,body')))
              : (e(
                  r[0] !== c && r[0] !== c.body,
                  'scrollParent should be an simple element or `window`, not document or body.',
                ),
                (m = r.offset().top),
                (j = a(this.span).offset().top - m + v),
                (i = y ? a(y.span).offset().top - m + v : 0),
                (l = Math.max(0, r.innerHeight() - r[0].clientHeight)),
                (u -= l)),
            v + s > j
              ? (z = j - s)
              : j + q > v + u - t &&
                ((z = j + q - u + t),
                y &&
                  (e(y.isRoot() || a(y.span).is(':visible'), 'topNode must be visible'),
                  z > i && (z = i - s))),
            null !== z
              ? n.effects
                ? ((n.effects.complete = function () {
                    o.resolveWith(p);
                  }),
                  w.stop(!0).animate({ scrollTop: z }, n.effects))
                : ((w[0].scrollTop = z), o.resolveWith(this))
              : o.resolveWith(this),
            o.promise())
          : (this.warn('scrollIntoView(): node is invisible.'), k());
      },
      setActive: function (a, b) {
        return this.tree._callHook('nodeSetActive', this, a, b);
      },
      setExpanded: function (a, b) {
        return this.tree._callHook('nodeSetExpanded', this, a, b);
      },
      setFocus: function (a) {
        return this.tree._callHook('nodeSetFocus', this, a);
      },
      setSelected: function (a) {
        return this.tree._callHook('nodeSetSelected', this, a);
      },
      setStatus: function (a, b, c) {
        return this.tree._callHook('nodeSetStatus', this, a, b, c);
      },
      setTitle: function (a) {
        (this.title = a), this.renderTitle();
      },
      sortChildren: function (a, b) {
        var c,
          d,
          e = this.children;
        if (e) {
          if (
            ((a =
              a ||
              function (a, b) {
                var c = a.title.toLowerCase(),
                  d = b.title.toLowerCase();
                return c === d ? 0 : c > d ? 1 : -1;
              }),
            e.sort(a),
            b)
          )
            for (c = 0, d = e.length; d > c; c++)
              e[c].children && e[c].sortChildren(a, '$norender$');
          '$norender$' !== b && this.render();
        }
      },
      toDict: function (b, c) {
        var d,
          e,
          f,
          g = {},
          h = this;
        if (
          (a.each(A, function (a, b) {
            (h[b] || h[b] === !1) && (g[b] = h[b]);
          }),
          a.isEmptyObject(this.data) ||
            ((g.data = a.extend({}, this.data)), a.isEmptyObject(g.data) && delete g.data),
          c && c(g),
          b && this.hasChildren())
        )
          for (g.children = [], d = 0, e = this.children.length; e > d; d++)
            (f = this.children[d]), f.isStatusNode() || g.children.push(f.toDict(!0, c));
        return g;
      },
      toggleExpanded: function () {
        return this.tree._callHook('nodeToggleExpanded', this);
      },
      toggleSelected: function () {
        return this.tree._callHook('nodeToggleSelected', this);
      },
      toString: function () {
        return '<FancytreeNode(#' + this.key + ", '" + this.title + "')>";
      },
      visit: function (a, b) {
        var c,
          d,
          e = !0,
          f = this.children;
        if (b === !0 && ((e = a(this)), e === !1 || 'skip' === e)) return e;
        if (f) for (c = 0, d = f.length; d > c && ((e = f[c].visit(a, !0)), e !== !1); c++);
        return e;
      },
      visitAndLoad: function (b, c, d) {
        var e,
          f,
          g,
          h = this;
        return b && c === !0 && ((f = b(h)), f === !1 || 'skip' === f)
          ? d
            ? f
            : k()
          : h.children || h.lazy
            ? ((e = new a.Deferred()),
              (g = []),
              h.load().done(function () {
                for (var c = 0, d = h.children.length; d > c; c++) {
                  if (((f = h.children[c].visitAndLoad(b, !0, !0)), f === !1)) {
                    e.reject();
                    break;
                  }
                  'skip' !== f && g.push(f);
                }
                a.when.apply(this, g).then(function () {
                  e.resolve();
                });
              }),
              e.promise())
            : k();
      },
      visitParents: function (a, b) {
        if (b && a(this) === !1) return !1;
        for (var c = this.parent; c; ) {
          if (a(c) === !1) return !1;
          c = c.parent;
        }
        return !0;
      },
      warn: function () {
        Array.prototype.unshift.call(arguments, this.toString()), f('warn', arguments);
      },
    }),
      (r.prototype = {
        _makeHookContext: function (b, c, e) {
          var f, g;
          return (
            b.node !== d
              ? (c && b.originalEvent !== c && a.error('invalid args'), (f = b))
              : b.tree
                ? ((g = b.tree),
                  (f = {
                    node: b,
                    tree: g,
                    widget: g.widget,
                    options: g.widget.options,
                    originalEvent: c,
                  }))
                : b.widget
                  ? (f = {
                      node: null,
                      tree: b,
                      widget: b.widget,
                      options: b.widget.options,
                      originalEvent: c,
                    })
                  : a.error('invalid args'),
            e && a.extend(f, e),
            f
          );
        },
        _callHook: function (b, c) {
          var d = this._makeHookContext(c),
            e = this[b],
            f = Array.prototype.slice.call(arguments, 2);
          return (
            a.isFunction(e) || a.error("_callHook('" + b + "') is not a function"),
            f.unshift(d),
            e.apply(this, f)
          );
        },
        _requireExtension: function (b, c, d, f) {
          d = !!d;
          var g = this._local.name,
            h = this.options.extensions,
            i = a.inArray(b, h) < a.inArray(g, h),
            j = c && null == this.ext[b],
            k = !j && null != d && d !== i;
          return (
            e(g && g !== b),
            j || k
              ? (f ||
                  (j || c
                    ? ((f = "'" + g + "' extension requires '" + b + "'"),
                      k && (f += ' to be registered ' + (d ? 'before' : 'after') + ' itself'))
                    : (f =
                        'If used together, `' +
                        b +
                        '` must be registered ' +
                        (d ? 'before' : 'after') +
                        ' `' +
                        g +
                        '`')),
                a.error(f),
                !1)
              : !0
          );
        },
        activateKey: function (a) {
          var b = this.getNodeByKey(a);
          return b ? b.setActive() : this.activeNode && this.activeNode.setActive(!1), b;
        },
        applyPatch: function (b) {
          var c,
            d,
            f,
            g,
            h,
            i,
            j = b.length,
            k = [];
          for (d = 0; j > d; d++)
            (f = b[d]),
              e(2 === f.length, 'patchList must be an array of length-2-arrays'),
              (g = f[0]),
              (h = f[1]),
              (i = null === g ? this.rootNode : this.getNodeByKey(g)),
              i
                ? ((c = new a.Deferred()), k.push(c), i.applyPatch(h).always(m(c, i)))
                : this.warn("could not find node with key '" + g + "'");
          return a.when.apply(a, k).promise();
        },
        count: function () {
          return this.rootNode.countChildren();
        },
        debug: function () {
          this.options.debugLevel >= 2 &&
            (Array.prototype.unshift.call(arguments, this.toString()), f('log', arguments));
        },
        findNextNode: function (b, c) {
          var d = null,
            e = c.parent.children,
            f = null,
            g = function (a, b, c) {
              var d,
                e,
                f = a.children,
                h = f.length,
                i = f[b];
              if (i && c(i) === !1) return !1;
              if (i && i.children && i.expanded && g(i, 0, c) === !1) return !1;
              for (d = b + 1; h > d; d++) if (g(a, d, c) === !1) return !1;
              return (e = a.parent), e ? g(e, e.children.indexOf(a) + 1, c) : g(a, 0, c);
            };
          return (
            (b = 'string' == typeof b ? p(b) : b),
            (c = c || this.getFirstChild()),
            g(c.parent, e.indexOf(c), function (e) {
              return e === d
                ? !1
                : ((d = d || e),
                  a(e.span).is(':visible')
                    ? b(e) && ((f = e), f !== c)
                      ? !1
                      : void 0
                    : void e.debug('quicksearch: skipping hidden node'));
            }),
            f
          );
        },
        generateFormElements: function (b, c, d) {
          d = d || {};
          var e,
            f = 'string' == typeof b ? b : 'ft_' + this._id + '[]',
            g = 'string' == typeof c ? c : 'ft_' + this._id + '_active',
            h = 'fancytree_result_' + this._id,
            i = a('#' + h),
            j = 3 === this.options.selectMode && d.stopOnParents !== !1;
          i.length ? i.empty() : (i = a('<div>', { id: h }).hide().insertAfter(this.$container)),
            b !== !1 &&
              ((e = this.getSelectedNodes(j)),
              a.each(e, function (b, c) {
                i.append(a('<input>', { type: 'checkbox', name: f, value: c.key, checked: !0 }));
              })),
            c !== !1 &&
              this.activeNode &&
              i.append(
                a('<input>', { type: 'radio', name: g, value: this.activeNode.key, checked: !0 }),
              );
        },
        getActiveNode: function () {
          return this.activeNode;
        },
        getFirstChild: function () {
          return this.rootNode.getFirstChild();
        },
        getFocusNode: function () {
          return this.focusNode;
        },
        getNodeByKey: function (a, b) {
          var d, e;
          return !b && (d = c.getElementById(this.options.idPrefix + a))
            ? d.ftnode
              ? d.ftnode
              : null
            : ((b = b || this.rootNode),
              (e = null),
              b.visit(function (b) {
                return b.key === a ? ((e = b), !1) : void 0;
              }, !0),
              e);
        },
        getRootNode: function () {
          return this.rootNode;
        },
        getSelectedNodes: function (a) {
          var b = [];
          return (
            this.rootNode.visit(function (c) {
              return c.selected && (b.push(c), a === !0) ? 'skip' : void 0;
            }),
            b
          );
        },
        hasFocus: function () {
          return !!this._hasFocus;
        },
        info: function () {
          this.options.debugLevel >= 1 &&
            (Array.prototype.unshift.call(arguments, this.toString()), f('info', arguments));
        },
        loadKeyPath: function (b, c, e) {
          function f(a, b, d) {
            c.call(r, b, 'loading'),
              b
                .load()
                .done(function () {
                  r.loadKeyPath.call(r, l[a], c, b).always(m(d, r));
                })
                .fail(function () {
                  r.warn('loadKeyPath: error loading: ' + a + ' (parent: ' + o + ')'),
                    c.call(r, b, 'error'),
                    d.reject();
                });
          }
          var g,
            h,
            i,
            j,
            k,
            l,
            n,
            o,
            p,
            q = this.options.keyPathSeparator,
            r = this;
          for (a.isArray(b) || (b = [b]), l = {}, i = 0; i < b.length; i++)
            for (
              o = e || this.rootNode,
                j = b[i],
                j.charAt(0) === q && (j = j.substr(1)),
                p = j.split(q);
              p.length;

            ) {
              if (((k = p.shift()), (n = o._findDirectChild(k)), !n)) {
                this.warn('loadKeyPath: key not found: ' + k + ' (parent: ' + o + ')'),
                  c.call(this, k, 'error');
                break;
              }
              if (0 === p.length) {
                c.call(this, n, 'ok');
                break;
              }
              if (n.lazy && n.hasChildren() === d) {
                c.call(this, n, 'loaded'), l[k] ? l[k].push(p.join(q)) : (l[k] = [p.join(q)]);
                break;
              }
              c.call(this, n, 'loaded'), (o = n);
            }
          g = [];
          for (k in l) (n = o._findDirectChild(k)), (h = new a.Deferred()), g.push(h), f(k, n, h);
          return a.when.apply(a, g).promise();
        },
        reactivate: function (a) {
          var b,
            c = this.activeNode;
          return c ? ((this.activeNode = null), (b = c.setActive()), a && c.setFocus(), b) : k();
        },
        reload: function (a) {
          return this._callHook('treeClear', this), this._callHook('treeLoad', this, a);
        },
        render: function (a, b) {
          return this.rootNode.render(a, b);
        },
        setFocus: function (a) {
          return this._callHook('treeSetFocus', this, a);
        },
        toDict: function (a, b) {
          var c = this.rootNode.toDict(!0, b);
          return a ? c : c.children;
        },
        toString: function () {
          return '<Fancytree(#' + this._id + ')>';
        },
        _triggerNodeEvent: function (a, b, c, e) {
          var f = this._makeHookContext(b, c, e),
            g = this.widget._trigger(a, c, f);
          return g !== !1 && f.result !== d ? f.result : g;
        },
        _triggerTreeEvent: function (a, b, c) {
          var e = this._makeHookContext(this, b, c),
            f = this.widget._trigger(a, b, e);
          return f !== !1 && e.result !== d ? e.result : f;
        },
        visit: function (a) {
          return this.rootNode.visit(a, !1);
        },
        warn: function () {
          Array.prototype.unshift.call(arguments, this.toString()), f('warn', arguments);
        },
      }),
      a.extend(r.prototype, {
        nodeClick: function (a) {
          var b,
            c,
            d = a.targetType,
            e = a.node;
          if ('expander' === d) this._callHook('nodeToggleExpanded', a);
          else if ('checkbox' === d)
            this._callHook('nodeToggleSelected', a),
              a.options.focusOnSelect && this._callHook('nodeSetFocus', a, !0);
          else {
            if (((c = !1), (b = !0), e.folder))
              switch (a.options.clickFolderMode) {
                case 2:
                  (c = !0), (b = !1);
                  break;
                case 3:
                  (b = !0), (c = !0);
              }
            b && (this.nodeSetFocus(a), this._callHook('nodeSetActive', a, !0)),
              c && this._callHook('nodeToggleExpanded', a);
          }
        },
        nodeCollapseSiblings: function (a, b) {
          var c,
            d,
            e,
            f = a.node;
          if (f.parent)
            for (c = f.parent.children, d = 0, e = c.length; e > d; d++)
              c[d] !== f && c[d].expanded && this._callHook('nodeSetExpanded', c[d], !1, b);
        },
        nodeDblclick: function (a) {
          'title' === a.targetType &&
            4 === a.options.clickFolderMode &&
            this._callHook('nodeToggleExpanded', a),
            'title' === a.targetType && a.originalEvent.preventDefault();
        },
        nodeKeydown: function (b) {
          var c,
            d,
            e,
            f = b.originalEvent,
            g = b.node,
            h = b.tree,
            i = b.options,
            j = f.which,
            k = String.fromCharCode(j),
            l = !(f.altKey || f.ctrlKey || f.metaKey || f.shiftKey),
            m = a(f.target),
            n = !0,
            o = !(f.ctrlKey || !i.autoActivate);
          if (
            (g ||
              ((this.getActiveNode() || this.getFirstChild()).setFocus(),
              (g = b.node = this.focusNode),
              g.debug('Keydown force focus on active node')),
            i.quicksearch && l && /\w/.test(k) && !m.is(':input:enabled'))
          )
            return (
              (d = new Date().getTime()),
              d - h.lastQuicksearchTime > 500 && (h.lastQuicksearchTerm = ''),
              (h.lastQuicksearchTime = d),
              (h.lastQuicksearchTerm += k),
              (c = h.findNextNode(h.lastQuicksearchTerm, h.getActiveNode())),
              c && c.setActive(),
              void f.preventDefault()
            );
          switch (t.eventToString(f)) {
            case '+':
            case '=':
              h.nodeSetExpanded(b, !0);
              break;
            case '-':
              h.nodeSetExpanded(b, !1);
              break;
            case 'space':
              i.checkbox ? h.nodeToggleSelected(b) : h.nodeSetActive(b, !0);
              break;
            case 'enter':
              h.nodeSetActive(b, !0);
              break;
            case 'backspace':
            case 'left':
            case 'right':
            case 'up':
            case 'down':
              e = g.navigate(f.which, o);
              break;
            default:
              n = !1;
          }
          n && f.preventDefault();
        },
        nodeLoadChildren: function (b, c) {
          var d,
            f,
            g,
            h = b.tree,
            i = b.node;
          return (
            a.isFunction(c) && (c = c()),
            c.url &&
              ((d = a.extend({}, b.options.ajax, c)),
              d.debugDelay
                ? ((f = d.debugDelay),
                  a.isArray(f) && (f = f[0] + Math.random() * (f[1] - f[0])),
                  i.debug('nodeLoadChildren waiting debug delay ' + Math.round(f) + 'ms'),
                  (d.debugDelay = !1),
                  (g = a.Deferred(function (b) {
                    setTimeout(function () {
                      a.ajax(d)
                        .done(function () {
                          b.resolveWith(this, arguments);
                        })
                        .fail(function () {
                          b.rejectWith(this, arguments);
                        });
                    }, f);
                  })))
                : (g = a.ajax(d)),
              (c = new a.Deferred()),
              g
                .done(function (d) {
                  var e, f;
                  if (
                    ('string' == typeof d &&
                      a.error(
                        'Ajax request returned a string (did you get the JSON dataType wrong?).',
                      ),
                    b.options.postProcess)
                  ) {
                    if (
                      ((f = h._triggerNodeEvent('postProcess', b, b.originalEvent, {
                        response: d,
                        error: null,
                        dataType: this.dataType,
                      })),
                      f.error)
                    )
                      return (
                        (e = a.isPlainObject(f.error) ? f.error : { message: f.error }),
                        (e = h._makeHookContext(i, null, e)),
                        void c.rejectWith(this, [e])
                      );
                    d = a.isArray(f) ? f : d;
                  } else
                    d &&
                      d.hasOwnProperty('d') &&
                      b.options.enableAspx &&
                      (d = 'string' == typeof d.d ? a.parseJSON(d.d) : d.d);
                  c.resolveWith(this, [d]);
                })
                .fail(function (a, b, d) {
                  var e = h._makeHookContext(i, null, {
                    error: a,
                    args: Array.prototype.slice.call(arguments),
                    message: d,
                    details: a.status + ': ' + d,
                  });
                  c.rejectWith(this, [e]);
                })),
            a.isFunction(c.then) &&
              a.isFunction(c['catch']) &&
              ((g = c),
              (c = new a.Deferred()),
              g.then(
                function (a) {
                  c.resolve(a);
                },
                function (a) {
                  c.reject(a);
                },
              )),
            a.isFunction(c.promise) &&
              (e(!i.isLoading()),
              h.nodeSetStatus(b, 'loading'),
              c
                .done(function () {
                  h.nodeSetStatus(b, 'ok');
                })
                .fail(function (a) {
                  var c;
                  (c =
                    a.node && a.error && a.message
                      ? a
                      : h._makeHookContext(i, null, {
                          error: a,
                          args: Array.prototype.slice.call(arguments),
                          message: a ? a.message || a.toString() : '',
                        })),
                    h._triggerNodeEvent('loadError', c, null) !== !1 &&
                      h.nodeSetStatus(b, 'error', c.message, c.details);
                })),
            a.when(c).done(function (b) {
              var c;
              a.isPlainObject(b) &&
                (e(a.isArray(b.children), 'source must contain (or be) an array of children'),
                e(i.isRoot(), 'source may only be an object for root nodes'),
                (c = b),
                (b = b.children),
                delete c.children,
                a.extend(h.data, c)),
                e(a.isArray(b), 'expected array of children'),
                i._setChildren(b),
                h._triggerNodeEvent('loadChildren', i);
            })
          );
        },
        nodeLoadKeyPath: function () {},
        nodeRemoveChild: function (b, c) {
          var d,
            f = b.node,
            g = b.options,
            h = a.extend({}, b, { node: c }),
            i = f.children;
          return 1 === i.length
            ? (e(c === i[0]), this.nodeRemoveChildren(b))
            : (this.activeNode &&
                (c === this.activeNode || this.activeNode.isDescendantOf(c)) &&
                this.activeNode.setActive(!1),
              this.focusNode &&
                (c === this.focusNode || this.focusNode.isDescendantOf(c)) &&
                (this.focusNode = null),
              this.nodeRemoveMarkup(h),
              this.nodeRemoveChildren(h),
              (d = a.inArray(c, i)),
              e(d >= 0),
              c.visit(function (a) {
                a.parent = null;
              }, !0),
              this._callHook('treeRegisterNode', this, !1, c),
              g.removeNode && g.removeNode.call(b.tree, { type: 'removeNode' }, h),
              void i.splice(d, 1));
        },
        nodeRemoveChildMarkup: function (b) {
          var c = b.node;
          c.ul &&
            (c.isRoot() ? a(c.ul).empty() : (a(c.ul).remove(), (c.ul = null)),
            c.visit(function (a) {
              a.li = a.ul = null;
            }));
        },
        nodeRemoveChildren: function (b) {
          var c,
            d = b.tree,
            e = b.node,
            f = e.children,
            g = b.options;
          f &&
            (this.activeNode && this.activeNode.isDescendantOf(e) && this.activeNode.setActive(!1),
            this.focusNode && this.focusNode.isDescendantOf(e) && (this.focusNode = null),
            this.nodeRemoveChildMarkup(b),
            (c = a.extend({}, b)),
            e.visit(function (a) {
              (a.parent = null),
                d._callHook('treeRegisterNode', d, !1, a),
                g.removeNode &&
                  ((c.node = a), g.removeNode.call(b.tree, { type: 'removeNode' }, c));
            }),
            (e.children = e.lazy ? [] : null),
            this.nodeRenderStatus(b));
        },
        nodeRemoveMarkup: function (b) {
          var c = b.node;
          c.li && (a(c.li).remove(), (c.li = null)), this.nodeRemoveChildMarkup(b);
        },
        nodeRender: function (b, d, f, g, h) {
          var i,
            j,
            k,
            l,
            m,
            n,
            o,
            p = b.node,
            q = b.tree,
            r = b.options,
            s = r.aria,
            t = !1,
            u = p.parent,
            v = !u,
            w = p.children;
          if (v || u.ul) {
            if (
              (e(v || u.ul, 'parent UL must exist'),
              v ||
                (p.li &&
                  (d || p.li.parentNode !== p.parent.ul) &&
                  (p.li.parentNode !== p.parent.ul &&
                    this.debug('Unlinking ' + p + ' (must be child of ' + p.parent + ')'),
                  this.nodeRemoveMarkup(b)),
                p.li
                  ? this.nodeRenderStatus(b)
                  : ((t = !0),
                    (p.li = c.createElement('li')),
                    (p.li.ftnode = p),
                    p.key && r.generateIds && (p.li.id = r.idPrefix + p.key),
                    (p.span = c.createElement('span')),
                    (p.span.className = 'fancytree-node'),
                    s && a(p.span).attr('aria-labelledby', 'ftal_' + p.key),
                    p.li.appendChild(p.span),
                    this.nodeRenderTitle(b),
                    r.createNode && r.createNode.call(q, { type: 'createNode' }, b)),
                r.renderNode && r.renderNode.call(q, { type: 'renderNode' }, b)),
              w)
            ) {
              if (v || p.expanded || f === !0) {
                for (
                  p.ul ||
                    ((p.ul = c.createElement('ul')),
                    ((g === !0 && !h) || !p.expanded) && (p.ul.style.display = 'none'),
                    s && a(p.ul).attr('role', 'group'),
                    p.li ? p.li.appendChild(p.ul) : p.tree.$div.append(p.ul)),
                    l = 0,
                    m = w.length;
                  m > l;
                  l++
                )
                  (o = a.extend({}, b, { node: w[l] })), this.nodeRender(o, d, f, !1, !0);
                for (i = p.ul.firstChild; i; )
                  (k = i.ftnode),
                    k && k.parent !== p
                      ? (p.debug('_fixParent: remove missing ' + k, i),
                        (n = i.nextSibling),
                        i.parentNode.removeChild(i),
                        (i = n))
                      : (i = i.nextSibling);
                for (i = p.ul.firstChild, l = 0, m = w.length - 1; m > l; l++)
                  (j = w[l]),
                    (k = i.ftnode),
                    j !== k ? p.ul.insertBefore(j.li, k.li) : (i = i.nextSibling);
              }
            } else
              p.ul && (this.warn('remove child markup for ' + p), this.nodeRemoveChildMarkup(b));
            v || (t && u.ul.appendChild(p.li));
          }
        },
        nodeRenderTitle: function (a, b) {
          var c,
            e,
            f,
            g,
            h,
            i,
            j = a.node,
            k = a.tree,
            l = a.options,
            m = l.aria,
            n = j.getLevel(),
            o = [],
            p = j.data.icon;
          b !== d && (j.title = b),
            j.span &&
              (n < l.minExpandLevel
                ? (j.lazy || (j.expanded = !0),
                  n > 1 &&
                    o.push(
                      m
                        ? "<span role='button' class='fancytree-expander fancytree-expander-fixed'></span>"
                        : "<span class='fancytree-expander fancytree-expander-fixed''></span>",
                    ))
                : o.push(
                    m
                      ? "<span role='button' class='fancytree-expander'></span>"
                      : "<span class='fancytree-expander'></span>",
                  ),
              l.checkbox &&
                j.hideCheckbox !== !0 &&
                !j.isStatusNode() &&
                o.push(
                  m
                    ? "<span role='checkbox' class='fancytree-checkbox'></span>"
                    : "<span class='fancytree-checkbox'></span>",
                ),
              (g = m ? " role='img'" : ''),
              (p === !0 || (p !== !1 && l.icons !== !1)) &&
                (p && 'string' == typeof p
                  ? ((p = '/' === p.charAt(0) ? p : (l.imagePath || '') + p),
                    o.push("<img src='" + p + "' class='fancytree-icon' alt='' />"))
                  : ((e = (l.iconClass && l.iconClass.call(k, j, a)) || j.data.iconclass || null),
                    o.push(
                      e
                        ? '<span ' + g + " class='fancytree-custom-icon " + e + "'></span>"
                        : '<span ' + g + " class='fancytree-icon'></span>",
                    ))),
              (f = ''),
              l.renderTitle && (f = l.renderTitle.call(k, { type: 'renderTitle' }, a) || ''),
              f ||
                ((i = j.tooltip ? " title='" + t.escapeHtml(j.tooltip) + "'" : ''),
                (c = m ? " id='ftal_" + j.key + "'" : ''),
                (g = m ? " role='treeitem'" : ''),
                (h = l.titlesTabbable ? " tabindex='0'" : ''),
                (f =
                  '<span ' +
                  g +
                  " class='fancytree-title'" +
                  c +
                  i +
                  h +
                  '>' +
                  j.title +
                  '</span>')),
              o.push(f),
              (j.span.innerHTML = o.join('')),
              this.nodeRenderStatus(a));
        },
        nodeRenderStatus: function (b) {
          var c = b.node,
            d = b.tree,
            e = b.options,
            f = c.hasChildren(),
            g = c.isLastSibling(),
            h = e.aria,
            i = a(c.span).find('.fancytree-title'),
            j = e._classNames,
            k = [],
            l = c[d.statusClassPropName];
          l &&
            (k.push(j.node),
            d.activeNode === c && k.push(j.active),
            d.focusNode === c
              ? (k.push(j.focused), h && i.attr('aria-activedescendant', !0))
              : h && i.removeAttr('aria-activedescendant'),
            c.expanded
              ? (k.push(j.expanded), h && i.attr('aria-expanded', !0))
              : h && i.removeAttr('aria-expanded'),
            c.folder && k.push(j.folder),
            f !== !1 && k.push(j.hasChildren),
            g && k.push(j.lastsib),
            c.lazy && null == c.children && k.push(j.lazy),
            c.partsel && k.push(j.partsel),
            c.unselectable && k.push(j.unselectable),
            c._isLoading && k.push(j.loading),
            c._error && k.push(j.error),
            c.selected
              ? (k.push(j.selected), h && i.attr('aria-selected', !0))
              : h && i.attr('aria-selected', !1),
            c.extraClasses && k.push(c.extraClasses),
            k.push(
              f === !1
                ? j.combinedExpanderPrefix + 'n' + (g ? 'l' : '')
                : j.combinedExpanderPrefix +
                    (c.expanded ? 'e' : 'c') +
                    (c.lazy && null == c.children ? 'd' : '') +
                    (g ? 'l' : ''),
            ),
            k.push(j.combinedIconPrefix + (c.expanded ? 'e' : 'c') + (c.folder ? 'f' : '')),
            (l.className = k.join(' ')),
            c.li && (c.li.className = g ? j.lastsib : ''));
        },
        nodeSetActive: function (b, c, d) {
          d = d || {};
          var f,
            g = b.node,
            h = b.tree,
            i = b.options,
            j = d.noEvents === !0,
            m = d.noFocus === !0,
            n = g === h.activeNode;
          return (
            (c = c !== !1),
            n === c
              ? k(g)
              : c && !j && this._triggerNodeEvent('beforeActivate', g, b.originalEvent) === !1
                ? l(g, ['rejected'])
                : void (c
                    ? (h.activeNode &&
                        (e(h.activeNode !== g, 'node was active (inconsistency)'),
                        (f = a.extend({}, b, { node: h.activeNode })),
                        h.nodeSetActive(f, !1),
                        e(null === h.activeNode, 'deactivate was out of sync?')),
                      i.activeVisible && g.makeVisible({ scrollIntoView: !1 }),
                      (h.activeNode = g),
                      h.nodeRenderStatus(b),
                      m || h.nodeSetFocus(b),
                      j || h._triggerNodeEvent('activate', g, b.originalEvent))
                    : (e(h.activeNode === g, 'node was not active (inconsistency)'),
                      (h.activeNode = null),
                      this.nodeRenderStatus(b),
                      j || b.tree._triggerNodeEvent('deactivate', g, b.originalEvent)))
          );
        },
        nodeSetExpanded: function (b, c, e) {
          e = e || {};
          var f,
            g,
            h,
            i,
            j,
            m,
            n = b.node,
            o = b.tree,
            p = b.options,
            q = e.noAnimation === !0,
            r = e.noEvents === !0;
          if (((c = c !== !1), (n.expanded && c) || (!n.expanded && !c))) return k(n);
          if (c && !n.lazy && !n.hasChildren()) return k(n);
          if (!c && n.getLevel() < p.minExpandLevel) return l(n, ['locked']);
          if (!r && this._triggerNodeEvent('beforeExpand', n, b.originalEvent) === !1)
            return l(n, ['rejected']);
          if (
            (q || n.isVisible() || (q = e.noAnimation = !0),
            (g = new a.Deferred()),
            c && !n.expanded && p.autoCollapse)
          ) {
            (j = n.getParentList(!1, !0)), (m = p.autoCollapse);
            try {
              for (p.autoCollapse = !1, h = 0, i = j.length; i > h; h++)
                this._callHook('nodeCollapseSiblings', j[h], e);
            } finally {
              p.autoCollapse = m;
            }
          }
          return (
            g.done(function () {
              c && p.autoScroll && !q
                ? n
                    .getLastChild()
                    .scrollIntoView(!0, { topNode: n })
                    .always(function () {
                      r || b.tree._triggerNodeEvent(c ? 'expand' : 'collapse', b);
                    })
                : r || b.tree._triggerNodeEvent(c ? 'expand' : 'collapse', b);
            }),
            (f = function (d) {
              var e,
                f,
                g = p.toggleEffect;
              if (((n.expanded = c), o._callHook('nodeRender', b, !1, !1, !0), n.ul))
                if (((e = 'none' !== n.ul.style.display), (f = !!n.expanded), e === f))
                  n.warn('nodeSetExpanded: UL.style.display already set');
                else {
                  if (g && !q)
                    return void a(n.ul).toggle(g.effect, g.options, g.duration, function () {
                      d();
                    });
                  n.ul.style.display = n.expanded || !parent ? '' : 'none';
                }
              d();
            }),
            c && n.lazy && n.hasChildren() === d
              ? n
                  .load()
                  .done(function () {
                    g.notifyWith && g.notifyWith(n, ['loaded']),
                      f(function () {
                        g.resolveWith(n);
                      });
                  })
                  .fail(function (a) {
                    f(function () {
                      g.rejectWith(n, ['load failed (' + a + ')']);
                    });
                  })
              : f(function () {
                  g.resolveWith(n);
                }),
            g.promise()
          );
        },
        nodeSetFocus: function (b, c) {
          var d,
            e = b.tree,
            f = b.node;
          if (((c = c !== !1), e.focusNode)) {
            if (e.focusNode === f && c) return;
            (d = a.extend({}, b, { node: e.focusNode })),
              (e.focusNode = null),
              this._triggerNodeEvent('blur', d),
              this._callHook('nodeRenderStatus', d);
          }
          c &&
            (this.hasFocus() ||
              (f.debug('nodeSetFocus: forcing container focus'),
              this._callHook('treeSetFocus', b, !0, { calledByNode: !0 })),
            f.makeVisible({ scrollIntoView: !1 }),
            (e.focusNode = f),
            this._triggerNodeEvent('focus', b),
            b.options.autoScroll && f.scrollIntoView(),
            this._callHook('nodeRenderStatus', b));
        },
        nodeSetSelected: function (a, b) {
          var c = a.node,
            d = a.tree,
            e = a.options;
          if (((b = b !== !1), c.debug('nodeSetSelected(' + b + ')', a), !c.unselectable)) {
            if ((c.selected && b) || (!c.selected && !b)) return !!c.selected;
            if (this._triggerNodeEvent('beforeSelect', c, a.originalEvent) === !1)
              return !!c.selected;
            b && 1 === e.selectMode
              ? d.lastSelectedNode && d.lastSelectedNode.setSelected(!1)
              : 3 === e.selectMode && ((c.selected = b), c.fixSelection3AfterClick()),
              (c.selected = b),
              this.nodeRenderStatus(a),
              (d.lastSelectedNode = b ? c : null),
              d._triggerNodeEvent('select', a);
          }
        },
        nodeSetStatus: function (b, c, d, e) {
          function f() {
            var a = h.children ? h.children[0] : null;
            if (a && a.isStatusNode()) {
              try {
                h.ul && (h.ul.removeChild(a.li), (a.li = null));
              } catch (b) {}
              1 === h.children.length ? (h.children = []) : h.children.shift();
            }
          }
          function g(b, c) {
            var d = h.children ? h.children[0] : null;
            return (
              d && d.isStatusNode()
                ? (a.extend(d, b), i._callHook('nodeRenderTitle', d))
                : ((b.key = '_statusNode'),
                  h._setChildren([b]),
                  (h.children[0].statusNodeType = c),
                  i.render()),
              h.children[0]
            );
          }
          var h = b.node,
            i = b.tree;
          switch (c) {
            case 'ok':
              f(), (h._isLoading = !1), (h._error = null), h.renderStatus();
              break;
            case 'loading':
              h.parent ||
                g(
                  {
                    title: i.options.strings.loading + (d ? ' (' + d + ') ' : ''),
                    tooltip: e,
                    extraClasses: 'fancytree-statusnode-wait',
                  },
                  c,
                ),
                (h._isLoading = !0),
                (h._error = null),
                h.renderStatus();
              break;
            case 'error':
              g(
                {
                  title: i.options.strings.loadError + (d ? ' (' + d + ') ' : ''),
                  tooltip: e,
                  extraClasses: 'fancytree-statusnode-error',
                },
                c,
              ),
                (h._isLoading = !1),
                (h._error = { message: d, details: e }),
                h.renderStatus();
              break;
            default:
              a.error('invalid node status ' + c);
          }
        },
        nodeToggleExpanded: function (a) {
          return this.nodeSetExpanded(a, !a.node.expanded);
        },
        nodeToggleSelected: function (a) {
          return this.nodeSetSelected(a, !a.node.selected);
        },
        treeClear: function (a) {
          var b = a.tree;
          (b.activeNode = null),
            (b.focusNode = null),
            b.$div.find('>ul.fancytree-container').empty(),
            (b.rootNode.children = null);
        },
        treeCreate: function () {},
        treeDestroy: function () {},
        treeInit: function (a) {
          this.treeLoad(a);
        },
        treeLoad: function (b, c) {
          var d,
            e,
            f,
            g = b.tree,
            h = b.widget.element,
            i = a.extend({}, b, { node: this.rootNode });
          if ((g.rootNode.children && this.treeClear(b), (c = c || this.options.source)))
            'string' == typeof c && a.error('Not implemented');
          else
            switch ((d = h.data('type') || 'html')) {
              case 'html':
                (e = h.find('>ul:first')),
                  e.addClass('ui-fancytree-source ui-helper-hidden'),
                  (c = a.ui.fancytree.parseHtml(e)),
                  (this.data = a.extend(this.data, n(e)));
                break;
              case 'json':
                (c = a.parseJSON(h.text())),
                  c.children && (c.title && (g.title = c.title), (c = c.children));
                break;
              default:
                a.error('Invalid data-type: ' + d);
            }
          return (f = this.nodeLoadChildren(i, c)
            .done(function () {
              g.render(),
                3 === b.options.selectMode && g.rootNode.fixSelection3FromEndNodes(),
                g._triggerTreeEvent('init', null, { status: !0 });
            })
            .fail(function () {
              g.render(), g._triggerTreeEvent('init', null, { status: !1 });
            }));
        },
        treeRegisterNode: function () {},
        treeSetFocus: function (a, b) {
          (b = b !== !1),
            b !== this.hasFocus() &&
              ((this._hasFocus = b),
              !b && this.focusNode && this.focusNode.setFocus(!1),
              this.$container.toggleClass('fancytree-treefocus', b),
              this._triggerTreeEvent(b ? 'focusTree' : 'blurTree'));
        },
      }),
      a.widget('ui.fancytree', {
        options: {
          activeVisible: !0,
          ajax: { type: 'GET', cache: !1, dataType: 'json' },
          aria: !1,
          autoActivate: !0,
          autoCollapse: !1,
          autoScroll: !1,
          checkbox: !1,
          clickFolderMode: 4,
          debugLevel: null,
          disabled: !1,
          enableAspx: !0,
          extensions: [],
          toggleEffect: {
            effect: 'blind',
            options: { direction: 'vertical', scale: 'box' },
            duration: 200,
          },
          generateIds: !1,
          icons: !0,
          idPrefix: 'ft_',
          focusOnSelect: !1,
          keyboard: !0,
          keyPathSeparator: '/',
          minExpandLevel: 1,
          quicksearch: !1,
          scrollOfs: { top: 0, bottom: 0 },
          scrollParent: null,
          selectMode: 2,
          strings: { loading: 'Loading&#8230;', loadError: 'Load error!' },
          tabbable: !0,
          titlesTabbable: !1,
          _classNames: {
            node: 'fancytree-node',
            folder: 'fancytree-folder',
            combinedExpanderPrefix: 'fancytree-exp-',
            combinedIconPrefix: 'fancytree-ico-',
            hasChildren: 'fancytree-has-children',
            active: 'fancytree-active',
            selected: 'fancytree-selected',
            expanded: 'fancytree-expanded',
            lazy: 'fancytree-lazy',
            focused: 'fancytree-focused',
            partsel: 'fancytree-partsel',
            unselectable: 'fancytree-unselectable',
            lastsib: 'fancytree-lastsib',
            loading: 'fancytree-loading',
            error: 'fancytree-error',
          },
          lazyLoad: null,
          postProcess: null,
        },
        _create: function () {
          (this.tree = new r(this)),
            (this.$source =
              this.source || 'json' === this.element.data('type')
                ? this.element
                : this.element.find('>ul:first'));
          var b,
            c,
            f,
            g = this.options.extensions,
            h = this.tree;
          for (f = 0; f < g.length; f++)
            (c = g[f]),
              (b = a.ui.fancytree._extensions[c]),
              b ||
                a.error(
                  "Could not apply extension '" +
                    c +
                    "' (it is not registered, did you forget to include it?)",
                ),
              (this.tree.options[c] = a.extend(!0, {}, b.options, this.tree.options[c])),
              e(
                this.tree.ext[c] === d,
                "Extension name must not exist as Fancytree.ext attribute: '" + c + "'",
              ),
              (this.tree.ext[c] = {}),
              j(this.tree, h, b, c),
              (h = b);
          this.tree._callHook('treeCreate', this.tree);
        },
        _init: function () {
          this.tree._callHook('treeInit', this.tree), this._bind();
        },
        _setOption: function (b, c) {
          var d = !0,
            e = !1;
          switch (b) {
            case 'aria':
            case 'checkbox':
            case 'icons':
            case 'minExpandLevel':
            case 'tabbable':
              this.tree._callHook('treeCreate', this.tree), (e = !0);
              break;
            case 'source':
              (d = !1), this.tree._callHook('treeLoad', this.tree, c);
          }
          this.tree.debug('set option ' + b + '=' + c + ' <' + typeof c + '>'),
            d && a.Widget.prototype._setOption.apply(this, arguments),
            e && this.tree.render(!0, !1);
        },
        destroy: function () {
          this._unbind(),
            this.tree._callHook('treeDestroy', this.tree),
            this.tree.$div.find('>ul.fancytree-container').remove(),
            this.$source && this.$source.removeClass('ui-helper-hidden'),
            a.Widget.prototype.destroy.call(this);
        },
        _unbind: function () {
          var b = this.tree._ns;
          this.element.unbind(b), this.tree.$container.unbind(b), a(c).unbind(b);
        },
        _bind: function () {
          var a = this,
            b = this.options,
            c = this.tree,
            d = c._ns;
          this._unbind(),
            c.$container
              .on('focusin' + d + ' focusout' + d, function (a) {
                var b = t.getNode(a),
                  d = 'focusin' === a.type;
                b ? c._callHook('nodeSetFocus', b, d) : c._callHook('treeSetFocus', c, d);
              })
              .on('selectstart' + d, 'span.fancytree-title', function (a) {
                a.preventDefault();
              })
              .on('keydown' + d, function (a) {
                if (b.disabled || b.keyboard === !1) return !0;
                var d,
                  e = c.focusNode,
                  f = c._makeHookContext(e || c, a),
                  g = c.phase;
                try {
                  return (
                    (c.phase = 'userEvent'),
                    (d = e
                      ? c._triggerNodeEvent('keydown', e, a)
                      : c._triggerTreeEvent('keydown', a)),
                    'preventNav' === d ? (d = !0) : d !== !1 && (d = c._callHook('nodeKeydown', f)),
                    d
                  );
                } finally {
                  c.phase = g;
                }
              })
              .on('click' + d + ' dblclick' + d, function (c) {
                if (b.disabled) return !0;
                var d,
                  e = t.getEventTarget(c),
                  f = e.node,
                  g = a.tree,
                  h = g.phase;
                if (!f) return !0;
                d = g._makeHookContext(f, c);
                try {
                  switch (((g.phase = 'userEvent'), c.type)) {
                    case 'click':
                      return (
                        (d.targetType = e.type),
                        g._triggerNodeEvent('click', d, c) === !1 ? !1 : g._callHook('nodeClick', d)
                      );
                    case 'dblclick':
                      return (
                        (d.targetType = e.type),
                        g._triggerNodeEvent('dblclick', d, c) === !1
                          ? !1
                          : g._callHook('nodeDblclick', d)
                      );
                  }
                } finally {
                  g.phase = h;
                }
              });
        },
        getActiveNode: function () {
          return this.tree.activeNode;
        },
        getNodeByKey: function (a) {
          return this.tree.getNodeByKey(a);
        },
        getRootNode: function () {
          return this.tree.rootNode;
        },
        getTree: function () {
          return this.tree;
        },
      }),
      (t = a.ui.fancytree),
      a.extend(a.ui.fancytree, {
        version: '2.8.1',
        buildType: 'production',
        debugLevel: 1,
        _nextId: 1,
        _nextNodeKey: 1,
        _extensions: {},
        _FancytreeClass: r,
        _FancytreeNodeClass: q,
        jquerySupports: { positionMyOfs: h(a.ui.version, 1, 9) },
        assert: function (a, b) {
          return e(a, b);
        },
        debounce: function (a, b, c, d) {
          var e;
          return (
            3 === arguments.length && 'boolean' != typeof c && ((d = c), (c = !1)),
            function () {
              var f = arguments;
              (d = d || this),
                c && !e && b.apply(d, f),
                clearTimeout(e),
                (e = setTimeout(function () {
                  c || b.apply(d, f), (e = null);
                }, a));
            }
          );
        },
        debug: function () {
          a.ui.fancytree.debugLevel >= 2 && f('log', arguments);
        },
        error: function () {
          f('error', arguments);
        },
        escapeHtml: function (a) {
          return ('' + a).replace(/[&<>"'\/]/g, function (a) {
            return u[a];
          });
        },
        fixPositionOptions: function (b) {
          if (
            ((b.offset || ('' + b.my + b.at).indexOf('%') >= 0) &&
              a.error("expected new position syntax (but '%' is not supported)"),
            !a.ui.fancytree.jquerySupports.positionMyOfs)
          ) {
            var c = /(\w+)([+-]?\d+)?\s+(\w+)([+-]?\d+)?/.exec(b.my),
              d = /(\w+)([+-]?\d+)?\s+(\w+)([+-]?\d+)?/.exec(b.at),
              e = (c[2] ? +c[2] : 0) + (d[2] ? +d[2] : 0),
              f = (c[4] ? +c[4] : 0) + (d[4] ? +d[4] : 0);
            (b = a.extend({}, b, { my: c[1] + ' ' + c[3], at: d[1] + ' ' + d[3] })),
              (e || f) && (b.offset = '' + e + ' ' + f);
          }
          return b;
        },
        getEventTargetType: function (a) {
          return this.getEventTarget(a).type;
        },
        getEventTarget: function (b) {
          var c = b && b.target ? b.target.className : '',
            e = { node: this.getNode(b.target), type: d };
          return (
            /\bfancytree-title\b/.test(c)
              ? (e.type = 'title')
              : /\bfancytree-expander\b/.test(c)
                ? (e.type = e.node.hasChildren() === !1 ? 'prefix' : 'expander')
                : /\bfancytree-checkbox\b/.test(c) || /\bfancytree-radio\b/.test(c)
                  ? (e.type = 'checkbox')
                  : /\bfancytree-icon\b/.test(c)
                    ? (e.type = 'icon')
                    : /\bfancytree-node\b/.test(c)
                      ? (e.type = 'title')
                      : b &&
                        b.target &&
                        a(b.target).closest('.fancytree-title').length &&
                        (e.type = 'title'),
            e
          );
        },
        getNode: function (a) {
          if (a instanceof q) return a;
          for (a.selector !== d ? (a = a[0]) : a.originalEvent !== d && (a = a.target); a; ) {
            if (a.ftnode) return a.ftnode;
            a = a.parentNode;
          }
          return null;
        },
        info: function () {
          a.ui.fancytree.debugLevel >= 1 && f('info', arguments);
        },
        eventToString: function (a) {
          var b = a.which,
            c = a.type,
            d = [];
          return (
            a.altKey && d.push('alt'),
            a.ctrlKey && d.push('ctrl'),
            a.metaKey && d.push('meta'),
            a.shiftKey && d.push('shift'),
            'click' === c || 'dblclick' === c
              ? d.push(x[a.button] + c)
              : v[b] || d.push(w[b] || String.fromCharCode(b).toLowerCase()),
            d.join('+')
          );
        },
        keyEventToString: function (a) {
          return (
            this.warn('keyEventToString() is deprecated: use eventToString()'),
            this.eventToString(a)
          );
        },
        parseHtml: function (b) {
          var c,
            e,
            f,
            g,
            h,
            i,
            j,
            k,
            l = b.find('>li'),
            m = [];
          return (
            l.each(function () {
              var l,
                o = a(this),
                p = o.find('>span:first', this),
                q = p.length ? null : o.find('>a:first'),
                r = { tooltip: null, data: {} };
              for (
                p.length
                  ? (r.title = p.html())
                  : q && q.length
                    ? ((r.title = q.html()),
                      (r.data.href = q.attr('href')),
                      (r.data.target = q.attr('target')),
                      (r.tooltip = q.attr('title')))
                    : ((r.title = o.html()),
                      (g = r.title.search(/<ul/i)),
                      g >= 0 && (r.title = r.title.substring(0, g))),
                  r.title = a.trim(r.title),
                  e = 0,
                  f = y.length;
                f > e;
                e++
              )
                r[y[e]] = d;
              for (j = this.className.split(' '), c = [], e = 0, f = j.length; f > e; e++)
                (k = j[e]), z[k] ? (r[k] = !0) : c.push(k);
              if (
                ((r.extraClasses = c.join(' ')),
                (h = o.attr('title')),
                h && (r.tooltip = h),
                (h = o.attr('id')),
                h && (r.key = h),
                (l = n(o)),
                l && !a.isEmptyObject(l))
              ) {
                for (e = 0, f = A.length; f > e; e++)
                  (h = A[e]), (i = l[h]), null != i && (delete l[h], (r[h] = i));
                a.extend(r.data, l);
              }
              (b = o.find('>ul:first')),
                (r.children = b.length ? a.ui.fancytree.parseHtml(b) : r.lazy ? d : null),
                m.push(r);
            }),
            m
          );
        },
        registerExtension: function (b) {
          e(null != b.name, 'extensions must have a `name` property.'),
            e(null != b.version, 'extensions must have a `version` property.'),
            (a.ui.fancytree._extensions[b.name] = b);
        },
        unescapeHtml: function (a) {
          var b = c.createElement('div');
          return (b.innerHTML = a), 0 === b.childNodes.length ? '' : b.childNodes[0].nodeValue;
        },
        warn: function () {
          f('warn', arguments);
        },
      });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.childcounter.min.js' */
  !(function (a) {
    'use strict';
    (a.ui.fancytree._FancytreeClass.prototype.countSelected = function (a) {
      {
        var b = this;
        b.options;
      }
      return b.getSelectedNodes(a).length;
    }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.toUpper = function () {
        var a = this;
        return a.setTitle(a.title.toUpperCase());
      }),
      (a.ui.fancytree.prototype.widgetMethod1 = function (a) {
        this.tree;
        return a;
      }),
      a.ui.fancytree.registerExtension({
        name: 'childcounter',
        version: '1.0.0',
        options: { deep: !0, hideZeros: !0, hideExpanded: !1 },
        foo: 42,
        _appendCounter: function () {},
        treeInit: function (a) {
          a.options, a.options.childcounter;
          this._superApply(arguments), this.$container.addClass('fancytree-ext-childcounter');
        },
        treeDestroy: function () {
          this._superApply(arguments);
        },
        nodeRenderTitle: function (b) {
          var c = b.node,
            d = b.options.childcounter,
            e = null == c.data.childCounter ? c.countChildren(d.deep) : +c.data.childCounter;
          this._superApply(arguments),
            (!e && d.hideZeros) ||
              (c.isExpanded() && d.hideExpanded) ||
              a('span.fancytree-icon', c.span).append(
                a("<span class='fancytree-childcounter'/>").text(e),
              );
        },
        nodeSetExpanded: function (a) {
          {
            var b = a.tree;
            a.node;
          }
          return this._superApply(arguments).always(function () {
            b.nodeRenderTitle(a);
          });
        },
      });
  })(jQuery);

  /*! Extension 'jquery.fancytree.clones.min.js' */
  !(function (a) {
    'use strict';
    function b(b, c) {
      b || ((c = c ? ': ' + c : ''), a.error('Assertion failed' + c));
    }
    function c(a, b) {
      var c;
      for (c = a.length - 1; c >= 0; c--) if (a[c] === b) return a.splice(c, 1), !0;
      return !1;
    }
    function d(a, b, c) {
      for (
        var d, e, f = 3 & a.length, g = a.length - f, h = c, i = 3432918353, j = 461845907, k = 0;
        g > k;

      )
        (e =
          (255 & a.charCodeAt(k)) |
          ((255 & a.charCodeAt(++k)) << 8) |
          ((255 & a.charCodeAt(++k)) << 16) |
          ((255 & a.charCodeAt(++k)) << 24)),
          ++k,
          (e = ((65535 & e) * i + ((((e >>> 16) * i) & 65535) << 16)) & 4294967295),
          (e = (e << 15) | (e >>> 17)),
          (e = ((65535 & e) * j + ((((e >>> 16) * j) & 65535) << 16)) & 4294967295),
          (h ^= e),
          (h = (h << 13) | (h >>> 19)),
          (d = (5 * (65535 & h) + (((5 * (h >>> 16)) & 65535) << 16)) & 4294967295),
          (h = (65535 & d) + 27492 + ((((d >>> 16) + 58964) & 65535) << 16));
      switch (((e = 0), f)) {
        case 3:
          e ^= (255 & a.charCodeAt(k + 2)) << 16;
        case 2:
          e ^= (255 & a.charCodeAt(k + 1)) << 8;
        case 1:
          (e ^= 255 & a.charCodeAt(k)),
            (e = ((65535 & e) * i + ((((e >>> 16) * i) & 65535) << 16)) & 4294967295),
            (e = (e << 15) | (e >>> 17)),
            (e = ((65535 & e) * j + ((((e >>> 16) * j) & 65535) << 16)) & 4294967295),
            (h ^= e);
      }
      return (
        (h ^= a.length),
        (h ^= h >>> 16),
        (h = (2246822507 * (65535 & h) + (((2246822507 * (h >>> 16)) & 65535) << 16)) & 4294967295),
        (h ^= h >>> 13),
        (h = (3266489909 * (65535 & h) + (((3266489909 * (h >>> 16)) & 65535) << 16)) & 4294967295),
        (h ^= h >>> 16),
        b ? ('0000000' + (h >>> 0).toString(16)).substr(-8) : h >>> 0
      );
    }
    function e(b) {
      var c,
        e = a.map(b.getParentList(!1, !0), function (a) {
          return a.refKey || a.key;
        });
      return (e = e.join('/')), (c = 'id_' + d(e, !0));
    }
    (a.ui.fancytree._FancytreeNodeClass.prototype.getCloneList = function (b) {
      var c,
        d = this.tree,
        e = d.refMap[this.refKey] || null,
        f = d.keyMap;
      return (
        e &&
          ((c = this.key),
          b
            ? (e = a.map(e, function (a) {
                return f[a];
              }))
            : ((e = a.map(e, function (a) {
                return a === c ? null : f[a];
              })),
              e.length < 1 && (e = null))),
        e
      );
    }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.isClone = function () {
        var a = this.refKey || null,
          b = (a && this.tree.refMap[a]) || null;
        return !!(b && b.length > 1);
      }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.reRegister = function (b, c) {
        (b = null == b ? null : '' + b), (c = null == c ? null : '' + c);
        var d = this.tree,
          e = this.key,
          f = this.refKey,
          g = d.keyMap,
          h = d.refMap,
          i = h[f] || null,
          j = !1;
        return (
          null != b &&
            b !== this.key &&
            (g[b] && a.error('[ext-clones] reRegister(' + b + '): already exists: ' + this),
            delete g[e],
            (g[b] = this),
            i &&
              (h[f] = a.map(i, function (a) {
                return a === e ? b : a;
              })),
            (this.key = b),
            (j = !0)),
          null != c &&
            c !== this.refKey &&
            (i &&
              (1 === i.length
                ? delete h[f]
                : (h[f] = a.map(i, function (a) {
                    return a === e ? null : a;
                  }))),
            h[c] ? h[c].append(b) : (h[c] = [this.key]),
            (this.refKey = c),
            (j = !0)),
          j
        );
      }),
      (a.ui.fancytree._FancytreeClass.prototype.getNodesByRef = function (b, c) {
        var d = this.keyMap,
          e = this.refMap[b] || null;
        return (
          e &&
            ((e = c
              ? a.map(e, function (a) {
                  var b = d[a];
                  return b.isDescendantOf(c) ? b : null;
                })
              : a.map(e, function (a) {
                  return d[a];
                })),
            e.length < 1 && (e = null)),
          e
        );
      }),
      (a.ui.fancytree._FancytreeClass.prototype.changeRefKey = function (a, b) {
        var c,
          d,
          e = this.keyMap,
          f = this.refMap[a] || null;
        if (f) {
          for (c = 0; c < f.length; c++) (d = e[f[c]]), (d.refKey = b);
          delete this.refMap[a], (this.refMap[b] = f);
        }
      }),
      a.ui.fancytree.registerExtension({
        name: 'clones',
        version: '0.0.3',
        options: { highlightActiveClones: !0, highlightClones: !1 },
        treeCreate: function (a) {
          this._superApply(arguments), (a.tree.refMap = {}), (a.tree.keyMap = {});
        },
        treeInit: function (a) {
          this.$container.addClass('fancytree-ext-clones'),
            b(null == a.options.defaultKey),
            (a.options.defaultKey = function (a) {
              return e(a);
            }),
            this._superApply(arguments);
        },
        treeClear: function (a) {
          return (a.tree.refMap = {}), (a.tree.keyMap = {}), this._superApply(arguments);
        },
        treeRegisterNode: function (d, e, f) {
          var g,
            h,
            i = d.tree,
            j = i.keyMap,
            k = i.refMap,
            l = f.key,
            m = f && null != f.refKey ? '' + f.refKey : null;
          return '_statusNode' === l
            ? this._superApply(arguments)
            : (e
                ? (null != j[f.key] &&
                    a.error('clones.treeRegisterNode: node.key already exists: ' + f),
                  (j[l] = f),
                  m &&
                    ((g = k[m]),
                    g
                      ? (g.push(l),
                        2 === g.length &&
                          d.options.clones.highlightClones &&
                          j[g[0]].renderStatus())
                      : (k[m] = [l])))
                : (null == j[l] &&
                    a.error('clones.treeRegisterNode: node.key not registered: ' + f.key),
                  delete j[l],
                  m &&
                    ((g = k[m]),
                    g &&
                      ((h = g.length),
                      1 >= h
                        ? (b(1 === h), b(g[0] === l), delete k[m])
                        : (c(g, l),
                          2 === h && d.options.clones.highlightClones && j[g[0]].renderStatus())))),
              this._superApply(arguments));
        },
        nodeRenderStatus: function (b) {
          var c,
            d,
            e = b.node;
          return (
            (d = this._superApply(arguments)),
            b.options.clones.highlightClones &&
              ((c = a(e[b.tree.statusClassPropName])),
              c.length && e.isClone() && c.addClass('fancytree-clone')),
            d
          );
        },
        nodeSetActive: function (b, c) {
          var d,
            e = b.tree.statusClassPropName,
            f = b.node;
          return (
            (d = this._superApply(arguments)),
            b.options.clones.highlightActiveClones &&
              f.isClone() &&
              a.each(f.getCloneList(!0), function (b, d) {
                a(d[e]).toggleClass('fancytree-active-clone', c !== !1);
              }),
            d
          );
        },
      });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.dnd.min.js' */
  !(function (a, b, c, d) {
    'use strict';
    function e(a) {
      return 0 === a ? '' : a > 0 ? '+' + a : '' + a;
    }
    function f(b) {
      var c = b.options.dnd || null;
      c && g(),
        c &&
          c.dragStart &&
          b.widget.element.draggable(
            a.extend(
              {
                addClasses: !1,
                appendTo: b.$container,
                containment: !1,
                delay: 0,
                distance: 4,
                revert: !1,
                scroll: !0,
                scrollSpeed: 7,
                scrollSensitivity: 10,
                connectToFancytree: !0,
                helper: function (b) {
                  var c,
                    d = a.ui.fancytree.getNode(b.target),
                    e = a(d.span);
                  return d
                    ? ((c = a(
                        "<div class='fancytree-drag-helper'><span class='fancytree-drag-helper-img' /></div>",
                      )
                        .css({ zIndex: 3, position: 'relative' })
                        .append(e.find('span.fancytree-title').clone())),
                      c.data('ftSourceNode', d),
                      c)
                    : '<div>ERROR?: helper requested but sourceNode not found</div>';
                },
                start: function (a, b) {
                  var c = b.helper.data('ftSourceNode');
                  return !!c;
                },
              },
              b.options.dnd.draggable,
            ),
          ),
        c &&
          c.dragDrop &&
          b.widget.element.droppable(
            a.extend(
              { addClasses: !1, tolerance: 'intersect', greedy: !1 },
              b.options.dnd.droppable,
            ),
          );
    }
    function g() {
      h ||
        (a.ui.plugin.add('draggable', 'connectToFancytree', {
          start: function (b, c) {
            var d = a(this).data('ui-draggable') || a(this).data('draggable'),
              e = c.helper.data('ftSourceNode') || null;
            return e
              ? ((d.offset.click.top = -2),
                (d.offset.click.left = 16),
                e.tree.ext.dnd._onDragEvent('start', e, null, b, c, d))
              : void 0;
          },
          drag: function (b, c) {
            var d,
              e,
              f = a(this).data('ui-draggable') || a(this).data('draggable'),
              g = c.helper.data('ftSourceNode') || null,
              h = c.helper.data('ftTargetNode') || null,
              i = a.ui.fancytree.getNode(b.target);
            return b.target &&
              !i &&
              (d =
                a(b.target).closest('div.fancytree-drag-helper,#fancytree-drop-marker').length > 0)
              ? ((e = g || h || a.ui.fancytree), void e.debug('Drag event over helper: ignored.'))
              : (c.helper.data('ftTargetNode', i),
                h && h !== i && h.tree.ext.dnd._onDragEvent('leave', h, g, b, c, f),
                void (
                  i &&
                  i.tree.options.dnd.dragDrop &&
                  (i === h
                    ? i.tree.ext.dnd._onDragEvent('over', i, g, b, c, f)
                    : i.tree.ext.dnd._onDragEvent('enter', i, g, b, c, f))
                ));
          },
          stop: function (b, c) {
            var d,
              e = a(this).data('ui-draggable') || a(this).data('draggable'),
              f = c.helper.data('ftSourceNode') || null,
              g = c.helper.data('ftTargetNode') || null,
              h = b.type,
              i = 'mouseup' === h && 1 === b.which;
            i || ((d = f || g || a.ui.fancytree), d.debug('Drag was cancelled')),
              g &&
                (i && g.tree.ext.dnd._onDragEvent('drop', g, f, b, c, e),
                g.tree.ext.dnd._onDragEvent('leave', g, f, b, c, e)),
              f && f.tree.ext.dnd._onDragEvent('stop', f, null, b, c, e);
          },
        }),
        (h = !0));
    }
    var h = !1;
    a.ui.fancytree.registerExtension({
      name: 'dnd',
      version: '0.1.0',
      options: {
        autoExpandMS: 1e3,
        draggable: null,
        droppable: null,
        focusOnClick: !1,
        preventVoidMoves: !0,
        preventRecursiveMoves: !0,
        dragStart: null,
        dragStop: null,
        dragEnter: null,
        dragOver: null,
        dragDrop: null,
        dragLeave: null,
      },
      treeInit: function (b) {
        var c = b.tree;
        this._superApply(arguments),
          c.options.dnd.dragStart &&
            c.$container.on('mousedown', function (d) {
              if (!c.hasFocus() && b.options.dnd.focusOnClick) {
                var e = a.ui.fancytree.getNode(d);
                e.debug('Re-enable focus that was prevented by jQuery UI draggable.'),
                  setTimeout(function () {
                    a(d.target).closest(':tabbable').focus();
                  }, 10);
              }
            }),
          f(c);
      },
      nodeKeydown: function (b) {
        var c = b.originalEvent;
        return (
          c.which === a.ui.keyCode.ESCAPE && this._local._cancelDrag(), this._superApply(arguments)
        );
      },
      nodeClick: function () {
        return this._superApply(arguments);
      },
      _setDndStatus: function (b, c, d, f, g) {
        var h = 0,
          i = 'center',
          j = this._local,
          k = b ? a(b.span) : null,
          l = a(c.span);
        if (
          (j.$dropMarker ||
            (j.$dropMarker = a("<div id='fancytree-drop-marker'></div>")
              .hide()
              .css({ 'z-index': 1e3 })
              .prependTo(a(this.$div).parent())),
          'after' === f || 'before' === f || 'over' === f)
        ) {
          switch (f) {
            case 'before':
              j.$dropMarker
                .removeClass('fancytree-drop-after fancytree-drop-over')
                .addClass('fancytree-drop-before'),
                (i = 'top');
              break;
            case 'after':
              j.$dropMarker
                .removeClass('fancytree-drop-before fancytree-drop-over')
                .addClass('fancytree-drop-after'),
                (i = 'bottom');
              break;
            default:
              j.$dropMarker
                .removeClass('fancytree-drop-after fancytree-drop-before')
                .addClass('fancytree-drop-over'),
                l.addClass('fancytree-drop-target'),
                (h = 8);
          }
          j.$dropMarker
            .show()
            .position(
              a.ui.fancytree.fixPositionOptions({
                my: 'left' + e(h) + ' center',
                at: 'left ' + i,
                of: l,
              }),
            );
        } else l.removeClass('fancytree-drop-target'), j.$dropMarker.hide();
        'after' === f ? l.addClass('fancytree-drop-after') : l.removeClass('fancytree-drop-after'),
          'before' === f
            ? l.addClass('fancytree-drop-before')
            : l.removeClass('fancytree-drop-before'),
          g === !0
            ? (k && k.addClass('fancytree-drop-accept'),
              l.addClass('fancytree-drop-accept'),
              d.addClass('fancytree-drop-accept'))
            : (k && k.removeClass('fancytree-drop-accept'),
              l.removeClass('fancytree-drop-accept'),
              d.removeClass('fancytree-drop-accept')),
          g === !1
            ? (k && k.addClass('fancytree-drop-reject'),
              l.addClass('fancytree-drop-reject'),
              d.addClass('fancytree-drop-reject'))
            : (k && k.removeClass('fancytree-drop-reject'),
              l.removeClass('fancytree-drop-reject'),
              d.removeClass('fancytree-drop-reject'));
      },
      _onDragEvent: function (b, c, e, f, g, h) {
        'over' !== b && this.debug('tree.ext.dnd._onDragEvent(%s, %o, %o) - %o', b, c, e, this);
        var i,
          j,
          k,
          l,
          m,
          n,
          o = this.options,
          p = o.dnd,
          q = this._makeHookContext(c, f, { otherNode: e, ui: g, draggable: h }),
          r = null,
          s = a(c.span);
        switch (b) {
          case 'start':
            c.isStatusNode() ? (r = !1) : p.dragStart && (r = p.dragStart(c, q)),
              r === !1
                ? (this.debug('tree.dragStart() cancelled'), g.helper.trigger('mouseup').hide())
                : s.addClass('fancytree-drag-source');
            break;
          case 'enter':
            (n =
              p.preventRecursiveMoves && c.isDescendantOf(e)
                ? !1
                : p.dragEnter
                  ? p.dragEnter(c, q)
                  : null),
              (r = n
                ? a.isArray(n)
                  ? {
                      over: a.inArray('over', n) >= 0,
                      before: a.inArray('before', n) >= 0,
                      after: a.inArray('after', n) >= 0,
                    }
                  : {
                      over: n === !0 || 'over' === n,
                      before: n === !0 || 'before' === n,
                      after: n === !0 || 'after' === n,
                    }
                : !1),
              g.helper.data('enterResponse', r),
              this.debug('helper.enterResponse: %o', r);
            break;
          case 'over':
            (l = g.helper.data('enterResponse')),
              (m = null),
              l === !1 ||
                ('string' == typeof l
                  ? (m = l)
                  : ((i = s.offset()),
                    (j = { x: f.pageX - i.left, y: f.pageY - i.top }),
                    (k = { x: j.x / s.width(), y: j.y / s.height() }),
                    l.after && k.y > 0.75
                      ? (m = 'after')
                      : !l.over && l.after && k.y > 0.5
                        ? (m = 'after')
                        : l.before && k.y <= 0.25
                          ? (m = 'before')
                          : !l.over && l.before && k.y <= 0.5
                            ? (m = 'before')
                            : l.over && (m = 'over'),
                    p.preventVoidMoves &&
                      (c === e
                        ? (this.debug('    drop over source node prevented'), (m = null))
                        : 'before' === m && e && c === e.getNextSibling()
                          ? (this.debug('    drop after source node prevented'), (m = null))
                          : 'after' === m && e && c === e.getPrevSibling()
                            ? (this.debug('    drop before source node prevented'), (m = null))
                            : 'over' === m &&
                              e &&
                              e.parent === c &&
                              e.isLastSibling() &&
                              (this.debug('    drop last child over own parent prevented'),
                              (m = null))),
                    g.helper.data('hitMode', m))),
              'over' === m &&
                p.autoExpandMS &&
                c.hasChildren() !== !1 &&
                !c.expanded &&
                c.scheduleAction('expand', p.autoExpandMS),
              m && p.dragOver && ((q.hitMode = m), (r = p.dragOver(c, q))),
              this._local._setDndStatus(e, c, g.helper, m, r !== !1 && null !== m);
            break;
          case 'drop':
            (m = g.helper.data('hitMode')), m && p.dragDrop && ((q.hitMode = m), p.dragDrop(c, q));
            break;
          case 'leave':
            c.scheduleAction('cancel'),
              g.helper.data('enterResponse', null),
              g.helper.data('hitMode', null),
              this._local._setDndStatus(e, c, g.helper, 'out', d),
              p.dragLeave && p.dragLeave(c, q);
            break;
          case 'stop':
            s.removeClass('fancytree-drag-source'), p.dragStop && p.dragStop(c, q);
            break;
          default:
            a.error('Unsupported drag event: ' + b);
        }
        return r;
      },
      _cancelDrag: function () {
        var b = a.ui.ddmanager.current;
        b && b.cancel();
      },
    });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.edit.min.js' */
  !(function (a, b, c) {
    'use strict';
    var d = /Mac/.test(navigator.platform),
      e = a.ui.fancytree.escapeHtml,
      f = a.ui.fancytree.unescapeHtml;
    (a.ui.fancytree._FancytreeNodeClass.prototype.editStart = function () {
      var b,
        d = this,
        e = this.tree,
        g = e.ext.edit,
        h = e.options.edit,
        i = a('.fancytree-title', d.span),
        j = {
          node: d,
          tree: e,
          options: e.options,
          isNew: a(d.span).hasClass('fancytree-edit-new'),
          orgTitle: d.title,
          input: null,
          dirty: !1,
        };
      return h.beforeEdit.call(d, { type: 'beforeEdit' }, j) === !1
        ? !1
        : (a.ui.fancytree.assert(!g.currentNode, 'recursive edit'),
          (g.currentNode = this),
          (g.eventData = j),
          e.widget._unbind(),
          a(c).on('mousedown.fancytree-edit', function (b) {
            a(b.target).hasClass('fancytree-edit-input') || d.editEnd(!0, b);
          }),
          (b = a('<input />', {
            class: 'fancytree-edit-input',
            type: 'text',
            value: f(j.orgTitle),
          })),
          (g.eventData.input = b),
          null != h.adjustWidthOfs && b.width(i.width() + h.adjustWidthOfs),
          null != h.inputCss && b.css(h.inputCss),
          i.html(b),
          b
            .focus()
            .change(function () {
              b.addClass('fancytree-edit-dirty');
            })
            .keydown(function (b) {
              switch (b.which) {
                case a.ui.keyCode.ESCAPE:
                  d.editEnd(!1, b);
                  break;
                case a.ui.keyCode.ENTER:
                  return d.editEnd(!0, b), !1;
              }
              b.stopPropagation();
            })
            .blur(function (a) {
              return d.editEnd(!0, a);
            }),
          void h.edit.call(d, { type: 'edit' }, j));
    }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.editEnd = function (b) {
        var d,
          f = this,
          g = this.tree,
          h = g.ext.edit,
          i = h.eventData,
          j = g.options.edit,
          k = a('.fancytree-title', f.span),
          l = k.find('input.fancytree-edit-input');
        return (
          j.trim && l.val(a.trim(l.val())),
          (d = l.val()),
          (i.dirty = d !== f.title),
          (i.save = b === !1 ? !1 : i.isNew ? '' !== d : i.dirty && '' !== d),
          j.beforeClose.call(f, { type: 'beforeClose' }, i) === !1
            ? !1
            : i.save && j.save.call(f, { type: 'save' }, i) === !1
              ? !1
              : (l.removeClass('fancytree-edit-dirty').unbind(),
                a(c).off('.fancytree-edit'),
                i.save
                  ? (f.setTitle(e(d)), f.setFocus())
                  : i.isNew
                    ? (f.remove(), (f = i.node = null), h.relatedNode.setFocus())
                    : (f.renderTitle(), f.setFocus()),
                (h.eventData = null),
                (h.currentNode = null),
                (h.relatedNode = null),
                g.widget._bind(),
                a(g.$container).focus(),
                (i.input = null),
                j.close.call(f, { type: 'close' }, i),
                !0)
        );
      }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.editCreateNode = function (b, c) {
        var d,
          e = this;
        return (
          (b = b || 'child'),
          null == c
            ? (c = { title: '' })
            : 'string' == typeof c
              ? (c = { title: c })
              : a.ui.fancytree.assert(a.isPlainObject(c)),
          'child' !== b || this.isExpanded() || this.hasChildren() === !1
            ? ((d = this.addNode(c, b)),
              void d.makeVisible().done(function () {
                a(d.span).addClass('fancytree-edit-new'),
                  (e.tree.ext.edit.relatedNode = e),
                  d.editStart();
              }))
            : void this.setExpanded().done(function () {
                e.editCreateNode(b, c);
              })
        );
      }),
      (a.ui.fancytree._FancytreeClass.prototype.isEditing = function () {
        return this.ext.edit.currentNode;
      }),
      (a.ui.fancytree._FancytreeNodeClass.prototype.isEditing = function () {
        return this.tree.ext.edit.currentNode === this;
      }),
      a.ui.fancytree.registerExtension({
        name: 'edit',
        version: '0.2.0',
        options: {
          adjustWidthOfs: 4,
          allowEmpty: !1,
          inputCss: { minWidth: '3em' },
          triggerCancel: ['esc', 'tab', 'click'],
          triggerStart: ['f2', 'shift+click', 'mac+enter'],
          trim: !0,
          beforeClose: a.noop,
          beforeEdit: a.noop,
          close: a.noop,
          edit: a.noop,
          save: a.noop,
        },
        currentNode: null,
        treeInit: function () {
          this._superApply(arguments), this.$container.addClass('fancytree-ext-edit');
        },
        nodeClick: function (b) {
          return a.inArray('shift+click', b.options.edit.triggerStart) >= 0 &&
            b.originalEvent.shiftKey
            ? (b.node.editStart(), !1)
            : this._superApply(arguments);
        },
        nodeDblclick: function (b) {
          return a.inArray('dblclick', b.options.edit.triggerStart) >= 0
            ? (b.node.editStart(), !1)
            : this._superApply(arguments);
        },
        nodeKeydown: function (b) {
          switch (b.originalEvent.which) {
            case 113:
              if (a.inArray('f2', b.options.edit.triggerStart) >= 0) return b.node.editStart(), !1;
              break;
            case a.ui.keyCode.ENTER:
              if (a.inArray('mac+enter', b.options.edit.triggerStart) >= 0 && d)
                return b.node.editStart(), !1;
          }
          return this._superApply(arguments);
        },
      });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.filter.min.js' */
  !(function (a) {
    'use strict';
    function b(a) {
      return (a + '').replace(/([.?*+\^\$\[\]\\(){}|-])/g, '\\$1');
    }
    (a.ui.fancytree._FancytreeClass.prototype._applyFilterImpl = function (a, c, d) {
      var e,
        f,
        g = 0,
        h = 'hide' === this.options.filter.mode;
      return (
        (d = !!d && !c),
        'string' == typeof a &&
          ((e = b(a)),
          (f = new RegExp('.*' + e + '.*', 'i')),
          (a = function (a) {
            return !!f.exec(a.title);
          })),
        (this.enableFilter = !0),
        (this.lastFilterArgs = arguments),
        this.$div.addClass('fancytree-ext-filter'),
        this.$div.addClass(h ? 'fancytree-ext-filter-hide' : 'fancytree-ext-filter-dimm'),
        this.visit(function (a) {
          delete a.match, delete a.subMatch;
        }),
        this.visit(function (b) {
          return (d && null != b.children) ||
            !a(b) ||
            (g++,
            (b.match = !0),
            b.visitParents(function (a) {
              a.subMatch = !0;
            }),
            !c)
            ? void 0
            : (b.visit(function (a) {
                a.match = !0;
              }),
              'skip');
        }),
        this.render(),
        g
      );
    }),
      (a.ui.fancytree._FancytreeClass.prototype.filterNodes = function (a, b) {
        return this._applyFilterImpl(a, !1, b);
      }),
      (a.ui.fancytree._FancytreeClass.prototype.applyFilter = function () {
        return (
          this.warn(
            'Fancytree.applyFilter() is deprecated since 2014-05-10. Use .filterNodes() instead.',
          ),
          this.filterNodes.apply(this, arguments)
        );
      }),
      (a.ui.fancytree._FancytreeClass.prototype.filterBranches = function (a) {
        return this._applyFilterImpl(a, !0, null);
      }),
      (a.ui.fancytree._FancytreeClass.prototype.clearFilter = function () {
        this.visit(function (a) {
          delete a.match, delete a.subMatch;
        }),
          (this.enableFilter = !1),
          (this.lastFilterArgs = null),
          this.$div.removeClass(
            'fancytree-ext-filter fancytree-ext-filter-dimm fancytree-ext-filter-hide',
          ),
          this.render();
      }),
      a.ui.fancytree.registerExtension({
        name: 'filter',
        version: '0.3.0',
        options: { autoApply: !0, mode: 'dimm' },
        treeInit: function () {
          this._superApply(arguments);
        },
        nodeLoadChildren: function (a) {
          return this._superApply(arguments).done(function () {
            a.tree.enableFilter &&
              a.tree.lastFilterArgs &&
              a.options.filter.autoApply &&
              a.tree._applyFilterImpl.apply(a.tree, a.tree.lastFilterArgs);
          });
        },
        nodeRenderStatus: function (b) {
          var c,
            d = b.node,
            e = b.tree,
            f = a(d[e.statusClassPropName]);
          return (
            (c = this._superApply(arguments)),
            f.length && e.enableFilter
              ? (f
                  .toggleClass('fancytree-match', !!d.match)
                  .toggleClass('fancytree-submatch', !!d.subMatch)
                  .toggleClass('fancytree-hide', !(d.match || d.subMatch)),
                c)
              : c
          );
        },
      });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.glyph.min.js' */
  !(function (a) {
    'use strict';
    function b(a, b) {
      return a.map[b];
    }
    a.ui.fancytree.registerExtension({
      name: 'glyph',
      version: '0.2.0',
      options: {
        map: {
          checkbox: 'icon-check-empty',
          checkboxSelected: 'icon-check',
          checkboxUnknown: 'icon-check icon-muted',
          error: 'icon-exclamation-sign',
          expanderClosed: 'icon-caret-right',
          expanderLazy: 'icon-angle-right',
          expanderOpen: 'icon-caret-down',
          doc: 'icon-file-alt',
          noExpander: '',
          docOpen: 'icon-file-alt',
          loading: 'icon-refresh icon-spin',
          folder: 'icon-folder-close-alt',
          folderOpen: 'icon-folder-open-alt',
        },
      },
      treeInit: function (a) {
        var b = a.tree;
        this._superApply(arguments), b.$container.addClass('fancytree-ext-glyph');
      },
      nodeRenderStatus: function (c) {
        var d,
          e,
          f = c.node,
          g = a(f.span),
          h = c.options.glyph,
          i = h.map;
        this._superApply(arguments),
          f.isRoot() ||
            ((e = g.children('span.fancytree-expander').get(0)),
            e &&
              ((d = f.isLoading()
                ? 'loading'
                : f.expanded
                  ? 'expanderOpen'
                  : f.isUndefined()
                    ? 'expanderLazy'
                    : f.hasChildren()
                      ? 'expanderClosed'
                      : 'noExpander'),
              (e.className = 'fancytree-expander ' + i[d])),
            (e = f.tr
              ? a('td', f.tr).children('span.fancytree-checkbox').get(0)
              : g.children('span.fancytree-checkbox').get(0)),
            e &&
              ((d = f.selected ? 'checkboxSelected' : f.partsel ? 'checkboxUnknown' : 'checkbox'),
              (e.className = 'fancytree-checkbox ' + i[d])),
            (e = g.children('span.fancytree-icon').get(0)),
            e &&
              ((d = f.folder
                ? f.expanded
                  ? b(h, 'folderOpen')
                  : b(h, 'folder')
                : f.expanded
                  ? b(h, 'docOpen')
                  : b(h, 'doc')),
              (e.className = 'fancytree-icon ' + d)));
      },
      nodeSetStatus: function (c, d) {
        var e,
          f = c.options.glyph,
          g = c.node;
        this._superApply(arguments),
          (e = g.parent
            ? a('span.fancytree-expander', g.span).get(0)
            : a(
                '.fancytree-statusnode-wait, .fancytree-statusnode-error',
                g[this.nodeContainerAttrName],
              )
                .find('span.fancytree-expander')
                .get(0)),
          'loading' === d
            ? (e.className = 'fancytree-expander ' + b(f, 'loading'))
            : 'error' === d && (e.className = 'fancytree-expander ' + b(f, 'error'));
      },
    });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.gridnav.min.js' */
  !(function (a) {
    'use strict';
    function b(b, c) {
      var d,
        e = c.get(0),
        f = 0;
      return (
        b.children().each(function () {
          return this === e ? !1 : ((d = a(this).prop('colspan')), void (f += d ? d : 1));
        }),
        f
      );
    }
    function c(b, c) {
      var d,
        e = null,
        f = 0;
      return (
        b.children().each(function () {
          return f >= c
            ? ((e = a(this)), !1)
            : ((d = a(this).prop('colspan')), void (f += d ? d : 1));
        }),
        e
      );
    }
    function d(a, d) {
      var f,
        g,
        h = a.closest('td'),
        i = null;
      switch (d) {
        case e.LEFT:
          i = h.prev();
          break;
        case e.RIGHT:
          i = h.next();
          break;
        case e.UP:
        case e.DOWN:
          for (f = h.parent(), g = b(f, h); ; ) {
            if (((f = d === e.UP ? f.prev() : f.next()), !f.length)) break;
            if (!f.is(':hidden') && ((i = c(f, g)), i && i.find(':input').length)) break;
          }
      }
      return i;
    }
    var e = a.ui.keyCode,
      f = {
        text: [e.UP, e.DOWN],
        checkbox: [e.UP, e.DOWN, e.LEFT, e.RIGHT],
        radiobutton: [e.UP, e.DOWN, e.LEFT, e.RIGHT],
        'select-one': [e.LEFT, e.RIGHT],
        'select-multiple': [e.LEFT, e.RIGHT],
      };
    a.ui.fancytree.registerExtension({
      name: 'gridnav',
      version: '0.0.1',
      options: { autofocusInput: !1, handleCursorKeys: !0 },
      treeInit: function (b) {
        this._requireExtension('table', !0, !0),
          this._superApply(arguments),
          this.$container.addClass('fancytree-ext-gridnav'),
          this.$container.on('focusin', function (c) {
            var d,
              e = a.ui.fancytree.getNode(c.target);
            e &&
              !e.isActive() &&
              ((d = b.tree._makeHookContext(e, c)), b.tree._callHook('nodeSetActive', d, !0));
          });
      },
      nodeSetActive: function (b, c) {
        var d,
          e = b.options.gridnav,
          f = b.node,
          g = b.originalEvent || {},
          h = a(g.target).is(':input');
        (c = c !== !1),
          this._superApply(arguments),
          c &&
            (b.options.titlesTabbable
              ? (h || (a(f.span).find('span.fancytree-title').focus(), f.setFocus()),
                b.tree.$container.attr('tabindex', '-1'))
              : e.autofocusInput &&
                !h &&
                ((d = a(f.tr || f.span)), d.find(':input:enabled:first').focus()));
      },
      nodeKeydown: function (b) {
        var c,
          e,
          g,
          h = b.options.gridnav,
          i = b.originalEvent,
          j = a(i.target);
        return (
          (c = j.is(':input:enabled') ? j.prop('type') : null),
          c && h.handleCursorKeys
            ? ((e = f[c]),
              e && a.inArray(i.which, e) >= 0 && ((g = d(j, i.which)), g && g.length)
                ? (g.find(':input:enabled').focus(), !1)
                : !0)
            : this._superApply(arguments)
        );
      },
    });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.persist.min.js' */
  !(function (a, b, c, d) {
    'use strict';
    function e(b, c, d, f, g) {
      var i,
        j,
        k,
        l,
        m = !1,
        n = [],
        o = [];
      for (d = d || [], g = g || a.Deferred(), i = 0, k = d.length; k > i; i++)
        (j = d[i]),
          (l = b.getNodeByKey(j)),
          l
            ? f && l.isUndefined()
              ? ((m = !0),
                b.debug('_loadLazyNodes: ' + l + ' is lazy: loading...'),
                n.push('expand' === f ? l.setExpanded() : l.load()))
              : (b.debug('_loadLazyNodes: ' + l + ' already loaded.'), l.setExpanded())
            : (o.push(j), b.debug('_loadLazyNodes: ' + l + ' was not yet found.'));
      return (
        a.when.apply(a, n).always(function () {
          if (m && o.length > 0) e(b, c, o, f, g);
          else {
            if (o.length)
              for (
                b.warn('_loadLazyNodes: could not load those keys: ', o), i = 0, k = o.length;
                k > i;
                i++
              )
                (j = d[i]), c._appendKey(h, d[i], !1);
            g.resolve();
          }
        }),
        g
      );
    }
    var f = a.ui.fancytree.assert,
      g = 'active',
      h = 'expanded',
      i = 'focus',
      j = 'selected';
    (a.ui.fancytree._FancytreeClass.prototype.clearCookies = function (a) {
      var b = this.ext.persist,
        c = b.cookiePrefix;
      (a = a || 'active expanded focus selected'),
        a.indexOf(g) >= 0 && b._data(c + g, null),
        a.indexOf(h) >= 0 && b._data(c + h, null),
        a.indexOf(i) >= 0 && b._data(c + i, null),
        a.indexOf(j) >= 0 && b._data(c + j, null);
    }),
      (a.ui.fancytree._FancytreeClass.prototype.getPersistData = function () {
        var a = this.ext.persist,
          b = a.cookiePrefix,
          c = a.cookieDelimiter,
          d = {};
        return (
          (d[g] = a._data(b + g)),
          (d[h] = (a._data(b + h) || '').split(c)),
          (d[j] = (a._data(b + j) || '').split(c)),
          (d[i] = a._data(b + i)),
          d
        );
      }),
      a.ui.fancytree.registerExtension({
        name: 'persist',
        version: '0.3.0',
        options: {
          cookieDelimiter: '~',
          cookiePrefix: d,
          cookie: { raw: !1, expires: '', path: '', domain: '', secure: !1 },
          expandLazy: !1,
          overrideSource: !0,
          store: 'auto',
          types: 'active expanded focus selected',
        },
        _data: function (b, c) {
          var e = this._local.localStorage;
          return c === d
            ? e
              ? e.getItem(b)
              : a.cookie(b)
            : void (null === c
                ? e
                  ? e.removeItem(b)
                  : a.removeCookie(b)
                : e
                  ? e.setItem(b, c)
                  : a.cookie(b, c, this.options.persist.cookie));
        },
        _appendKey: function (b, c, d) {
          c = '' + c;
          var e = this._local,
            f = this.options.persist,
            g = f.cookieDelimiter,
            h = e.cookiePrefix + b,
            i = e._data(h),
            j = i ? i.split(g) : [],
            k = a.inArray(c, j);
          k >= 0 && j.splice(k, 1), d && j.push(c), e._data(h, j.join(g));
        },
        treeInit: function (c) {
          var k = c.tree,
            l = c.options,
            m = this._local,
            n = this.options.persist;
          return (
            f(
              'localStore' === n.store || a.cookie,
              "Missing required plugin for 'persist' extension: jquery.cookie.js",
            ),
            (m.cookiePrefix = n.cookiePrefix || 'fancytree-' + k._id + '-'),
            (m.storeActive = n.types.indexOf(g) >= 0),
            (m.storeExpanded = n.types.indexOf(h) >= 0),
            (m.storeSelected = n.types.indexOf(j) >= 0),
            (m.storeFocus = n.types.indexOf(i) >= 0),
            (m.localStorage =
              'cookie' !== n.store && b.localStorage
                ? 'local' === n.store
                  ? b.localStorage
                  : b.sessionStorage
                : null),
            k.$div.bind('fancytreeinit', function () {
              var b,
                c,
                f,
                o,
                p,
                q = m._data(m.cookiePrefix + i);
              (b = m._data(m.cookiePrefix + h)),
                (o = b && b.split(n.cookieDelimiter)),
                (c = m.storeExpanded
                  ? e(k, m, o, n.expandLazy ? 'expand' : !1, null)
                  : new a.Deferred().resolve()),
                c.done(function () {
                  if (m.storeSelected) {
                    if ((b = m._data(m.cookiePrefix + j)))
                      for (o = b.split(n.cookieDelimiter), f = 0; f < o.length; f++)
                        (p = k.getNodeByKey(o[f])),
                          p
                            ? (p.selected === d || (n.overrideSource && p.selected === !1)) &&
                              ((p.selected = !0), p.renderStatus())
                            : m._appendKey(j, o[f], !1);
                    3 === k.options.selectMode &&
                      k.visit(function (a) {
                        return a.selected ? (a.fixSelection3AfterClick(), 'skip') : void 0;
                      });
                  }
                  m.storeActive &&
                    ((b = m._data(m.cookiePrefix + g)),
                    !b ||
                      (!l.persist.overrideSource && k.activeNode) ||
                      ((p = k.getNodeByKey(b)),
                      p && (p.debug('persist: set active', b), p.setActive(!0, { noFocus: !0 })))),
                    m.storeFocus &&
                      q &&
                      ((p = k.getNodeByKey(q)),
                      p &&
                        (k.options.titlesTabbable
                          ? a(p.span).find('.fancytree-title').focus()
                          : a(k.$container).focus())),
                    k._triggerTreeEvent('restore', null, {});
                });
            }),
            this._superApply(arguments)
          );
        },
        nodeSetActive: function (a, b) {
          var c,
            d = this._local;
          return (
            (b = b !== !1),
            (c = this._superApply(arguments)),
            d.storeActive &&
              d._data(d.cookiePrefix + g, this.activeNode ? this.activeNode.key : null),
            c
          );
        },
        nodeSetExpanded: function (a, b) {
          var c,
            d = a.node,
            e = this._local;
          return (
            (b = b !== !1),
            (c = this._superApply(arguments)),
            e.storeExpanded && e._appendKey(h, d.key, b),
            c
          );
        },
        nodeSetFocus: function (a, b) {
          var c,
            d = this._local;
          return (
            (b = b !== !1),
            (c = this._superApply(arguments)),
            d.storeFocus && d._data(d.cookiePrefix + i, this.focusNode ? this.focusNode.key : null),
            c
          );
        },
        nodeSetSelected: function (b, c) {
          var d,
            e,
            f = b.tree,
            g = b.node,
            h = this._local;
          return (
            (c = c !== !1),
            (d = this._superApply(arguments)),
            h.storeSelected &&
              (3 === f.options.selectMode
                ? ((e = a.map(f.getSelectedNodes(!0), function (a) {
                    return a.key;
                  })),
                  (e = e.join(b.options.persist.cookieDelimiter)),
                  h._data(h.cookiePrefix + j, e))
                : h._appendKey(j, g.key, c)),
            d
          );
        },
      });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.table.min.js' */
  !(function (a, b, c) {
    'use strict';
    function d(b, c) {
      (c = c || ''), b || a.error('Assertion failed ' + c);
    }
    function e(a, b) {
      a.parentNode.insertBefore(b, a.nextSibling);
    }
    function f(a, b) {
      a.visit(function (a) {
        var c = a.tr;
        return c && (c.style.display = a.hide || !b ? 'none' : ''), a.expanded ? void 0 : 'skip';
      });
    }
    function g(b) {
      var c,
        e,
        f,
        g = b.parent,
        h = g ? g.children : null;
      if (h && h.length > 1 && h[0] !== b)
        for (
          c = a.inArray(b, h), f = h[c - 1], d(f.tr);
          f.children && ((e = f.children[f.children.length - 1]), e.tr);

        )
          f = e;
      else f = g;
      return f;
    }
    a.ui.fancytree.registerExtension({
      name: 'table',
      version: '0.2.1',
      options: { checkboxColumnIdx: null, customStatus: !1, indentation: 16, nodeColumnIdx: 0 },
      treeInit: function (b) {
        var d,
          e,
          f,
          g = b.tree,
          h = g.widget.element;
        for (
          h.addClass('fancytree-container fancytree-ext-table'),
            g.tbody = h.find('> tbody')[0],
            g.columnCount = a('thead >tr >th', h).length,
            a(g.tbody).empty(),
            g.rowFragment = c.createDocumentFragment(),
            e = a('<tr />'),
            f = '',
            b.options.aria && (e.attr('role', 'row'), (f = " role='gridcell'")),
            d = 0;
          d < g.columnCount;
          d++
        )
          e.append(
            b.options.table.nodeColumnIdx === d
              ? '<td' + f + "><span class='fancytree-node' /></td>"
              : '<td' + f + ' />',
          );
        g.rowFragment.appendChild(e.get(0)),
          (g.statusClassPropName = 'tr'),
          (g.ariaPropName = 'tr'),
          (this.nodeContainerAttrName = 'tr'),
          this._superApply(arguments),
          a(g.rootNode.ul).remove(),
          (g.rootNode.ul = null),
          (g.$container = h),
          this.$container.attr('tabindex', this.options.tabbable ? '0' : '-1'),
          this.options.aria && g.$container.attr('role', 'treegrid').attr('aria-readonly', !0);
      },
      nodeRemoveChildMarkup: function (b) {
        var c = b.node;
        c.visit(function (b) {
          b.tr && (a(b.tr).remove(), (b.tr = null));
        });
      },
      nodeRemoveMarkup: function (b) {
        var c = b.node;
        c.tr && (a(c.tr).remove(), (c.tr = null)), this.nodeRemoveChildMarkup(b);
      },
      nodeRender: function (b, c, h, i, j) {
        var k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s = b.tree,
          t = b.node,
          u = b.options,
          v = !t.parent;
        if ((j || (b.hasCollapsedParents = t.parent && !t.parent.expanded), !v))
          if (t.tr) c ? this.nodeRenderTitle(b) : this.nodeRenderStatus(b);
          else {
            if (b.hasCollapsedParents)
              return void t.debug('nodeRender ignored due to unrendered parent');
            (o = s.rowFragment.firstChild.cloneNode(!0)),
              (p = g(t)),
              d(p),
              i === !0 && j
                ? (o.style.display = 'none')
                : h && b.hasCollapsedParents && (o.style.display = 'none'),
              p.tr
                ? e(p.tr, o)
                : (d(!p.parent, 'prev. row must have a tr, or is system root'),
                  s.tbody.appendChild(o)),
              (t.tr = o),
              t.key && u.generateIds && (t.tr.id = u.idPrefix + t.key),
              (t.tr.ftnode = t),
              u.aria && a(t.tr).attr('aria-labelledby', 'ftal_' + t.key),
              (t.span = a('span.fancytree-node', t.tr).get(0)),
              this.nodeRenderTitle(b),
              u.createNode && u.createNode.call(s, { type: 'createNode' }, b);
          }
        if (
          (u.renderNode && u.renderNode.call(s, { type: 'renderNode' }, b),
          (k = t.children),
          k && (v || h || t.expanded))
        )
          for (m = 0, n = k.length; n > m; m++)
            (r = a.extend({}, b, { node: k[m] })),
              (r.hasCollapsedParents = r.hasCollapsedParents || !t.expanded),
              this.nodeRender(r, c, h, i, !0);
        k &&
          !j &&
          ((q = t.tr || null),
          (l = s.tbody.firstChild),
          t.visit(function (a) {
            if (a.tr) {
              if (
                (a.parent.expanded ||
                  'none' === a.tr.style.display ||
                  ((a.tr.style.display = 'none'), f(a, !1)),
                a.tr.previousSibling !== q)
              ) {
                t.debug('_fixOrder: mismatch at node: ' + a);
                var b = q ? q.nextSibling : l;
                s.tbody.insertBefore(a.tr, b);
              }
              q = a.tr;
            }
          }));
      },
      nodeRenderTitle: function (b) {
        var c,
          d = b.node,
          e = b.options;
        this._superApply(arguments),
          e.checkbox &&
            null != e.table.checkboxColumnIdx &&
            ((c = a('span.fancytree-checkbox', d.span).detach()),
            a(d.tr).find('td').eq(+e.table.checkboxColumnIdx).html(c)),
          d.isRoot() || this.nodeRenderStatus(b),
          (!e.table.customStatus && d.isStatusNode()) ||
            (e.renderColumns && e.renderColumns.call(b.tree, { type: 'renderColumns' }, b));
      },
      nodeRenderStatus: function (b) {
        var c,
          d = b.node,
          e = b.options;
        this._superApply(arguments),
          a(d.tr).removeClass('fancytree-node'),
          (c = (d.getLevel() - 1) * e.table.indentation),
          a(d.span).css({ marginLeft: c + 'px' });
      },
      nodeSetExpanded: function (b, c, d) {
        function e(a) {
          (c = c !== !1),
            f(b.node, c),
            a
              ? c && b.options.autoScroll && !d.noAnimation && b.node.hasChildren()
                ? b.node
                    .getLastChild()
                    .scrollIntoView(!0, { topNode: b.node })
                    .always(function () {
                      d.noEvents || b.tree._triggerNodeEvent(c ? 'expand' : 'collapse', b),
                        g.resolveWith(b.node);
                    })
                : (d.noEvents || b.tree._triggerNodeEvent(c ? 'expand' : 'collapse', b),
                  g.resolveWith(b.node))
              : (d.noEvents || b.tree._triggerNodeEvent(c ? 'expand' : 'collapse', b),
                g.rejectWith(b.node));
        }
        var g = new a.Deferred(),
          h = a.extend({}, d, { noEvents: !0, noAnimation: !0 });
        return (
          (d = d || {}),
          this._super(b, c, h)
            .done(function () {
              e(!0);
            })
            .fail(function () {
              e(!1);
            }),
          g.promise()
        );
      },
      nodeSetStatus: function (b, c) {
        if ('ok' === c) {
          var d = b.node,
            e = d.children ? d.children[0] : null;
          e && e.isStatusNode() && a(e.tr).remove();
        }
        return this._superApply(arguments);
      },
      treeClear: function () {
        return (
          this.nodeRemoveChildMarkup(this._makeHookContext(this.rootNode)),
          this._superApply(arguments)
        );
      },
    });
  })(jQuery, window, document);

  /*! Extension 'jquery.fancytree.themeroller.min.js' */
  !(function (a) {
    'use strict';
    a.ui.fancytree.registerExtension({
      name: 'themeroller',
      version: '0.0.1',
      options: {
        activeClass: 'ui-state-active',
        foccusClass: 'ui-state-focus',
        hoverClass: 'ui-state-hover',
        selectedClass: 'ui-state-highlight',
      },
      treeInit: function (b) {
        this._superApply(arguments);
        var c = b.widget.element;
        'TABLE' === c[0].nodeName
          ? (c.addClass('ui-widget ui-corner-all'),
            c.find('>thead tr').addClass('ui-widget-header'),
            c.find('>tbody').addClass('ui-widget-conent'))
          : c.addClass('ui-widget ui-widget-content ui-corner-all'),
          c.delegate('.fancytree-node', 'mouseenter mouseleave', function (b) {
            var c = a.ui.fancytree.getNode(b.target),
              d = 'mouseenter' === b.type;
            c.debug('hover: ' + d), a(c.span).toggleClass('ui-state-hover ui-corner-all', d);
          });
      },
      treeDestroy: function (a) {
        this._superApply(arguments),
          a.widget.element.removeClass('ui-widget ui-widget-content ui-corner-all');
      },
      nodeRenderStatus: function (b) {
        var c = b.node,
          d = a(c.span);
        this._superApply(arguments),
          d.toggleClass('ui-state-active', c.isActive()),
          d.toggleClass('ui-state-focus', c.hasFocus()),
          d.toggleClass('ui-state-highlight', c.isSelected());
      },
    });
  })(jQuery, window, document);
});