@dialpad/dialtone 9.54.2 → 9.55.1

package/dist/vue3/lib/scrollbar-directive.cjs

@@ -0,0 +1,2407 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+/*!
+ * OverlayScrollbars
+ * Version: 2.9.1
+ *
+ * Copyright (c) Rene Haas | KingSora.
+ * https://github.com/KingSora
+ *
+ * Released under the MIT license.
+ */
+const createCache = (t2, n2) => {
+  const { o: o2, i: s2, u: e2 } = t2;
+  let c2 = o2;
+  let r2;
+  const cacheUpdateContextual = (t3, n3) => {
+    const o3 = c2;
+    const l2 = t3;
+    const i2 = n3 || (s2 ? !s2(o3, l2) : o3 !== l2);
+    if (i2 || e2) {
+      c2 = l2;
+      r2 = o3;
+    }
+    return [c2, i2, r2];
+  };
+  const cacheUpdateIsolated = (t3) => cacheUpdateContextual(n2(c2, r2), t3);
+  const getCurrentCache = (t3) => [c2, !!t3, r2];
+  return [n2 ? cacheUpdateIsolated : cacheUpdateContextual, getCurrentCache];
+};
+const t = typeof window !== "undefined" && typeof HTMLElement !== "undefined" && !!window.document;
+const n = t ? window : {};
+const o = Math.max;
+const s = Math.min;
+const e = Math.round;
+const c = Math.abs;
+const r = Math.sign;
+const l = n.cancelAnimationFrame;
+const i = n.requestAnimationFrame;
+const a = n.setTimeout;
+const u = n.clearTimeout;
+const getApi = (t2) => typeof n[t2] !== "undefined" ? n[t2] : void 0;
+const _ = getApi("MutationObserver");
+const d = getApi("IntersectionObserver");
+const f = getApi("ResizeObserver");
+const p = getApi("ScrollTimeline");
+const isUndefined = (t2) => t2 === void 0;
+const isNull = (t2) => t2 === null;
+const isNumber = (t2) => typeof t2 === "number";
+const isString = (t2) => typeof t2 === "string";
+const isBoolean = (t2) => typeof t2 === "boolean";
+const isFunction = (t2) => typeof t2 === "function";
+const isArray = (t2) => Array.isArray(t2);
+const isObject = (t2) => typeof t2 === "object" && !isArray(t2) && !isNull(t2);
+const isArrayLike = (t2) => {
+  const n2 = !!t2 && t2.length;
+  const o2 = isNumber(n2) && n2 > -1 && n2 % 1 == 0;
+  return isArray(t2) || !isFunction(t2) && o2 ? n2 > 0 && isObject(t2) ? n2 - 1 in t2 : true : false;
+};
+const isPlainObject = (t2) => !!t2 && t2.constructor === Object;
+const isHTMLElement = (t2) => t2 instanceof HTMLElement;
+const isElement = (t2) => t2 instanceof Element;
+const animationCurrentTime = () => performance.now();
+const animateNumber = (t2, n2, s2, e2, c2) => {
+  let r2 = 0;
+  const a2 = animationCurrentTime();
+  const u2 = o(0, s2);
+  const frame = (s3) => {
+    const l2 = animationCurrentTime();
+    const _2 = l2 - a2;
+    const d2 = _2 >= u2;
+    const f2 = s3 ? 1 : 1 - (o(0, a2 + u2 - l2) / u2 || 0);
+    const p2 = (n2 - t2) * (isFunction(c2) ? c2(f2, f2 * u2, 0, 1, u2) : f2) + t2;
+    const v2 = d2 || f2 === 1;
+    e2 && e2(p2, f2, v2);
+    r2 = v2 ? 0 : i(() => frame());
+  };
+  frame();
+  return (t3) => {
+    l(r2);
+    t3 && frame(t3);
+  };
+};
+function each(t2, n2) {
+  if (isArrayLike(t2)) {
+    for (let o2 = 0; o2 < t2.length; o2++) {
+      if (n2(t2[o2], o2, t2) === false) {
+        break;
+      }
+    }
+  } else if (t2) {
+    each(Object.keys(t2), (o2) => n2(t2[o2], o2, t2));
+  }
+  return t2;
+}
+const inArray = (t2, n2) => t2.indexOf(n2) >= 0;
+const concat = (t2, n2) => t2.concat(n2);
+const push = (t2, n2, o2) => {
+  !o2 && !isString(n2) && isArrayLike(n2) ? Array.prototype.push.apply(t2, n2) : t2.push(n2);
+  return t2;
+};
+const from = (t2) => Array.from(t2 || []);
+const createOrKeepArray = (t2) => {
+  if (isArray(t2)) {
+    return t2;
+  }
+  return !isString(t2) && isArrayLike(t2) ? from(t2) : [t2];
+};
+const isEmptyArray = (t2) => !!t2 && !t2.length;
+const deduplicateArray = (t2) => from(new Set(t2));
+const runEachAndClear = (t2, n2, o2) => {
+  const runFn = (t3) => t3 && t3.apply(void 0, n2 || []);
+  each(t2, runFn);
+  !o2 && (t2.length = 0);
+};
+const v = "paddingTop";
+const g = "paddingRight";
+const h = "paddingLeft";
+const b = "paddingBottom";
+const w = "marginLeft";
+const y = "marginRight";
+const S = "marginBottom";
+const m = "overflowX";
+const O = "overflowY";
+const $ = "width";
+const C = "height";
+const x = "visible";
+const H = "hidden";
+const E = "scroll";
+const capitalizeFirstLetter = (t2) => {
+  const n2 = String(t2 || "");
+  return n2 ? n2[0].toUpperCase() + n2.slice(1) : "";
+};
+const equal = (t2, n2, o2, s2) => {
+  if (t2 && n2) {
+    let e2 = true;
+    each(o2, (o3) => {
+      const c2 = s2 ? s2(t2[o3]) : t2[o3];
+      const r2 = s2 ? s2(n2[o3]) : n2[o3];
+      if (c2 !== r2) {
+        e2 = false;
+      }
+    });
+    return e2;
+  }
+  return false;
+};
+const equalWH = (t2, n2) => equal(t2, n2, ["w", "h"]);
+const equalXY = (t2, n2) => equal(t2, n2, ["x", "y"]);
+const equalTRBL = (t2, n2) => equal(t2, n2, ["t", "r", "b", "l"]);
+const noop = () => {
+};
+const bind = (t2, ...n2) => t2.bind(0, ...n2);
+const selfClearTimeout = (t2) => {
+  let n2;
+  const o2 = t2 ? a : i;
+  const s2 = t2 ? u : l;
+  return [(e2) => {
+    s2(n2);
+    n2 = o2(() => e2(), isFunction(t2) ? t2() : t2);
+  }, () => s2(n2)];
+};
+const debounce = (t2, n2) => {
+  const { _: o2, p: s2, v: e2, S: c2 } = n2 || {};
+  let r2;
+  let _2;
+  let d2;
+  let f2;
+  let p2 = noop;
+  const v2 = function invokeFunctionToDebounce(n3) {
+    p2();
+    u(r2);
+    f2 = r2 = _2 = void 0;
+    p2 = noop;
+    t2.apply(this, n3);
+  };
+  const mergeParms = (t3) => c2 && _2 ? c2(_2, t3) : t3;
+  const flush = () => {
+    if (p2 !== noop) {
+      v2(mergeParms(d2) || d2);
+    }
+  };
+  const g2 = function debouncedFn() {
+    const t3 = from(arguments);
+    const n3 = isFunction(o2) ? o2() : o2;
+    const c3 = isNumber(n3) && n3 >= 0;
+    if (c3) {
+      const o3 = isFunction(s2) ? s2() : s2;
+      const c4 = isNumber(o3) && o3 >= 0;
+      const g3 = n3 > 0 ? a : i;
+      const h2 = n3 > 0 ? u : l;
+      const b2 = mergeParms(t3);
+      const w2 = b2 || t3;
+      const y2 = v2.bind(0, w2);
+      let S2;
+      p2();
+      if (e2 && !f2) {
+        y2();
+        f2 = true;
+        S2 = g3(() => f2 = void 0, n3);
+      } else {
+        S2 = g3(y2, n3);
+        if (c4 && !r2) {
+          r2 = a(flush, o3);
+        }
+      }
+      p2 = () => h2(S2);
+      _2 = d2 = w2;
+    } else {
+      v2(t3);
+    }
+  };
+  g2.m = flush;
+  return g2;
+};
+const hasOwnProperty = (t2, n2) => Object.prototype.hasOwnProperty.call(t2, n2);
+const keys = (t2) => t2 ? Object.keys(t2) : [];
+const assignDeep = (t2, n2, o2, s2, e2, c2, r2) => {
+  const l2 = [n2, o2, s2, e2, c2, r2];
+  if ((typeof t2 !== "object" || isNull(t2)) && !isFunction(t2)) {
+    t2 = {};
+  }
+  each(l2, (n3) => {
+    each(n3, (o3, s3) => {
+      const e3 = n3[s3];
+      if (t2 === e3) {
+        return true;
+      }
+      const c3 = isArray(e3);
+      if (e3 && isPlainObject(e3)) {
+        const n4 = t2[s3];
+        let o4 = n4;
+        if (c3 && !isArray(n4)) {
+          o4 = [];
+        } else if (!c3 && !isPlainObject(n4)) {
+          o4 = {};
+        }
+        t2[s3] = assignDeep(o4, e3);
+      } else {
+        t2[s3] = c3 ? e3.slice() : e3;
+      }
+    });
+  });
+  return t2;
+};
+const removeUndefinedProperties = (t2, n2) => each(assignDeep({}, t2), (t3, o2, s2) => {
+  if (t3 === void 0) {
+    delete s2[o2];
+  } else if (n2 && t3 && isPlainObject(t3)) {
+    s2[o2] = removeUndefinedProperties(t3, n2);
+  }
+});
+const isEmptyObject = (t2) => !keys(t2).length;
+const capNumber = (t2, n2, e2) => o(t2, s(n2, e2));
+const getDomTokensArray = (t2) => deduplicateArray((isArray(t2) ? t2 : (t2 || "").split(" ")).filter((t3) => t3));
+const getAttr = (t2, n2) => t2 && t2.getAttribute(n2);
+const hasAttr = (t2, n2) => t2 && t2.hasAttribute(n2);
+const setAttrs = (t2, n2, o2) => {
+  each(getDomTokensArray(n2), (n3) => {
+    t2 && t2.setAttribute(n3, String(o2 || ""));
+  });
+};
+const removeAttrs = (t2, n2) => {
+  each(getDomTokensArray(n2), (n3) => t2 && t2.removeAttribute(n3));
+};
+const domTokenListAttr = (t2, n2) => {
+  const o2 = getDomTokensArray(getAttr(t2, n2));
+  const s2 = bind(setAttrs, t2, n2);
+  const domTokenListOperation = (t3, n3) => {
+    const s3 = new Set(o2);
+    each(getDomTokensArray(t3), (t4) => {
+      s3[n3](t4);
+    });
+    return from(s3).join(" ");
+  };
+  return {
+    O: (t3) => s2(domTokenListOperation(t3, "delete")),
+    $: (t3) => s2(domTokenListOperation(t3, "add")),
+    C: (t3) => {
+      const n3 = getDomTokensArray(t3);
+      return n3.reduce((t4, n4) => t4 && o2.includes(n4), n3.length > 0);
+    }
+  };
+};
+const removeAttrClass = (t2, n2, o2) => {
+  domTokenListAttr(t2, n2).O(o2);
+  return bind(addAttrClass, t2, n2, o2);
+};
+const addAttrClass = (t2, n2, o2) => {
+  domTokenListAttr(t2, n2).$(o2);
+  return bind(removeAttrClass, t2, n2, o2);
+};
+const addRemoveAttrClass = (t2, n2, o2, s2) => (s2 ? addAttrClass : removeAttrClass)(t2, n2, o2);
+const hasAttrClass = (t2, n2, o2) => domTokenListAttr(t2, n2).C(o2);
+const createDomTokenListClass = (t2) => domTokenListAttr(t2, "class");
+const removeClass = (t2, n2) => {
+  createDomTokenListClass(t2).O(n2);
+};
+const addClass = (t2, n2) => {
+  createDomTokenListClass(t2).$(n2);
+  return bind(removeClass, t2, n2);
+};
+const find = (t2, n2) => {
+  const o2 = n2 ? isElement(n2) && n2 : document;
+  return o2 ? from(o2.querySelectorAll(t2)) : [];
+};
+const findFirst = (t2, n2) => {
+  const o2 = n2 ? isElement(n2) && n2 : document;
+  return o2 && o2.querySelector(t2);
+};
+const is = (t2, n2) => isElement(t2) && t2.matches(n2);
+const isBodyElement = (t2) => is(t2, "body");
+const contents = (t2) => t2 ? from(t2.childNodes) : [];
+const parent = (t2) => t2 && t2.parentElement;
+const closest = (t2, n2) => isElement(t2) && t2.closest(n2);
+const getFocusedElement = (t2) => (t2 || document).activeElement;
+const liesBetween = (t2, n2, o2) => {
+  const s2 = closest(t2, n2);
+  const e2 = t2 && findFirst(o2, s2);
+  const c2 = closest(e2, n2) === s2;
+  return s2 && e2 ? s2 === t2 || e2 === t2 || c2 && closest(closest(t2, o2), n2) !== s2 : false;
+};
+const removeElements = (t2) => {
+  each(createOrKeepArray(t2), (t3) => {
+    const n2 = parent(t3);
+    t3 && n2 && n2.removeChild(t3);
+  });
+};
+const appendChildren = (t2, n2) => bind(removeElements, t2 && n2 && each(createOrKeepArray(n2), (n3) => {
+  n3 && t2.appendChild(n3);
+}));
+const createDiv = (t2) => {
+  const n2 = document.createElement("div");
+  setAttrs(n2, "class", t2);
+  return n2;
+};
+const createDOM = (t2) => {
+  const n2 = createDiv();
+  n2.innerHTML = t2.trim();
+  return each(contents(n2), (t3) => removeElements(t3));
+};
+const getCSSVal = (t2, n2) => t2.getPropertyValue(n2) || t2[n2] || "";
+const validFiniteNumber = (t2) => {
+  const n2 = t2 || 0;
+  return isFinite(n2) ? n2 : 0;
+};
+const parseToZeroOrNumber = (t2) => validFiniteNumber(parseFloat(t2 || ""));
+const roundCssNumber = (t2) => Math.round(t2 * 1e4) / 1e4;
+const numberToCssPx = (t2) => `${roundCssNumber(validFiniteNumber(t2))}px`;
+function setStyles(t2, n2) {
+  t2 && n2 && each(n2, (n3, o2) => {
+    try {
+      const s2 = t2.style;
+      const e2 = isNull(n3) || isBoolean(n3) ? "" : isNumber(n3) ? numberToCssPx(n3) : n3;
+      if (o2.indexOf("--") === 0) {
+        s2.setProperty(o2, e2);
+      } else {
+        s2[o2] = e2;
+      }
+    } catch (s2) {
+    }
+  });
+}
+function getStyles(t2, o2, s2) {
+  const e2 = isString(o2);
+  let c2 = e2 ? "" : {};
+  if (t2) {
+    const r2 = n.getComputedStyle(t2, s2) || t2.style;
+    c2 = e2 ? getCSSVal(r2, o2) : from(o2).reduce((t3, n2) => {
+      t3[n2] = getCSSVal(r2, n2);
+      return t3;
+    }, c2);
+  }
+  return c2;
+}
+const topRightBottomLeft = (t2, n2, o2) => {
+  const s2 = n2 ? `${n2}-` : "";
+  const e2 = o2 ? `-${o2}` : "";
+  const c2 = `${s2}top${e2}`;
+  const r2 = `${s2}right${e2}`;
+  const l2 = `${s2}bottom${e2}`;
+  const i2 = `${s2}left${e2}`;
+  const a2 = getStyles(t2, [c2, r2, l2, i2]);
+  return {
+    t: parseToZeroOrNumber(a2[c2]),
+    r: parseToZeroOrNumber(a2[r2]),
+    b: parseToZeroOrNumber(a2[l2]),
+    l: parseToZeroOrNumber(a2[i2])
+  };
+};
+const getTrasformTranslateValue = (t2, n2) => `translate${isObject(t2) ? `(${t2.x},${t2.y})` : `${n2 ? "X" : "Y"}(${t2})`}`;
+const elementHasDimensions = (t2) => !!(t2.offsetWidth || t2.offsetHeight || t2.getClientRects().length);
+const z = {
+  w: 0,
+  h: 0
+};
+const getElmWidthHeightProperty = (t2, n2) => n2 ? {
+  w: n2[`${t2}Width`],
+  h: n2[`${t2}Height`]
+} : z;
+const getWindowSize = (t2) => getElmWidthHeightProperty("inner", t2 || n);
+const I = bind(getElmWidthHeightProperty, "offset");
+const A = bind(getElmWidthHeightProperty, "client");
+const D = bind(getElmWidthHeightProperty, "scroll");
+const getFractionalSize = (t2) => {
+  const n2 = parseFloat(getStyles(t2, $)) || 0;
+  const o2 = parseFloat(getStyles(t2, C)) || 0;
+  return {
+    w: n2 - e(n2),
+    h: o2 - e(o2)
+  };
+};
+const getBoundingClientRect = (t2) => t2.getBoundingClientRect();
+const hasDimensions = (t2) => !!t2 && elementHasDimensions(t2);
+const domRectHasDimensions = (t2) => !!(t2 && (t2[C] || t2[$]));
+const domRectAppeared = (t2, n2) => {
+  const o2 = domRectHasDimensions(t2);
+  const s2 = domRectHasDimensions(n2);
+  return !s2 && o2;
+};
+const removeEventListener = (t2, n2, o2, s2) => {
+  each(getDomTokensArray(n2), (n3) => {
+    t2 && t2.removeEventListener(n3, o2, s2);
+  });
+};
+const addEventListener = (t2, n2, o2, s2) => {
+  var e2;
+  const c2 = (e2 = s2 && s2.H) != null ? e2 : true;
+  const r2 = s2 && s2.I || false;
+  const l2 = s2 && s2.A || false;
+  const i2 = {
+    passive: c2,
+    capture: r2
+  };
+  return bind(runEachAndClear, getDomTokensArray(n2).map((n3) => {
+    const s3 = l2 ? (e3) => {
+      removeEventListener(t2, n3, s3, r2);
+      o2 && o2(e3);
+    } : o2;
+    t2 && t2.addEventListener(n3, s3, i2);
+    return bind(removeEventListener, t2, n3, s3, r2);
+  }));
+};
+const stopPropagation = (t2) => t2.stopPropagation();
+const preventDefault = (t2) => t2.preventDefault();
+const stopAndPrevent = (t2) => stopPropagation(t2) || preventDefault(t2);
+const scrollElementTo = (t2, n2) => {
+  const { x: o2, y: s2 } = isNumber(n2) ? {
+    x: n2,
+    y: n2
+  } : n2 || {};
+  isNumber(o2) && (t2.scrollLeft = o2);
+  isNumber(s2) && (t2.scrollTop = s2);
+};
+const getElementScroll = (t2) => ({
+  x: t2.scrollLeft,
+  y: t2.scrollTop
+});
+const getZeroScrollCoordinates = () => ({
+  D: {
+    x: 0,
+    y: 0
+  },
+  T: {
+    x: 0,
+    y: 0
+  }
+});
+const sanitizeScrollCoordinates = (t2, n2) => {
+  const { D: o2, T: s2 } = t2;
+  const { w: e2, h: l2 } = n2;
+  const sanitizeAxis = (t3, n3, o3) => {
+    let s3 = r(t3) * o3;
+    let e3 = r(n3) * o3;
+    if (s3 === e3) {
+      const o4 = c(t3);
+      const r2 = c(n3);
+      e3 = o4 > r2 ? 0 : e3;
+      s3 = o4 < r2 ? 0 : s3;
+    }
+    s3 = s3 === e3 ? 0 : s3;
+    return [s3 + 0, e3 + 0];
+  };
+  const [i2, a2] = sanitizeAxis(o2.x, s2.x, e2);
+  const [u2, _2] = sanitizeAxis(o2.y, s2.y, l2);
+  return {
+    D: {
+      x: i2,
+      y: u2
+    },
+    T: {
+      x: a2,
+      y: _2
+    }
+  };
+};
+const isDefaultDirectionScrollCoordinates = ({ D: t2, T: n2 }) => {
+  const getAxis = (t3, n3) => t3 === 0 && t3 <= n3;
+  return {
+    x: getAxis(t2.x, n2.x),
+    y: getAxis(t2.y, n2.y)
+  };
+};
+const getScrollCoordinatesPercent = ({ D: t2, T: n2 }, o2) => {
+  const getAxis = (t3, n3, o3) => capNumber(0, 1, (t3 - o3) / (t3 - n3) || 0);
+  return {
+    x: getAxis(t2.x, n2.x, o2.x),
+    y: getAxis(t2.y, n2.y, o2.y)
+  };
+};
+const focusElement = (t2) => {
+  if (t2 && t2.focus) {
+    t2.focus({
+      preventScroll: true
+    });
+  }
+};
+const manageListener = (t2, n2) => {
+  each(createOrKeepArray(n2), t2);
+};
+const createEventListenerHub = (t2) => {
+  const n2 = /* @__PURE__ */ new Map();
+  const removeEvent = (t3, o2) => {
+    if (t3) {
+      const s2 = n2.get(t3);
+      manageListener((t4) => {
+        if (s2) {
+          s2[t4 ? "delete" : "clear"](t4);
+        }
+      }, o2);
+    } else {
+      n2.forEach((t4) => {
+        t4.clear();
+      });
+      n2.clear();
+    }
+  };
+  const addEvent = (t3, o2) => {
+    if (isString(t3)) {
+      const s3 = n2.get(t3) || /* @__PURE__ */ new Set();
+      n2.set(t3, s3);
+      manageListener((t4) => {
+        isFunction(t4) && s3.add(t4);
+      }, o2);
+      return bind(removeEvent, t3, o2);
+    }
+    if (isBoolean(o2) && o2) {
+      removeEvent();
+    }
+    const s2 = keys(t3);
+    const e2 = [];
+    each(s2, (n3) => {
+      const o3 = t3[n3];
+      o3 && push(e2, addEvent(n3, o3));
+    });
+    return bind(runEachAndClear, e2);
+  };
+  const triggerEvent = (t3, o2) => {
+    each(from(n2.get(t3)), (t4) => {
+      if (o2 && !isEmptyArray(o2)) {
+        t4.apply(0, o2);
+      } else {
+        t4();
+      }
+    });
+  };
+  addEvent(t2 || {});
+  return [addEvent, removeEvent, triggerEvent];
+};
+const opsStringify = (t2) => JSON.stringify(t2, (t3, n2) => {
+  if (isFunction(n2)) {
+    throw 0;
+  }
+  return n2;
+});
+const getPropByPath = (t2, n2) => t2 ? `${n2}`.split(".").reduce((t3, n3) => t3 && hasOwnProperty(t3, n3) ? t3[n3] : void 0, t2) : void 0;
+const T = {
+  paddingAbsolute: false,
+  showNativeOverlaidScrollbars: false,
+  update: {
+    elementEvents: [["img", "load"]],
+    debounce: [0, 33],
+    attributes: null,
+    ignoreMutation: null
+  },
+  overflow: {
+    x: "scroll",
+    y: "scroll"
+  },
+  scrollbars: {
+    theme: "os-theme-dark",
+    visibility: "auto",
+    autoHide: "never",
+    autoHideDelay: 1300,
+    autoHideSuspend: false,
+    dragScroll: true,
+    clickScroll: false,
+    pointers: ["mouse", "touch", "pen"]
+  }
+};
+const getOptionsDiff = (t2, n2) => {
+  const o2 = {};
+  const s2 = concat(keys(n2), keys(t2));
+  each(s2, (s3) => {
+    const e2 = t2[s3];
+    const c2 = n2[s3];
+    if (isObject(e2) && isObject(c2)) {
+      assignDeep(o2[s3] = {}, getOptionsDiff(e2, c2));
+      if (isEmptyObject(o2[s3])) {
+        delete o2[s3];
+      }
+    } else if (hasOwnProperty(n2, s3) && c2 !== e2) {
+      let t3 = true;
+      if (isArray(e2) || isArray(c2)) {
+        try {
+          if (opsStringify(e2) === opsStringify(c2)) {
+            t3 = false;
+          }
+        } catch (r2) {
+        }
+      }
+      if (t3) {
+        o2[s3] = c2;
+      }
+    }
+  });
+  return o2;
+};
+const createOptionCheck = (t2, n2, o2) => (s2) => [getPropByPath(t2, s2), o2 || getPropByPath(n2, s2) !== void 0];
+const k = `data-overlayscrollbars`;
+const M = "os-environment";
+const R = `${M}-scrollbar-hidden`;
+const V = `${k}-initialize`;
+const L = "noClipping";
+const U = `${k}-body`;
+const P = k;
+const N = "host";
+const q = `${k}-viewport`;
+const B = m;
+const F = O;
+const j = "arrange";
+const X = "measuring";
+const Y = "scrolling";
+const W = "scrollbarHidden";
+const J = "noContent";
+const G = `${k}-padding`;
+const K = `${k}-content`;
+const Q = "os-size-observer";
+const Z = `${Q}-appear`;
+const tt = `${Q}-listener`;
+const et = "os-trinsic-observer";
+const ct = "os-theme-none";
+const rt = "os-scrollbar";
+const lt = `${rt}-rtl`;
+const it = `${rt}-horizontal`;
+const at = `${rt}-vertical`;
+const ut = `${rt}-track`;
+const _t = `${rt}-handle`;
+const dt = `${rt}-visible`;
+const ft = `${rt}-cornerless`;
+const pt = `${rt}-interaction`;
+const vt = `${rt}-unusable`;
+const gt = `${rt}-auto-hide`;
+const ht = `${gt}-hidden`;
+const bt = `${rt}-wheel`;
+const wt = `${ut}-interactive`;
+const yt = `${_t}-interactive`;
+let St;
+const getNonce = () => St;
+const setNonce = (t2) => {
+  St = t2;
+};
+let mt;
+const createEnvironment = () => {
+  const getNativeScrollbarSize = (t3, n2, o3) => {
+    appendChildren(document.body, t3);
+    appendChildren(document.body, t3);
+    const s3 = A(t3);
+    const e3 = I(t3);
+    const c3 = getFractionalSize(n2);
+    o3 && removeElements(t3);
+    return {
+      x: e3.h - s3.h + c3.h,
+      y: e3.w - s3.w + c3.w
+    };
+  };
+  const getNativeScrollbarsHiding = (t3) => {
+    let n2 = false;
+    const o3 = addClass(t3, R);
+    try {
+      n2 = getStyles(t3, "scrollbar-width") === "none" || getStyles(t3, "display", "::-webkit-scrollbar") === "none";
+    } catch (s3) {
+    }
+    o3();
+    return n2;
+  };
+  const t2 = `.${M}{scroll-behavior:auto!important;position:fixed;opacity:0;visibility:hidden;overflow:scroll;height:200px;width:200px;z-index:-1}.${M} div{width:200%;height:200%;margin:10px 0}.${R}{scrollbar-width:none!important}.${R}::-webkit-scrollbar,.${R}::-webkit-scrollbar-corner{appearance:none!important;display:none!important;width:0!important;height:0!important}`;
+  const o2 = createDOM(`<div class="${M}"><div></div><style>${t2}</style></div>`);
+  const s2 = o2[0];
+  const e2 = s2.firstChild;
+  const c2 = s2.lastChild;
+  const r2 = getNonce();
+  if (r2) {
+    c2.nonce = r2;
+  }
+  const [l2, , i2] = createEventListenerHub();
+  const [a2, u2] = createCache({
+    o: getNativeScrollbarSize(s2, e2),
+    i: equalXY
+  }, bind(getNativeScrollbarSize, s2, e2, true));
+  const [_2] = u2();
+  const d2 = getNativeScrollbarsHiding(s2);
+  const f2 = {
+    x: _2.x === 0,
+    y: _2.y === 0
+  };
+  const v2 = {
+    elements: {
+      host: null,
+      padding: !d2,
+      viewport: (t3) => d2 && isBodyElement(t3) && t3,
+      content: false
+    },
+    scrollbars: {
+      slot: true
+    },
+    cancel: {
+      nativeScrollbarsOverlaid: false,
+      body: null
+    }
+  };
+  const g2 = assignDeep({}, T);
+  const h2 = bind(assignDeep, {}, g2);
+  const b2 = bind(assignDeep, {}, v2);
+  const w2 = {
+    k: _2,
+    M: f2,
+    R: d2,
+    V: !!p,
+    L: bind(l2, "r"),
+    U: b2,
+    P: (t3) => assignDeep(v2, t3) && b2(),
+    N: h2,
+    q: (t3) => assignDeep(g2, t3) && h2(),
+    B: assignDeep({}, v2),
+    F: assignDeep({}, g2)
+  };
+  removeAttrs(s2, "style");
+  removeElements(s2);
+  addEventListener(n, "resize", () => {
+    i2("r", []);
+  });
+  if (isFunction(n.matchMedia) && !d2 && (!f2.x || !f2.y)) {
+    const addZoomListener = (t3) => {
+      const o3 = n.matchMedia(`(resolution: ${n.devicePixelRatio}dppx)`);
+      addEventListener(o3, "change", () => {
+        t3();
+        addZoomListener(t3);
+      }, {
+        A: true
+      });
+    };
+    addZoomListener(() => {
+      const [t3, n2] = a2();
+      assignDeep(w2.k, t3);
+      i2("r", [n2]);
+    });
+  }
+  return w2;
+};
+const getEnvironment = () => {
+  if (!mt) {
+    mt = createEnvironment();
+  }
+  return mt;
+};
+const resolveInitialization = (t2, n2) => isFunction(n2) ? n2.apply(0, t2) : n2;
+const staticInitializationElement = (t2, n2, o2, s2) => {
+  const e2 = isUndefined(s2) ? o2 : s2;
+  const c2 = resolveInitialization(t2, e2);
+  return c2 || n2.apply(0, t2);
+};
+const dynamicInitializationElement = (t2, n2, o2, s2) => {
+  const e2 = isUndefined(s2) ? o2 : s2;
+  const c2 = resolveInitialization(t2, e2);
+  return !!c2 && (isHTMLElement(c2) ? c2 : n2.apply(0, t2));
+};
+const cancelInitialization = (t2, n2) => {
+  const { nativeScrollbarsOverlaid: o2, body: s2 } = n2 || {};
+  const { M: e2, R: c2, U: r2 } = getEnvironment();
+  const { nativeScrollbarsOverlaid: l2, body: i2 } = r2().cancel;
+  const a2 = o2 != null ? o2 : l2;
+  const u2 = isUndefined(s2) ? i2 : s2;
+  const _2 = (e2.x || e2.y) && a2;
+  const d2 = t2 && (isNull(u2) ? !c2 : u2);
+  return !!_2 || !!d2;
+};
+const Ot = /* @__PURE__ */ new WeakMap();
+const addInstance = (t2, n2) => {
+  Ot.set(t2, n2);
+};
+const removeInstance = (t2) => {
+  Ot.delete(t2);
+};
+const getInstance = (t2) => Ot.get(t2);
+const createEventContentChange = (t2, n2, o2) => {
+  let s2 = false;
+  const e2 = o2 ? /* @__PURE__ */ new WeakMap() : false;
+  const destroy = () => {
+    s2 = true;
+  };
+  const updateElements = (c2) => {
+    if (e2 && o2) {
+      const r2 = o2.map((n3) => {
+        const [o3, s3] = n3 || [];
+        const e3 = s3 && o3 ? (c2 || find)(o3, t2) : [];
+        return [e3, s3];
+      });
+      each(r2, (o3) => each(o3[0], (c3) => {
+        const r3 = o3[1];
+        const l2 = e2.get(c3) || [];
+        const i2 = t2.contains(c3);
+        if (i2 && r3) {
+          const t3 = addEventListener(c3, r3, (o4) => {
+            if (s2) {
+              t3();
+              e2.delete(c3);
+            } else {
+              n2(o4);
+            }
+          });
+          e2.set(c3, push(l2, t3));
+        } else {
+          runEachAndClear(l2);
+          e2.delete(c3);
+        }
+      }));
+    }
+  };
+  updateElements();
+  return [destroy, updateElements];
+};
+const createDOMObserver = (t2, n2, o2, s2) => {
+  let e2 = false;
+  const { j: c2, X: r2, Y: l2, W: i2, J: a2, G: u2 } = s2 || {};
+  const d2 = debounce(() => e2 && o2(true), {
+    _: 33,
+    p: 99
+  });
+  const [f2, p2] = createEventContentChange(t2, d2, l2);
+  const v2 = c2 || [];
+  const g2 = r2 || [];
+  const h2 = concat(v2, g2);
+  const observerCallback = (e3, c3) => {
+    if (!isEmptyArray(c3)) {
+      const r3 = a2 || noop;
+      const l3 = u2 || noop;
+      const _2 = [];
+      const d3 = [];
+      let f3 = false;
+      let v3 = false;
+      each(c3, (o3) => {
+        const { attributeName: e4, target: c4, type: a3, oldValue: u3, addedNodes: p3, removedNodes: h3 } = o3;
+        const b3 = a3 === "attributes";
+        const w2 = a3 === "childList";
+        const y2 = t2 === c4;
+        const S2 = b3 && e4;
+        const m2 = S2 && getAttr(c4, e4 || "");
+        const O2 = isString(m2) ? m2 : null;
+        const $2 = S2 && u3 !== O2;
+        const C2 = inArray(g2, e4) && $2;
+        if (n2 && (w2 || !y2)) {
+          const n3 = b3 && $2;
+          const a4 = n3 && i2 && is(c4, i2);
+          const d4 = a4 ? !r3(c4, e4, u3, O2) : !b3 || n3;
+          const f4 = d4 && !l3(o3, !!a4, t2, s2);
+          each(p3, (t3) => push(_2, t3));
+          each(h3, (t3) => push(_2, t3));
+          v3 = v3 || f4;
+        }
+        if (!n2 && y2 && $2 && !r3(c4, e4, u3, O2)) {
+          push(d3, e4);
+          f3 = f3 || C2;
+        }
+      });
+      p2((t3) => deduplicateArray(_2).reduce((n3, o3) => {
+        push(n3, find(t3, o3));
+        return is(o3, t3) ? push(n3, o3) : n3;
+      }, []));
+      if (n2) {
+        !e3 && v3 && o2(false);
+        return [false];
+      }
+      if (!isEmptyArray(d3) || f3) {
+        const t3 = [deduplicateArray(d3), f3];
+        !e3 && o2.apply(0, t3);
+        return t3;
+      }
+    }
+  };
+  const b2 = new _(bind(observerCallback, false));
+  return [() => {
+    b2.observe(t2, {
+      attributes: true,
+      attributeOldValue: true,
+      attributeFilter: h2,
+      subtree: n2,
+      childList: n2,
+      characterData: n2
+    });
+    e2 = true;
+    return () => {
+      if (e2) {
+        f2();
+        b2.disconnect();
+        e2 = false;
+      }
+    };
+  }, () => {
+    if (e2) {
+      d2.m();
+      return observerCallback(true, b2.takeRecords());
+    }
+  }];
+};
+const $t = {};
+const Ct = {};
+const addPlugins = (t2) => {
+  each(t2, (t3) => each(t3, (n2, o2) => {
+    $t[o2] = t3[o2];
+  }));
+};
+const registerPluginModuleInstances = (t2, n2, o2) => keys(t2).map((s2) => {
+  const { static: e2, instance: c2 } = t2[s2];
+  const [r2, l2, i2] = o2 || [];
+  const a2 = o2 ? c2 : e2;
+  if (a2) {
+    const t3 = o2 ? a2(r2, l2, n2) : a2(n2);
+    return (i2 || Ct)[s2] = t3;
+  }
+});
+const getStaticPluginModuleInstance = (t2) => Ct[t2];
+const xt = "__osOptionsValidationPlugin";
+const Ht = "__osSizeObserverPlugin";
+const getShowNativeOverlaidScrollbars = (t2, n2) => {
+  const { M: o2 } = n2;
+  const [s2, e2] = t2("showNativeOverlaidScrollbars");
+  return [s2 && o2.x && o2.y, e2];
+};
+const overflowIsVisible = (t2) => t2.indexOf(x) === 0;
+const createViewportOverflowState = (t2, n2) => {
+  const getAxisOverflowStyle = (t3, n3, o3, s2) => {
+    const e2 = t3 === x ? H : t3.replace(`${x}-`, "");
+    const c2 = overflowIsVisible(t3);
+    const r2 = overflowIsVisible(o3);
+    if (!n3 && !s2) {
+      return H;
+    }
+    if (c2 && r2) {
+      return x;
+    }
+    if (c2) {
+      const t4 = n3 ? x : H;
+      return n3 && s2 ? e2 : t4;
+    }
+    const l2 = r2 && s2 ? x : H;
+    return n3 ? e2 : l2;
+  };
+  const o2 = {
+    x: getAxisOverflowStyle(n2.x, t2.x, n2.y, t2.y),
+    y: getAxisOverflowStyle(n2.y, t2.y, n2.x, t2.x)
+  };
+  return {
+    K: o2,
+    Z: {
+      x: o2.x === E,
+      y: o2.y === E
+    }
+  };
+};
+const zt = "__osScrollbarsHidingPlugin";
+const At = "__osClickScrollPlugin";
+const Dt = /* @__PURE__ */ (() => ({
+  [At]: {
+    static: () => (t2, n2, o2, s2, e2) => {
+      let c2 = false;
+      let r2 = noop;
+      let l2 = noop;
+      const [i2, a2] = selfClearTimeout(133);
+      const animateClickScroll = (r3, a3, u2) => animateNumber(r3, r3 + s2 * Math.sign(o2), a3 ? 133 : 222, (o3, r4, u3) => {
+        t2(o3);
+        const _2 = n2();
+        const d2 = _2 + s2;
+        const f2 = e2 >= _2 && e2 <= d2;
+        const animationCompletedAction = () => {
+          l2 = animateClickScroll(o3, a3 + 1);
+        };
+        if (!c2 && u3 && !f2) {
+          if (a3) {
+            animationCompletedAction();
+          } else {
+            i2(animationCompletedAction);
+          }
+        }
+      }, u2);
+      r2 = animateClickScroll(0, 0, (t3) => 1 - (1 - t3) * (1 - t3));
+      return (t3) => {
+        c2 = true;
+        a2();
+        if (t3) {
+          r2();
+          l2();
+        } else {
+          l2();
+        }
+      };
+    }
+  }
+}))();
+const createSizeObserver = (t2, n2, o2) => {
+  const { dt: s2 } = o2 || {};
+  const e2 = getStaticPluginModuleInstance(Ht);
+  const [c2] = createCache({
+    o: false,
+    u: true
+  });
+  return () => {
+    const o3 = [];
+    const r2 = createDOM(`<div class="${Q}"><div class="${tt}"></div></div>`);
+    const l2 = r2[0];
+    const i2 = l2.firstChild;
+    const onSizeChangedCallbackProxy = (t3) => {
+      const o4 = t3 instanceof ResizeObserverEntry;
+      let s3 = false;
+      let e3 = false;
+      if (o4) {
+        const [n3, , o5] = c2(t3.contentRect);
+        const r3 = domRectHasDimensions(n3);
+        e3 = domRectAppeared(n3, o5);
+        s3 = !e3 && !r3;
+      } else {
+        e3 = t3 === true;
+      }
+      if (!s3) {
+        n2({
+          ft: true,
+          dt: e3
+        });
+      }
+    };
+    if (f) {
+      const t3 = new f((t4) => onSizeChangedCallbackProxy(t4.pop()));
+      t3.observe(i2);
+      push(o3, () => {
+        t3.disconnect();
+      });
+    } else if (e2) {
+      const [t3, n3] = e2(i2, onSizeChangedCallbackProxy, s2);
+      push(o3, concat([addClass(l2, Z), addEventListener(l2, "animationstart", t3)], n3));
+    } else {
+      return noop;
+    }
+    return bind(runEachAndClear, push(o3, appendChildren(t2, l2)));
+  };
+};
+const createTrinsicObserver = (t2, n2) => {
+  let o2;
+  const isHeightIntrinsic = (t3) => t3.h === 0 || t3.isIntersecting || t3.intersectionRatio > 0;
+  const s2 = createDiv(et);
+  const [e2] = createCache({
+    o: false
+  });
+  const triggerOnTrinsicChangedCallback = (t3, o3) => {
+    if (t3) {
+      const s3 = e2(isHeightIntrinsic(t3));
+      const [, c2] = s3;
+      return c2 && !o3 && n2(s3) && [s3];
+    }
+  };
+  const intersectionObserverCallback = (t3, n3) => triggerOnTrinsicChangedCallback(n3.pop(), t3);
+  return [() => {
+    const n3 = [];
+    if (d) {
+      o2 = new d(bind(intersectionObserverCallback, false), {
+        root: t2
+      });
+      o2.observe(s2);
+      push(n3, () => {
+        o2.disconnect();
+      });
+    } else {
+      const onSizeChanged = () => {
+        const t3 = I(s2);
+        triggerOnTrinsicChangedCallback(t3);
+      };
+      push(n3, createSizeObserver(s2, onSizeChanged)());
+      onSizeChanged();
+    }
+    return bind(runEachAndClear, push(n3, appendChildren(t2, s2)));
+  }, () => o2 && intersectionObserverCallback(true, o2.takeRecords())];
+};
+const createObserversSetup = (t2, n2, o2, s2) => {
+  let e2;
+  let c2;
+  let r2;
+  let l2;
+  let i2;
+  let a2;
+  const u2 = `[${P}]`;
+  const _2 = `[${q}]`;
+  const d2 = ["id", "class", "style", "open", "wrap", "cols", "rows"];
+  const { vt: p2, gt: v2, ot: g2, ht: h2, bt: b2, nt: w2, wt: y2, yt: S2, St: m2, Ot: O2 } = t2;
+  const getDirectionIsRTL = (t3) => getStyles(t3, "direction") === "rtl";
+  const $2 = {
+    $t: false,
+    ct: getDirectionIsRTL(p2)
+  };
+  const C2 = getEnvironment();
+  const x2 = getStaticPluginModuleInstance(zt);
+  const [H2] = createCache({
+    i: equalWH,
+    o: {
+      w: 0,
+      h: 0
+    }
+  }, () => {
+    const s3 = x2 && x2.tt(t2, n2, $2, C2, o2).ut;
+    const e3 = y2 && w2;
+    const c3 = !e3 && hasAttrClass(v2, P, L);
+    const r3 = !w2 && S2(j);
+    const l3 = r3 && getElementScroll(h2);
+    const i3 = l3 && O2();
+    const a3 = m2(X, c3);
+    const u3 = r3 && s3 && s3()[0];
+    const _3 = D(g2);
+    const d3 = getFractionalSize(g2);
+    u3 && u3();
+    scrollElementTo(h2, l3);
+    i3 && i3();
+    c3 && a3();
+    return {
+      w: _3.w + d3.w,
+      h: _3.h + d3.h
+    };
+  });
+  const E2 = debounce(s2, {
+    _: () => e2,
+    p: () => c2,
+    S(t3, n3) {
+      const [o3] = t3;
+      const [s3] = n3;
+      return [concat(keys(o3), keys(s3)).reduce((t4, n4) => {
+        t4[n4] = o3[n4] || s3[n4];
+        return t4;
+      }, {})];
+    }
+  });
+  const setDirection = (t3) => {
+    const n3 = getDirectionIsRTL(p2);
+    assignDeep(t3, {
+      Ct: a2 !== n3
+    });
+    assignDeep($2, {
+      ct: n3
+    });
+    a2 = n3;
+  };
+  const onTrinsicChanged = (t3, n3) => {
+    const [o3, e3] = t3;
+    const c3 = {
+      xt: e3
+    };
+    assignDeep($2, {
+      $t: o3
+    });
+    !n3 && s2(c3);
+    return c3;
+  };
+  const onSizeChanged = ({ ft: t3, dt: n3 }) => {
+    const o3 = t3 && !n3;
+    const e3 = !o3 && C2.R ? E2 : s2;
+    const c3 = {
+      ft: t3 || n3,
+      dt: n3
+    };
+    setDirection(c3);
+    e3(c3);
+  };
+  const onContentMutation = (t3, n3) => {
+    const [, o3] = H2();
+    const e3 = {
+      Ht: o3
+    };
+    setDirection(e3);
+    const c3 = t3 ? s2 : E2;
+    o3 && !n3 && c3(e3);
+    return e3;
+  };
+  const onHostMutation = (t3, n3, o3) => {
+    const s3 = {
+      Et: n3
+    };
+    setDirection(s3);
+    if (n3 && !o3) {
+      E2(s3);
+    }
+    return s3;
+  };
+  const [z2, I2] = b2 ? createTrinsicObserver(v2, onTrinsicChanged) : [];
+  const A2 = !w2 && createSizeObserver(v2, onSizeChanged, {
+    dt: true
+  });
+  const [T2, k2] = createDOMObserver(v2, false, onHostMutation, {
+    X: d2,
+    j: d2
+  });
+  const M2 = w2 && f && new f((t3) => {
+    const n3 = t3[t3.length - 1].contentRect;
+    onSizeChanged({
+      ft: true,
+      dt: domRectAppeared(n3, i2)
+    });
+    i2 = n3;
+  });
+  const R2 = debounce(() => {
+    const [, t3] = H2();
+    s2({
+      Ht: t3
+    });
+  }, {
+    _: 222,
+    v: true
+  });
+  return [() => {
+    M2 && M2.observe(v2);
+    const t3 = A2 && A2();
+    const n3 = z2 && z2();
+    const o3 = T2();
+    const s3 = C2.L((t4) => {
+      if (t4) {
+        E2({
+          zt: t4
+        });
+      } else {
+        R2();
+      }
+    });
+    return () => {
+      M2 && M2.disconnect();
+      t3 && t3();
+      n3 && n3();
+      l2 && l2();
+      o3();
+      s3();
+    };
+  }, ({ It: t3, At: n3, Dt: o3 }) => {
+    const s3 = {};
+    const [i3] = t3("update.ignoreMutation");
+    const [a3, f2] = t3("update.attributes");
+    const [p3, v3] = t3("update.elementEvents");
+    const [h3, y3] = t3("update.debounce");
+    const S3 = v3 || f2;
+    const m3 = n3 || o3;
+    const ignoreMutationFromOptions = (t4) => isFunction(i3) && i3(t4);
+    if (S3) {
+      r2 && r2();
+      l2 && l2();
+      const [t4, n4] = createDOMObserver(b2 || g2, true, onContentMutation, {
+        j: concat(d2, a3 || []),
+        Y: p3,
+        W: u2,
+        G: (t5, n5) => {
+          const { target: o4, attributeName: s4 } = t5;
+          const e3 = !n5 && s4 && !w2 ? liesBetween(o4, u2, _2) : false;
+          return e3 || !!closest(o4, `.${rt}`) || !!ignoreMutationFromOptions(t5);
+        }
+      });
+      l2 = t4();
+      r2 = n4;
+    }
+    if (y3) {
+      E2.m();
+      if (isArray(h3)) {
+        const t4 = h3[0];
+        const n4 = h3[1];
+        e2 = isNumber(t4) && t4;
+        c2 = isNumber(n4) && n4;
+      } else if (isNumber(h3)) {
+        e2 = h3;
+        c2 = false;
+      } else {
+        e2 = false;
+        c2 = false;
+      }
+    }
+    if (m3) {
+      const t4 = k2();
+      const n4 = I2 && I2();
+      const o4 = r2 && r2();
+      t4 && assignDeep(s3, onHostMutation(t4[0], t4[1], m3));
+      n4 && assignDeep(s3, onTrinsicChanged(n4[0], m3));
+      o4 && assignDeep(s3, onContentMutation(o4[0], m3));
+    }
+    setDirection(s3);
+    return s3;
+  }, $2];
+};
+const createScrollbarsSetupElements = (t2, n2, o2, s2) => {
+  const e2 = "--os-viewport-percent";
+  const c2 = "--os-scroll-percent";
+  const r2 = "--os-scroll-direction";
+  const { U: l2 } = getEnvironment();
+  const { scrollbars: i2 } = l2();
+  const { slot: a2 } = i2;
+  const { vt: u2, gt: _2, ot: d2, Tt: f2, ht: v2, wt: g2, nt: h2 } = n2;
+  const { scrollbars: b2 } = f2 ? {} : t2;
+  const { slot: w2 } = b2 || {};
+  const y2 = [];
+  const S2 = [];
+  const m2 = [];
+  const O2 = dynamicInitializationElement([u2, _2, d2], () => h2 && g2 ? u2 : _2, a2, w2);
+  const initScrollTimeline = (t3) => {
+    if (p) {
+      const n3 = new p({
+        source: v2,
+        axis: t3
+      });
+      const _addScrollPercentAnimation = (t4) => {
+        const o3 = t4.kt.animate({
+          clear: ["left"],
+          [c2]: [0, 1]
+        }, {
+          timeline: n3
+        });
+        return () => o3.cancel();
+      };
+      return {
+        Mt: _addScrollPercentAnimation
+      };
+    }
+  };
+  const $2 = {
+    x: initScrollTimeline("x"),
+    y: initScrollTimeline("y")
+  };
+  const getViewportPercent = () => {
+    const { Rt: t3, Vt: n3 } = o2;
+    const getAxisValue = (t4, n4) => capNumber(0, 1, t4 / (t4 + n4) || 0);
+    return {
+      x: getAxisValue(n3.x, t3.x),
+      y: getAxisValue(n3.y, t3.y)
+    };
+  };
+  const scrollbarStructureAddRemoveClass = (t3, n3, o3) => {
+    const s3 = o3 ? addClass : removeClass;
+    each(t3, (t4) => {
+      s3(t4.kt, n3);
+    });
+  };
+  const scrollbarStyle = (t3, n3) => {
+    each(t3, (t4) => {
+      const [o3, s3] = n3(t4);
+      setStyles(o3, s3);
+    });
+  };
+  const scrollbarsAddRemoveClass = (t3, n3, o3) => {
+    const s3 = isBoolean(o3);
+    const e3 = s3 ? o3 : true;
+    const c3 = s3 ? !o3 : true;
+    e3 && scrollbarStructureAddRemoveClass(S2, t3, n3);
+    c3 && scrollbarStructureAddRemoveClass(m2, t3, n3);
+  };
+  const refreshScrollbarsHandleLength = () => {
+    const t3 = getViewportPercent();
+    const createScrollbarStyleFn = (t4) => (n3) => [n3.kt, {
+      [e2]: roundCssNumber(t4) + ""
+    }];
+    scrollbarStyle(S2, createScrollbarStyleFn(t3.x));
+    scrollbarStyle(m2, createScrollbarStyleFn(t3.y));
+  };
+  const refreshScrollbarsHandleOffset = () => {
+    if (!p) {
+      const { Lt: t3 } = o2;
+      const n3 = getScrollCoordinatesPercent(t3, getElementScroll(v2));
+      const createScrollbarStyleFn = (t4) => (n4) => [n4.kt, {
+        [c2]: roundCssNumber(t4) + ""
+      }];
+      scrollbarStyle(S2, createScrollbarStyleFn(n3.x));
+      scrollbarStyle(m2, createScrollbarStyleFn(n3.y));
+    }
+  };
+  const refreshScrollbarsScrollCoordinates = () => {
+    const { Lt: t3 } = o2;
+    const n3 = isDefaultDirectionScrollCoordinates(t3);
+    const createScrollbarStyleFn = (t4) => (n4) => [n4.kt, {
+      [r2]: t4 ? "0" : "1"
+    }];
+    scrollbarStyle(S2, createScrollbarStyleFn(n3.x));
+    scrollbarStyle(m2, createScrollbarStyleFn(n3.y));
+  };
+  const refreshScrollbarsScrollbarOffset = () => {
+    if (h2 && !g2) {
+      const { Rt: t3, Lt: n3 } = o2;
+      const s3 = isDefaultDirectionScrollCoordinates(n3);
+      const e3 = getScrollCoordinatesPercent(n3, getElementScroll(v2));
+      const styleScrollbarPosition = (n4) => {
+        const { kt: o3 } = n4;
+        const c3 = parent(o3) === d2 && o3;
+        const getTranslateValue = (t4, n5, o4) => {
+          const s4 = n5 * t4;
+          return numberToCssPx(o4 ? s4 : -s4);
+        };
+        return [c3, c3 && {
+          transform: getTrasformTranslateValue({
+            x: getTranslateValue(e3.x, t3.x, s3.x),
+            y: getTranslateValue(e3.y, t3.y, s3.y)
+          })
+        }];
+      };
+      scrollbarStyle(S2, styleScrollbarPosition);
+      scrollbarStyle(m2, styleScrollbarPosition);
+    }
+  };
+  const generateScrollbarDOM = (t3) => {
+    const n3 = t3 ? "x" : "y";
+    const o3 = t3 ? it : at;
+    const e3 = createDiv(`${rt} ${o3}`);
+    const c3 = createDiv(ut);
+    const r3 = createDiv(_t);
+    const l3 = {
+      kt: e3,
+      Ut: c3,
+      Pt: r3
+    };
+    const i3 = $2[n3];
+    push(t3 ? S2 : m2, l3);
+    push(y2, [appendChildren(e3, c3), appendChildren(c3, r3), bind(removeElements, e3), i3 && i3.Mt(l3), s2(l3, scrollbarsAddRemoveClass, t3)]);
+    return l3;
+  };
+  const C2 = bind(generateScrollbarDOM, true);
+  const x2 = bind(generateScrollbarDOM, false);
+  const appendElements = () => {
+    appendChildren(O2, S2[0].kt);
+    appendChildren(O2, m2[0].kt);
+    return bind(runEachAndClear, y2);
+  };
+  C2();
+  x2();
+  return [{
+    Nt: refreshScrollbarsHandleLength,
+    qt: refreshScrollbarsHandleOffset,
+    Bt: refreshScrollbarsScrollCoordinates,
+    Ft: refreshScrollbarsScrollbarOffset,
+    jt: scrollbarsAddRemoveClass,
+    Xt: {
+      Yt: S2,
+      Wt: C2,
+      Jt: bind(scrollbarStyle, S2)
+    },
+    Gt: {
+      Yt: m2,
+      Wt: x2,
+      Jt: bind(scrollbarStyle, m2)
+    }
+  }, appendElements];
+};
+const createScrollbarsSetupEvents = (t2, n2, o2, s2) => (r2, l2, i2) => {
+  const { gt: u2, ot: _2, nt: d2, ht: f2, Kt: p2, Ot: v2 } = n2;
+  const { kt: g2, Ut: h2, Pt: b2 } = r2;
+  const [w2, y2] = selfClearTimeout(333);
+  const [S2, m2] = selfClearTimeout(444);
+  const scrollOffsetElementScrollBy = (t3) => {
+    isFunction(f2.scrollBy) && f2.scrollBy({
+      behavior: "smooth",
+      left: t3.x,
+      top: t3.y
+    });
+  };
+  const createInteractiveScrollEvents = () => {
+    const n3 = "pointerup pointercancel lostpointercapture";
+    const s3 = `client${i2 ? "X" : "Y"}`;
+    const r3 = i2 ? $ : C;
+    const l3 = i2 ? "left" : "top";
+    const a2 = i2 ? "w" : "h";
+    const u3 = i2 ? "x" : "y";
+    const createRelativeHandleMove = (t3, n4) => (s4) => {
+      const { Rt: e2 } = o2;
+      const c2 = I(h2)[a2] - I(b2)[a2];
+      const r4 = n4 * s4 / c2;
+      const l4 = r4 * e2[u3];
+      scrollElementTo(f2, {
+        [u3]: t3 + l4
+      });
+    };
+    const _3 = [];
+    return addEventListener(h2, "pointerdown", (o3) => {
+      const i3 = closest(o3.target, `.${_t}`) === b2;
+      const d3 = i3 ? b2 : h2;
+      const g3 = t2.scrollbars;
+      const { button: w3, isPrimary: y3, pointerType: O3 } = o3;
+      const { pointers: $2 } = g3;
+      const C2 = w3 === 0 && y3 && g3[i3 ? "dragScroll" : "clickScroll"] && ($2 || []).includes(O3);
+      if (C2) {
+        runEachAndClear(_3);
+        m2();
+        const t3 = !i3 && o3.shiftKey;
+        const g4 = bind(getBoundingClientRect, b2);
+        const w4 = bind(getBoundingClientRect, h2);
+        const getHandleOffset = (t4, n4) => (t4 || g4())[l3] - (n4 || w4())[l3];
+        const y4 = e(getBoundingClientRect(f2)[r3]) / I(f2)[a2] || 1;
+        const O4 = createRelativeHandleMove(getElementScroll(f2)[u3], 1 / y4);
+        const $3 = o3[s3];
+        const C3 = g4();
+        const x2 = w4();
+        const H2 = C3[r3];
+        const E2 = getHandleOffset(C3, x2) + H2 / 2;
+        const z2 = $3 - x2[l3];
+        const A2 = i3 ? 0 : z2 - E2;
+        const releasePointerCapture = (t4) => {
+          runEachAndClear(T2);
+          d3.releasePointerCapture(t4.pointerId);
+        };
+        const D2 = v2();
+        const T2 = [() => {
+          const t4 = getElementScroll(f2);
+          D2();
+          const n4 = getElementScroll(f2);
+          const o4 = {
+            x: n4.x - t4.x,
+            y: n4.y - t4.y
+          };
+          if (c(o4.x) > 3 || c(o4.y) > 3) {
+            v2();
+            scrollElementTo(f2, t4);
+            scrollOffsetElementScrollBy(o4);
+            S2(D2);
+          }
+        }, addEventListener(p2, n3, releasePointerCapture), addEventListener(p2, "selectstart", (t4) => preventDefault(t4), {
+          H: false
+        }), addEventListener(h2, n3, releasePointerCapture), addEventListener(h2, "pointermove", (n4) => {
+          const o4 = n4[s3] - $3;
+          if (i3 || t3) {
+            O4(A2 + o4);
+          }
+        })];
+        d3.setPointerCapture(o3.pointerId);
+        if (t3) {
+          O4(A2);
+        } else if (!i3) {
+          const t4 = getStaticPluginModuleInstance(At);
+          if (t4) {
+            const n4 = t4(O4, getHandleOffset, A2, H2, z2);
+            push(T2, bind(n4));
+            push(_3, bind(n4, true));
+          }
+        }
+      }
+    });
+  };
+  let O2 = true;
+  return bind(runEachAndClear, [addEventListener(b2, "pointermove pointerleave", s2), addEventListener(g2, "pointerenter", () => {
+    l2(pt, true);
+  }), addEventListener(g2, "pointerleave pointercancel", () => {
+    l2(pt, false);
+  }), !d2 && addEventListener(g2, "mousedown", () => {
+    const t3 = getFocusedElement();
+    if (hasAttr(t3, q) || hasAttr(t3, P) || t3 === document.body) {
+      a(bind(focusElement, _2), 25);
+    }
+  }), addEventListener(g2, "wheel", (t3) => {
+    const { deltaX: n3, deltaY: o3, deltaMode: s3 } = t3;
+    if (O2 && s3 === 0 && parent(g2) === u2) {
+      scrollOffsetElementScrollBy({
+        x: n3,
+        y: o3
+      });
+    }
+    O2 = false;
+    l2(bt, true);
+    w2(() => {
+      O2 = true;
+      l2(bt);
+    });
+    preventDefault(t3);
+  }, {
+    H: false,
+    I: true
+  }), addEventListener(g2, "pointerdown", bind(addEventListener, p2, "click", stopAndPrevent, {
+    A: true,
+    I: true,
+    H: false
+  }), {
+    I: true
+  }), createInteractiveScrollEvents(), y2, m2]);
+};
+const createScrollbarsSetup = (t2, n2, o2, s2, e2, c2) => {
+  let r2;
+  let l2;
+  let i2;
+  let a2;
+  let u2;
+  let _2 = noop;
+  let d2 = 0;
+  const isHoverablePointerType = (t3) => t3.pointerType === "mouse";
+  const [f2, p2] = selfClearTimeout();
+  const [v2, g2] = selfClearTimeout(100);
+  const [h2, b2] = selfClearTimeout(100);
+  const [w2, y2] = selfClearTimeout(() => d2);
+  const [S2, m2] = createScrollbarsSetupElements(t2, e2, s2, createScrollbarsSetupEvents(n2, e2, s2, (t3) => isHoverablePointerType(t3) && manageScrollbarsAutoHideInstantInteraction()));
+  const { gt: O2, Qt: $2, wt: C2 } = e2;
+  const { jt: H2, Nt: z2, qt: I2, Bt: A2, Ft: D2 } = S2;
+  const manageScrollbarsAutoHide = (t3, n3) => {
+    y2();
+    if (t3) {
+      H2(ht);
+    } else {
+      const t4 = bind(H2, ht, true);
+      if (d2 > 0 && !n3) {
+        w2(t4);
+      } else {
+        t4();
+      }
+    }
+  };
+  const manageScrollbarsAutoHideInstantInteraction = () => {
+    if (i2 ? !r2 : !a2) {
+      manageScrollbarsAutoHide(true);
+      v2(() => {
+        manageScrollbarsAutoHide(false);
+      });
+    }
+  };
+  const manageAutoHideSuspension = (t3) => {
+    H2(gt, t3, true);
+    H2(gt, t3, false);
+  };
+  const onHostMouseEnter = (t3) => {
+    if (isHoverablePointerType(t3)) {
+      r2 = i2;
+      i2 && manageScrollbarsAutoHide(true);
+    }
+  };
+  const T2 = [y2, g2, b2, p2, () => _2(), addEventListener(O2, "pointerover", onHostMouseEnter, {
+    A: true
+  }), addEventListener(O2, "pointerenter", onHostMouseEnter), addEventListener(O2, "pointerleave", (t3) => {
+    if (isHoverablePointerType(t3)) {
+      r2 = false;
+      i2 && manageScrollbarsAutoHide(false);
+    }
+  }), addEventListener(O2, "pointermove", (t3) => {
+    isHoverablePointerType(t3) && l2 && manageScrollbarsAutoHideInstantInteraction();
+  }), addEventListener($2, "scroll", (t3) => {
+    f2(() => {
+      I2();
+      manageScrollbarsAutoHideInstantInteraction();
+    });
+    c2(t3);
+    D2();
+  })];
+  return [() => bind(runEachAndClear, push(T2, m2())), ({ It: t3, Dt: n3, Zt: e3, tn: c3 }) => {
+    const { nn: r3, sn: f3, en: p3, cn: v3 } = c3 || {};
+    const { Ct: g3, dt: b3 } = e3 || {};
+    const { ct: w3 } = o2;
+    const { M: y3 } = getEnvironment();
+    const { K: S3, rn: m3 } = s2;
+    const [O3, T3] = t3("showNativeOverlaidScrollbars");
+    const [k2, M2] = t3("scrollbars.theme");
+    const [R2, V2] = t3("scrollbars.visibility");
+    const [L2, U2] = t3("scrollbars.autoHide");
+    const [P2, N2] = t3("scrollbars.autoHideSuspend");
+    const [q2] = t3("scrollbars.autoHideDelay");
+    const [B2, F2] = t3("scrollbars.dragScroll");
+    const [j2, X2] = t3("scrollbars.clickScroll");
+    const [Y2, W2] = t3("overflow");
+    const J2 = b3 && !n3;
+    const G2 = m3.x || m3.y;
+    const K2 = r3 || f3 || v3 || g3 || n3;
+    const Q2 = p3 || V2 || W2;
+    const Z2 = O3 && y3.x && y3.y;
+    const setScrollbarVisibility = (t4, n4, o3) => {
+      const s3 = t4.includes(E) && (R2 === x || R2 === "auto" && n4 === E);
+      H2(dt, s3, o3);
+      return s3;
+    };
+    d2 = q2;
+    if (J2) {
+      if (P2 && G2) {
+        manageAutoHideSuspension(false);
+        _2();
+        h2(() => {
+          _2 = addEventListener($2, "scroll", bind(manageAutoHideSuspension, true), {
+            A: true
+          });
+        });
+      } else {
+        manageAutoHideSuspension(true);
+      }
+    }
+    if (T3) {
+      H2(ct, Z2);
+    }
+    if (M2) {
+      H2(u2);
+      H2(k2, true);
+      u2 = k2;
+    }
+    if (N2 && !P2) {
+      manageAutoHideSuspension(true);
+    }
+    if (U2) {
+      l2 = L2 === "move";
+      i2 = L2 === "leave";
+      a2 = L2 === "never";
+      manageScrollbarsAutoHide(a2, true);
+    }
+    if (F2) {
+      H2(yt, B2);
+    }
+    if (X2) {
+      H2(wt, j2);
+    }
+    if (Q2) {
+      const t4 = setScrollbarVisibility(Y2.x, S3.x, true);
+      const n4 = setScrollbarVisibility(Y2.y, S3.y, false);
+      const o3 = t4 && n4;
+      H2(ft, !o3);
+    }
+    if (K2) {
+      I2();
+      z2();
+      D2();
+      v3 && A2();
+      H2(vt, !m3.x, true);
+      H2(vt, !m3.y, false);
+      H2(lt, w3 && !C2);
+    }
+  }, {}, S2];
+};
+const createStructureSetupElements = (t2) => {
+  const o2 = getEnvironment();
+  const { U: s2, R: e2 } = o2;
+  const { elements: c2 } = s2();
+  const { padding: r2, viewport: l2, content: i2 } = c2;
+  const a2 = isHTMLElement(t2);
+  const u2 = a2 ? {} : t2;
+  const { elements: _2 } = u2;
+  const { padding: d2, viewport: f2, content: p2 } = _2 || {};
+  const v2 = a2 ? t2 : u2.target;
+  const g2 = isBodyElement(v2);
+  const h2 = v2.ownerDocument;
+  const b2 = h2.documentElement;
+  const getDocumentWindow = () => h2.defaultView || n;
+  const w2 = bind(staticInitializationElement, [v2]);
+  const y2 = bind(dynamicInitializationElement, [v2]);
+  const S2 = bind(createDiv, "");
+  const $2 = bind(w2, S2, l2);
+  const C2 = bind(y2, S2, i2);
+  const elementHasOverflow = (t3) => {
+    const n2 = I(t3);
+    const o3 = D(t3);
+    const s3 = getStyles(t3, m);
+    const e3 = getStyles(t3, O);
+    return o3.w - n2.w > 0 && !overflowIsVisible(s3) || o3.h - n2.h > 0 && !overflowIsVisible(e3);
+  };
+  const x2 = $2(f2);
+  const H2 = x2 === v2;
+  const E2 = H2 && g2;
+  const z2 = !H2 && C2(p2);
+  const A2 = !H2 && x2 === z2;
+  const T2 = E2 ? b2 : x2;
+  const k2 = E2 ? T2 : v2;
+  const M2 = !H2 && y2(S2, r2, d2);
+  const R2 = !A2 && z2;
+  const L2 = [R2, T2, M2, k2].map((t3) => isHTMLElement(t3) && !parent(t3) && t3);
+  const elementIsGenerated = (t3) => t3 && inArray(L2, t3);
+  const B2 = !elementIsGenerated(T2) && elementHasOverflow(T2) ? T2 : v2;
+  const F2 = E2 ? b2 : T2;
+  const j2 = E2 ? h2 : T2;
+  const X2 = {
+    vt: v2,
+    gt: k2,
+    ot: T2,
+    ln: M2,
+    bt: R2,
+    ht: F2,
+    Qt: j2,
+    an: g2 ? b2 : B2,
+    Kt: h2,
+    wt: g2,
+    Tt: a2,
+    nt: H2,
+    un: getDocumentWindow,
+    yt: (t3) => hasAttrClass(T2, q, t3),
+    St: (t3, n2) => addRemoveAttrClass(T2, q, t3, n2),
+    Ot: () => addRemoveAttrClass(F2, q, Y, true)
+  };
+  const { vt: J2, gt: Q2, ln: Z2, ot: tt2, bt: nt } = X2;
+  const ot = [() => {
+    removeAttrs(Q2, [P, V]);
+    removeAttrs(J2, V);
+    if (g2) {
+      removeAttrs(b2, [V, P]);
+    }
+  }];
+  let st = contents([nt, tt2, Z2, Q2, J2].find((t3) => t3 && !elementIsGenerated(t3)));
+  const et2 = E2 ? J2 : nt || tt2;
+  const ct2 = bind(runEachAndClear, ot);
+  const appendElements = () => {
+    const t3 = getDocumentWindow();
+    const n2 = getFocusedElement();
+    const unwrap = (t4) => {
+      appendChildren(parent(t4), contents(t4));
+      removeElements(t4);
+    };
+    const prepareWrapUnwrapFocus = (t4) => addEventListener(t4, "focusin focusout focus blur", stopAndPrevent, {
+      I: true,
+      H: false
+    });
+    const o3 = "tabindex";
+    const s3 = getAttr(tt2, o3);
+    const c3 = prepareWrapUnwrapFocus(n2);
+    setAttrs(Q2, P, H2 ? "" : N);
+    setAttrs(Z2, G, "");
+    setAttrs(tt2, q, "");
+    setAttrs(nt, K, "");
+    if (!H2) {
+      setAttrs(tt2, o3, s3 || "-1");
+      g2 && setAttrs(b2, U, "");
+    }
+    appendChildren(et2, st);
+    appendChildren(Q2, Z2);
+    appendChildren(Z2 || Q2, !H2 && tt2);
+    appendChildren(tt2, nt);
+    push(ot, [c3, () => {
+      const t4 = getFocusedElement();
+      const n3 = elementIsGenerated(tt2);
+      const e3 = n3 && t4 === tt2 ? J2 : t4;
+      const c4 = prepareWrapUnwrapFocus(e3);
+      removeAttrs(Z2, G);
+      removeAttrs(nt, K);
+      removeAttrs(tt2, q);
+      g2 && removeAttrs(b2, U);
+      s3 ? setAttrs(tt2, o3, s3) : removeAttrs(tt2, o3);
+      elementIsGenerated(nt) && unwrap(nt);
+      n3 && unwrap(tt2);
+      elementIsGenerated(Z2) && unwrap(Z2);
+      focusElement(e3);
+      c4();
+    }]);
+    if (e2 && !H2) {
+      addAttrClass(tt2, q, W);
+      push(ot, bind(removeAttrs, tt2, q));
+    }
+    focusElement(!H2 && g2 && n2 === J2 && t3.top === t3 ? tt2 : n2);
+    c3();
+    st = 0;
+    return ct2;
+  };
+  return [X2, appendElements, ct2];
+};
+const createTrinsicUpdateSegment = ({ bt: t2 }) => ({ Zt: n2, _n: o2, Dt: s2 }) => {
+  const { xt: e2 } = n2 || {};
+  const { $t: c2 } = o2;
+  const r2 = t2 && (e2 || s2);
+  if (r2) {
+    setStyles(t2, {
+      [C]: c2 && "100%"
+    });
+  }
+};
+const createPaddingUpdateSegment = ({ gt: t2, ln: n2, ot: o2, nt: s2 }, e2) => {
+  const [c2, r2] = createCache({
+    i: equalTRBL,
+    o: topRightBottomLeft()
+  }, bind(topRightBottomLeft, t2, "padding", ""));
+  return ({ It: t3, Zt: l2, _n: i2, Dt: a2 }) => {
+    let [u2, _2] = r2(a2);
+    const { R: d2 } = getEnvironment();
+    const { ft: f2, Ht: p2, Ct: m2 } = l2 || {};
+    const { ct: O2 } = i2;
+    const [C2, x2] = t3("paddingAbsolute");
+    const H2 = a2 || p2;
+    if (f2 || _2 || H2) {
+      [u2, _2] = c2(a2);
+    }
+    const E2 = !s2 && (x2 || m2 || _2);
+    if (E2) {
+      const t4 = !C2 || !n2 && !d2;
+      const s3 = u2.r + u2.l;
+      const c3 = u2.t + u2.b;
+      const r3 = {
+        [y]: t4 && !O2 ? -s3 : 0,
+        [S]: t4 ? -c3 : 0,
+        [w]: t4 && O2 ? -s3 : 0,
+        top: t4 ? -u2.t : 0,
+        right: t4 ? O2 ? -u2.r : "auto" : 0,
+        left: t4 ? O2 ? "auto" : -u2.l : 0,
+        [$]: t4 && `calc(100% + ${s3}px)`
+      };
+      const l3 = {
+        [v]: t4 ? u2.t : 0,
+        [g]: t4 ? u2.r : 0,
+        [b]: t4 ? u2.b : 0,
+        [h]: t4 ? u2.l : 0
+      };
+      setStyles(n2 || o2, r3);
+      setStyles(o2, l3);
+      assignDeep(e2, {
+        ln: u2,
+        dn: !t4,
+        rt: n2 ? l3 : assignDeep({}, r3, l3)
+      });
+    }
+    return {
+      fn: E2
+    };
+  };
+};
+const createOverflowUpdateSegment = (t2, s2) => {
+  const e2 = getEnvironment();
+  const { gt: c2, ln: r2, ot: l2, nt: a2, Qt: u2, ht: _2, wt: d2, St: f2, un: p2 } = t2;
+  const { R: v2 } = e2;
+  const g2 = d2 && a2;
+  const h2 = bind(o, 0);
+  const b2 = ["display", "direction", "flexDirection", "writingMode"];
+  const w2 = {
+    i: equalWH,
+    o: {
+      w: 0,
+      h: 0
+    }
+  };
+  const y2 = {
+    i: equalXY,
+    o: {}
+  };
+  const setMeasuringMode = (t3) => {
+    f2(X, !g2 && t3);
+  };
+  const getOverflowAmount = (t3, o2) => {
+    const s3 = n.devicePixelRatio % 1 !== 0 ? 1 : 0;
+    const e3 = {
+      w: h2(t3.w - o2.w),
+      h: h2(t3.h - o2.h)
+    };
+    return {
+      w: e3.w > s3 ? e3.w : 0,
+      h: e3.h > s3 ? e3.h : 0
+    };
+  };
+  const [S2, m2] = createCache(w2, bind(getFractionalSize, l2));
+  const [O2, $2] = createCache(w2, bind(D, l2));
+  const [C2, z2] = createCache(w2);
+  const [I2] = createCache(y2);
+  const [T2, k2] = createCache(w2);
+  const [M2] = createCache(y2);
+  const [R2] = createCache({
+    i: (t3, n2) => equal(t3, n2, b2),
+    o: {}
+  }, () => hasDimensions(l2) ? getStyles(l2, b2) : {});
+  const [V2, U2] = createCache({
+    i: (t3, n2) => equalXY(t3.D, n2.D) && equalXY(t3.T, n2.T),
+    o: getZeroScrollCoordinates()
+  }, () => {
+    setMeasuringMode(true);
+    const t3 = getElementScroll(_2);
+    const n2 = f2(J, true);
+    const o2 = addEventListener(u2, E, (n3) => {
+      const o3 = getElementScroll(_2);
+      if (n3.isTrusted && o3.x === t3.x && o3.y === t3.y) {
+        stopPropagation(n3);
+      }
+    }, {
+      I: true,
+      A: true
+    });
+    scrollElementTo(_2, {
+      x: 0,
+      y: 0
+    });
+    n2();
+    const s3 = getElementScroll(_2);
+    const e3 = D(_2);
+    scrollElementTo(_2, {
+      x: e3.w,
+      y: e3.h
+    });
+    const c3 = getElementScroll(_2);
+    scrollElementTo(_2, {
+      x: c3.x - s3.x < 1 && -e3.w,
+      y: c3.y - s3.y < 1 && -e3.h
+    });
+    const r3 = getElementScroll(_2);
+    scrollElementTo(_2, t3);
+    i(() => o2());
+    return {
+      D: s3,
+      T: r3
+    };
+  });
+  const N2 = getStaticPluginModuleInstance(zt);
+  const createViewportOverflowStyleClassName = (t3, n2) => {
+    const o2 = n2 ? B : F;
+    return `${o2}${capitalizeFirstLetter(t3)}`;
+  };
+  const setViewportOverflowStyle = (t3) => {
+    const createAllOverflowStyleClassNames = (t4) => [x, H, E].map((n3) => createViewportOverflowStyleClassName(n3, t4));
+    const n2 = createAllOverflowStyleClassNames(true).concat(createAllOverflowStyleClassNames()).join(" ");
+    f2(n2);
+    f2(keys(t3).map((n3) => createViewportOverflowStyleClassName(t3[n3], n3 === "x")).join(" "), true);
+  };
+  return ({ It: n2, Zt: o2, _n: i2, Dt: a3 }, { fn: u3 }) => {
+    const { ft: _3, Ht: d3, Ct: b3, dt: w3, zt: y3 } = o2 || {};
+    const x2 = N2 && N2.tt(t2, s2, i2, e2, n2);
+    const { it: H2, ut: E2, _t: D2 } = x2 || {};
+    const [q2, B2] = getShowNativeOverlaidScrollbars(n2, e2);
+    const [F2, j2] = n2("overflow");
+    const X2 = overflowIsVisible(F2.x);
+    const Y2 = overflowIsVisible(F2.y);
+    const J2 = true;
+    let K2 = m2(a3);
+    let Q2 = $2(a3);
+    let Z2 = z2(a3);
+    let tt2 = k2(a3);
+    if (B2 && v2) {
+      f2(W, !q2);
+    }
+    {
+      if (hasAttrClass(c2, P, L)) {
+        setMeasuringMode(true);
+      }
+      const [t3] = E2 ? E2() : [];
+      const [n3] = K2 = S2(a3);
+      const [o3] = Q2 = O2(a3);
+      const s3 = A(l2);
+      const e3 = g2 && getWindowSize(p2());
+      const r3 = {
+        w: h2(o3.w + n3.w),
+        h: h2(o3.h + n3.h)
+      };
+      const i3 = {
+        w: h2((e3 ? e3.w : s3.w + h2(s3.w - o3.w)) + n3.w),
+        h: h2((e3 ? e3.h : s3.h + h2(s3.h - o3.h)) + n3.h)
+      };
+      t3 && t3();
+      tt2 = T2(i3);
+      Z2 = C2(getOverflowAmount(r3, i3), a3);
+    }
+    const [nt, ot] = tt2;
+    const [st, et2] = Z2;
+    const [ct2, rt2] = Q2;
+    const [lt2, it2] = K2;
+    const [at2, ut2] = I2({
+      x: st.w > 0,
+      y: st.h > 0
+    });
+    const _t2 = X2 && Y2 && (at2.x || at2.y) || X2 && at2.x && !at2.y || Y2 && at2.y && !at2.x;
+    const dt2 = u3 || b3 || y3 || it2 || rt2 || ot || et2 || j2 || B2 || J2;
+    const ft2 = createViewportOverflowState(at2, F2);
+    const [pt2, vt2] = M2(ft2.K);
+    const [, gt2] = R2(a3);
+    const ht2 = b3 || w3 || gt2 || ut2 || a3;
+    const [bt2, wt2] = ht2 ? V2(a3) : U2();
+    if (dt2) {
+      vt2 && setViewportOverflowStyle(ft2.K);
+      if (D2 && H2) {
+        setStyles(l2, D2(ft2, i2, H2(ft2, ct2, lt2)));
+      }
+    }
+    setMeasuringMode(false);
+    addRemoveAttrClass(c2, P, L, _t2);
+    addRemoveAttrClass(r2, G, L, _t2);
+    assignDeep(s2, {
+      K: pt2,
+      Vt: {
+        x: nt.w,
+        y: nt.h
+      },
+      Rt: {
+        x: st.w,
+        y: st.h
+      },
+      rn: at2,
+      Lt: sanitizeScrollCoordinates(bt2, st)
+    });
+    return {
+      en: vt2,
+      nn: ot,
+      sn: et2,
+      cn: wt2 || et2,
+      pn: ht2
+    };
+  };
+};
+const createStructureSetup = (t2) => {
+  const [n2, o2, s2] = createStructureSetupElements(t2);
+  const e2 = {
+    ln: {
+      t: 0,
+      r: 0,
+      b: 0,
+      l: 0
+    },
+    dn: false,
+    rt: {
+      [y]: 0,
+      [S]: 0,
+      [w]: 0,
+      [v]: 0,
+      [g]: 0,
+      [b]: 0,
+      [h]: 0
+    },
+    Vt: {
+      x: 0,
+      y: 0
+    },
+    Rt: {
+      x: 0,
+      y: 0
+    },
+    K: {
+      x: H,
+      y: H
+    },
+    rn: {
+      x: false,
+      y: false
+    },
+    Lt: getZeroScrollCoordinates()
+  };
+  const { vt: c2, ht: r2, nt: l2, Ot: i2 } = n2;
+  const { R: a2, M: u2 } = getEnvironment();
+  const _2 = !a2 && (u2.x || u2.y);
+  const d2 = [createTrinsicUpdateSegment(n2), createPaddingUpdateSegment(n2, e2), createOverflowUpdateSegment(n2, e2)];
+  return [o2, (t3) => {
+    const n3 = {};
+    const o3 = _2;
+    const s3 = o3 && getElementScroll(r2);
+    const e3 = s3 && i2();
+    each(d2, (o4) => {
+      assignDeep(n3, o4(t3, n3) || {});
+    });
+    scrollElementTo(r2, s3);
+    e3 && e3();
+    !l2 && scrollElementTo(c2, 0);
+    return n3;
+  }, e2, n2, s2];
+};
+const createSetups = (t2, n2, o2, s2, e2) => {
+  let c2 = false;
+  const r2 = createOptionCheck(n2, {});
+  const [l2, i2, a2, u2, _2] = createStructureSetup(t2);
+  const [d2, f2, p2] = createObserversSetup(u2, a2, r2, (t3) => {
+    update({}, t3);
+  });
+  const [v2, g2, , h2] = createScrollbarsSetup(t2, n2, p2, a2, u2, e2);
+  const updateHintsAreTruthy = (t3) => keys(t3).some((n3) => !!t3[n3]);
+  const update = (t3, e3) => {
+    if (o2()) {
+      return false;
+    }
+    const { vn: r3, Dt: l3, At: a3, gn: u3 } = t3;
+    const _3 = r3 || {};
+    const d3 = !!l3 || !c2;
+    const v3 = {
+      It: createOptionCheck(n2, _3, d3),
+      vn: _3,
+      Dt: d3
+    };
+    if (u3) {
+      g2(v3);
+      return false;
+    }
+    const h3 = e3 || f2(assignDeep({}, v3, {
+      At: a3
+    }));
+    const b2 = i2(assignDeep({}, v3, {
+      _n: p2,
+      Zt: h3
+    }));
+    g2(assignDeep({}, v3, {
+      Zt: h3,
+      tn: b2
+    }));
+    const w2 = updateHintsAreTruthy(h3);
+    const y2 = updateHintsAreTruthy(b2);
+    const S2 = w2 || y2 || !isEmptyObject(_3) || d3;
+    c2 = true;
+    S2 && s2(t3, {
+      Zt: h3,
+      tn: b2
+    });
+    return S2;
+  };
+  return [() => {
+    const { an: t3, ht: n3, Ot: o3 } = u2;
+    const s3 = getElementScroll(t3);
+    const e3 = [d2(), l2(), v2()];
+    const c3 = o3();
+    scrollElementTo(n3, s3);
+    c3();
+    return bind(runEachAndClear, e3);
+  }, update, () => ({
+    hn: p2,
+    bn: a2
+  }), {
+    wn: u2,
+    yn: h2
+  }, _2];
+};
+const OverlayScrollbars = (t2, n2, o2) => {
+  const { N: s2 } = getEnvironment();
+  const e2 = isHTMLElement(t2);
+  const c2 = e2 ? t2 : t2.target;
+  const r2 = getInstance(c2);
+  if (n2 && !r2) {
+    let r3 = false;
+    const l2 = [];
+    const i2 = {};
+    const validateOptions = (t3) => {
+      const n3 = removeUndefinedProperties(t3, true);
+      const o3 = getStaticPluginModuleInstance(xt);
+      return o3 ? o3(n3, true) : n3;
+    };
+    const a2 = assignDeep({}, s2(), validateOptions(n2));
+    const [u2, _2, d2] = createEventListenerHub();
+    const [f2, p2, v2] = createEventListenerHub(o2);
+    const triggerEvent = (t3, n3) => {
+      v2(t3, n3);
+      d2(t3, n3);
+    };
+    const [g2, h2, b2, w2, y2] = createSetups(t2, a2, () => r3, ({ vn: t3, Dt: n3 }, { Zt: o3, tn: s3 }) => {
+      const { ft: e3, Ct: c3, xt: r4, Ht: l3, Et: i3, dt: a3 } = o3;
+      const { nn: u3, sn: _3, en: d3, cn: f3 } = s3;
+      triggerEvent("updated", [S2, {
+        updateHints: {
+          sizeChanged: !!e3,
+          directionChanged: !!c3,
+          heightIntrinsicChanged: !!r4,
+          overflowEdgeChanged: !!u3,
+          overflowAmountChanged: !!_3,
+          overflowStyleChanged: !!d3,
+          scrollCoordinatesChanged: !!f3,
+          contentMutation: !!l3,
+          hostMutation: !!i3,
+          appear: !!a3
+        },
+        changedOptions: t3 || {},
+        force: !!n3
+      }]);
+    }, (t3) => triggerEvent("scroll", [S2, t3]));
+    const destroy = (t3) => {
+      removeInstance(c2);
+      runEachAndClear(l2);
+      r3 = true;
+      triggerEvent("destroyed", [S2, t3]);
+      _2();
+      p2();
+    };
+    const S2 = {
+      options(t3, n3) {
+        if (t3) {
+          const o3 = n3 ? s2() : {};
+          const e3 = getOptionsDiff(a2, assignDeep(o3, validateOptions(t3)));
+          if (!isEmptyObject(e3)) {
+            assignDeep(a2, e3);
+            h2({
+              vn: e3
+            });
+          }
+        }
+        return assignDeep({}, a2);
+      },
+      on: f2,
+      off: (t3, n3) => {
+        t3 && n3 && p2(t3, n3);
+      },
+      state() {
+        const { hn: t3, bn: n3 } = b2();
+        const { ct: o3 } = t3;
+        const { Vt: s3, Rt: e3, K: c3, rn: l3, ln: i3, dn: a3, Lt: u3 } = n3;
+        return assignDeep({}, {
+          overflowEdge: s3,
+          overflowAmount: e3,
+          overflowStyle: c3,
+          hasOverflow: l3,
+          scrollCoordinates: {
+            start: u3.D,
+            end: u3.T
+          },
+          padding: i3,
+          paddingAbsolute: a3,
+          directionRTL: o3,
+          destroyed: r3
+        });
+      },
+      elements() {
+        const { vt: t3, gt: n3, ln: o3, ot: s3, bt: e3, ht: c3, Qt: r4 } = w2.wn;
+        const { Xt: l3, Gt: i3 } = w2.yn;
+        const translateScrollbarStructure = (t4) => {
+          const { Pt: n4, Ut: o4, kt: s4 } = t4;
+          return {
+            scrollbar: s4,
+            track: o4,
+            handle: n4
+          };
+        };
+        const translateScrollbarsSetupElement = (t4) => {
+          const { Yt: n4, Wt: o4 } = t4;
+          const s4 = translateScrollbarStructure(n4[0]);
+          return assignDeep({}, s4, {
+            clone: () => {
+              const t5 = translateScrollbarStructure(o4());
+              h2({
+                gn: true
+              });
+              return t5;
+            }
+          });
+        };
+        return assignDeep({}, {
+          target: t3,
+          host: n3,
+          padding: o3 || s3,
+          viewport: s3,
+          content: e3 || s3,
+          scrollOffsetElement: c3,
+          scrollEventElement: r4,
+          scrollbarHorizontal: translateScrollbarsSetupElement(l3),
+          scrollbarVertical: translateScrollbarsSetupElement(i3)
+        });
+      },
+      update: (t3) => h2({
+        Dt: t3,
+        At: true
+      }),
+      destroy: bind(destroy, false),
+      plugin: (t3) => i2[keys(t3)[0]]
+    };
+    push(l2, [y2]);
+    addInstance(c2, S2);
+    registerPluginModuleInstances($t, OverlayScrollbars, [S2, u2, i2]);
+    if (cancelInitialization(w2.wn.wt, !e2 && t2.cancel)) {
+      destroy(true);
+      return S2;
+    }
+    push(l2, g2());
+    triggerEvent("initialized", [S2]);
+    S2.update();
+    return S2;
+  }
+  return r2;
+};
+OverlayScrollbars.plugin = (t2) => {
+  const n2 = isArray(t2);
+  const o2 = n2 ? t2 : [t2];
+  const s2 = o2.map((t3) => registerPluginModuleInstances(t3, OverlayScrollbars)[0]);
+  addPlugins(o2);
+  return n2 ? s2 : s2[0];
+};
+OverlayScrollbars.valid = (t2) => {
+  const n2 = t2 && t2.elements;
+  const o2 = isFunction(n2) && n2();
+  return isPlainObject(o2) && !!getInstance(o2.target);
+};
+OverlayScrollbars.env = () => {
+  const { k: t2, M: n2, R: o2, V: s2, B: e2, F: c2, U: r2, P: l2, N: i2, q: a2 } = getEnvironment();
+  return assignDeep({}, {
+    scrollbarsSize: t2,
+    scrollbarsOverlaid: n2,
+    scrollbarsHiding: o2,
+    scrollTimeline: s2,
+    staticDefaultInitialization: e2,
+    staticDefaultOptions: c2,
+    getDefaultInitialization: r2,
+    setDefaultInitialization: l2,
+    getDefaultOptions: i2,
+    setDefaultOptions: a2
+  });
+};
+OverlayScrollbars.nonce = setNonce;
+const DtScrollbarDirective = {
+  name: "dt-scrollbar-directive",
+  install(app) {
+    OverlayScrollbars.plugin(Dt);
+    app.directive("dt-scrollbar", {
+      mounted(el, binding) {
+        OverlayScrollbars({
+          target: el,
+          elements: {
+            viewport: el.children[0]
+          }
+        }, {
+          scrollbars: {
+            autoHide: `${binding.arg || "leave"}`,
+            clickScroll: true,
+            autoHideDelay: `${!binding.arg || binding.arg === "leave" ? 0 : 1300}`
+          }
+        });
+        el.setAttribute("data-overlayscrollbars-initialize", true);
+        el.classList.add("scrollbar");
+      }
+    });
+  }
+};
+exports.DtScrollbarDirective = DtScrollbarDirective;
+//# sourceMappingURL=scrollbar-directive.cjs.map