nyx/node_modules/.vite/deps/chunk-BAESQNSA.js

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

export {
  $t,
  Ht,
  zt,
  OverlayScrollbars
};
//# sourceMappingURL=chunk-BAESQNSA.js.map