@amirjalili1374/ui-kit 1.5.57 → 1.5.59

package/dist/ui-kit.es.js

@@ -660,13 +660,13 @@ function animate(el, keyframes, options) {
   }
   return animation;
 }
-const handlers = /* @__PURE__ */ new WeakMap();
+const handlers$1 = /* @__PURE__ */ new WeakMap();
 function bindProps(el, props) {
   Object.keys(props).forEach((k) => {
     var _a;
     if (isOn(k)) {
       const name2 = eventName(k);
-      const handler = handlers.get(el);
+      const handler = handlers$1.get(el);
       if (props[k] == null) {
         handler == null ? void 0 : handler.forEach((v) => {
           const [n, fn] = v;
@@ -679,7 +679,7 @@ function bindProps(el, props) {
         el.addEventListener(name2, props[k]);
         const _handler = handler || /* @__PURE__ */ new Set();
         _handler.add([name2, props[k]]);
-        if (!handlers.has(el)) handlers.set(el, _handler);
+        if (!handlers$1.has(el)) handlers$1.set(el, _handler);
       }
     } else {
       if (props[k] == null) {
@@ -694,7 +694,7 @@ function unbindProps(el, props) {
   Object.keys(props).forEach((k) => {
     if (isOn(k)) {
       const name2 = eventName(k);
-      const handler = handlers.get(el);
+      const handler = handlers$1.get(el);
       handler == null ? void 0 : handler.forEach((v) => {
         const [n, fn] = v;
         if (n === name2) {
@@ -5684,10 +5684,10 @@ function useScrollStrategies(props, data2) {
   });
 }
 function closeScrollStrategy(data2) {
-  function onScroll(e) {
+  function onScroll2(e) {
     data2.isActive.value = false;
   }
-  bindScroll(getTargetEl(data2.target.value, data2.contentEl.value), onScroll);
+  bindScroll(getTargetEl(data2.target.value, data2.contentEl.value), onScroll2);
 }
 function blockScrollStrategy(data2, props) {
   var _a;
@@ -5730,7 +5730,7 @@ function repositionScrollStrategy(data2, props, scope) {
   let slow = false;
   let raf2 = -1;
   let ric = -1;
-  function update(e) {
+  function update2(e) {
     requestNewFrame(() => {
       var _a, _b;
       const start = performance.now();
@@ -5746,11 +5746,11 @@ function repositionScrollStrategy(data2, props, scope) {
           cancelAnimationFrame(raf2);
           raf2 = requestAnimationFrame(() => {
             raf2 = requestAnimationFrame(() => {
-              update(e);
+              update2(e);
             });
           });
         } else {
-          update(e);
+          update2(e);
         }
       });
     });
@@ -5763,16 +5763,16 @@ function repositionScrollStrategy(data2, props, scope) {
 function getTargetEl(target, contentEl) {
   return Array.isArray(target) ? document.elementsFromPoint(...target).find((el) => !(contentEl == null ? void 0 : contentEl.contains(el))) : target ?? contentEl;
 }
-function bindScroll(el, onScroll) {
+function bindScroll(el, onScroll2) {
   const scrollElements = [document, ...getScrollParents(el)];
   scrollElements.forEach((el2) => {
-    el2.addEventListener("scroll", onScroll, {
+    el2.addEventListener("scroll", onScroll2, {
       passive: true
     });
   });
   onScopeDispose(() => {
     scrollElements.forEach((el2) => {
-      el2.removeEventListener("scroll", onScroll);
+      el2.removeEventListener("scroll", onScroll2);
     });
   });
 }
@@ -7508,13 +7508,13 @@ function useValidation(props) {
     let value2 = (props.validateOn ?? ((_a = form.validateOn) == null ? void 0 : _a.value)) || "input";
     if (value2 === "lazy") value2 = "input lazy";
     if (value2 === "eager") value2 = "input eager";
-    const set = new Set((value2 == null ? void 0 : value2.split(" ")) ?? []);
+    const set2 = new Set((value2 == null ? void 0 : value2.split(" ")) ?? []);
     return {
-      input: set.has("input"),
-      blur: set.has("blur") || set.has("input") || set.has("invalid-input"),
-      invalidInput: set.has("invalid-input"),
-      lazy: set.has("lazy"),
-      eager: set.has("eager")
+      input: set2.has("input"),
+      blur: set2.has("blur") || set2.has("input") || set2.has("invalid-input"),
+      invalidInput: set2.has("invalid-input"),
+      lazy: set2.has("lazy"),
+      eager: set2.has("eager")
     };
   });
   const isValid = computed(() => {
@@ -8163,7 +8163,7 @@ const VSlideGroup = genericComponent()({
         goTo(newPosition, goToOptions.value);
       }
     }
-    function onScroll(e) {
+    function onScroll2(e) {
       const {
         scrollTop,
         scrollLeft
@@ -8325,7 +8325,7 @@ const VSlideGroup = genericComponent()({
           "key": "container",
           "ref": containerRef,
           "class": normalizeClass(["v-slide-group__container", props.contentClass]),
-          "onScroll": onScroll
+          "onScroll": onScroll2
         }, [createElementVNode("div", {
           "ref": contentRef,
           "class": "v-slide-group__content",
@@ -8837,19 +8837,19 @@ const independentActiveStrategy = (mandatory) => {
       return activated;
     },
     in: (v, children, parents) => {
-      let set = /* @__PURE__ */ new Set();
+      let set2 = /* @__PURE__ */ new Set();
       if (v != null) {
         for (const id of wrapInArray(v)) {
-          set = strategy.activate({
+          set2 = strategy.activate({
             id,
             value: true,
-            activated: new Set(set),
+            activated: new Set(set2),
             children,
             parents
           });
         }
       }
-      return set;
+      return set2;
     },
     out: (v) => {
       return Array.from(v);
@@ -8875,14 +8875,14 @@ const independentSingleActiveStrategy = (mandatory) => {
       });
     },
     in: (v, children, parents) => {
-      let set = /* @__PURE__ */ new Set();
+      let set2 = /* @__PURE__ */ new Set();
       if (v != null) {
         const arr = wrapInArray(v);
         if (arr.length) {
-          set = parentStrategy.in(arr.slice(0, 1), children, parents);
+          set2 = parentStrategy.in(arr.slice(0, 1), children, parents);
         }
       }
-      return set;
+      return set2;
     },
     out: (v, children, parents) => {
       return parentStrategy.out(v, children, parents);
@@ -12163,11 +12163,11 @@ function useFilter(props, items, query, options) {
     results.forEach((_ref) => {
       let {
         index: index2,
-        matches
+        matches: matches2
       } = _ref;
       const item = originalItems[index2];
       _filteredItems.push(item);
-      _filteredMatches.set(item.value, matches);
+      _filteredMatches.set(item.value, matches2);
     });
     filteredItems.value = _filteredItems;
     filteredMatches.value = _filteredMatches;
@@ -12181,16 +12181,16 @@ function useFilter(props, items, query, options) {
     getMatches
   };
 }
-function highlightResult(name2, text2, matches) {
-  if (matches == null || !matches.length) return text2;
-  return matches.map((match, i) => {
-    const start = i === 0 ? 0 : matches[i - 1][1];
+function highlightResult(name2, text2, matches2) {
+  if (matches2 == null || !matches2.length) return text2;
+  return matches2.map((match, i) => {
+    const start = i === 0 ? 0 : matches2[i - 1][1];
     const result = [createElementVNode("span", {
       "class": normalizeClass(`${name2}__unmask`)
     }, [text2.slice(start, match[0])]), createElementVNode("span", {
       "class": normalizeClass(`${name2}__mask`)
     }, [text2.slice(match[0], match[1])])];
-    if (i === matches.length - 1) {
+    if (i === matches2.length - 1) {
       result.push(createElementVNode("span", {
         "class": normalizeClass(`${name2}__unmask`)
       }, [text2.slice(match[1])]));
@@ -12455,11 +12455,11 @@ const VSelect = genericComponent()({
       }
     }
     function select(item) {
-      let set = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+      let set2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
       if (item.props.disabled) return;
       if (props.multiple) {
         const index2 = model.value.findIndex((selection) => (props.valueComparator || deepEqual)(selection.value, item.value));
-        const add2 = set == null ? !~index2 : set;
+        const add2 = set2 == null ? !~index2 : set2;
         if (~index2) {
           const value2 = add2 ? [...model.value, item] : [...model.value];
           value2.splice(index2, 1);
@@ -12468,7 +12468,7 @@ const VSelect = genericComponent()({
           model.value = [...model.value, item];
         }
       } else {
-        const add2 = set !== false;
+        const add2 = set2 !== false;
         model.value = add2 ? [item] : [];
         nextTick(() => {
           menu.value = false;
@@ -13055,11 +13055,11 @@ const VAutocomplete = genericComponent()({
     }
     const isSelecting = shallowRef(false);
     function select(item) {
-      let set = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+      let set2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
       if (!item || item.props.disabled) return;
       if (props.multiple) {
         const index2 = model.value.findIndex((selection) => (props.valueComparator || deepEqual)(selection.value, item.value));
-        const add2 = set == null ? !~index2 : set;
+        const add2 = set2 == null ? !~index2 : set2;
         if (~index2) {
           const value2 = add2 ? [...model.value, item] : [...model.value];
           value2.splice(index2, 1);
@@ -13071,7 +13071,7 @@ const VAutocomplete = genericComponent()({
           search.value = "";
         }
       } else {
-        const add2 = set !== false;
+        const add2 = set2 !== false;
         model.value = add2 ? [item] : [];
         _searchLock.value = isPristine.value ? "" : search.value ?? "";
         search.value = add2 && !hasSelectionSlot.value ? item.title : "";
@@ -14393,18 +14393,18 @@ function jalCal(jy, withoutLeap) {
     jump = jm - jp;
     if (jy < jm)
       break;
-    leapJ = leapJ + div(jump, 33) * 8 + div(mod(jump, 33), 4);
+    leapJ = leapJ + div$1(jump, 33) * 8 + div$1(mod(jump, 33), 4);
     jp = jm;
   }
   n = jy - jp;
-  leapJ = leapJ + div(n, 33) * 8 + div(mod(n, 33) + 3, 4);
+  leapJ = leapJ + div$1(n, 33) * 8 + div$1(mod(n, 33) + 3, 4);
   if (mod(jump, 33) === 4 && jump - n === 4)
     leapJ += 1;
-  leapG = div(gy, 4) - div((div(gy, 100) + 1) * 3, 4) - 150;
+  leapG = div$1(gy, 4) - div$1((div$1(gy, 100) + 1) * 3, 4) - 150;
   march = 20 + leapJ - leapG;
   if (withoutLeap) return { gy, march };
   if (jump - n < 6)
-    n = n - jump + div(jump + 4, 33) * 33;
+    n = n - jump + div$1(jump + 4, 33) * 33;
   leap = mod(mod(n + 1, 33) - 1, 4);
   if (leap === -1) {
     leap = 4;
@@ -14417,14 +14417,14 @@ function jalCal(jy, withoutLeap) {
 }
 function j2d(jy, jm, jd) {
   var r = jalCal(jy, true);
-  return g2d(r.gy, 3, r.march) + (jm - 1) * 31 - div(jm, 7) * (jm - 7) + jd - 1;
+  return g2d(r.gy, 3, r.march) + (jm - 1) * 31 - div$1(jm, 7) * (jm - 7) + jd - 1;
 }
 function d2j(jdn) {
   var gy = d2g(jdn).gy, jy = gy - 621, r = jalCal(jy, false), jdn1f = g2d(gy, 3, r.march), jd, jm, k;
   k = jdn - jdn1f;
   if (k >= 0) {
     if (k <= 185) {
-      jm = 1 + div(k, 31);
+      jm = 1 + div$1(k, 31);
       jd = mod(k, 31) + 1;
       return {
         jy,
@@ -14440,7 +14440,7 @@ function d2j(jdn) {
     if (r.leap === 1)
       k += 1;
   }
-  jm = 7 + div(k, 30);
+  jm = 7 + div$1(k, 30);
   jd = mod(k, 30) + 1;
   return {
     jy,
@@ -14449,25 +14449,25 @@ function d2j(jdn) {
   };
 }
 function g2d(gy, gm, gd) {
-  var d = div((gy + div(gm - 8, 6) + 100100) * 1461, 4) + div(153 * mod(gm + 9, 12) + 2, 5) + gd - 34840408;
-  d = d - div(div(gy + 100100 + div(gm - 8, 6), 100) * 3, 4) + 752;
+  var d = div$1((gy + div$1(gm - 8, 6) + 100100) * 1461, 4) + div$1(153 * mod(gm + 9, 12) + 2, 5) + gd - 34840408;
+  d = d - div$1(div$1(gy + 100100 + div$1(gm - 8, 6), 100) * 3, 4) + 752;
   return d;
 }
 function d2g(jdn) {
   var j, i, gd, gm, gy;
   j = 4 * jdn + 139361631;
-  j = j + div(div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908;
-  i = div(mod(j, 1461), 4) * 5 + 308;
-  gd = div(mod(i, 153), 5) + 1;
-  gm = mod(div(i, 153), 12) + 1;
-  gy = div(j, 1461) - 100100 + div(8 - gm, 6);
+  j = j + div$1(div$1(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908;
+  i = div$1(mod(j, 1461), 4) * 5 + 308;
+  gd = div$1(mod(i, 153), 5) + 1;
+  gm = mod(div$1(i, 153), 12) + 1;
+  gy = div$1(j, 1461) - 100100 + div$1(8 - gm, 6);
   return {
     gy,
     gm,
     gd
   };
 }
-function div(a, b) {
+function div$1(a, b) {
   return ~~(a / b);
 }
 function mod(a, b) {
@@ -20671,7 +20671,8 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent$1({
         createVNode(VDialog, {
           modelValue: filterDialog.value,
           "onUpdate:modelValue": _cache[18] || (_cache[18] = ($event) => filterDialog.value = $event),
-          "max-width": "1500"
+          "max-width": "1600",
+          "content-class": "white-list-filter-dialog"
         }, {
           default: withCtx(() => [
             createVNode(VCard, null, {
@@ -20712,7 +20713,6 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent$1({
                                       variant: "underlined",
                                       "hide-details": "",
                                       class: "mb-1",
-                                      attach: "",
                                       "menu-props": { zIndex: 2e4 }
                                     }, null, 8, ["modelValue", "onUpdate:modelValue", "items"])) : createCommentVNode("", true),
                                     isDateHeader(header) ? (openBlock(), createBlock(ShamsiDatePicker, {
@@ -20737,7 +20737,6 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent$1({
                                       disabled: isHeaderDisabled(header),
                                       clearable: "",
                                       variant: "outlined",
-                                      attach: "",
                                       "menu-props": { zIndex: 2e4 }
                                     }, null, 8, ["modelValue", "onUpdate:modelValue", "label", "items", "item-title", "item-value", "return-object", "multiple", "chips", "closable-chips", "disabled"])) : isMoneyHeader(header) ? (openBlock(), createBlock(_sfc_main$i, {
                                       key: 3,
@@ -23211,7 +23210,7 @@ var lottie = { exports: {} };
         }
         return null;
       }
-      function destroy() {
+      function destroy2() {
         this.imagesLoadedCb = null;
         this.images.length = 0;
       }
@@ -23249,7 +23248,7 @@ var lottie = { exports: {} };
         setPath,
         loadedImages,
         loadedFootages,
-        destroy,
+        destroy: destroy2,
         getAsset,
         createImgData,
         createImageData,
@@ -24191,7 +24190,7 @@ var lottie = { exports: {} };
           registeredAnimations[i].animation.togglePause(animation);
         }
       }
-      function destroy(animation) {
+      function destroy2(animation) {
         var i;
         for (i = len - 1; i >= 0; i -= 1) {
           registeredAnimations[i].animation.destroy(animation);
@@ -24271,7 +24270,7 @@ var lottie = { exports: {} };
       moduleOb.searchAnimations = searchAnimations2;
       moduleOb.resize = resize;
       moduleOb.goToAndStop = goToAndStop;
-      moduleOb.destroy = destroy;
+      moduleOb.destroy = destroy2;
       moduleOb.freeze = freeze;
       moduleOb.unfreeze = unfreeze;
       moduleOb.setVolume = setVolume;
@@ -24306,14 +24305,14 @@ var lottie = { exports: {} };
       function B(aA1, aA2) {
         return 3 * aA2 - 6 * aA1;
       }
-      function C(aA1) {
+      function C2(aA1) {
         return 3 * aA1;
       }
       function calcBezier(aT, aA1, aA2) {
-        return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+        return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C2(aA1)) * aT;
       }
       function getSlope(aT, aA1, aA2) {
-        return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
+        return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C2(aA1);
       }
       function binarySubdivide(aX, aA, aB, mX1, mX2) {
         var currentX, currentT, i = 0;
@@ -24344,7 +24343,7 @@ var lottie = { exports: {} };
         this.get = this.get.bind(this);
       }
       BezierEasing.prototype = {
-        get: function get(x) {
+        get: function get2(x) {
           var mX1 = this._p[0], mY1 = this._p[1], mX2 = this._p[2], mY2 = this._p[3];
           if (!this._precomputed) this._precompute();
           if (mX1 === mY1 && mX2 === mY2) return x;
@@ -29491,7 +29490,7 @@ var lottie = { exports: {} };
           this.prepareProperties(num, this.isInRange);
           this.checkTransparency();
         },
-        destroy: function destroy() {
+        destroy: function destroy2() {
           this.innerElem = null;
           this.destroyBaseElement();
         }
@@ -32756,7 +32755,7 @@ var lottie = { exports: {} };
           this._isFirstFrame = false;
         }
       },
-      destroy: function destroy() {
+      destroy: function destroy2() {
         this.canvasContext = null;
         this.data = null;
         this.globalData = null;
@@ -34102,7 +34101,7 @@ var lottie = { exports: {} };
           this._isFirstFrame = false;
         }
       },
-      destroy: function destroy() {
+      destroy: function destroy2() {
         this.layerElement = null;
         this.transformedElement = null;
         if (this.matteElement) {
@@ -35678,7 +35677,7 @@ var lottie = { exports: {} };
         var thisProperty = property;
         thisProperty.valueAtTime = thisProperty.getValueAtTime;
         Object.defineProperty(thisProperty, "value", {
-          get: function get() {
+          get: function get2() {
             return thisProperty.v;
           }
         });
@@ -36019,7 +36018,7 @@ var lottie = { exports: {} };
         this._data = data2;
       }
       Object.defineProperty(MaskInterface.prototype, "maskPath", {
-        get: function get() {
+        get: function get2() {
           if (this._mask.prop.k) {
             this._mask.prop.getValue();
           }
@@ -36027,7 +36026,7 @@ var lottie = { exports: {} };
         }
       });
       Object.defineProperty(MaskInterface.prototype, "maskOpacity", {
-        get: function get() {
+        get: function get2() {
           if (this._mask.op.k) {
             this._mask.op.getValue();
           }
@@ -36068,7 +36067,7 @@ var lottie = { exports: {} };
       };
       function completeProperty(expressionValue, property2, type) {
         Object.defineProperty(expressionValue, "velocity", {
-          get: function get() {
+          get: function get2() {
             return property2.getVelocityAtTime(property2.comp.currentFrame);
           }
         });
@@ -36224,7 +36223,7 @@ var lottie = { exports: {} };
           }
         }
         Object.defineProperty(_thisFunction, "position", {
-          get: function get() {
+          get: function get2() {
             if (transform2.p) {
               return _transformFactory();
             }
@@ -36376,12 +36375,12 @@ var lottie = { exports: {} };
         var anchorPointDescriptor = getDescriptor(transformInterface, "anchorPoint");
         Object.defineProperties(_thisLayerFunction, {
           hasParent: {
-            get: function get() {
+            get: function get2() {
               return elem2.hierarchy.length;
             }
           },
           parent: {
-            get: function get() {
+            get: function get2() {
               return elem2.hierarchy[0].layerInterface;
             }
           },
@@ -36392,12 +36391,12 @@ var lottie = { exports: {} };
           anchorPoint: anchorPointDescriptor,
           anchor_point: anchorPointDescriptor,
           transform: {
-            get: function get() {
+            get: function get2() {
               return transformInterface;
             }
           },
           active: {
-            get: function get() {
+            get: function get2() {
               return elem2.isInRange;
             }
           }
@@ -36467,7 +36466,7 @@ var lottie = { exports: {} };
             return null;
           };
           Object.defineProperty(groupInterface, "numProperties", {
-            get: function get() {
+            get: function get2() {
               return effects.length;
             }
           });
@@ -36504,14 +36503,14 @@ var lottie = { exports: {} };
         }
         if (data2.mn === "ADBE Color Control") {
           Object.defineProperty(groupInterface, "color", {
-            get: function get() {
+            get: function get2() {
               return effectElements[0]();
             }
           });
         }
         Object.defineProperties(groupInterface, {
           numProperties: {
-            get: function get() {
+            get: function get2() {
               return data2.np;
             }
           },
@@ -36554,7 +36553,7 @@ var lottie = { exports: {} };
         prop.setGroupProperty(PropertyInterface("Path", _propertyGroup));
         Object.defineProperties(interfaceFunction, {
           path: {
-            get: function get() {
+            get: function get2() {
               if (prop.k) {
                 prop.getValue();
               }
@@ -36562,7 +36561,7 @@ var lottie = { exports: {} };
             }
           },
           shape: {
-            get: function get() {
+            get: function get2() {
               if (prop.k) {
                 prop.getValue();
               }
@@ -36665,7 +36664,7 @@ var lottie = { exports: {} };
         interfaceFunction.content = content2;
         interfaceFunction.transform = transformInterface;
         Object.defineProperty(interfaceFunction, "_name", {
-          get: function get() {
+          get: function get2() {
             return shape.nm;
           }
         });
@@ -36727,7 +36726,7 @@ var lottie = { exports: {} };
             get: ExpressionPropertyInterface(view.o)
           },
           type: {
-            get: function get() {
+            get: function get2() {
               return "a";
             }
           },
@@ -36787,7 +36786,7 @@ var lottie = { exports: {} };
             get: ExpressionPropertyInterface(view.w)
           },
           dash: {
-            get: function get() {
+            get: function get2() {
               return dashOb;
             }
           },
@@ -37131,14 +37130,14 @@ var lottie = { exports: {} };
           }
         }
         Object.defineProperty(_thisLayerFunction, "sourceText", {
-          get: function get() {
+          get: function get2() {
             elem2.textProperty.getValue();
             var stringValue = elem2.textProperty.currentData.t;
             if (!_sourceText || stringValue !== _sourceText.value) {
               _sourceText = new String(stringValue);
               _sourceText.value = stringValue || new String(stringValue);
               Object.defineProperty(_sourceText, "style", {
-                get: function get2() {
+                get: function get3() {
                   return {
                     fillColor: elem2.textProperty.currentData.fc
                   };
@@ -38653,7 +38652,7 @@ const _sfc_main$7 = defineComponent$1({
         lottieAnimation.stop();
       }
     };
-    const destroy = () => {
+    const destroy2 = () => {
       if (lottieAnimation) {
         lottieAnimation.destroy();
       }
@@ -38713,7 +38712,7 @@ const _sfc_main$7 = defineComponent$1({
       play,
       pause,
       stop,
-      destroy,
+      destroy: destroy2,
       setSpeed,
       setDirection,
       goToAndStop,
@@ -38976,6 +38975,1095 @@ const _sfc_main$3 = {
     };
   }
 };
+/*!
+ * perfect-scrollbar v1.5.6
+ * Copyright 2024 Hyunje Jun, MDBootstrap and Contributors
+ * Licensed under MIT
+ */
+function get(element) {
+  return getComputedStyle(element);
+}
+function set(element, obj) {
+  for (var key2 in obj) {
+    var val2 = obj[key2];
+    if (typeof val2 === "number") {
+      val2 = val2 + "px";
+    }
+    element.style[key2] = val2;
+  }
+  return element;
+}
+function div(className) {
+  var div2 = document.createElement("div");
+  div2.className = className;
+  return div2;
+}
+var elMatches = typeof Element !== "undefined" && (Element.prototype.matches || Element.prototype.webkitMatchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector);
+function matches(element, query) {
+  if (!elMatches) {
+    throw new Error("No element matching method supported");
+  }
+  return elMatches.call(element, query);
+}
+function remove(element) {
+  if (element.remove) {
+    element.remove();
+  } else {
+    if (element.parentNode) {
+      element.parentNode.removeChild(element);
+    }
+  }
+}
+function queryChildren(element, selector) {
+  return Array.prototype.filter.call(
+    element.children,
+    function(child) {
+      return matches(child, selector);
+    }
+  );
+}
+var cls = {
+  main: "ps",
+  rtl: "ps__rtl",
+  element: {
+    thumb: function(x) {
+      return "ps__thumb-" + x;
+    },
+    rail: function(x) {
+      return "ps__rail-" + x;
+    },
+    consuming: "ps__child--consume"
+  },
+  state: {
+    focus: "ps--focus",
+    clicking: "ps--clicking",
+    active: function(x) {
+      return "ps--active-" + x;
+    },
+    scrolling: function(x) {
+      return "ps--scrolling-" + x;
+    }
+  }
+};
+var scrollingClassTimeout = { x: null, y: null };
+function addScrollingClass(i, x) {
+  var classList = i.element.classList;
+  var className = cls.state.scrolling(x);
+  if (classList.contains(className)) {
+    clearTimeout(scrollingClassTimeout[x]);
+  } else {
+    classList.add(className);
+  }
+}
+function removeScrollingClass(i, x) {
+  scrollingClassTimeout[x] = setTimeout(
+    function() {
+      return i.isAlive && i.element.classList.remove(cls.state.scrolling(x));
+    },
+    i.settings.scrollingThreshold
+  );
+}
+function setScrollingClassInstantly(i, x) {
+  addScrollingClass(i, x);
+  removeScrollingClass(i, x);
+}
+var EventElement = function EventElement2(element) {
+  this.element = element;
+  this.handlers = {};
+};
+var prototypeAccessors = { isEmpty: { configurable: true } };
+EventElement.prototype.bind = function bind(eventName2, handler) {
+  if (typeof this.handlers[eventName2] === "undefined") {
+    this.handlers[eventName2] = [];
+  }
+  this.handlers[eventName2].push(handler);
+  this.element.addEventListener(eventName2, handler, false);
+};
+EventElement.prototype.unbind = function unbind(eventName2, target) {
+  var this$1$1 = this;
+  this.handlers[eventName2] = this.handlers[eventName2].filter(function(handler) {
+    if (target && handler !== target) {
+      return true;
+    }
+    this$1$1.element.removeEventListener(eventName2, handler, false);
+    return false;
+  });
+};
+EventElement.prototype.unbindAll = function unbindAll() {
+  for (var name2 in this.handlers) {
+    this.unbind(name2);
+  }
+};
+prototypeAccessors.isEmpty.get = function() {
+  var this$1$1 = this;
+  return Object.keys(this.handlers).every(
+    function(key2) {
+      return this$1$1.handlers[key2].length === 0;
+    }
+  );
+};
+Object.defineProperties(EventElement.prototype, prototypeAccessors);
+var EventManager = function EventManager2() {
+  this.eventElements = [];
+};
+EventManager.prototype.eventElement = function eventElement(element) {
+  var ee = this.eventElements.filter(function(ee2) {
+    return ee2.element === element;
+  })[0];
+  if (!ee) {
+    ee = new EventElement(element);
+    this.eventElements.push(ee);
+  }
+  return ee;
+};
+EventManager.prototype.bind = function bind2(element, eventName2, handler) {
+  this.eventElement(element).bind(eventName2, handler);
+};
+EventManager.prototype.unbind = function unbind2(element, eventName2, handler) {
+  var ee = this.eventElement(element);
+  ee.unbind(eventName2, handler);
+  if (ee.isEmpty) {
+    this.eventElements.splice(this.eventElements.indexOf(ee), 1);
+  }
+};
+EventManager.prototype.unbindAll = function unbindAll2() {
+  this.eventElements.forEach(function(e) {
+    return e.unbindAll();
+  });
+  this.eventElements = [];
+};
+EventManager.prototype.once = function once(element, eventName2, handler) {
+  var ee = this.eventElement(element);
+  var onceHandler = function(evt) {
+    ee.unbind(eventName2, onceHandler);
+    handler(evt);
+  };
+  ee.bind(eventName2, onceHandler);
+};
+function createEvent(name2) {
+  if (typeof window.CustomEvent === "function") {
+    return new CustomEvent(name2);
+  }
+  var evt = document.createEvent("CustomEvent");
+  evt.initCustomEvent(name2, false, false, void 0);
+  return evt;
+}
+function processScrollDiff(i, axis, diff, useScrollingClass, forceFireReachEvent) {
+  if (useScrollingClass === void 0) useScrollingClass = true;
+  if (forceFireReachEvent === void 0) forceFireReachEvent = false;
+  var fields;
+  if (axis === "top") {
+    fields = ["contentHeight", "containerHeight", "scrollTop", "y", "up", "down"];
+  } else if (axis === "left") {
+    fields = ["contentWidth", "containerWidth", "scrollLeft", "x", "left", "right"];
+  } else {
+    throw new Error("A proper axis should be provided");
+  }
+  processScrollDiff$1(i, diff, fields, useScrollingClass, forceFireReachEvent);
+}
+function processScrollDiff$1(i, diff, ref2, useScrollingClass, forceFireReachEvent) {
+  var contentHeight = ref2[0];
+  var containerHeight = ref2[1];
+  var scrollTop = ref2[2];
+  var y = ref2[3];
+  var up = ref2[4];
+  var down = ref2[5];
+  if (useScrollingClass === void 0) useScrollingClass = true;
+  if (forceFireReachEvent === void 0) forceFireReachEvent = false;
+  var element = i.element;
+  i.reach[y] = null;
+  if (element[scrollTop] < 1) {
+    i.reach[y] = "start";
+  }
+  if (element[scrollTop] > i[contentHeight] - i[containerHeight] - 1) {
+    i.reach[y] = "end";
+  }
+  if (diff) {
+    element.dispatchEvent(createEvent("ps-scroll-" + y));
+    if (diff < 0) {
+      element.dispatchEvent(createEvent("ps-scroll-" + up));
+    } else if (diff > 0) {
+      element.dispatchEvent(createEvent("ps-scroll-" + down));
+    }
+    if (useScrollingClass) {
+      setScrollingClassInstantly(i, y);
+    }
+  }
+  if (i.reach[y] && (diff || forceFireReachEvent)) {
+    element.dispatchEvent(createEvent("ps-" + y + "-reach-" + i.reach[y]));
+  }
+}
+function toInt(x) {
+  return parseInt(x, 10) || 0;
+}
+function isEditable(el) {
+  return matches(el, "input,[contenteditable]") || matches(el, "select,[contenteditable]") || matches(el, "textarea,[contenteditable]") || matches(el, "button,[contenteditable]");
+}
+function outerWidth(element) {
+  var styles = get(element);
+  return toInt(styles.width) + toInt(styles.paddingLeft) + toInt(styles.paddingRight) + toInt(styles.borderLeftWidth) + toInt(styles.borderRightWidth);
+}
+var env = {
+  isWebKit: typeof document !== "undefined" && "WebkitAppearance" in document.documentElement.style,
+  supportsTouch: typeof window !== "undefined" && ("ontouchstart" in window || "maxTouchPoints" in window.navigator && window.navigator.maxTouchPoints > 0 || window.DocumentTouch && document instanceof window.DocumentTouch),
+  supportsIePointer: typeof navigator !== "undefined" && navigator.msMaxTouchPoints,
+  isChrome: typeof navigator !== "undefined" && /Chrome/i.test(navigator && navigator.userAgent)
+};
+function updateGeometry(i) {
+  var element = i.element;
+  var roundedScrollTop = Math.floor(element.scrollTop);
+  var rect = element.getBoundingClientRect();
+  i.containerWidth = Math.floor(rect.width);
+  i.containerHeight = Math.floor(rect.height);
+  i.contentWidth = element.scrollWidth;
+  i.contentHeight = element.scrollHeight;
+  if (!element.contains(i.scrollbarXRail)) {
+    queryChildren(element, cls.element.rail("x")).forEach(function(el) {
+      return remove(el);
+    });
+    element.appendChild(i.scrollbarXRail);
+  }
+  if (!element.contains(i.scrollbarYRail)) {
+    queryChildren(element, cls.element.rail("y")).forEach(function(el) {
+      return remove(el);
+    });
+    element.appendChild(i.scrollbarYRail);
+  }
+  if (!i.settings.suppressScrollX && i.containerWidth + i.settings.scrollXMarginOffset < i.contentWidth) {
+    i.scrollbarXActive = true;
+    i.railXWidth = i.containerWidth - i.railXMarginWidth;
+    i.railXRatio = i.containerWidth / i.railXWidth;
+    i.scrollbarXWidth = getThumbSize(i, toInt(i.railXWidth * i.containerWidth / i.contentWidth));
+    i.scrollbarXLeft = toInt(
+      (i.negativeScrollAdjustment + element.scrollLeft) * (i.railXWidth - i.scrollbarXWidth) / (i.contentWidth - i.containerWidth)
+    );
+  } else {
+    i.scrollbarXActive = false;
+  }
+  if (!i.settings.suppressScrollY && i.containerHeight + i.settings.scrollYMarginOffset < i.contentHeight) {
+    i.scrollbarYActive = true;
+    i.railYHeight = i.containerHeight - i.railYMarginHeight;
+    i.railYRatio = i.containerHeight / i.railYHeight;
+    i.scrollbarYHeight = getThumbSize(
+      i,
+      toInt(i.railYHeight * i.containerHeight / i.contentHeight)
+    );
+    i.scrollbarYTop = toInt(
+      roundedScrollTop * (i.railYHeight - i.scrollbarYHeight) / (i.contentHeight - i.containerHeight)
+    );
+  } else {
+    i.scrollbarYActive = false;
+  }
+  if (i.scrollbarXLeft >= i.railXWidth - i.scrollbarXWidth) {
+    i.scrollbarXLeft = i.railXWidth - i.scrollbarXWidth;
+  }
+  if (i.scrollbarYTop >= i.railYHeight - i.scrollbarYHeight) {
+    i.scrollbarYTop = i.railYHeight - i.scrollbarYHeight;
+  }
+  updateCss(element, i);
+  if (i.scrollbarXActive) {
+    element.classList.add(cls.state.active("x"));
+  } else {
+    element.classList.remove(cls.state.active("x"));
+    i.scrollbarXWidth = 0;
+    i.scrollbarXLeft = 0;
+    element.scrollLeft = i.isRtl === true ? i.contentWidth : 0;
+  }
+  if (i.scrollbarYActive) {
+    element.classList.add(cls.state.active("y"));
+  } else {
+    element.classList.remove(cls.state.active("y"));
+    i.scrollbarYHeight = 0;
+    i.scrollbarYTop = 0;
+    element.scrollTop = 0;
+  }
+}
+function getThumbSize(i, thumbSize) {
+  if (i.settings.minScrollbarLength) {
+    thumbSize = Math.max(thumbSize, i.settings.minScrollbarLength);
+  }
+  if (i.settings.maxScrollbarLength) {
+    thumbSize = Math.min(thumbSize, i.settings.maxScrollbarLength);
+  }
+  return thumbSize;
+}
+function updateCss(element, i) {
+  var xRailOffset = { width: i.railXWidth };
+  var roundedScrollTop = Math.floor(element.scrollTop);
+  if (i.isRtl) {
+    xRailOffset.left = i.negativeScrollAdjustment + element.scrollLeft + i.containerWidth - i.contentWidth;
+  } else {
+    xRailOffset.left = element.scrollLeft;
+  }
+  if (i.isScrollbarXUsingBottom) {
+    xRailOffset.bottom = i.scrollbarXBottom - roundedScrollTop;
+  } else {
+    xRailOffset.top = i.scrollbarXTop + roundedScrollTop;
+  }
+  set(i.scrollbarXRail, xRailOffset);
+  var yRailOffset = { top: roundedScrollTop, height: i.railYHeight };
+  if (i.isScrollbarYUsingRight) {
+    if (i.isRtl) {
+      yRailOffset.right = i.contentWidth - (i.negativeScrollAdjustment + element.scrollLeft) - i.scrollbarYRight - i.scrollbarYOuterWidth - 9;
+    } else {
+      yRailOffset.right = i.scrollbarYRight - element.scrollLeft;
+    }
+  } else {
+    if (i.isRtl) {
+      yRailOffset.left = i.negativeScrollAdjustment + element.scrollLeft + i.containerWidth * 2 - i.contentWidth - i.scrollbarYLeft - i.scrollbarYOuterWidth;
+    } else {
+      yRailOffset.left = i.scrollbarYLeft + element.scrollLeft;
+    }
+  }
+  set(i.scrollbarYRail, yRailOffset);
+  set(i.scrollbarX, {
+    left: i.scrollbarXLeft,
+    width: i.scrollbarXWidth - i.railBorderXWidth
+  });
+  set(i.scrollbarY, {
+    top: i.scrollbarYTop,
+    height: i.scrollbarYHeight - i.railBorderYWidth
+  });
+}
+function clickRail(i) {
+  i.event.bind(i.scrollbarY, "mousedown", function(e) {
+    return e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarYRail, "mousedown", function(e) {
+    var positionTop = e.pageY - window.pageYOffset - i.scrollbarYRail.getBoundingClientRect().top;
+    var direction = positionTop > i.scrollbarYTop ? 1 : -1;
+    i.element.scrollTop += direction * i.containerHeight;
+    updateGeometry(i);
+    e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarX, "mousedown", function(e) {
+    return e.stopPropagation();
+  });
+  i.event.bind(i.scrollbarXRail, "mousedown", function(e) {
+    var positionLeft = e.pageX - window.pageXOffset - i.scrollbarXRail.getBoundingClientRect().left;
+    var direction = positionLeft > i.scrollbarXLeft ? 1 : -1;
+    i.element.scrollLeft += direction * i.containerWidth;
+    updateGeometry(i);
+    e.stopPropagation();
+  });
+}
+var activeSlider = null;
+function setupScrollHandlers(i) {
+  bindMouseScrollHandler(i, [
+    "containerHeight",
+    "contentHeight",
+    "pageY",
+    "railYHeight",
+    "scrollbarY",
+    "scrollbarYHeight",
+    "scrollTop",
+    "y",
+    "scrollbarYRail"
+  ]);
+  bindMouseScrollHandler(i, [
+    "containerWidth",
+    "contentWidth",
+    "pageX",
+    "railXWidth",
+    "scrollbarX",
+    "scrollbarXWidth",
+    "scrollLeft",
+    "x",
+    "scrollbarXRail"
+  ]);
+}
+function bindMouseScrollHandler(i, ref2) {
+  var containerDimension = ref2[0];
+  var contentDimension = ref2[1];
+  var pageAxis = ref2[2];
+  var railDimension = ref2[3];
+  var scrollbarAxis = ref2[4];
+  var scrollbarDimension = ref2[5];
+  var scrollAxis = ref2[6];
+  var axis = ref2[7];
+  var scrollbarRail = ref2[8];
+  var element = i.element;
+  var startingScrollPosition = null;
+  var startingMousePagePosition = null;
+  var scrollBy = null;
+  function moveHandler(e) {
+    if (e.touches && e.touches[0]) {
+      e[pageAxis] = e.touches[0]["page" + axis.toUpperCase()];
+    }
+    if (activeSlider === scrollbarAxis) {
+      element[scrollAxis] = startingScrollPosition + scrollBy * (e[pageAxis] - startingMousePagePosition);
+      addScrollingClass(i, axis);
+      updateGeometry(i);
+      e.stopPropagation();
+      e.preventDefault();
+    }
+  }
+  function endHandler() {
+    removeScrollingClass(i, axis);
+    i[scrollbarRail].classList.remove(cls.state.clicking);
+    document.removeEventListener("mousemove", moveHandler);
+    document.removeEventListener("mouseup", endHandler);
+    document.removeEventListener("touchmove", moveHandler);
+    document.removeEventListener("touchend", endHandler);
+    activeSlider = null;
+  }
+  function bindMoves(e) {
+    if (activeSlider === null) {
+      activeSlider = scrollbarAxis;
+      startingScrollPosition = element[scrollAxis];
+      if (e.touches) {
+        e[pageAxis] = e.touches[0]["page" + axis.toUpperCase()];
+      }
+      startingMousePagePosition = e[pageAxis];
+      scrollBy = (i[contentDimension] - i[containerDimension]) / (i[railDimension] - i[scrollbarDimension]);
+      if (!e.touches) {
+        document.addEventListener("mousemove", moveHandler);
+        document.addEventListener("mouseup", endHandler);
+      } else {
+        document.addEventListener("touchmove", moveHandler, { passive: false });
+        document.addEventListener("touchend", endHandler);
+      }
+      i[scrollbarRail].classList.add(cls.state.clicking);
+    }
+    e.stopPropagation();
+    if (e.cancelable) {
+      e.preventDefault();
+    }
+  }
+  i[scrollbarAxis].addEventListener("mousedown", bindMoves);
+  i[scrollbarAxis].addEventListener("touchstart", bindMoves);
+}
+function keyboard(i) {
+  var element = i.element;
+  var elementHovered = function() {
+    return matches(element, ":hover");
+  };
+  var scrollbarFocused = function() {
+    return matches(i.scrollbarX, ":focus") || matches(i.scrollbarY, ":focus");
+  };
+  function shouldPreventDefault(deltaX, deltaY) {
+    var scrollTop = Math.floor(element.scrollTop);
+    if (deltaX === 0) {
+      if (!i.scrollbarYActive) {
+        return false;
+      }
+      if (scrollTop === 0 && deltaY > 0 || scrollTop >= i.contentHeight - i.containerHeight && deltaY < 0) {
+        return !i.settings.wheelPropagation;
+      }
+    }
+    var scrollLeft = element.scrollLeft;
+    if (deltaY === 0) {
+      if (!i.scrollbarXActive) {
+        return false;
+      }
+      if (scrollLeft === 0 && deltaX < 0 || scrollLeft >= i.contentWidth - i.containerWidth && deltaX > 0) {
+        return !i.settings.wheelPropagation;
+      }
+    }
+    return true;
+  }
+  i.event.bind(i.ownerDocument, "keydown", function(e) {
+    if (e.isDefaultPrevented && e.isDefaultPrevented() || e.defaultPrevented) {
+      return;
+    }
+    if (!elementHovered() && !scrollbarFocused()) {
+      return;
+    }
+    var activeElement = document.activeElement ? document.activeElement : i.ownerDocument.activeElement;
+    if (activeElement) {
+      if (activeElement.tagName === "IFRAME") {
+        activeElement = activeElement.contentDocument.activeElement;
+      } else {
+        while (activeElement.shadowRoot) {
+          activeElement = activeElement.shadowRoot.activeElement;
+        }
+      }
+      if (isEditable(activeElement)) {
+        return;
+      }
+    }
+    var deltaX = 0;
+    var deltaY = 0;
+    switch (e.which) {
+      case 37:
+        if (e.metaKey) {
+          deltaX = -i.contentWidth;
+        } else if (e.altKey) {
+          deltaX = -i.containerWidth;
+        } else {
+          deltaX = -30;
+        }
+        break;
+      case 38:
+        if (e.metaKey) {
+          deltaY = i.contentHeight;
+        } else if (e.altKey) {
+          deltaY = i.containerHeight;
+        } else {
+          deltaY = 30;
+        }
+        break;
+      case 39:
+        if (e.metaKey) {
+          deltaX = i.contentWidth;
+        } else if (e.altKey) {
+          deltaX = i.containerWidth;
+        } else {
+          deltaX = 30;
+        }
+        break;
+      case 40:
+        if (e.metaKey) {
+          deltaY = -i.contentHeight;
+        } else if (e.altKey) {
+          deltaY = -i.containerHeight;
+        } else {
+          deltaY = -30;
+        }
+        break;
+      case 32:
+        if (e.shiftKey) {
+          deltaY = i.containerHeight;
+        } else {
+          deltaY = -i.containerHeight;
+        }
+        break;
+      case 33:
+        deltaY = i.containerHeight;
+        break;
+      case 34:
+        deltaY = -i.containerHeight;
+        break;
+      case 36:
+        deltaY = i.contentHeight;
+        break;
+      case 35:
+        deltaY = -i.contentHeight;
+        break;
+      default:
+        return;
+    }
+    if (i.settings.suppressScrollX && deltaX !== 0) {
+      return;
+    }
+    if (i.settings.suppressScrollY && deltaY !== 0) {
+      return;
+    }
+    element.scrollTop -= deltaY;
+    element.scrollLeft += deltaX;
+    updateGeometry(i);
+    if (shouldPreventDefault(deltaX, deltaY)) {
+      e.preventDefault();
+    }
+  });
+}
+function wheel(i) {
+  var element = i.element;
+  function shouldPreventDefault(deltaX, deltaY) {
+    var roundedScrollTop = Math.floor(element.scrollTop);
+    var isTop = element.scrollTop === 0;
+    var isBottom = roundedScrollTop + element.offsetHeight === element.scrollHeight;
+    var isLeft = element.scrollLeft === 0;
+    var isRight = element.scrollLeft + element.offsetWidth === element.scrollWidth;
+    var hitsBound;
+    if (Math.abs(deltaY) > Math.abs(deltaX)) {
+      hitsBound = isTop || isBottom;
+    } else {
+      hitsBound = isLeft || isRight;
+    }
+    return hitsBound ? !i.settings.wheelPropagation : true;
+  }
+  function getDeltaFromEvent(e) {
+    var deltaX = e.deltaX;
+    var deltaY = -1 * e.deltaY;
+    if (typeof deltaX === "undefined" || typeof deltaY === "undefined") {
+      deltaX = -1 * e.wheelDeltaX / 6;
+      deltaY = e.wheelDeltaY / 6;
+    }
+    if (e.deltaMode && e.deltaMode === 1) {
+      deltaX *= 10;
+      deltaY *= 10;
+    }
+    if (deltaX !== deltaX && deltaY !== deltaY) {
+      deltaX = 0;
+      deltaY = e.wheelDelta;
+    }
+    if (e.shiftKey) {
+      return [-deltaY, -deltaX];
+    }
+    return [deltaX, deltaY];
+  }
+  function shouldBeConsumedByChild(target, deltaX, deltaY) {
+    if (!env.isWebKit && element.querySelector("select:focus")) {
+      return true;
+    }
+    if (!element.contains(target)) {
+      return false;
+    }
+    var cursor = target;
+    while (cursor && cursor !== element) {
+      if (cursor.classList.contains(cls.element.consuming)) {
+        return true;
+      }
+      var style = get(cursor);
+      if (deltaY && style.overflowY.match(/(scroll|auto)/)) {
+        var maxScrollTop = cursor.scrollHeight - cursor.clientHeight;
+        if (maxScrollTop > 0) {
+          if (cursor.scrollTop > 0 && deltaY < 0 || cursor.scrollTop < maxScrollTop && deltaY > 0) {
+            return true;
+          }
+        }
+      }
+      if (deltaX && style.overflowX.match(/(scroll|auto)/)) {
+        var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth;
+        if (maxScrollLeft > 0) {
+          if (cursor.scrollLeft > 0 && deltaX < 0 || cursor.scrollLeft < maxScrollLeft && deltaX > 0) {
+            return true;
+          }
+        }
+      }
+      cursor = cursor.parentNode;
+    }
+    return false;
+  }
+  function mousewheelHandler(e) {
+    var ref2 = getDeltaFromEvent(e);
+    var deltaX = ref2[0];
+    var deltaY = ref2[1];
+    if (shouldBeConsumedByChild(e.target, deltaX, deltaY)) {
+      return;
+    }
+    var shouldPrevent = false;
+    if (!i.settings.useBothWheelAxes) {
+      element.scrollTop -= deltaY * i.settings.wheelSpeed;
+      element.scrollLeft += deltaX * i.settings.wheelSpeed;
+    } else if (i.scrollbarYActive && !i.scrollbarXActive) {
+      if (deltaY) {
+        element.scrollTop -= deltaY * i.settings.wheelSpeed;
+      } else {
+        element.scrollTop += deltaX * i.settings.wheelSpeed;
+      }
+      shouldPrevent = true;
+    } else if (i.scrollbarXActive && !i.scrollbarYActive) {
+      if (deltaX) {
+        element.scrollLeft += deltaX * i.settings.wheelSpeed;
+      } else {
+        element.scrollLeft -= deltaY * i.settings.wheelSpeed;
+      }
+      shouldPrevent = true;
+    }
+    updateGeometry(i);
+    shouldPrevent = shouldPrevent || shouldPreventDefault(deltaX, deltaY);
+    if (shouldPrevent && !e.ctrlKey) {
+      e.stopPropagation();
+      e.preventDefault();
+    }
+  }
+  if (typeof window.onwheel !== "undefined") {
+    i.event.bind(element, "wheel", mousewheelHandler);
+  } else if (typeof window.onmousewheel !== "undefined") {
+    i.event.bind(element, "mousewheel", mousewheelHandler);
+  }
+}
+function touch(i) {
+  if (!env.supportsTouch && !env.supportsIePointer) {
+    return;
+  }
+  var element = i.element;
+  var state = {
+    startOffset: {},
+    startTime: 0,
+    speed: {},
+    easingLoop: null
+  };
+  function shouldPrevent(deltaX, deltaY) {
+    var scrollTop = Math.floor(element.scrollTop);
+    var scrollLeft = element.scrollLeft;
+    var magnitudeX = Math.abs(deltaX);
+    var magnitudeY = Math.abs(deltaY);
+    if (magnitudeY > magnitudeX) {
+      if (deltaY < 0 && scrollTop === i.contentHeight - i.containerHeight || deltaY > 0 && scrollTop === 0) {
+        return window.scrollY === 0 && deltaY > 0 && env.isChrome;
+      }
+    } else if (magnitudeX > magnitudeY) {
+      if (deltaX < 0 && scrollLeft === i.contentWidth - i.containerWidth || deltaX > 0 && scrollLeft === 0) {
+        return true;
+      }
+    }
+    return true;
+  }
+  function applyTouchMove(differenceX, differenceY) {
+    element.scrollTop -= differenceY;
+    element.scrollLeft -= differenceX;
+    updateGeometry(i);
+  }
+  function getTouch(e) {
+    if (e.targetTouches) {
+      return e.targetTouches[0];
+    }
+    return e;
+  }
+  function shouldHandle(e) {
+    if (e.target === i.scrollbarX || e.target === i.scrollbarY) {
+      return false;
+    }
+    if (e.pointerType && e.pointerType === "pen" && e.buttons === 0) {
+      return false;
+    }
+    if (e.targetTouches && e.targetTouches.length === 1) {
+      return true;
+    }
+    if (e.pointerType && e.pointerType !== "mouse" && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) {
+      return true;
+    }
+    return false;
+  }
+  function touchStart(e) {
+    if (!shouldHandle(e)) {
+      return;
+    }
+    var touch2 = getTouch(e);
+    state.startOffset.pageX = touch2.pageX;
+    state.startOffset.pageY = touch2.pageY;
+    state.startTime = (/* @__PURE__ */ new Date()).getTime();
+    if (state.easingLoop !== null) {
+      clearInterval(state.easingLoop);
+    }
+  }
+  function shouldBeConsumedByChild(target, deltaX, deltaY) {
+    if (!element.contains(target)) {
+      return false;
+    }
+    var cursor = target;
+    while (cursor && cursor !== element) {
+      if (cursor.classList.contains(cls.element.consuming)) {
+        return true;
+      }
+      var style = get(cursor);
+      if (deltaY && style.overflowY.match(/(scroll|auto)/)) {
+        var maxScrollTop = cursor.scrollHeight - cursor.clientHeight;
+        if (maxScrollTop > 0) {
+          if (cursor.scrollTop > 0 && deltaY < 0 || cursor.scrollTop < maxScrollTop && deltaY > 0) {
+            return true;
+          }
+        }
+      }
+      if (deltaX && style.overflowX.match(/(scroll|auto)/)) {
+        var maxScrollLeft = cursor.scrollWidth - cursor.clientWidth;
+        if (maxScrollLeft > 0) {
+          if (cursor.scrollLeft > 0 && deltaX < 0 || cursor.scrollLeft < maxScrollLeft && deltaX > 0) {
+            return true;
+          }
+        }
+      }
+      cursor = cursor.parentNode;
+    }
+    return false;
+  }
+  function touchMove(e) {
+    if (shouldHandle(e)) {
+      var touch2 = getTouch(e);
+      var currentOffset = { pageX: touch2.pageX, pageY: touch2.pageY };
+      var differenceX = currentOffset.pageX - state.startOffset.pageX;
+      var differenceY = currentOffset.pageY - state.startOffset.pageY;
+      if (shouldBeConsumedByChild(e.target, differenceX, differenceY)) {
+        return;
+      }
+      applyTouchMove(differenceX, differenceY);
+      state.startOffset = currentOffset;
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      var timeGap = currentTime - state.startTime;
+      if (timeGap > 0) {
+        state.speed.x = differenceX / timeGap;
+        state.speed.y = differenceY / timeGap;
+        state.startTime = currentTime;
+      }
+      if (shouldPrevent(differenceX, differenceY)) {
+        if (e.cancelable) {
+          e.preventDefault();
+        }
+      }
+    }
+  }
+  function touchEnd() {
+    if (i.settings.swipeEasing) {
+      clearInterval(state.easingLoop);
+      state.easingLoop = setInterval(function() {
+        if (i.isInitialized) {
+          clearInterval(state.easingLoop);
+          return;
+        }
+        if (!state.speed.x && !state.speed.y) {
+          clearInterval(state.easingLoop);
+          return;
+        }
+        if (Math.abs(state.speed.x) < 0.01 && Math.abs(state.speed.y) < 0.01) {
+          clearInterval(state.easingLoop);
+          return;
+        }
+        applyTouchMove(state.speed.x * 30, state.speed.y * 30);
+        state.speed.x *= 0.8;
+        state.speed.y *= 0.8;
+      }, 10);
+    }
+  }
+  if (env.supportsTouch) {
+    i.event.bind(element, "touchstart", touchStart);
+    i.event.bind(element, "touchmove", touchMove);
+    i.event.bind(element, "touchend", touchEnd);
+  } else if (env.supportsIePointer) {
+    if (window.PointerEvent) {
+      i.event.bind(element, "pointerdown", touchStart);
+      i.event.bind(element, "pointermove", touchMove);
+      i.event.bind(element, "pointerup", touchEnd);
+    } else if (window.MSPointerEvent) {
+      i.event.bind(element, "MSPointerDown", touchStart);
+      i.event.bind(element, "MSPointerMove", touchMove);
+      i.event.bind(element, "MSPointerUp", touchEnd);
+    }
+  }
+}
+var defaultSettings = function() {
+  return {
+    handlers: ["click-rail", "drag-thumb", "keyboard", "wheel", "touch"],
+    maxScrollbarLength: null,
+    minScrollbarLength: null,
+    scrollingThreshold: 1e3,
+    scrollXMarginOffset: 0,
+    scrollYMarginOffset: 0,
+    suppressScrollX: false,
+    suppressScrollY: false,
+    swipeEasing: true,
+    useBothWheelAxes: false,
+    wheelPropagation: true,
+    wheelSpeed: 1
+  };
+};
+var handlers = {
+  "click-rail": clickRail,
+  "drag-thumb": setupScrollHandlers,
+  keyboard,
+  wheel,
+  touch
+};
+var PerfectScrollbar = function PerfectScrollbar2(element, userSettings) {
+  var this$1$1 = this;
+  if (userSettings === void 0) userSettings = {};
+  if (typeof element === "string") {
+    element = document.querySelector(element);
+  }
+  if (!element || !element.nodeName) {
+    throw new Error("no element is specified to initialize PerfectScrollbar");
+  }
+  this.element = element;
+  element.classList.add(cls.main);
+  this.settings = defaultSettings();
+  for (var key2 in userSettings) {
+    this.settings[key2] = userSettings[key2];
+  }
+  this.containerWidth = null;
+  this.containerHeight = null;
+  this.contentWidth = null;
+  this.contentHeight = null;
+  var focus = function() {
+    return element.classList.add(cls.state.focus);
+  };
+  var blur = function() {
+    return element.classList.remove(cls.state.focus);
+  };
+  this.isRtl = get(element).direction === "rtl";
+  if (this.isRtl === true) {
+    element.classList.add(cls.rtl);
+  }
+  this.isNegativeScroll = function() {
+    var originalScrollLeft = element.scrollLeft;
+    var result = null;
+    element.scrollLeft = -1;
+    result = element.scrollLeft < 0;
+    element.scrollLeft = originalScrollLeft;
+    return result;
+  }();
+  this.negativeScrollAdjustment = this.isNegativeScroll ? element.scrollWidth - element.clientWidth : 0;
+  this.event = new EventManager();
+  this.ownerDocument = element.ownerDocument || document;
+  this.scrollbarXRail = div(cls.element.rail("x"));
+  element.appendChild(this.scrollbarXRail);
+  this.scrollbarX = div(cls.element.thumb("x"));
+  this.scrollbarXRail.appendChild(this.scrollbarX);
+  this.scrollbarX.setAttribute("tabindex", 0);
+  this.event.bind(this.scrollbarX, "focus", focus);
+  this.event.bind(this.scrollbarX, "blur", blur);
+  this.scrollbarXActive = null;
+  this.scrollbarXWidth = null;
+  this.scrollbarXLeft = null;
+  var railXStyle = get(this.scrollbarXRail);
+  this.scrollbarXBottom = parseInt(railXStyle.bottom, 10);
+  if (isNaN(this.scrollbarXBottom)) {
+    this.isScrollbarXUsingBottom = false;
+    this.scrollbarXTop = toInt(railXStyle.top);
+  } else {
+    this.isScrollbarXUsingBottom = true;
+  }
+  this.railBorderXWidth = toInt(railXStyle.borderLeftWidth) + toInt(railXStyle.borderRightWidth);
+  set(this.scrollbarXRail, { display: "block" });
+  this.railXMarginWidth = toInt(railXStyle.marginLeft) + toInt(railXStyle.marginRight);
+  set(this.scrollbarXRail, { display: "" });
+  this.railXWidth = null;
+  this.railXRatio = null;
+  this.scrollbarYRail = div(cls.element.rail("y"));
+  element.appendChild(this.scrollbarYRail);
+  this.scrollbarY = div(cls.element.thumb("y"));
+  this.scrollbarYRail.appendChild(this.scrollbarY);
+  this.scrollbarY.setAttribute("tabindex", 0);
+  this.event.bind(this.scrollbarY, "focus", focus);
+  this.event.bind(this.scrollbarY, "blur", blur);
+  this.scrollbarYActive = null;
+  this.scrollbarYHeight = null;
+  this.scrollbarYTop = null;
+  var railYStyle = get(this.scrollbarYRail);
+  this.scrollbarYRight = parseInt(railYStyle.right, 10);
+  if (isNaN(this.scrollbarYRight)) {
+    this.isScrollbarYUsingRight = false;
+    this.scrollbarYLeft = toInt(railYStyle.left);
+  } else {
+    this.isScrollbarYUsingRight = true;
+  }
+  this.scrollbarYOuterWidth = this.isRtl ? outerWidth(this.scrollbarY) : null;
+  this.railBorderYWidth = toInt(railYStyle.borderTopWidth) + toInt(railYStyle.borderBottomWidth);
+  set(this.scrollbarYRail, { display: "block" });
+  this.railYMarginHeight = toInt(railYStyle.marginTop) + toInt(railYStyle.marginBottom);
+  set(this.scrollbarYRail, { display: "" });
+  this.railYHeight = null;
+  this.railYRatio = null;
+  this.reach = {
+    x: element.scrollLeft <= 0 ? "start" : element.scrollLeft >= this.contentWidth - this.containerWidth ? "end" : null,
+    y: element.scrollTop <= 0 ? "start" : element.scrollTop >= this.contentHeight - this.containerHeight ? "end" : null
+  };
+  this.isAlive = true;
+  this.settings.handlers.forEach(function(handlerName) {
+    return handlers[handlerName](this$1$1);
+  });
+  this.lastScrollTop = Math.floor(element.scrollTop);
+  this.lastScrollLeft = element.scrollLeft;
+  this.event.bind(this.element, "scroll", function(e) {
+    return this$1$1.onScroll(e);
+  });
+  updateGeometry(this);
+};
+PerfectScrollbar.prototype.update = function update() {
+  if (!this.isAlive) {
+    return;
+  }
+  this.negativeScrollAdjustment = this.isNegativeScroll ? this.element.scrollWidth - this.element.clientWidth : 0;
+  set(this.scrollbarXRail, { display: "block" });
+  set(this.scrollbarYRail, { display: "block" });
+  this.railXMarginWidth = toInt(get(this.scrollbarXRail).marginLeft) + toInt(get(this.scrollbarXRail).marginRight);
+  this.railYMarginHeight = toInt(get(this.scrollbarYRail).marginTop) + toInt(get(this.scrollbarYRail).marginBottom);
+  set(this.scrollbarXRail, { display: "none" });
+  set(this.scrollbarYRail, { display: "none" });
+  updateGeometry(this);
+  processScrollDiff(this, "top", 0, false, true);
+  processScrollDiff(this, "left", 0, false, true);
+  set(this.scrollbarXRail, { display: "" });
+  set(this.scrollbarYRail, { display: "" });
+};
+PerfectScrollbar.prototype.onScroll = function onScroll(e) {
+  if (!this.isAlive) {
+    return;
+  }
+  updateGeometry(this);
+  processScrollDiff(this, "top", this.element.scrollTop - this.lastScrollTop);
+  processScrollDiff(this, "left", this.element.scrollLeft - this.lastScrollLeft);
+  this.lastScrollTop = Math.floor(this.element.scrollTop);
+  this.lastScrollLeft = this.element.scrollLeft;
+};
+PerfectScrollbar.prototype.destroy = function destroy() {
+  if (!this.isAlive) {
+    return;
+  }
+  this.event.unbindAll();
+  remove(this.scrollbarX);
+  remove(this.scrollbarY);
+  remove(this.scrollbarXRail);
+  remove(this.scrollbarYRail);
+  this.removePsClasses();
+  this.element = null;
+  this.scrollbarX = null;
+  this.scrollbarY = null;
+  this.scrollbarXRail = null;
+  this.scrollbarYRail = null;
+  this.isAlive = false;
+};
+PerfectScrollbar.prototype.removePsClasses = function removePsClasses() {
+  this.element.className = this.element.className.split(" ").filter(function(name2) {
+    return !name2.match(/^ps([-_].+|)$/);
+  }).join(" ");
+};
+const C = /* @__PURE__ */ defineComponent$1({
+  __name: "PerfectScrollbar",
+  props: {
+    tag: { default: "div" },
+    options: { default: () => ({}) }
+  },
+  emits: ["scroll", "ps-scroll-y", "ps-scroll-x", "ps-scroll-up", "ps-scroll-down", "ps-scroll-left", "ps-scroll-right", "ps-y-reach-start", "ps-y-reach-end", "ps-x-reach-start", "ps-x-reach-end"],
+  setup(o, { expose: n, emit: c }) {
+    const a = o, y = c, l = ref(null), s = ref(null);
+    watch(
+      () => a.options,
+      () => {
+        i(), p();
+      },
+      { deep: true }
+    ), onMounted(() => {
+      l.value && p();
+    }), onBeforeUnmount(() => {
+      i();
+    });
+    function p() {
+      l.value && (s.value = new PerfectScrollbar(l.value, a.options), u());
+    }
+    function i() {
+      s.value && (u(false), s.value.destroy(), s.value = null);
+    }
+    const x = {
+      scroll: e("scroll"),
+      "ps-scroll-y": e("ps-scroll-y"),
+      "ps-scroll-x": e("ps-scroll-x"),
+      "ps-scroll-up": e("ps-scroll-up"),
+      "ps-scroll-down": e("ps-scroll-down"),
+      "ps-scroll-left": e("ps-scroll-left"),
+      "ps-scroll-right": e("ps-scroll-right"),
+      "ps-y-reach-start": e("ps-y-reach-start"),
+      "ps-y-reach-end": e("ps-y-reach-end"),
+      "ps-x-reach-start": e("ps-x-reach-start"),
+      "ps-x-reach-end": e("ps-x-reach-end")
+    };
+    function e(r) {
+      return function(t) {
+        y(r, t);
+      };
+    }
+    function u(r = true) {
+      var t;
+      (t = s.value) != null && t.element && Object.entries(x).forEach(([f, d]) => {
+        var m, h2;
+        r ? (m = s.value) == null || m.element.addEventListener(f, d) : (h2 = s.value) == null || h2.element.removeEventListener(f, d);
+      });
+    }
+    return n({
+      ps: s
+    }), (r, t) => (openBlock(), createBlock(resolveDynamicComponent(r.tag), {
+      ref_key: "scrollbar",
+      ref: l,
+      class: "ps"
+    }, {
+      default: withCtx(() => [
+        renderSlot(r.$slots, "default")
+      ]),
+      _: 3
+    }, 512));
+  }
+});
 function useSticky(_ref) {
   let {
     rootEl,
@@ -38999,21 +40087,21 @@ function useSticky(_ref) {
   onMounted(() => {
     watch(isSticky, (val2) => {
       if (val2) {
-        window.addEventListener("scroll", onScroll, {
+        window.addEventListener("scroll", onScroll2, {
           passive: true
         });
       } else {
-        window.removeEventListener("scroll", onScroll);
+        window.removeEventListener("scroll", onScroll2);
       }
     }, {
       immediate: true
     });
   });
   onBeforeUnmount(() => {
-    window.removeEventListener("scroll", onScroll);
+    window.removeEventListener("scroll", onScroll2);
   });
   let lastScrollTop = 0;
-  function onScroll() {
+  function onScroll2() {
     const direction = lastScrollTop > window.scrollY ? "up" : "down";
     const rect = rootEl.value.getBoundingClientRect();
     const layoutTop = parseFloat(layoutItemStyles.value.top ?? 0);
@@ -39078,14 +40166,14 @@ function calculateImpulseVelocity(samples) {
 function useVelocity() {
   const touches = {};
   function addMovement(e) {
-    Array.from(e.changedTouches).forEach((touch) => {
-      const samples = touches[touch.identifier] ?? (touches[touch.identifier] = new CircularBuffer(HISTORY));
-      samples.push([e.timeStamp, touch]);
+    Array.from(e.changedTouches).forEach((touch2) => {
+      const samples = touches[touch2.identifier] ?? (touches[touch2.identifier] = new CircularBuffer(HISTORY));
+      samples.push([e.timeStamp, touch2]);
     });
   }
   function endTouch(e) {
-    Array.from(e.changedTouches).forEach((touch) => {
-      delete touches[touch.identifier];
+    Array.from(e.changedTouches).forEach((touch2) => {
+      delete touches[touch2.identifier];
     });
   }
   function getVelocity(id) {
@@ -39553,7 +40641,6 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent$1({
       return props.sidebarItems;
     });
     return (_ctx, _cache) => {
-      const _component_perfect_scrollbar = resolveComponent("perfect-scrollbar");
       return openBlock(), createBlock(VNavigationDrawer, {
         right: "",
         "model-value": __props.sidebarDrawer,
@@ -39569,7 +40656,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent$1({
           createElementVNode("div", _hoisted_1$2, [
             (openBlock(), createBlock(resolveDynamicComponent(__props.logoComponent)))
           ]),
-          createVNode(_component_perfect_scrollbar, { class: "scrollnavbar" }, {
+          createVNode(unref(C), { class: "scrollnavbar" }, {
             default: withCtx(() => [
               createVNode(VList, { class: "pa-4" }, {
                 default: withCtx(() => [
@@ -39617,7 +40704,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent$1({
     };
   }
 });
-const AppSidebar = /* @__PURE__ */ _export_sfc$1(_sfc_main$2, [["__scopeId", "data-v-3e3fe433"]]);
+const AppSidebar = /* @__PURE__ */ _export_sfc$1(_sfc_main$2, [["__scopeId", "data-v-f94ee123"]]);
 const makeVToolbarTitleProps = propsFactory({
   text: String,
   ...makeComponentProps(),
@@ -39861,7 +40948,7 @@ function useScroll(props) {
   function onResize() {
     checkScrollableSpace();
   }
-  function onScroll() {
+  function onScroll2() {
     const targetEl = target.value;
     if (!targetEl || canScroll && !canScroll.value) return;
     previousScroll = currentScroll.value;
@@ -39906,9 +40993,9 @@ function useScroll(props) {
         return;
       }
       if (newTarget === target.value) return;
-      (_a = target.value) == null ? void 0 : _a.removeEventListener("scroll", onScroll);
+      (_a = target.value) == null ? void 0 : _a.removeEventListener("scroll", onScroll2);
       target.value = newTarget;
-      target.value.addEventListener("scroll", onScroll, {
+      target.value.addEventListener("scroll", onScroll2, {
         passive: true
       });
       Promise.resolve().then(() => {
@@ -39923,10 +41010,10 @@ function useScroll(props) {
   });
   onBeforeUnmount(() => {
     var _a;
-    (_a = target.value) == null ? void 0 : _a.removeEventListener("scroll", onScroll);
+    (_a = target.value) == null ? void 0 : _a.removeEventListener("scroll", onScroll2);
     window.removeEventListener("resize", onResize);
   });
-  canScroll && watch(canScroll, onScroll, {
+  canScroll && watch(canScroll, onScroll2, {
     immediate: true
   });
   return {