@wix/editor-react-components 1.2153.0

package/dist/site/components/AudioPlayer/component.js

@@ -0,0 +1,4757 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _shouldStopPropagation;
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import React__default, { useState, useRef, useCallback, useMemo, useEffect, useContext, createContext, forwardRef, useSyncExternalStore } from "react";
+import { c as clsx } from "../chunks/clsx.js";
+import { useService } from "@wix/services-manager-react";
+import { d as definitionExports } from "../chunks/index2.js";
+import { f as convertA11yKeysToHtmlFormat } from "../chunks/a11y.js";
+import { d as directionStyles } from "../chunks/direction.module.js";
+import Image3 from "../Image3/component.js";
+import { A as ARIA_LABELS, s as selectors, d as dataDefaults } from "../chunks/constants31.js";
+import { c as commonjsGlobal } from "../chunks/_commonjsHelpers.js";
+import { $ as $8e9d2fae0ecb9001$export$457c3d6518dd4c6f, a as $f39a9eba43920ace$export$86427a43e3e48ebb, b as $64fa3d84918910a7$export$29f1550f4b0d4415, c as $64fa3d84918910a7$export$4d86445c2cf5e3, g as $65484d02dcb7eb3e$export$457c3d6518dd4c6f, e as $64fa3d84918910a7$export$9d4c57ee4c6ffdd8, h as $64fa3d84918910a7$export$2881499e37b75b9a, d as $64fa3d84918910a7$export$fabf2dc03a41866e } from "../chunks/filterDOMProps.js";
+import { o as $2add3ce32c6007eb$export$fedb369cb70207f1, p as $d447af545b77c9f1$export$b204af158042fbac, q as $081cb5757e08788e$export$24490316f764c430, r as $d447af545b77c9f1$export$f21a1ffae260145a, s as $48a7d519b337145d$export$4eaf04e54aa8eed6, a as $fe16bffc7a557bf0$export$7f54fc3180508a52, t as $a92dc41f639950be$export$c2b7abe5d61ec696, u as $a92dc41f639950be$export$525bc4921d56d4a, v as $23f2114a1b82827e$export$4282f70798064fe0, c as $23f2114a1b82827e$export$e58f029f0fbfdb29, w as $b5c62b033c25b96d$export$29bf1b5f2c56cf63, x as $a92dc41f639950be$export$cabe61c495ee3649, y as $1969ac565cfec8d0$export$de79e2c695e052f3, z as $b5c62b033c25b96d$export$60278871457622de, f as $bbaa08b3cd72f041$export$9d1611c77c2fe928, A as $b7115c395c64f7b5$export$4debdb1a3f0fa79e, B as $caaf0dd3060ed57c$export$95185d699e05d4d7, C as $a4e76a5424781910$export$e08e3b67e392101e, D as $2add3ce32c6007eb$export$9ac100e40613ea10, h as $d1116acdf220c2da$export$4c014de7c8940b4c, E as $2c9edc598a03d523$export$420e68273165f4ec, d as $0beb20c9744a2065$export$8467354a121f1b9f, b as $8f5a2122b0992be3$export$8397ddfc504fdb9a, F as $8296dad1a4c5e0dc$export$8f71654801c2f7cd, i as $3274bf1495747a7b$export$5add1d006293d136, k as $0c4a58759813079a$export$4e328f61c538687f, j as $e969f22b6713ca4a$export$ae780daf29e6d456, G as $390e54f620492c70$export$f680877a34711e37, g as $3e6197669829fe11$export$40bfa8c7b0832715, l as $01b77f81d0f07f68$export$75b6ee27786ba447, H as $a049562f99e7db0e$export$eb2fcfdbd7ba97d4 } from "../chunks/Group.js";
+import { flushSync } from "react-dom";
+import { $ as $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7 } from "../chunks/I18nProvider.js";
+const PauseFilled = ({ size, ...props }) => /* @__PURE__ */ React.createElement("svg", { viewBox: "0 0 24 24", fill: "currentColor", width: size || "24", height: size || "24", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M9.5,7 C10.3284271,7 11,7.67157288 11,8.5 L11,15.5 C11,16.3284271 10.3284271,17 9.5,17 C8.67157288,17 8,16.3284271 8,15.5 L8,8.5 C8,7.67157288 8.67157288,7 9.5,7 Z M14.5,7 C15.3284271,7 16,7.67157288 16,8.5 L16,15.5 C16,16.3284271 15.3284271,17 14.5,17 C13.6715729,17 13,16.3284271 13,15.5 L13,8.5 C13,7.67157288 13.6715729,7 14.5,7 Z" }));
+PauseFilled.displayName = "PauseFilled";
+var PauseFilled_default = PauseFilled;
+const PlayFilled = ({ size, ...props }) => /* @__PURE__ */ React.createElement("svg", { viewBox: "0 0 24 24", fill: "currentColor", width: size || "24", height: size || "24", ...props }, /* @__PURE__ */ React.createElement("path", { d: "M8.26582096,6.80664662 L16.1774936,11.1221044 C16.6623419,11.3865672 16.8409998,11.9940038 16.5765371,12.4788521 C16.4845917,12.6474186 16.3460601,12.7859502 16.1774936,12.8778956 L8.26582096,17.1933534 C7.78097262,17.4578161 7.17353598,17.2791583 6.90907325,16.7943099 C6.8289522,16.6474213 6.78696883,16.4827768 6.78696883,16.3154578 L6.78696883,7.68454219 C6.78696883,7.13225744 7.23468408,6.68454219 7.78696883,6.68454219 C7.95428782,6.68454219 8.11893236,6.72652556 8.26582096,6.80664662 Z" }));
+PlayFilled.displayName = "PlayFilled";
+var PlayFilled_default = PlayFilled;
+const $319e236875307eab$var$LIVEREGION_TIMEOUT_DELAY = 7e3;
+let $319e236875307eab$var$liveAnnouncer = null;
+function $319e236875307eab$export$a9b970dcc4ae71a9(message, assertiveness = "assertive", timeout = $319e236875307eab$var$LIVEREGION_TIMEOUT_DELAY) {
+  if (!$319e236875307eab$var$liveAnnouncer) {
+    $319e236875307eab$var$liveAnnouncer = new $319e236875307eab$var$LiveAnnouncer();
+    if (!(typeof IS_REACT_ACT_ENVIRONMENT === "boolean" ? IS_REACT_ACT_ENVIRONMENT : typeof jest !== "undefined")) setTimeout(() => {
+      if ($319e236875307eab$var$liveAnnouncer === null || $319e236875307eab$var$liveAnnouncer === void 0 ? void 0 : $319e236875307eab$var$liveAnnouncer.isAttached()) $319e236875307eab$var$liveAnnouncer === null || $319e236875307eab$var$liveAnnouncer === void 0 ? void 0 : $319e236875307eab$var$liveAnnouncer.announce(message, assertiveness, timeout);
+    }, 100);
+    else $319e236875307eab$var$liveAnnouncer.announce(message, assertiveness, timeout);
+  } else $319e236875307eab$var$liveAnnouncer.announce(message, assertiveness, timeout);
+}
+class $319e236875307eab$var$LiveAnnouncer {
+  isAttached() {
+    var _this_node;
+    return (_this_node = this.node) === null || _this_node === void 0 ? void 0 : _this_node.isConnected;
+  }
+  createLog(ariaLive) {
+    let node = document.createElement("div");
+    node.setAttribute("role", "log");
+    node.setAttribute("aria-live", ariaLive);
+    node.setAttribute("aria-relevant", "additions");
+    return node;
+  }
+  destroy() {
+    if (!this.node) return;
+    document.body.removeChild(this.node);
+    this.node = null;
+  }
+  announce(message, assertiveness = "assertive", timeout = $319e236875307eab$var$LIVEREGION_TIMEOUT_DELAY) {
+    var _this_assertiveLog, _this_politeLog;
+    if (!this.node) return;
+    let node = document.createElement("div");
+    if (typeof message === "object") {
+      node.setAttribute("role", "img");
+      node.setAttribute("aria-labelledby", message["aria-labelledby"]);
+    } else node.textContent = message;
+    if (assertiveness === "assertive") (_this_assertiveLog = this.assertiveLog) === null || _this_assertiveLog === void 0 ? void 0 : _this_assertiveLog.appendChild(node);
+    else (_this_politeLog = this.politeLog) === null || _this_politeLog === void 0 ? void 0 : _this_politeLog.appendChild(node);
+    if (message !== "") setTimeout(() => {
+      node.remove();
+    }, timeout);
+  }
+  clear(assertiveness) {
+    if (!this.node) return;
+    if ((!assertiveness || assertiveness === "assertive") && this.assertiveLog) this.assertiveLog.innerHTML = "";
+    if ((!assertiveness || assertiveness === "polite") && this.politeLog) this.politeLog.innerHTML = "";
+  }
+  constructor() {
+    this.node = null;
+    this.assertiveLog = null;
+    this.politeLog = null;
+    if (typeof document !== "undefined") {
+      this.node = document.createElement("div");
+      this.node.dataset.liveAnnouncer = "true";
+      Object.assign(this.node.style, {
+        border: 0,
+        clip: "rect(0 0 0 0)",
+        clipPath: "inset(50%)",
+        height: "1px",
+        margin: "-1px",
+        overflow: "hidden",
+        padding: 0,
+        position: "absolute",
+        width: "1px",
+        whiteSpace: "nowrap"
+      });
+      this.assertiveLog = this.createLog("assertive");
+      this.node.appendChild(this.assertiveLog);
+      this.politeLog = this.createLog("polite");
+      this.node.appendChild(this.politeLog);
+      document.body.prepend(this.node);
+    }
+  }
+}
+let $1dfb119a85e764e5$var$formatterCache = /* @__PURE__ */ new Map();
+let $1dfb119a85e764e5$var$supportsSignDisplay = false;
+try {
+  $1dfb119a85e764e5$var$supportsSignDisplay = new Intl.NumberFormat("de-DE", {
+    signDisplay: "exceptZero"
+  }).resolvedOptions().signDisplay === "exceptZero";
+} catch {
+}
+let $1dfb119a85e764e5$var$supportsUnit = false;
+try {
+  $1dfb119a85e764e5$var$supportsUnit = new Intl.NumberFormat("de-DE", {
+    style: "unit",
+    unit: "degree"
+  }).resolvedOptions().style === "unit";
+} catch {
+}
+const $1dfb119a85e764e5$var$UNITS = {
+  degree: {
+    narrow: {
+      default: "°",
+      "ja-JP": " 度",
+      "zh-TW": "度",
+      "sl-SI": " °"
+    }
+  }
+};
+class $1dfb119a85e764e5$export$cc77c4ff7e8673c5 {
+  constructor(locale, options = {}) {
+    this.numberFormatter = $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options);
+    this.options = options;
+  }
+  /** Formats a number value as a string, according to the locale and options provided to the constructor. */
+  format(value) {
+    var _a;
+    let res = "";
+    if (!$1dfb119a85e764e5$var$supportsSignDisplay && this.options.signDisplay != null) res = $1dfb119a85e764e5$export$711b50b3c525e0f2(this.numberFormatter, this.options.signDisplay, value);
+    else res = this.numberFormatter.format(value);
+    if (this.options.style === "unit" && !$1dfb119a85e764e5$var$supportsUnit) {
+      let { unit, unitDisplay = "short", locale } = this.resolvedOptions();
+      if (!unit) return res;
+      let values = (_a = $1dfb119a85e764e5$var$UNITS[unit]) == null ? void 0 : _a[unitDisplay];
+      res += values[locale] || values.default;
+    }
+    return res;
+  }
+  /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+  formatToParts(value) {
+    return this.numberFormatter.formatToParts(value);
+  }
+  /** Formats a number range as a string. */
+  formatRange(start, end) {
+    if (typeof this.numberFormatter.formatRange === "function") return this.numberFormatter.formatRange(start, end);
+    if (end < start) throw new RangeError("End date must be >= start date");
+    return `${this.format(start)} – ${this.format(end)}`;
+  }
+  /** Formats a number range as an array of parts. */
+  formatRangeToParts(start, end) {
+    if (typeof this.numberFormatter.formatRangeToParts === "function") return this.numberFormatter.formatRangeToParts(start, end);
+    if (end < start) throw new RangeError("End date must be >= start date");
+    let startParts = this.numberFormatter.formatToParts(start);
+    let endParts = this.numberFormatter.formatToParts(end);
+    return [
+      ...startParts.map((p2) => ({
+        ...p2,
+        source: "startRange"
+      })),
+      {
+        type: "literal",
+        value: " – ",
+        source: "shared"
+      },
+      ...endParts.map((p2) => ({
+        ...p2,
+        source: "endRange"
+      }))
+    ];
+  }
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions() {
+    let options = this.numberFormatter.resolvedOptions();
+    if (!$1dfb119a85e764e5$var$supportsSignDisplay && this.options.signDisplay != null) options = {
+      ...options,
+      signDisplay: this.options.signDisplay
+    };
+    if (!$1dfb119a85e764e5$var$supportsUnit && this.options.style === "unit") options = {
+      ...options,
+      style: "unit",
+      unit: this.options.unit,
+      unitDisplay: this.options.unitDisplay
+    };
+    return options;
+  }
+}
+function $1dfb119a85e764e5$var$getCachedNumberFormatter(locale, options = {}) {
+  var _a;
+  let { numberingSystem } = options;
+  if (numberingSystem && locale.includes("-nu-")) {
+    if (!locale.includes("-u-")) locale += "-u-";
+    locale += `-nu-${numberingSystem}`;
+  }
+  if (options.style === "unit" && !$1dfb119a85e764e5$var$supportsUnit) {
+    let { unit, unitDisplay = "short" } = options;
+    if (!unit) throw new Error('unit option must be provided with style: "unit"');
+    if (!((_a = $1dfb119a85e764e5$var$UNITS[unit]) == null ? void 0 : _a[unitDisplay])) throw new Error(`Unsupported unit ${unit} with unitDisplay = ${unitDisplay}`);
+    options = {
+      ...options,
+      style: "decimal"
+    };
+  }
+  let cacheKey = locale + (options ? Object.entries(options).sort((a, b2) => a[0] < b2[0] ? -1 : 1).join() : "");
+  if ($1dfb119a85e764e5$var$formatterCache.has(cacheKey)) return $1dfb119a85e764e5$var$formatterCache.get(cacheKey);
+  let numberFormatter = new Intl.NumberFormat(locale, options);
+  $1dfb119a85e764e5$var$formatterCache.set(cacheKey, numberFormatter);
+  return numberFormatter;
+}
+function $1dfb119a85e764e5$export$711b50b3c525e0f2(numberFormat, signDisplay, num) {
+  if (signDisplay === "auto") return numberFormat.format(num);
+  else if (signDisplay === "never") return numberFormat.format(Math.abs(num));
+  else {
+    let needsPositiveSign = false;
+    if (signDisplay === "always") needsPositiveSign = num > 0 || Object.is(num, 0);
+    else if (signDisplay === "exceptZero") {
+      if (Object.is(num, -0) || Object.is(num, 0)) num = Math.abs(num);
+      else needsPositiveSign = num > 0;
+    }
+    if (needsPositiveSign) {
+      let negative = numberFormat.format(-num);
+      let noSign = numberFormat.format(num);
+      let minus = negative.replace(noSign, "").replace(/\u200e|\u061C/, "");
+      if ([
+        ...minus
+      ].length !== 1) console.warn("@react-aria/i18n polyfill for NumberFormat signDisplay: Unsupported case");
+      let positive = negative.replace(noSign, "!!!").replace(minus, "+").replace("!!!", noSign);
+      return positive;
+    } else return numberFormat.format(num);
+  }
+}
+let $cbf007e418543821$var$state = "default";
+let $cbf007e418543821$var$savedUserSelect = "";
+let $cbf007e418543821$var$modifiedElementMap = /* @__PURE__ */ new WeakMap();
+function $cbf007e418543821$export$16a4697467175487(target) {
+  if ($2add3ce32c6007eb$export$fedb369cb70207f1()) {
+    if ($cbf007e418543821$var$state === "default") {
+      const documentObject = $d447af545b77c9f1$export$b204af158042fbac(target);
+      $cbf007e418543821$var$savedUserSelect = documentObject.documentElement.style.webkitUserSelect;
+      documentObject.documentElement.style.webkitUserSelect = "none";
+    }
+    $cbf007e418543821$var$state = "disabled";
+  } else if (target instanceof HTMLElement || target instanceof SVGElement) {
+    let property = "userSelect" in target.style ? "userSelect" : "webkitUserSelect";
+    $cbf007e418543821$var$modifiedElementMap.set(target, target.style[property]);
+    target.style[property] = "none";
+  }
+}
+function $cbf007e418543821$export$b0d6fa1ab32e3295(target) {
+  if ($2add3ce32c6007eb$export$fedb369cb70207f1()) {
+    if ($cbf007e418543821$var$state !== "disabled") return;
+    $cbf007e418543821$var$state = "restoring";
+    setTimeout(() => {
+      $081cb5757e08788e$export$24490316f764c430(() => {
+        if ($cbf007e418543821$var$state === "restoring") {
+          const documentObject = $d447af545b77c9f1$export$b204af158042fbac(target);
+          if (documentObject.documentElement.style.webkitUserSelect === "none") documentObject.documentElement.style.webkitUserSelect = $cbf007e418543821$var$savedUserSelect || "";
+          $cbf007e418543821$var$savedUserSelect = "";
+          $cbf007e418543821$var$state = "default";
+        }
+      });
+    }, 300);
+  } else if (target instanceof HTMLElement || target instanceof SVGElement) {
+    if (target && $cbf007e418543821$var$modifiedElementMap.has(target)) {
+      let targetOldUserSelect = $cbf007e418543821$var$modifiedElementMap.get(target);
+      let property = "userSelect" in target.style ? "userSelect" : "webkitUserSelect";
+      if (target.style[property] === "none") target.style[property] = targetOldUserSelect;
+      if (target.getAttribute("style") === "") target.removeAttribute("style");
+      $cbf007e418543821$var$modifiedElementMap.delete(target);
+    }
+  }
+}
+function $2b2d34ff061957fb$var$getWebpackNonce(doc) {
+  let ownerWindow = doc == null ? void 0 : doc.defaultView;
+  return (ownerWindow == null ? void 0 : ownerWindow.__webpack_nonce__) || globalThis["__webpack_nonce__"] || void 0;
+}
+let $2b2d34ff061957fb$var$nonceCache = /* @__PURE__ */ new WeakMap();
+function $2b2d34ff061957fb$export$2b85b721e524d74b(doc) {
+  let d2 = doc ?? (typeof document !== "undefined" ? document : void 0);
+  if (!d2) return $2b2d34ff061957fb$var$getWebpackNonce(d2);
+  if ($2b2d34ff061957fb$var$nonceCache.has(d2)) return $2b2d34ff061957fb$var$nonceCache.get(d2);
+  let meta = d2.querySelector('meta[property="csp-nonce"]');
+  let nonce = meta && meta instanceof $d447af545b77c9f1$export$f21a1ffae260145a(meta).HTMLMetaElement && (meta.nonce || meta.content) || $2b2d34ff061957fb$var$getWebpackNonce(d2) || void 0;
+  if (nonce !== void 0) $2b2d34ff061957fb$var$nonceCache.set(d2, nonce);
+  return nonce;
+}
+const $24f9a20f226ad820$export$5165eccb35aaadb5 = React__default.createContext({
+  register: () => {
+  }
+});
+$24f9a20f226ad820$export$5165eccb35aaadb5.displayName = "PressResponderContext";
+function $d27d541f9569d26d$var$usePressResponderContext(props) {
+  let context = useContext($24f9a20f226ad820$export$5165eccb35aaadb5);
+  if (context) {
+    let { register, ref, ...contextProps } = context;
+    props = $bbaa08b3cd72f041$export$9d1611c77c2fe928(contextProps, props);
+    register();
+  }
+  $b7115c395c64f7b5$export$4debdb1a3f0fa79e(context, props.ref);
+  return props;
+}
+class $d27d541f9569d26d$var$PressEvent {
+  constructor(type, pointerType, originalEvent, state) {
+    __privateAdd(this, _shouldStopPropagation);
+    __privateSet(this, _shouldStopPropagation, true);
+    let currentTarget = (state == null ? void 0 : state.target) ?? originalEvent.currentTarget;
+    const rect = currentTarget == null ? void 0 : currentTarget.getBoundingClientRect();
+    let x, y2 = 0;
+    let clientX, clientY = null;
+    if (originalEvent.clientX != null && originalEvent.clientY != null) {
+      clientX = originalEvent.clientX;
+      clientY = originalEvent.clientY;
+    }
+    if (rect) {
+      if (clientX != null && clientY != null) {
+        x = clientX - rect.left;
+        y2 = clientY - rect.top;
+      } else {
+        x = rect.width / 2;
+        y2 = rect.height / 2;
+      }
+    }
+    this.type = type;
+    this.pointerType = pointerType;
+    this.target = originalEvent.currentTarget;
+    this.shiftKey = originalEvent.shiftKey;
+    this.metaKey = originalEvent.metaKey;
+    this.ctrlKey = originalEvent.ctrlKey;
+    this.altKey = originalEvent.altKey;
+    this.x = x;
+    this.y = y2;
+    this.key = originalEvent.key;
+  }
+  continuePropagation() {
+    __privateSet(this, _shouldStopPropagation, false);
+  }
+  get shouldStopPropagation() {
+    return __privateGet(this, _shouldStopPropagation);
+  }
+}
+_shouldStopPropagation = new WeakMap();
+const $d27d541f9569d26d$var$LINK_CLICKED = Symbol("linkClicked");
+const $d27d541f9569d26d$var$STYLE_ID = "react-aria-pressable-style";
+const $d27d541f9569d26d$var$PRESSABLE_ATTRIBUTE = "data-react-aria-pressable";
+function $d27d541f9569d26d$export$45712eceda6fad21(props) {
+  let { onPress, onPressChange, onPressStart, onPressEnd, onPressUp, onClick, isDisabled, isPressed: isPressedProp, preventFocusOnPress, shouldCancelOnPointerExit, allowTextSelectionOnPress, ref: domRef, ...domProps } = $d27d541f9569d26d$var$usePressResponderContext(props);
+  let [isPressed, setPressed] = useState(false);
+  let ref = useRef({
+    isPressed: false,
+    ignoreEmulatedMouseEvents: false,
+    didFirePressStart: false,
+    isTriggeringEvent: false,
+    activePointerId: null,
+    target: null,
+    isOverTarget: false,
+    pointerType: null,
+    disposables: []
+  });
+  let { addGlobalListener, removeAllGlobalListeners } = $48a7d519b337145d$export$4eaf04e54aa8eed6();
+  let triggerPressStart = useCallback((originalEvent, pointerType) => {
+    let state = ref.current;
+    if (isDisabled || state.didFirePressStart) return false;
+    let shouldStopPropagation = true;
+    state.isTriggeringEvent = true;
+    if (onPressStart) {
+      let event = new $d27d541f9569d26d$var$PressEvent("pressstart", pointerType, originalEvent);
+      onPressStart(event);
+      shouldStopPropagation = event.shouldStopPropagation;
+    }
+    if (onPressChange) onPressChange(true);
+    state.isTriggeringEvent = false;
+    state.didFirePressStart = true;
+    setPressed(true);
+    return shouldStopPropagation;
+  }, [
+    isDisabled,
+    onPressStart,
+    onPressChange
+  ]);
+  let triggerPressEnd = useCallback((originalEvent, pointerType, wasPressed = true) => {
+    let state = ref.current;
+    if (!state.didFirePressStart) return false;
+    state.didFirePressStart = false;
+    state.isTriggeringEvent = true;
+    let shouldStopPropagation = true;
+    if (onPressEnd) {
+      let event = new $d27d541f9569d26d$var$PressEvent("pressend", pointerType, originalEvent);
+      onPressEnd(event);
+      shouldStopPropagation = event.shouldStopPropagation;
+    }
+    if (onPressChange) onPressChange(false);
+    setPressed(false);
+    if (onPress && wasPressed && !isDisabled) {
+      let event = new $d27d541f9569d26d$var$PressEvent("press", pointerType, originalEvent);
+      onPress(event);
+      shouldStopPropagation && (shouldStopPropagation = event.shouldStopPropagation);
+    }
+    state.isTriggeringEvent = false;
+    return shouldStopPropagation;
+  }, [
+    isDisabled,
+    onPressEnd,
+    onPressChange,
+    onPress
+  ]);
+  let triggerPressEndEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(triggerPressEnd);
+  let triggerPressUp = useCallback((originalEvent, pointerType) => {
+    let state = ref.current;
+    if (isDisabled) return false;
+    if (onPressUp) {
+      state.isTriggeringEvent = true;
+      let event = new $d27d541f9569d26d$var$PressEvent("pressup", pointerType, originalEvent);
+      onPressUp(event);
+      state.isTriggeringEvent = false;
+      return event.shouldStopPropagation;
+    }
+    return true;
+  }, [
+    isDisabled,
+    onPressUp
+  ]);
+  let triggerPressUpEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(triggerPressUp);
+  let cancel = useCallback((e) => {
+    let state = ref.current;
+    if (state.isPressed && state.target) {
+      if (state.didFirePressStart && state.pointerType != null) triggerPressEnd($d27d541f9569d26d$var$createEvent(state.target, e), state.pointerType, false);
+      state.isPressed = false;
+      state.isOverTarget = false;
+      state.activePointerId = null;
+      state.pointerType = null;
+      removeAllGlobalListeners();
+      if (!allowTextSelectionOnPress) $cbf007e418543821$export$b0d6fa1ab32e3295(state.target);
+      for (let dispose of state.disposables) dispose();
+      state.disposables = [];
+    }
+  }, [
+    allowTextSelectionOnPress,
+    removeAllGlobalListeners,
+    triggerPressEnd
+  ]);
+  let cancelEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(cancel);
+  let cancelOnPointerExit = useCallback((e) => {
+    if (shouldCancelOnPointerExit) cancel(e);
+  }, [
+    shouldCancelOnPointerExit,
+    cancel
+  ]);
+  let triggerClick = useCallback((e) => {
+    if (isDisabled) return;
+    onClick == null ? void 0 : onClick(e);
+  }, [
+    isDisabled,
+    onClick
+  ]);
+  let triggerSyntheticClick = useCallback((e, target) => {
+    if (isDisabled) return;
+    if (onClick) {
+      let event = new MouseEvent("click", e);
+      $a92dc41f639950be$export$c2b7abe5d61ec696(event, target);
+      onClick($a92dc41f639950be$export$525bc4921d56d4a(event));
+    }
+  }, [
+    isDisabled,
+    onClick
+  ]);
+  let pressProps = useMemo(() => {
+    let state = ref.current;
+    let pressProps2 = {
+      onKeyDown(e) {
+        var _a;
+        if ($d27d541f9569d26d$var$isValidKeyboardEvent(e.nativeEvent, e.currentTarget) && $23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) {
+          if ($d27d541f9569d26d$var$shouldPreventDefaultKeyboard($23f2114a1b82827e$export$e58f029f0fbfdb29(e), e.key)) e.preventDefault();
+          let shouldStopPropagation = true;
+          if (!state.isPressed && !e.repeat) {
+            state.target = e.currentTarget;
+            state.isPressed = true;
+            state.pointerType = "keyboard";
+            shouldStopPropagation = triggerPressStart(e, "keyboard");
+          }
+          let originalTarget = e.currentTarget;
+          let pressUp = (e2) => {
+            if ($d27d541f9569d26d$var$isValidKeyboardEvent(e2, originalTarget) && !e2.repeat && $23f2114a1b82827e$export$4282f70798064fe0(originalTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e2)) && state.target)
+              triggerPressUpEvent($d27d541f9569d26d$var$createEvent(state.target, e2), "keyboard");
+          };
+          addGlobalListener($d447af545b77c9f1$export$b204af158042fbac(e.currentTarget), "keyup", $a4e76a5424781910$export$e08e3b67e392101e(pressUp, onKeyUp), true);
+          if (shouldStopPropagation) e.stopPropagation();
+          if (e.metaKey && $2add3ce32c6007eb$export$9ac100e40613ea10()) (_a = state.metaKeyEvents) == null ? void 0 : _a.set(e.key, e.nativeEvent);
+        } else if (e.key === "Meta") state.metaKeyEvents = /* @__PURE__ */ new Map();
+      },
+      onClick(e) {
+        if (e && !$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (e && e.button === 0 && !state.isTriggeringEvent && !$caaf0dd3060ed57c$export$95185d699e05d4d7.isOpening) {
+          let shouldStopPropagation = true;
+          if (isDisabled) e.preventDefault();
+          if (!state.ignoreEmulatedMouseEvents && !state.isPressed && (state.pointerType === "virtual" || $b5c62b033c25b96d$export$60278871457622de(e.nativeEvent))) {
+            let stopPressStart = triggerPressStart(e, "virtual");
+            let stopPressUp = triggerPressUpEvent(e, "virtual");
+            let stopPressEnd = triggerPressEndEvent(e, "virtual");
+            triggerClick(e);
+            shouldStopPropagation = stopPressStart && stopPressUp && stopPressEnd;
+          } else if (state.isPressed && state.pointerType !== "keyboard") {
+            let pointerType = state.pointerType || e.nativeEvent.pointerType || "virtual";
+            let stopPressUp = triggerPressUpEvent($d27d541f9569d26d$var$createEvent(e.currentTarget, e), pointerType);
+            let stopPressEnd = triggerPressEndEvent($d27d541f9569d26d$var$createEvent(e.currentTarget, e), pointerType, true);
+            shouldStopPropagation = stopPressUp && stopPressEnd;
+            state.isOverTarget = false;
+            triggerClick(e);
+            cancelEvent(e);
+          }
+          state.ignoreEmulatedMouseEvents = false;
+          if (shouldStopPropagation) e.stopPropagation();
+        }
+      }
+    };
+    let onKeyUp = (e) => {
+      var _a, _b, _c;
+      if (state.isPressed && state.target && $d27d541f9569d26d$var$isValidKeyboardEvent(e, state.target)) {
+        if ($d27d541f9569d26d$var$shouldPreventDefaultKeyboard($23f2114a1b82827e$export$e58f029f0fbfdb29(e), e.key)) e.preventDefault();
+        let target = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+        let wasPressed = $23f2114a1b82827e$export$4282f70798064fe0(state.target, target);
+        triggerPressEndEvent($d27d541f9569d26d$var$createEvent(state.target, e), "keyboard", wasPressed);
+        if (wasPressed) triggerSyntheticClick(e, state.target);
+        removeAllGlobalListeners();
+        if (e.key !== "Enter" && $d27d541f9569d26d$var$isHTMLAnchorLink(state.target) && $23f2114a1b82827e$export$4282f70798064fe0(state.target, target) && !e[$d27d541f9569d26d$var$LINK_CLICKED]) {
+          e[$d27d541f9569d26d$var$LINK_CLICKED] = true;
+          $caaf0dd3060ed57c$export$95185d699e05d4d7(state.target, e, false);
+        }
+        state.isPressed = false;
+        (_a = state.metaKeyEvents) == null ? void 0 : _a.delete(e.key);
+      } else if (e.key === "Meta" && ((_b = state.metaKeyEvents) == null ? void 0 : _b.size)) {
+        let events = state.metaKeyEvents;
+        state.metaKeyEvents = void 0;
+        for (let event of events.values()) (_c = state.target) == null ? void 0 : _c.dispatchEvent(new KeyboardEvent("keyup", event));
+      }
+    };
+    if (typeof PointerEvent !== "undefined") {
+      pressProps2.onPointerDown = (e) => {
+        if (e.button !== 0 || !$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if ($b5c62b033c25b96d$export$29bf1b5f2c56cf63(e.nativeEvent)) {
+          state.pointerType = "virtual";
+          return;
+        }
+        state.pointerType = e.pointerType;
+        let shouldStopPropagation = true;
+        if (!state.isPressed) {
+          state.isPressed = true;
+          state.isOverTarget = true;
+          state.activePointerId = e.pointerId;
+          state.target = e.currentTarget;
+          if (!allowTextSelectionOnPress) $cbf007e418543821$export$16a4697467175487(state.target);
+          shouldStopPropagation = triggerPressStart(e, state.pointerType);
+          let target = $23f2114a1b82827e$export$e58f029f0fbfdb29(e);
+          if ("releasePointerCapture" in target) {
+            if ("hasPointerCapture" in target) {
+              if (target.hasPointerCapture(e.pointerId)) target.releasePointerCapture(e.pointerId);
+            } else target.releasePointerCapture(e.pointerId);
+          }
+          addGlobalListener($d447af545b77c9f1$export$b204af158042fbac(e.currentTarget), "pointerup", onPointerUp, false);
+          addGlobalListener($d447af545b77c9f1$export$b204af158042fbac(e.currentTarget), "pointercancel", onPointerCancel, false);
+        }
+        if (shouldStopPropagation) e.stopPropagation();
+      };
+      pressProps2.onMouseDown = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (e.button === 0) {
+          if (preventFocusOnPress) {
+            let dispose = $a92dc41f639950be$export$cabe61c495ee3649(e.target);
+            if (dispose) state.disposables.push(dispose);
+          }
+          e.stopPropagation();
+        }
+      };
+      pressProps2.onPointerUp = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e)) || state.pointerType === "virtual") return;
+        if (e.button === 0 && !state.isPressed)
+          triggerPressUpEvent(e, state.pointerType || e.pointerType);
+      };
+      pressProps2.onPointerEnter = (e) => {
+        if (e.pointerId === state.activePointerId && state.target && !state.isOverTarget && state.pointerType != null) {
+          state.isOverTarget = true;
+          triggerPressStart($d27d541f9569d26d$var$createEvent(state.target, e), state.pointerType);
+        }
+      };
+      pressProps2.onPointerLeave = (e) => {
+        if (e.pointerId === state.activePointerId && state.target && state.isOverTarget && state.pointerType != null) {
+          state.isOverTarget = false;
+          triggerPressEndEvent($d27d541f9569d26d$var$createEvent(state.target, e), state.pointerType, false);
+          cancelOnPointerExit(e);
+        }
+      };
+      let onPointerUp = (e) => {
+        if (e.pointerId === state.activePointerId && state.isPressed && e.button === 0 && state.target) {
+          if ($23f2114a1b82827e$export$4282f70798064fe0(state.target, $23f2114a1b82827e$export$e58f029f0fbfdb29(e)) && state.pointerType != null) {
+            let clicked = false;
+            let timeout = setTimeout(() => {
+              if (state.isPressed && state.target instanceof HTMLElement) {
+                if (clicked)
+                  cancelEvent(e);
+                else {
+                  $1969ac565cfec8d0$export$de79e2c695e052f3(state.target);
+                  state.target.click();
+                }
+              }
+            }, 80);
+            addGlobalListener(e.currentTarget, "click", () => clicked = true, true);
+            state.disposables.push(() => clearTimeout(timeout));
+          } else
+            cancelEvent(e);
+          state.isOverTarget = false;
+        }
+      };
+      let onPointerCancel = (e) => {
+        cancelEvent(e);
+      };
+      pressProps2.onDragStart = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        cancelEvent(e);
+      };
+    } else if (process.env.NODE_ENV === "test") {
+      pressProps2.onMouseDown = (e) => {
+        if (e.button !== 0 || !$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (state.ignoreEmulatedMouseEvents) {
+          e.stopPropagation();
+          return;
+        }
+        state.isPressed = true;
+        state.isOverTarget = true;
+        state.target = e.currentTarget;
+        state.pointerType = $b5c62b033c25b96d$export$60278871457622de(e.nativeEvent) ? "virtual" : "mouse";
+        let shouldStopPropagation = flushSync(() => triggerPressStart(e, state.pointerType));
+        if (shouldStopPropagation) e.stopPropagation();
+        if (preventFocusOnPress) {
+          let dispose = $a92dc41f639950be$export$cabe61c495ee3649(e.target);
+          if (dispose) state.disposables.push(dispose);
+        }
+        addGlobalListener($d447af545b77c9f1$export$b204af158042fbac(e.currentTarget), "mouseup", onMouseUp, false);
+      };
+      pressProps2.onMouseEnter = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        let shouldStopPropagation = true;
+        if (state.isPressed && !state.ignoreEmulatedMouseEvents && state.pointerType != null) {
+          state.isOverTarget = true;
+          shouldStopPropagation = triggerPressStart(e, state.pointerType);
+        }
+        if (shouldStopPropagation) e.stopPropagation();
+      };
+      pressProps2.onMouseLeave = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        let shouldStopPropagation = true;
+        if (state.isPressed && !state.ignoreEmulatedMouseEvents && state.pointerType != null) {
+          state.isOverTarget = false;
+          shouldStopPropagation = triggerPressEndEvent(e, state.pointerType, false);
+          cancelOnPointerExit(e);
+        }
+        if (shouldStopPropagation) e.stopPropagation();
+      };
+      pressProps2.onMouseUp = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (!state.ignoreEmulatedMouseEvents && e.button === 0 && !state.isPressed)
+          triggerPressUpEvent(e, state.pointerType || "mouse");
+      };
+      let onMouseUp = (e) => {
+        if (e.button !== 0) return;
+        if (state.ignoreEmulatedMouseEvents) {
+          state.ignoreEmulatedMouseEvents = false;
+          return;
+        }
+        if (state.target && $23f2114a1b82827e$export$4282f70798064fe0(state.target, $23f2114a1b82827e$export$e58f029f0fbfdb29(e)) && state.pointerType != null) ;
+        else
+          cancelEvent(e);
+        state.isOverTarget = false;
+      };
+      pressProps2.onTouchStart = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        let touch = $d27d541f9569d26d$var$getTouchFromEvent(e.nativeEvent);
+        if (!touch) return;
+        state.activePointerId = touch.identifier;
+        state.ignoreEmulatedMouseEvents = true;
+        state.isOverTarget = true;
+        state.isPressed = true;
+        state.target = e.currentTarget;
+        state.pointerType = "touch";
+        if (!allowTextSelectionOnPress) $cbf007e418543821$export$16a4697467175487(state.target);
+        let shouldStopPropagation = triggerPressStart($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType);
+        if (shouldStopPropagation) e.stopPropagation();
+        addGlobalListener($d447af545b77c9f1$export$f21a1ffae260145a(e.currentTarget), "scroll", onScroll, true);
+      };
+      pressProps2.onTouchMove = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (!state.isPressed) {
+          e.stopPropagation();
+          return;
+        }
+        let touch = $d27d541f9569d26d$var$getTouchById(e.nativeEvent, state.activePointerId);
+        let shouldStopPropagation = true;
+        if (touch && $d27d541f9569d26d$var$isOverTarget(touch, e.currentTarget)) {
+          if (!state.isOverTarget && state.pointerType != null) {
+            state.isOverTarget = true;
+            shouldStopPropagation = triggerPressStart($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType);
+          }
+        } else if (state.isOverTarget && state.pointerType != null) {
+          state.isOverTarget = false;
+          shouldStopPropagation = triggerPressEndEvent($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType, false);
+          cancelOnPointerExit($d27d541f9569d26d$var$createTouchEvent(state.target, e));
+        }
+        if (shouldStopPropagation) e.stopPropagation();
+      };
+      pressProps2.onTouchEnd = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        if (!state.isPressed) {
+          e.stopPropagation();
+          return;
+        }
+        let touch = $d27d541f9569d26d$var$getTouchById(e.nativeEvent, state.activePointerId);
+        let shouldStopPropagation = true;
+        if (touch && $d27d541f9569d26d$var$isOverTarget(touch, e.currentTarget) && state.pointerType != null) {
+          triggerPressUpEvent($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType);
+          shouldStopPropagation = triggerPressEndEvent($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType);
+          triggerSyntheticClick(e.nativeEvent, state.target);
+        } else if (state.isOverTarget && state.pointerType != null)
+          shouldStopPropagation = triggerPressEndEvent($d27d541f9569d26d$var$createTouchEvent(state.target, e), state.pointerType, false);
+        if (shouldStopPropagation) e.stopPropagation();
+        state.isPressed = false;
+        state.activePointerId = null;
+        state.isOverTarget = false;
+        state.ignoreEmulatedMouseEvents = true;
+        if (state.target && !allowTextSelectionOnPress) $cbf007e418543821$export$b0d6fa1ab32e3295(state.target);
+        removeAllGlobalListeners();
+      };
+      pressProps2.onTouchCancel = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        e.stopPropagation();
+        if (state.isPressed)
+          cancelEvent($d27d541f9569d26d$var$createTouchEvent(state.target, e));
+      };
+      let onScroll = (e) => {
+        if (state.isPressed && $23f2114a1b82827e$export$4282f70798064fe0($23f2114a1b82827e$export$e58f029f0fbfdb29(e), state.target))
+          cancelEvent({
+            currentTarget: state.target,
+            shiftKey: false,
+            ctrlKey: false,
+            metaKey: false,
+            altKey: false
+          });
+      };
+      pressProps2.onDragStart = (e) => {
+        if (!$23f2114a1b82827e$export$4282f70798064fe0(e.currentTarget, $23f2114a1b82827e$export$e58f029f0fbfdb29(e))) return;
+        cancelEvent(e);
+      };
+    }
+    return pressProps2;
+  }, [
+    addGlobalListener,
+    isDisabled,
+    preventFocusOnPress,
+    removeAllGlobalListeners,
+    allowTextSelectionOnPress,
+    cancelOnPointerExit,
+    triggerPressStart,
+    triggerClick,
+    triggerSyntheticClick
+  ]);
+  useEffect(() => {
+    if (!domRef || process.env.NODE_ENV === "test") return;
+    const ownerDocument = $d447af545b77c9f1$export$b204af158042fbac(domRef.current);
+    if (!ownerDocument || !ownerDocument.head || ownerDocument.getElementById($d27d541f9569d26d$var$STYLE_ID)) return;
+    const style = ownerDocument.createElement("style");
+    style.id = $d27d541f9569d26d$var$STYLE_ID;
+    let nonce = $2b2d34ff061957fb$export$2b85b721e524d74b(ownerDocument);
+    if (nonce) style.nonce = nonce;
+    style.textContent = `
+@layer {
+  [${$d27d541f9569d26d$var$PRESSABLE_ATTRIBUTE}] {
+    touch-action: pan-x pan-y pinch-zoom;
+  }
+}
+    `.trim();
+    ownerDocument.head.prepend(style);
+  }, [
+    domRef
+  ]);
+  useEffect(() => {
+    let state = ref.current;
+    return () => {
+      if (!allowTextSelectionOnPress) $cbf007e418543821$export$b0d6fa1ab32e3295(state.target ?? void 0);
+      for (let dispose of state.disposables) dispose();
+      state.disposables = [];
+    };
+  }, [
+    allowTextSelectionOnPress
+  ]);
+  return {
+    isPressed: isPressedProp || isPressed,
+    pressProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(domProps, pressProps, {
+      [$d27d541f9569d26d$var$PRESSABLE_ATTRIBUTE]: true
+    })
+  };
+}
+function $d27d541f9569d26d$var$isHTMLAnchorLink(target) {
+  return target.tagName === "A" && target.hasAttribute("href");
+}
+function $d27d541f9569d26d$var$isValidKeyboardEvent(event, currentTarget) {
+  const { key, code } = event;
+  const element = currentTarget;
+  const role = element.getAttribute("role");
+  return (key === "Enter" || key === " " || key === "Spacebar" || code === "Space") && !(element instanceof $d447af545b77c9f1$export$f21a1ffae260145a(element).HTMLInputElement && !$d27d541f9569d26d$var$isValidInputKey(element, key) || element instanceof $d447af545b77c9f1$export$f21a1ffae260145a(element).HTMLTextAreaElement || element.isContentEditable) && // Links should only trigger with Enter key
+  !((role === "link" || !role && $d27d541f9569d26d$var$isHTMLAnchorLink(element)) && key !== "Enter");
+}
+function $d27d541f9569d26d$var$getTouchFromEvent(event) {
+  const { targetTouches } = event;
+  if (targetTouches.length > 0) return targetTouches[0];
+  return null;
+}
+function $d27d541f9569d26d$var$getTouchById(event, pointerId) {
+  const changedTouches = event.changedTouches;
+  for (let i = 0; i < changedTouches.length; i++) {
+    const touch = changedTouches[i];
+    if (touch.identifier === pointerId) return touch;
+  }
+  return null;
+}
+function $d27d541f9569d26d$var$createTouchEvent(target, e) {
+  let clientX = 0;
+  let clientY = 0;
+  if (e.targetTouches && e.targetTouches.length === 1) {
+    clientX = e.targetTouches[0].clientX;
+    clientY = e.targetTouches[0].clientY;
+  }
+  return {
+    currentTarget: target,
+    shiftKey: e.shiftKey,
+    ctrlKey: e.ctrlKey,
+    metaKey: e.metaKey,
+    altKey: e.altKey,
+    clientX,
+    clientY
+  };
+}
+function $d27d541f9569d26d$var$createEvent(target, e) {
+  let clientX = e.clientX;
+  let clientY = e.clientY;
+  return {
+    currentTarget: target,
+    shiftKey: e.shiftKey,
+    ctrlKey: e.ctrlKey,
+    metaKey: e.metaKey,
+    altKey: e.altKey,
+    clientX,
+    clientY,
+    key: e.key
+  };
+}
+function $d27d541f9569d26d$var$getPointClientRect(point) {
+  let offsetX = 0;
+  let offsetY = 0;
+  if (point.width !== void 0) offsetX = point.width / 2;
+  else if (point.radiusX !== void 0) offsetX = point.radiusX;
+  if (point.height !== void 0) offsetY = point.height / 2;
+  else if (point.radiusY !== void 0) offsetY = point.radiusY;
+  return {
+    top: point.clientY - offsetY,
+    right: point.clientX + offsetX,
+    bottom: point.clientY + offsetY,
+    left: point.clientX - offsetX
+  };
+}
+function $d27d541f9569d26d$var$areRectanglesOverlapping(a, b2) {
+  if (a.left > b2.right || b2.left > a.right) return false;
+  if (a.top > b2.bottom || b2.top > a.bottom) return false;
+  return true;
+}
+function $d27d541f9569d26d$var$isOverTarget(point, target) {
+  let rect = target.getBoundingClientRect();
+  let pointRect = $d27d541f9569d26d$var$getPointClientRect(point);
+  return $d27d541f9569d26d$var$areRectanglesOverlapping(rect, pointRect);
+}
+function $d27d541f9569d26d$var$shouldPreventDefaultUp(target) {
+  if (target instanceof HTMLInputElement) return false;
+  if (target instanceof HTMLButtonElement) return target.type !== "submit" && target.type !== "reset";
+  if ($d27d541f9569d26d$var$isHTMLAnchorLink(target)) return false;
+  return true;
+}
+function $d27d541f9569d26d$var$shouldPreventDefaultKeyboard(target, key) {
+  if (target instanceof HTMLInputElement) return !$d27d541f9569d26d$var$isValidInputKey(target, key);
+  return $d27d541f9569d26d$var$shouldPreventDefaultUp(target);
+}
+const $d27d541f9569d26d$var$nonTextInputTypes = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function $d27d541f9569d26d$var$isValidInputKey(target, key) {
+  return target.type === "checkbox" || target.type === "radio" ? key === " " : $d27d541f9569d26d$var$nonTextInputTypes.has(target.type);
+}
+function $ac4318a9c075bb9f$export$ea18c227d4417cc3(props, ref) {
+  let { elementType = "button", isDisabled, onPress, onPressStart, onPressEnd, onPressUp, onPressChange, preventFocusOnPress, allowFocusWhenDisabled, onClick, href, target, rel, type = "button" } = props;
+  let additionalProps;
+  if (elementType === "button") additionalProps = {
+    type,
+    disabled: isDisabled,
+    form: props.form,
+    formAction: props.formAction,
+    formEncType: props.formEncType,
+    formMethod: props.formMethod,
+    formNoValidate: props.formNoValidate,
+    formTarget: props.formTarget,
+    name: props.name,
+    value: props.value
+  };
+  else additionalProps = {
+    role: "button",
+    href: elementType === "a" && !isDisabled ? href : void 0,
+    target: elementType === "a" ? target : void 0,
+    type: elementType === "input" ? type : void 0,
+    disabled: elementType === "input" ? isDisabled : void 0,
+    "aria-disabled": !isDisabled || elementType === "input" ? void 0 : isDisabled,
+    rel: elementType === "a" ? rel : void 0
+  };
+  let { pressProps, isPressed } = $d27d541f9569d26d$export$45712eceda6fad21({
+    onPressStart,
+    onPressEnd,
+    onPressChange,
+    onPress,
+    onPressUp,
+    onClick,
+    isDisabled,
+    preventFocusOnPress,
+    ref
+  });
+  let { focusableProps } = $d1116acdf220c2da$export$4c014de7c8940b4c(props, ref);
+  if (allowFocusWhenDisabled) focusableProps.tabIndex = isDisabled ? -1 : focusableProps.tabIndex;
+  let buttonProps = $bbaa08b3cd72f041$export$9d1611c77c2fe928(focusableProps, pressProps, $8e9d2fae0ecb9001$export$457c3d6518dd4c6f(props, {
+    labelable: true
+  }));
+  return {
+    isPressed,
+    buttonProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(additionalProps, buttonProps, {
+      "aria-haspopup": props["aria-haspopup"],
+      "aria-expanded": props["aria-expanded"],
+      "aria-controls": props["aria-controls"],
+      "aria-pressed": props["aria-pressed"],
+      "aria-current": props["aria-current"],
+      "aria-disabled": props["aria-disabled"]
+    })
+  };
+}
+function $240e9101ba2842f5$export$7d15b64cf5a3a4c4(value, min = -Infinity, max = Infinity) {
+  let newValue = Math.min(Math.max(value, min), max);
+  return newValue;
+}
+function $240e9101ba2842f5$export$e1a7b8e69ef6c52f(value, step) {
+  let roundedValue = value;
+  let precision = 0;
+  let stepString = step.toString();
+  let eIndex = stepString.toLowerCase().indexOf("e-");
+  if (eIndex > 0) precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + eIndex;
+  else {
+    let pointIndex = stepString.indexOf(".");
+    if (pointIndex >= 0) precision = stepString.length - pointIndex;
+  }
+  if (precision > 0) {
+    let pow = Math.pow(10, precision);
+    roundedValue = Math.round(roundedValue * pow) / pow;
+  }
+  return roundedValue;
+}
+function $240e9101ba2842f5$export$cb6e0bb50bc19463(value, min, max, step) {
+  min = Number(min);
+  max = Number(max);
+  let remainder = (value - (isNaN(min) ? 0 : min)) % step;
+  let snappedValue = $240e9101ba2842f5$export$e1a7b8e69ef6c52f(Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder, step);
+  if (!isNaN(min)) {
+    if (snappedValue < min) snappedValue = min;
+    else if (!isNaN(max) && snappedValue > max) snappedValue = min + Math.floor($240e9101ba2842f5$export$e1a7b8e69ef6c52f((max - min) / step, step)) * step;
+  } else if (!isNaN(max) && snappedValue > max) snappedValue = Math.floor($240e9101ba2842f5$export$e1a7b8e69ef6c52f(max / step, step)) * step;
+  snappedValue = $240e9101ba2842f5$export$e1a7b8e69ef6c52f(snappedValue, step);
+  return snappedValue;
+}
+function $1dfdc54e7eb53ba0$export$36da96379f79f245(props) {
+  let { onMoveStart, onMove, onMoveEnd } = props;
+  let state = useRef({
+    didMove: false,
+    lastPosition: null,
+    id: null
+  });
+  let { addGlobalListener, removeGlobalListener } = $48a7d519b337145d$export$4eaf04e54aa8eed6();
+  let move = useCallback((originalEvent, pointerType, deltaX, deltaY) => {
+    if (deltaX === 0 && deltaY === 0) return;
+    if (!state.current.didMove) {
+      state.current.didMove = true;
+      onMoveStart == null ? void 0 : onMoveStart({
+        type: "movestart",
+        pointerType,
+        shiftKey: originalEvent.shiftKey,
+        metaKey: originalEvent.metaKey,
+        ctrlKey: originalEvent.ctrlKey,
+        altKey: originalEvent.altKey
+      });
+    }
+    onMove == null ? void 0 : onMove({
+      type: "move",
+      pointerType,
+      deltaX,
+      deltaY,
+      shiftKey: originalEvent.shiftKey,
+      metaKey: originalEvent.metaKey,
+      ctrlKey: originalEvent.ctrlKey,
+      altKey: originalEvent.altKey
+    });
+  }, [
+    onMoveStart,
+    onMove,
+    state
+  ]);
+  let moveEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(move);
+  let end = useCallback((originalEvent, pointerType) => {
+    $cbf007e418543821$export$b0d6fa1ab32e3295();
+    if (state.current.didMove) onMoveEnd == null ? void 0 : onMoveEnd({
+      type: "moveend",
+      pointerType,
+      shiftKey: originalEvent.shiftKey,
+      metaKey: originalEvent.metaKey,
+      ctrlKey: originalEvent.ctrlKey,
+      altKey: originalEvent.altKey
+    });
+  }, [
+    onMoveEnd,
+    state
+  ]);
+  let endEvent = $fe16bffc7a557bf0$export$7f54fc3180508a52(end);
+  let moveProps = useMemo(() => {
+    let moveProps2 = {};
+    let start = () => {
+      $cbf007e418543821$export$16a4697467175487();
+      state.current.didMove = false;
+    };
+    if (typeof PointerEvent === "undefined" && process.env.NODE_ENV === "test") {
+      let onMouseMove = (e) => {
+        var _a, _b;
+        if (e.button === 0) {
+          moveEvent(e, "mouse", e.pageX - (((_a = state.current.lastPosition) == null ? void 0 : _a.pageX) ?? 0), e.pageY - (((_b = state.current.lastPosition) == null ? void 0 : _b.pageY) ?? 0));
+          state.current.lastPosition = {
+            pageX: e.pageX,
+            pageY: e.pageY
+          };
+        }
+      };
+      let onMouseUp = (e) => {
+        if (e.button === 0) {
+          endEvent(e, "mouse");
+          let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+          removeGlobalListener(ownerWindow, "mousemove", onMouseMove, false);
+          removeGlobalListener(ownerWindow, "mouseup", onMouseUp, false);
+        }
+      };
+      moveProps2.onMouseDown = (e) => {
+        if (e.button === 0) {
+          start();
+          e.stopPropagation();
+          e.preventDefault();
+          state.current.lastPosition = {
+            pageX: e.pageX,
+            pageY: e.pageY
+          };
+          let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+          addGlobalListener(ownerWindow, "mousemove", onMouseMove, false);
+          addGlobalListener(ownerWindow, "mouseup", onMouseUp, false);
+        }
+      };
+      let onTouchMove = (e) => {
+        var _a, _b;
+        let touch = [
+          ...e.changedTouches
+        ].findIndex(({ identifier }) => identifier === state.current.id);
+        if (touch >= 0) {
+          let { pageX, pageY } = e.changedTouches[touch];
+          moveEvent(e, "touch", pageX - (((_a = state.current.lastPosition) == null ? void 0 : _a.pageX) ?? 0), pageY - (((_b = state.current.lastPosition) == null ? void 0 : _b.pageY) ?? 0));
+          state.current.lastPosition = {
+            pageX,
+            pageY
+          };
+        }
+      };
+      let onTouchEnd = (e) => {
+        let touch = [
+          ...e.changedTouches
+        ].findIndex(({ identifier }) => identifier === state.current.id);
+        if (touch >= 0) {
+          endEvent(e, "touch");
+          state.current.id = null;
+          let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+          removeGlobalListener(ownerWindow, "touchmove", onTouchMove);
+          removeGlobalListener(ownerWindow, "touchend", onTouchEnd);
+          removeGlobalListener(ownerWindow, "touchcancel", onTouchEnd);
+        }
+      };
+      moveProps2.onTouchStart = (e) => {
+        if (e.changedTouches.length === 0 || state.current.id != null) return;
+        let { pageX, pageY, identifier } = e.changedTouches[0];
+        start();
+        e.stopPropagation();
+        e.preventDefault();
+        state.current.lastPosition = {
+          pageX,
+          pageY
+        };
+        state.current.id = identifier;
+        let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+        addGlobalListener(ownerWindow, "touchmove", onTouchMove, false);
+        addGlobalListener(ownerWindow, "touchend", onTouchEnd, false);
+        addGlobalListener(ownerWindow, "touchcancel", onTouchEnd, false);
+      };
+    } else {
+      let onPointerMove = (e) => {
+        var _a, _b;
+        if (e.pointerId === state.current.id) {
+          let pointerType = e.pointerType || "mouse";
+          moveEvent(e, pointerType, e.pageX - (((_a = state.current.lastPosition) == null ? void 0 : _a.pageX) ?? 0), e.pageY - (((_b = state.current.lastPosition) == null ? void 0 : _b.pageY) ?? 0));
+          state.current.lastPosition = {
+            pageX: e.pageX,
+            pageY: e.pageY
+          };
+        }
+      };
+      let onPointerUp = (e) => {
+        if (e.pointerId === state.current.id) {
+          let pointerType = e.pointerType || "mouse";
+          endEvent(e, pointerType);
+          state.current.id = null;
+          let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+          removeGlobalListener(ownerWindow, "pointermove", onPointerMove, false);
+          removeGlobalListener(ownerWindow, "pointerup", onPointerUp, false);
+          removeGlobalListener(ownerWindow, "pointercancel", onPointerUp, false);
+        }
+      };
+      moveProps2.onPointerDown = (e) => {
+        if (e.button === 0 && state.current.id == null) {
+          start();
+          e.stopPropagation();
+          e.preventDefault();
+          state.current.lastPosition = {
+            pageX: e.pageX,
+            pageY: e.pageY
+          };
+          state.current.id = e.pointerId;
+          let ownerWindow = $d447af545b77c9f1$export$f21a1ffae260145a($23f2114a1b82827e$export$e58f029f0fbfdb29(e));
+          addGlobalListener(ownerWindow, "pointermove", onPointerMove, false);
+          addGlobalListener(ownerWindow, "pointerup", onPointerUp, false);
+          addGlobalListener(ownerWindow, "pointercancel", onPointerUp, false);
+        }
+      };
+    }
+    let triggerKeyboardMove = (e, deltaX, deltaY) => {
+      start();
+      moveEvent(e, "keyboard", deltaX, deltaY);
+      endEvent(e, "keyboard");
+    };
+    moveProps2.onKeyDown = (e) => {
+      switch (e.key) {
+        case "Left":
+        case "ArrowLeft":
+          e.preventDefault();
+          e.stopPropagation();
+          triggerKeyboardMove(e, -1, 0);
+          break;
+        case "Right":
+        case "ArrowRight":
+          e.preventDefault();
+          e.stopPropagation();
+          triggerKeyboardMove(e, 1, 0);
+          break;
+        case "Up":
+        case "ArrowUp":
+          e.preventDefault();
+          e.stopPropagation();
+          triggerKeyboardMove(e, 0, -1);
+          break;
+        case "Down":
+        case "ArrowDown":
+          e.preventDefault();
+          e.stopPropagation();
+          triggerKeyboardMove(e, 0, 1);
+          break;
+      }
+    };
+    return moveProps2;
+  }, [
+    addGlobalListener,
+    removeGlobalListener,
+    state
+  ]);
+  return {
+    moveProps
+  };
+}
+const $ea3928288112382f$var$styles = {
+  border: 0,
+  clip: "rect(0 0 0 0)",
+  clipPath: "inset(50%)",
+  height: "1px",
+  margin: "-1px",
+  overflow: "hidden",
+  padding: 0,
+  position: "absolute",
+  width: "1px",
+  whiteSpace: "nowrap"
+};
+function $ea3928288112382f$export$a966af930f325cab(props = {}) {
+  let { style, isFocusable } = props;
+  let [isFocused, setFocused] = useState(false);
+  let { focusWithinProps } = $2c9edc598a03d523$export$420e68273165f4ec({
+    isDisabled: !isFocusable,
+    onFocusWithinChange: (val) => setFocused(val)
+  });
+  let combinedStyles = useMemo(() => {
+    if (isFocused) return style;
+    else if (style) return {
+      ...$ea3928288112382f$var$styles,
+      ...style
+    };
+    else return $ea3928288112382f$var$styles;
+  }, [
+    isFocused
+  ]);
+  return {
+    visuallyHiddenProps: {
+      ...focusWithinProps,
+      style: combinedStyles
+    }
+  };
+}
+function $ea3928288112382f$export$439d29a4e110a164(props) {
+  let { children, elementType: Element = "div", isFocusable, style, ...otherProps } = props;
+  let { visuallyHiddenProps } = $ea3928288112382f$export$a966af930f325cab(props);
+  return /* @__PURE__ */ React__default.createElement(Element, $bbaa08b3cd72f041$export$9d1611c77c2fe928(otherProps, visuallyHiddenProps), children);
+}
+function $bd90acf18e792be6$export$b7a616150fdb9f44(options = {}) {
+  let { locale } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+  return useMemo(() => new $1dfb119a85e764e5$export$cc77c4ff7e8673c5(locale, options), [
+    locale,
+    options
+  ]);
+}
+const $b2a66ce670b3f60f$export$d6c8d9636a3dc49c = /* @__PURE__ */ new WeakMap();
+function $b2a66ce670b3f60f$export$68e648cbec363a18(state, index) {
+  let data = $b2a66ce670b3f60f$export$d6c8d9636a3dc49c.get(state);
+  if (!data) throw new Error("Unknown slider state");
+  return `${data.id}-${index}`;
+}
+function $4b964a467b2bc7ea$export$56b2c08e277f365(props, state, trackRef) {
+  let { labelProps, fieldProps } = $0beb20c9744a2065$export$8467354a121f1b9f(props);
+  let isVertical = props.orientation === "vertical";
+  $b2a66ce670b3f60f$export$d6c8d9636a3dc49c.set(state, {
+    id: labelProps.id ?? fieldProps.id,
+    "aria-describedby": props["aria-describedby"],
+    "aria-details": props["aria-details"]
+  });
+  let { direction } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+  let { addGlobalListener, removeGlobalListener } = $48a7d519b337145d$export$4eaf04e54aa8eed6();
+  const realTimeTrackDraggingIndex = useRef(null);
+  const reverseX = direction === "rtl";
+  const currentPosition = useRef(null);
+  const { moveProps } = $1dfdc54e7eb53ba0$export$36da96379f79f245({
+    onMoveStart() {
+      currentPosition.current = null;
+    },
+    onMove({ deltaX, deltaY }) {
+      if (!trackRef.current) return;
+      let { height, width } = trackRef.current.getBoundingClientRect();
+      let size = isVertical ? height : width;
+      if (currentPosition.current == null && realTimeTrackDraggingIndex.current != null) currentPosition.current = state.getThumbPercent(realTimeTrackDraggingIndex.current) * size;
+      let delta = isVertical ? deltaY : deltaX;
+      if (isVertical || reverseX) delta = -delta;
+      currentPosition.current += delta;
+      if (realTimeTrackDraggingIndex.current != null && trackRef.current) {
+        const percent = $240e9101ba2842f5$export$7d15b64cf5a3a4c4(currentPosition.current / size, 0, 1);
+        state.setThumbPercent(realTimeTrackDraggingIndex.current, percent);
+      }
+    },
+    onMoveEnd() {
+      if (realTimeTrackDraggingIndex.current != null) {
+        state.setThumbDragging(realTimeTrackDraggingIndex.current, false);
+        realTimeTrackDraggingIndex.current = null;
+      }
+    }
+  });
+  let currentPointer = useRef(void 0);
+  let onDownTrack = (e, id, clientX, clientY) => {
+    if (trackRef.current && !props.isDisabled && state.values.every((_, i) => !state.isThumbDragging(i))) {
+      let { height, width, top, left } = trackRef.current.getBoundingClientRect();
+      let size = isVertical ? height : width;
+      const trackPosition = isVertical ? top : left;
+      const clickPosition = isVertical ? clientY : clientX;
+      const offset = clickPosition - trackPosition;
+      let percent = offset / size;
+      if (direction === "rtl" || isVertical) percent = 1 - percent;
+      let value = state.getPercentValue(percent);
+      let closestThumb;
+      let split = state.values.findIndex((v2) => value - v2 < 0);
+      if (split === 0) closestThumb = split;
+      else if (split === -1) closestThumb = state.values.length - 1;
+      else {
+        let lastLeft = state.values[split - 1];
+        let firstRight = state.values[split];
+        if (Math.abs(lastLeft - value) < Math.abs(firstRight - value)) closestThumb = split - 1;
+        else closestThumb = split;
+      }
+      if (closestThumb >= 0 && state.isThumbEditable(closestThumb)) {
+        e.preventDefault();
+        realTimeTrackDraggingIndex.current = closestThumb;
+        state.setFocusedThumb(closestThumb);
+        currentPointer.current = id;
+        state.setThumbDragging(realTimeTrackDraggingIndex.current, true);
+        state.setThumbValue(closestThumb, value);
+        addGlobalListener(window, "mouseup", onUpTrack, false);
+        addGlobalListener(window, "touchend", onUpTrack, false);
+        addGlobalListener(window, "pointerup", onUpTrack, false);
+      } else realTimeTrackDraggingIndex.current = null;
+    }
+  };
+  let onUpTrack = (e) => {
+    var _a;
+    let id = e.pointerId ?? ((_a = e.changedTouches) == null ? void 0 : _a[0].identifier);
+    if (id === currentPointer.current) {
+      if (realTimeTrackDraggingIndex.current != null) {
+        state.setThumbDragging(realTimeTrackDraggingIndex.current, false);
+        realTimeTrackDraggingIndex.current = null;
+      }
+      removeGlobalListener(window, "mouseup", onUpTrack, false);
+      removeGlobalListener(window, "touchend", onUpTrack, false);
+      removeGlobalListener(window, "pointerup", onUpTrack, false);
+    }
+  };
+  if ("htmlFor" in labelProps && labelProps.htmlFor) {
+    delete labelProps.htmlFor;
+    labelProps.onClick = () => {
+      var _a;
+      (_a = document.getElementById($b2a66ce670b3f60f$export$68e648cbec363a18(state, 0))) == null ? void 0 : _a.focus();
+      $8f5a2122b0992be3$export$8397ddfc504fdb9a("keyboard");
+    };
+  }
+  return {
+    labelProps,
+    // The root element of the Slider will have role="group" to group together
+    // all the thumb inputs in the Slider.  The label of the Slider will
+    // be used to label the group.
+    groupProps: {
+      role: "group",
+      ...fieldProps
+    },
+    trackProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928({
+      onMouseDown(e) {
+        if (e.button !== 0 || e.altKey || e.ctrlKey || e.metaKey) return;
+        onDownTrack(e, void 0, e.clientX, e.clientY);
+      },
+      onPointerDown(e) {
+        if (e.pointerType === "mouse" && (e.button !== 0 || e.altKey || e.ctrlKey || e.metaKey)) return;
+        onDownTrack(e, e.pointerId, e.clientX, e.clientY);
+      },
+      onTouchStart(e) {
+        onDownTrack(e, e.changedTouches[0].identifier, e.changedTouches[0].clientX, e.changedTouches[0].clientY);
+      },
+      style: {
+        position: "relative",
+        touchAction: "none"
+      }
+    }, moveProps),
+    outputProps: {
+      htmlFor: state.values.map((_, index) => $b2a66ce670b3f60f$export$68e648cbec363a18(state, index)).join(" "),
+      "aria-live": "off"
+    }
+  };
+}
+function $4a5dd96ecb58ab11$export$8d15029008292ae(opts, state) {
+  let { index = 0, isRequired, validationState, isInvalid, trackRef, inputRef, orientation = state.orientation, name, form } = opts;
+  let isDisabled = opts.isDisabled || state.isDisabled;
+  let isVertical = orientation === "vertical";
+  let { direction } = $2eb8e6d23f3d0cb0$export$43bb16f9c6d9e3f7();
+  let { addGlobalListener, removeGlobalListener } = $48a7d519b337145d$export$4eaf04e54aa8eed6();
+  let data = $b2a66ce670b3f60f$export$d6c8d9636a3dc49c.get(state);
+  const { labelProps, fieldProps } = $0beb20c9744a2065$export$8467354a121f1b9f({
+    ...opts,
+    id: $b2a66ce670b3f60f$export$68e648cbec363a18(state, index),
+    "aria-labelledby": `${data.id} ${opts["aria-labelledby"] ?? ""}`.trim()
+  });
+  const value = state.values[index];
+  const focusInput = useCallback(() => {
+    if (inputRef.current) $1969ac565cfec8d0$export$de79e2c695e052f3(inputRef.current);
+  }, [
+    inputRef
+  ]);
+  const isFocused = state.focusedThumb === index;
+  useEffect(() => {
+    if (isFocused) focusInput();
+  }, [
+    isFocused,
+    focusInput
+  ]);
+  let reverseX = direction === "rtl";
+  let currentPosition = useRef(null);
+  let { keyboardProps } = $8296dad1a4c5e0dc$export$8f71654801c2f7cd({
+    onKeyDown(e) {
+      let { getThumbMaxValue, getThumbMinValue, decrementThumb, incrementThumb, setThumbValue, setThumbDragging, pageSize } = state;
+      if (!/^(PageUp|PageDown|Home|End)$/.test(e.key)) {
+        e.continuePropagation();
+        return;
+      }
+      e.preventDefault();
+      setThumbDragging(index, true);
+      switch (e.key) {
+        case "PageUp":
+          incrementThumb(index, pageSize);
+          break;
+        case "PageDown":
+          decrementThumb(index, pageSize);
+          break;
+        case "Home":
+          setThumbValue(index, getThumbMinValue(index));
+          break;
+        case "End":
+          setThumbValue(index, getThumbMaxValue(index));
+          break;
+      }
+      setThumbDragging(index, false);
+    }
+  });
+  let { moveProps } = $1dfdc54e7eb53ba0$export$36da96379f79f245({
+    onMoveStart() {
+      currentPosition.current = null;
+      state.setThumbDragging(index, true);
+    },
+    onMove({ deltaX, deltaY, pointerType, shiftKey }) {
+      const { getThumbPercent, setThumbPercent, decrementThumb, incrementThumb, step, pageSize } = state;
+      if (!trackRef.current) return;
+      let { width, height } = trackRef.current.getBoundingClientRect();
+      let size = isVertical ? height : width;
+      if (currentPosition.current == null) currentPosition.current = getThumbPercent(index) * size;
+      if (pointerType === "keyboard") {
+        if (deltaX > 0 && reverseX || deltaX < 0 && !reverseX || deltaY > 0) decrementThumb(index, shiftKey ? pageSize : step);
+        else incrementThumb(index, shiftKey ? pageSize : step);
+      } else {
+        let delta = isVertical ? deltaY : deltaX;
+        if (isVertical || reverseX) delta = -delta;
+        currentPosition.current += delta;
+        setThumbPercent(index, $240e9101ba2842f5$export$7d15b64cf5a3a4c4(currentPosition.current / size, 0, 1));
+      }
+    },
+    onMoveEnd() {
+      state.setThumbDragging(index, false);
+    }
+  });
+  state.setThumbEditable(index, !isDisabled);
+  const { focusableProps } = $d1116acdf220c2da$export$4c014de7c8940b4c($bbaa08b3cd72f041$export$9d1611c77c2fe928(opts, {
+    onFocus: () => state.setFocusedThumb(index),
+    onBlur: () => state.setFocusedThumb(void 0)
+  }), inputRef);
+  let currentPointer = useRef(void 0);
+  let onDown = (id) => {
+    focusInput();
+    currentPointer.current = id;
+    state.setThumbDragging(index, true);
+    addGlobalListener(window, "mouseup", onUp, false);
+    addGlobalListener(window, "touchend", onUp, false);
+    addGlobalListener(window, "pointerup", onUp, false);
+  };
+  let onUp = (e) => {
+    var _a;
+    let id = e.pointerId ?? ((_a = e.changedTouches) == null ? void 0 : _a[0].identifier);
+    if (id === currentPointer.current) {
+      focusInput();
+      state.setThumbDragging(index, false);
+      removeGlobalListener(window, "mouseup", onUp, false);
+      removeGlobalListener(window, "touchend", onUp, false);
+      removeGlobalListener(window, "pointerup", onUp, false);
+    }
+  };
+  let thumbPosition = state.getThumbPercent(index);
+  if (isVertical || direction === "rtl") thumbPosition = 1 - thumbPosition;
+  let interactions = !isDisabled ? $bbaa08b3cd72f041$export$9d1611c77c2fe928(keyboardProps, moveProps, {
+    onMouseDown: (e) => {
+      if (e.button !== 0 || e.altKey || e.ctrlKey || e.metaKey) return;
+      onDown();
+    },
+    onPointerDown: (e) => {
+      if (e.button !== 0 || e.altKey || e.ctrlKey || e.metaKey) return;
+      onDown(e.pointerId);
+    },
+    onTouchStart: (e) => {
+      onDown(e.changedTouches[0].identifier);
+    }
+  }) : {};
+  $3274bf1495747a7b$export$5add1d006293d136(inputRef, state.defaultValues[index], (v2) => {
+    state.setThumbValue(index, v2);
+  });
+  return {
+    inputProps: $bbaa08b3cd72f041$export$9d1611c77c2fe928(focusableProps, fieldProps, {
+      type: "range",
+      tabIndex: !isDisabled ? 0 : void 0,
+      min: state.getThumbMinValue(index),
+      max: state.getThumbMaxValue(index),
+      step: state.step,
+      value,
+      name,
+      form,
+      disabled: isDisabled,
+      "aria-orientation": orientation,
+      "aria-valuetext": state.getThumbValueLabel(index),
+      "aria-required": isRequired || void 0,
+      "aria-invalid": isInvalid || validationState === "invalid" || void 0,
+      "aria-errormessage": opts["aria-errormessage"],
+      "aria-describedby": [
+        data["aria-describedby"],
+        opts["aria-describedby"]
+      ].filter(Boolean).join(" "),
+      "aria-details": [
+        data["aria-details"],
+        opts["aria-details"]
+      ].filter(Boolean).join(" "),
+      onChange: (e) => {
+        state.setThumbValue(index, parseFloat($23f2114a1b82827e$export$e58f029f0fbfdb29(e).value));
+      }
+    }),
+    thumbProps: {
+      ...interactions,
+      style: {
+        position: "absolute",
+        [isVertical ? "top" : "left"]: `${thumbPosition * 100}%`,
+        transform: "translate(-50%, -50%)",
+        touchAction: "none"
+      }
+    },
+    labelProps,
+    isDragging: state.isThumbDragging(index),
+    isDisabled,
+    isFocused
+  };
+}
+const $0393f8ab869a0f1a$export$e9f3bf65a26ce129 = /* @__PURE__ */ createContext(null);
+const $d2b4bc8c273e7be6$export$24d547caef80ccd1 = /* @__PURE__ */ createContext({});
+const $d2b4bc8c273e7be6$export$353f5b6fc5456de1 = /* @__PURE__ */ $f39a9eba43920ace$export$86427a43e3e48ebb(function Button(props, ref) {
+  [props, ref] = $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, $d2b4bc8c273e7be6$export$24d547caef80ccd1);
+  props = $d2b4bc8c273e7be6$var$disablePendingProps(props);
+  let ctx = props;
+  let { isPending } = ctx;
+  let { buttonProps, isPressed } = $ac4318a9c075bb9f$export$ea18c227d4417cc3(props, ref);
+  let { focusProps, isFocused, isFocusVisible } = $0c4a58759813079a$export$4e328f61c538687f(props);
+  let { hoverProps, isHovered } = $e969f22b6713ca4a$export$ae780daf29e6d456({
+    ...props,
+    isDisabled: props.isDisabled || isPending
+  });
+  let renderValues = {
+    isHovered,
+    isPressed: (ctx.isPressed || isPressed) && !isPending,
+    isFocused,
+    isFocusVisible,
+    isDisabled: props.isDisabled || false,
+    isPending: isPending !== null && isPending !== void 0 ? isPending : false
+  };
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    values: renderValues,
+    defaultClassName: "react-aria-Button"
+  });
+  let buttonId = $390e54f620492c70$export$f680877a34711e37(buttonProps.id);
+  let progressId = $390e54f620492c70$export$f680877a34711e37();
+  let ariaLabelledby = buttonProps["aria-labelledby"];
+  if (isPending) {
+    if (ariaLabelledby) ariaLabelledby = `${ariaLabelledby} ${progressId}`;
+    else if (buttonProps["aria-label"]) ariaLabelledby = `${buttonId} ${progressId}`;
+  }
+  let wasPending = useRef(isPending);
+  useEffect(() => {
+    let message = {
+      "aria-labelledby": ariaLabelledby || buttonId
+    };
+    if (!wasPending.current && isFocused && isPending) $319e236875307eab$export$a9b970dcc4ae71a9(message, "assertive");
+    else if (wasPending.current && isFocused && !isPending) $319e236875307eab$export$a9b970dcc4ae71a9(message, "assertive");
+    wasPending.current = isPending;
+  }, [
+    isPending,
+    isFocused,
+    ariaLabelledby,
+    buttonId
+  ]);
+  let DOMProps = $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    global: true
+  });
+  delete DOMProps.onClick;
+  return /* @__PURE__ */ React__default.createElement("button", {
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(DOMProps, renderProps, buttonProps, focusProps, hoverProps),
+    // When the button is in a pending state, we want to stop implicit form submission (ie. when the user presses enter on a text input).
+    // We do this by changing the button's type to button.
+    type: buttonProps.type === "submit" && isPending ? "button" : buttonProps.type,
+    id: buttonId,
+    ref,
+    "aria-labelledby": ariaLabelledby,
+    slot: props.slot || void 0,
+    "aria-disabled": isPending ? "true" : buttonProps["aria-disabled"],
+    "data-disabled": props.isDisabled || void 0,
+    "data-pressed": renderValues.isPressed || void 0,
+    "data-hovered": isHovered || void 0,
+    "data-focused": isFocused || void 0,
+    "data-pending": isPending || void 0,
+    "data-focus-visible": isFocusVisible || void 0
+  }, /* @__PURE__ */ React__default.createElement($0393f8ab869a0f1a$export$e9f3bf65a26ce129.Provider, {
+    value: {
+      id: progressId
+    }
+  }, renderProps.children));
+});
+function $d2b4bc8c273e7be6$var$disablePendingProps(props) {
+  if (props.isPending) {
+    props.onPress = void 0;
+    props.onPressStart = void 0;
+    props.onPressEnd = void 0;
+    props.onPressChange = void 0;
+    props.onPressUp = void 0;
+    props.onKeyDown = void 0;
+    props.onKeyUp = void 0;
+    props.onClick = void 0;
+    props.href = void 0;
+  }
+  return props;
+}
+const $d806310b82f07e9d$var$DEFAULT_MIN_VALUE = 0;
+const $d806310b82f07e9d$var$DEFAULT_MAX_VALUE = 100;
+const $d806310b82f07e9d$var$DEFAULT_STEP_VALUE = 1;
+function $d806310b82f07e9d$export$e5fda3247f5d67f9(props) {
+  const { isDisabled = false, minValue = $d806310b82f07e9d$var$DEFAULT_MIN_VALUE, maxValue = $d806310b82f07e9d$var$DEFAULT_MAX_VALUE, numberFormatter: formatter, step = $d806310b82f07e9d$var$DEFAULT_STEP_VALUE, orientation = "horizontal" } = props;
+  let pageSize = useMemo(() => {
+    let calcPageSize = (maxValue - minValue) / 10;
+    calcPageSize = $240e9101ba2842f5$export$cb6e0bb50bc19463(calcPageSize, 0, calcPageSize + step, step);
+    return Math.max(calcPageSize, step);
+  }, [
+    step,
+    maxValue,
+    minValue
+  ]);
+  let restrictValues = useCallback((values2) => values2 == null ? void 0 : values2.map((val, idx) => {
+    let min = idx === 0 ? minValue : values2[idx - 1];
+    let max = idx === values2.length - 1 ? maxValue : values2[idx + 1];
+    return $240e9101ba2842f5$export$cb6e0bb50bc19463(val, min, max, step);
+  }), [
+    minValue,
+    maxValue,
+    step
+  ]);
+  let value = useMemo(() => restrictValues($d806310b82f07e9d$var$convertValue(props.value)), [
+    props.value,
+    restrictValues
+  ]);
+  let defaultValue = useMemo(() => restrictValues($d806310b82f07e9d$var$convertValue(props.defaultValue) ?? [
+    minValue
+  ]), [
+    props.defaultValue,
+    minValue,
+    restrictValues
+  ]);
+  let onChange = $d806310b82f07e9d$var$createOnChange(props.value, props.defaultValue, props.onChange);
+  let onChangeEnd = $d806310b82f07e9d$var$createOnChange(props.value, props.defaultValue, props.onChangeEnd);
+  const [values, setValuesState] = $3e6197669829fe11$export$40bfa8c7b0832715(value, defaultValue, onChange);
+  let [initialValues] = useState(values);
+  const [isDraggings, setDraggingsState] = useState(new Array(values.length).fill(false));
+  const isEditablesRef = useRef(new Array(values.length).fill(true));
+  const [focusedIndex, setFocusedIndex] = useState(void 0);
+  const valuesRef = useRef(values);
+  const isDraggingsRef = useRef(isDraggings);
+  let setValues = (values2) => {
+    valuesRef.current = values2;
+    setValuesState(values2);
+  };
+  let setDraggings = (draggings) => {
+    isDraggingsRef.current = draggings;
+    setDraggingsState(draggings);
+  };
+  function getValuePercent(value2) {
+    return (value2 - minValue) / (maxValue - minValue);
+  }
+  function getThumbMinValue(index) {
+    return index === 0 ? minValue : values[index - 1];
+  }
+  function getThumbMaxValue(index) {
+    return index === values.length - 1 ? maxValue : values[index + 1];
+  }
+  function isThumbEditable(index) {
+    return isEditablesRef.current[index];
+  }
+  function setThumbEditable(index, editable) {
+    isEditablesRef.current[index] = editable;
+  }
+  function updateValue(index, value2) {
+    if (isDisabled || !isThumbEditable(index)) return;
+    const thisMin = getThumbMinValue(index);
+    const thisMax = getThumbMaxValue(index);
+    value2 = $240e9101ba2842f5$export$cb6e0bb50bc19463(value2, thisMin, thisMax, step);
+    let newValues = $d806310b82f07e9d$var$replaceIndex(valuesRef.current, index, value2);
+    setValues(newValues);
+  }
+  function updateDragging(index, dragging) {
+    if (isDisabled || !isThumbEditable(index)) return;
+    if (dragging) valuesRef.current = values;
+    const wasDragging = isDraggingsRef.current[index];
+    isDraggingsRef.current = $d806310b82f07e9d$var$replaceIndex(isDraggingsRef.current, index, dragging);
+    setDraggings(isDraggingsRef.current);
+    if (onChangeEnd && wasDragging && !isDraggingsRef.current.some(Boolean)) onChangeEnd(valuesRef.current);
+  }
+  function getFormattedValue(value2) {
+    return formatter.format(value2);
+  }
+  function setThumbPercent(index, percent) {
+    updateValue(index, getPercentValue(percent));
+  }
+  function getRoundedValue(value2) {
+    return Math.round((value2 - minValue) / step) * step + minValue;
+  }
+  function getPercentValue(percent) {
+    const val = percent * (maxValue - minValue) + minValue;
+    return $240e9101ba2842f5$export$7d15b64cf5a3a4c4(getRoundedValue(val), minValue, maxValue);
+  }
+  function incrementThumb(index, stepSize = 1) {
+    let s2 = Math.max(stepSize, step);
+    updateValue(index, $240e9101ba2842f5$export$cb6e0bb50bc19463(values[index] + s2, minValue, maxValue, step));
+  }
+  function decrementThumb(index, stepSize = 1) {
+    let s2 = Math.max(stepSize, step);
+    updateValue(index, $240e9101ba2842f5$export$cb6e0bb50bc19463(values[index] - s2, minValue, maxValue, step));
+  }
+  return {
+    values,
+    defaultValues: props.defaultValue !== void 0 ? defaultValue : initialValues,
+    getThumbValue: (index) => values[index],
+    setThumbValue: updateValue,
+    setThumbPercent,
+    isThumbDragging: (index) => isDraggings[index],
+    setThumbDragging: updateDragging,
+    focusedThumb: focusedIndex,
+    setFocusedThumb: setFocusedIndex,
+    getThumbPercent: (index) => getValuePercent(values[index]),
+    getValuePercent,
+    getThumbValueLabel: (index) => getFormattedValue(values[index]),
+    getFormattedValue,
+    getThumbMinValue,
+    getThumbMaxValue,
+    getPercentValue,
+    isThumbEditable,
+    setThumbEditable,
+    incrementThumb,
+    decrementThumb,
+    step,
+    pageSize,
+    orientation,
+    isDisabled
+  };
+}
+function $d806310b82f07e9d$var$replaceIndex(array, index, value) {
+  if (array[index] === value) return array;
+  return [
+    ...array.slice(0, index),
+    value,
+    ...array.slice(index + 1)
+  ];
+}
+function $d806310b82f07e9d$var$convertValue(value) {
+  if (value == null) return void 0;
+  return Array.isArray(value) ? value : [
+    value
+  ];
+}
+function $d806310b82f07e9d$var$createOnChange(value, defaultValue, onChange) {
+  return (newValue) => {
+    if (typeof value === "number" || typeof defaultValue === "number") onChange == null ? void 0 : onChange(newValue[0]);
+    else onChange == null ? void 0 : onChange(newValue);
+  };
+}
+const $6f909507e6374d18$export$e99164f0030f3bff = /* @__PURE__ */ createContext(null);
+const $6f909507e6374d18$export$1e7083018727fa60 = /* @__PURE__ */ createContext(null);
+const $6f909507e6374d18$export$f1fce0420cc6d8ee = /* @__PURE__ */ createContext(null);
+const $6f909507e6374d18$export$6189c2744041d8f8 = /* @__PURE__ */ createContext(null);
+const $6f909507e6374d18$export$472062a354075cee = /* @__PURE__ */ forwardRef(function Slider(props, ref) {
+  [props, ref] = $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, $6f909507e6374d18$export$e99164f0030f3bff);
+  let trackRef = useRef(null);
+  let numberFormatter = $bd90acf18e792be6$export$b7a616150fdb9f44(props.formatOptions);
+  let state = $d806310b82f07e9d$export$e5fda3247f5d67f9({
+    ...props,
+    numberFormatter
+  });
+  let [labelRef, label] = $64fa3d84918910a7$export$9d4c57ee4c6ffdd8(!props["aria-label"] && !props["aria-labelledby"]);
+  let { groupProps, trackProps, labelProps, outputProps } = $4b964a467b2bc7ea$export$56b2c08e277f365({
+    ...props,
+    label
+  }, state, trackRef);
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    values: {
+      orientation: state.orientation,
+      isDisabled: state.isDisabled,
+      state
+    },
+    defaultClassName: "react-aria-Slider"
+  });
+  let DOMProps = $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    global: true
+  });
+  delete DOMProps.id;
+  return /* @__PURE__ */ React__default.createElement($64fa3d84918910a7$export$2881499e37b75b9a, {
+    values: [
+      [
+        $6f909507e6374d18$export$1e7083018727fa60,
+        state
+      ],
+      [
+        $6f909507e6374d18$export$f1fce0420cc6d8ee,
+        {
+          ...trackProps,
+          ref: trackRef
+        }
+      ],
+      [
+        $6f909507e6374d18$export$6189c2744041d8f8,
+        outputProps
+      ],
+      [
+        $01b77f81d0f07f68$export$75b6ee27786ba447,
+        {
+          ...labelProps,
+          ref: labelRef
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ React__default.createElement("div", {
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(DOMProps, renderProps, groupProps),
+    ref,
+    slot: props.slot || void 0,
+    "data-orientation": state.orientation,
+    "data-disabled": state.isDisabled || void 0
+  }));
+});
+const $6f909507e6374d18$export$105594979f116971 = /* @__PURE__ */ forwardRef(function SliderTrack(props, ref) {
+  [props, ref] = $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, $6f909507e6374d18$export$f1fce0420cc6d8ee);
+  let state = useContext($6f909507e6374d18$export$1e7083018727fa60);
+  let { onHoverStart, onHoverEnd, onHoverChange, ...otherProps } = props;
+  let { hoverProps, isHovered } = $e969f22b6713ca4a$export$ae780daf29e6d456({
+    onHoverStart,
+    onHoverEnd,
+    onHoverChange
+  });
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    defaultClassName: "react-aria-SliderTrack",
+    values: {
+      orientation: state.orientation,
+      isDisabled: state.isDisabled,
+      isHovered,
+      state
+    }
+  });
+  return /* @__PURE__ */ React__default.createElement("div", {
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(otherProps, hoverProps),
+    ...renderProps,
+    ref,
+    "data-hovered": isHovered || void 0,
+    "data-orientation": state.orientation || void 0,
+    "data-disabled": state.isDisabled || void 0
+  });
+});
+const $6f909507e6374d18$export$2c1b491743890dec = /* @__PURE__ */ forwardRef(function SliderThumb(props, ref) {
+  let { inputRef: userInputRef = null } = props;
+  let state = useContext($6f909507e6374d18$export$1e7083018727fa60);
+  let { ref: trackRef } = $64fa3d84918910a7$export$fabf2dc03a41866e($6f909507e6374d18$export$f1fce0420cc6d8ee);
+  let { index = 0 } = props;
+  let defaultInputRef = useRef(null);
+  let inputRef = userInputRef || defaultInputRef;
+  let [labelRef, label] = $64fa3d84918910a7$export$9d4c57ee4c6ffdd8(!props["aria-label"] && !props["aria-labelledby"]);
+  let { thumbProps, inputProps, labelProps, isDragging, isFocused, isDisabled } = $4a5dd96ecb58ab11$export$8d15029008292ae({
+    ...props,
+    index,
+    trackRef,
+    inputRef,
+    label
+  }, state);
+  let { focusProps, isFocusVisible } = $0c4a58759813079a$export$4e328f61c538687f();
+  let { hoverProps, isHovered } = $e969f22b6713ca4a$export$ae780daf29e6d456(props);
+  let renderProps = $64fa3d84918910a7$export$4d86445c2cf5e3({
+    ...props,
+    defaultClassName: "react-aria-SliderThumb",
+    values: {
+      state,
+      isHovered,
+      isDragging,
+      isFocused,
+      isFocusVisible,
+      isDisabled
+    }
+  });
+  let DOMProps = $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    global: true
+  });
+  delete DOMProps.id;
+  return /* @__PURE__ */ React__default.createElement("div", {
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(DOMProps, thumbProps, hoverProps),
+    ...renderProps,
+    ref,
+    style: {
+      ...thumbProps.style,
+      ...renderProps.style
+    },
+    "data-hovered": isHovered || void 0,
+    "data-dragging": isDragging || void 0,
+    "data-focused": isFocused || void 0,
+    "data-focus-visible": isFocusVisible || void 0,
+    "data-disabled": isDisabled || void 0
+  }, /* @__PURE__ */ React__default.createElement($ea3928288112382f$export$439d29a4e110a164, null, /* @__PURE__ */ React__default.createElement("input", {
+    ref: inputRef,
+    ...$bbaa08b3cd72f041$export$9d1611c77c2fe928(inputProps, focusProps)
+  })), /* @__PURE__ */ React__default.createElement($64fa3d84918910a7$export$2881499e37b75b9a, {
+    values: [
+      [
+        $01b77f81d0f07f68$export$75b6ee27786ba447,
+        {
+          ...labelProps,
+          ref: labelRef
+        }
+      ]
+    ]
+  }, renderProps.children));
+});
+var howler = {};
+/*!
+ *  howler.js v2.2.4
+ *  howlerjs.com
+ *
+ *  (c) 2013-2020, James Simpson of GoldFire Studios
+ *  goldfirestudios.com
+ *
+ *  MIT License
+ */
+var hasRequiredHowler;
+function requireHowler() {
+  if (hasRequiredHowler) return howler;
+  hasRequiredHowler = 1;
+  (function(exports$1) {
+    (function() {
+      var HowlerGlobal2 = function() {
+        this.init();
+      };
+      HowlerGlobal2.prototype = {
+        /**
+         * Initialize the global Howler object.
+         * @return {Howler}
+         */
+        init: function() {
+          var self = this || Howler2;
+          self._counter = 1e3;
+          self._html5AudioPool = [];
+          self.html5PoolSize = 10;
+          self._codecs = {};
+          self._howls = [];
+          self._muted = false;
+          self._volume = 1;
+          self._canPlayEvent = "canplaythrough";
+          self._navigator = typeof window !== "undefined" && window.navigator ? window.navigator : null;
+          self.masterGain = null;
+          self.noAudio = false;
+          self.usingWebAudio = true;
+          self.autoSuspend = true;
+          self.ctx = null;
+          self.autoUnlock = true;
+          self._setup();
+          return self;
+        },
+        /**
+         * Get/set the global volume for all sounds.
+         * @param  {Float} vol Volume from 0.0 to 1.0.
+         * @return {Howler/Float}     Returns self or current volume.
+         */
+        volume: function(vol) {
+          var self = this || Howler2;
+          vol = parseFloat(vol);
+          if (!self.ctx) {
+            setupAudioContext();
+          }
+          if (typeof vol !== "undefined" && vol >= 0 && vol <= 1) {
+            self._volume = vol;
+            if (self._muted) {
+              return self;
+            }
+            if (self.usingWebAudio) {
+              self.masterGain.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+            }
+            for (var i = 0; i < self._howls.length; i++) {
+              if (!self._howls[i]._webAudio) {
+                var ids = self._howls[i]._getSoundIds();
+                for (var j = 0; j < ids.length; j++) {
+                  var sound = self._howls[i]._soundById(ids[j]);
+                  if (sound && sound._node) {
+                    sound._node.volume = sound._volume * vol;
+                  }
+                }
+              }
+            }
+            return self;
+          }
+          return self._volume;
+        },
+        /**
+         * Handle muting and unmuting globally.
+         * @param  {Boolean} muted Is muted or not.
+         */
+        mute: function(muted) {
+          var self = this || Howler2;
+          if (!self.ctx) {
+            setupAudioContext();
+          }
+          self._muted = muted;
+          if (self.usingWebAudio) {
+            self.masterGain.gain.setValueAtTime(muted ? 0 : self._volume, Howler2.ctx.currentTime);
+          }
+          for (var i = 0; i < self._howls.length; i++) {
+            if (!self._howls[i]._webAudio) {
+              var ids = self._howls[i]._getSoundIds();
+              for (var j = 0; j < ids.length; j++) {
+                var sound = self._howls[i]._soundById(ids[j]);
+                if (sound && sound._node) {
+                  sound._node.muted = muted ? true : sound._muted;
+                }
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Handle stopping all sounds globally.
+         */
+        stop: function() {
+          var self = this || Howler2;
+          for (var i = 0; i < self._howls.length; i++) {
+            self._howls[i].stop();
+          }
+          return self;
+        },
+        /**
+         * Unload and destroy all currently loaded Howl objects.
+         * @return {Howler}
+         */
+        unload: function() {
+          var self = this || Howler2;
+          for (var i = self._howls.length - 1; i >= 0; i--) {
+            self._howls[i].unload();
+          }
+          if (self.usingWebAudio && self.ctx && typeof self.ctx.close !== "undefined") {
+            self.ctx.close();
+            self.ctx = null;
+            setupAudioContext();
+          }
+          return self;
+        },
+        /**
+         * Check for codec support of specific extension.
+         * @param  {String} ext Audio file extention.
+         * @return {Boolean}
+         */
+        codecs: function(ext) {
+          return (this || Howler2)._codecs[ext.replace(/^x-/, "")];
+        },
+        /**
+         * Setup various state values for global tracking.
+         * @return {Howler}
+         */
+        _setup: function() {
+          var self = this || Howler2;
+          self.state = self.ctx ? self.ctx.state || "suspended" : "suspended";
+          self._autoSuspend();
+          if (!self.usingWebAudio) {
+            if (typeof Audio !== "undefined") {
+              try {
+                var test = new Audio();
+                if (typeof test.oncanplaythrough === "undefined") {
+                  self._canPlayEvent = "canplay";
+                }
+              } catch (e) {
+                self.noAudio = true;
+              }
+            } else {
+              self.noAudio = true;
+            }
+          }
+          try {
+            var test = new Audio();
+            if (test.muted) {
+              self.noAudio = true;
+            }
+          } catch (e) {
+          }
+          if (!self.noAudio) {
+            self._setupCodecs();
+          }
+          return self;
+        },
+        /**
+         * Check for browser support for various codecs and cache the results.
+         * @return {Howler}
+         */
+        _setupCodecs: function() {
+          var self = this || Howler2;
+          var audioTest = null;
+          try {
+            audioTest = typeof Audio !== "undefined" ? new Audio() : null;
+          } catch (err) {
+            return self;
+          }
+          if (!audioTest || typeof audioTest.canPlayType !== "function") {
+            return self;
+          }
+          var mpegTest = audioTest.canPlayType("audio/mpeg;").replace(/^no$/, "");
+          var ua = self._navigator ? self._navigator.userAgent : "";
+          var checkOpera = ua.match(/OPR\/(\d+)/g);
+          var isOldOpera = checkOpera && parseInt(checkOpera[0].split("/")[1], 10) < 33;
+          var checkSafari = ua.indexOf("Safari") !== -1 && ua.indexOf("Chrome") === -1;
+          var safariVersion = ua.match(/Version\/(.*?) /);
+          var isOldSafari = checkSafari && safariVersion && parseInt(safariVersion[1], 10) < 15;
+          self._codecs = {
+            mp3: !!(!isOldOpera && (mpegTest || audioTest.canPlayType("audio/mp3;").replace(/^no$/, ""))),
+            mpeg: !!mpegTest,
+            opus: !!audioTest.canPlayType('audio/ogg; codecs="opus"').replace(/^no$/, ""),
+            ogg: !!audioTest.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ""),
+            oga: !!audioTest.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, ""),
+            wav: !!(audioTest.canPlayType('audio/wav; codecs="1"') || audioTest.canPlayType("audio/wav")).replace(/^no$/, ""),
+            aac: !!audioTest.canPlayType("audio/aac;").replace(/^no$/, ""),
+            caf: !!audioTest.canPlayType("audio/x-caf;").replace(/^no$/, ""),
+            m4a: !!(audioTest.canPlayType("audio/x-m4a;") || audioTest.canPlayType("audio/m4a;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+            m4b: !!(audioTest.canPlayType("audio/x-m4b;") || audioTest.canPlayType("audio/m4b;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+            mp4: !!(audioTest.canPlayType("audio/x-mp4;") || audioTest.canPlayType("audio/mp4;") || audioTest.canPlayType("audio/aac;")).replace(/^no$/, ""),
+            weba: !!(!isOldSafari && audioTest.canPlayType('audio/webm; codecs="vorbis"').replace(/^no$/, "")),
+            webm: !!(!isOldSafari && audioTest.canPlayType('audio/webm; codecs="vorbis"').replace(/^no$/, "")),
+            dolby: !!audioTest.canPlayType('audio/mp4; codecs="ec-3"').replace(/^no$/, ""),
+            flac: !!(audioTest.canPlayType("audio/x-flac;") || audioTest.canPlayType("audio/flac;")).replace(/^no$/, "")
+          };
+          return self;
+        },
+        /**
+         * Some browsers/devices will only allow audio to be played after a user interaction.
+         * Attempt to automatically unlock audio on the first user interaction.
+         * Concept from: http://paulbakaus.com/tutorials/html5/web-audio-on-ios/
+         * @return {Howler}
+         */
+        _unlockAudio: function() {
+          var self = this || Howler2;
+          if (self._audioUnlocked || !self.ctx) {
+            return;
+          }
+          self._audioUnlocked = false;
+          self.autoUnlock = false;
+          if (!self._mobileUnloaded && self.ctx.sampleRate !== 44100) {
+            self._mobileUnloaded = true;
+            self.unload();
+          }
+          self._scratchBuffer = self.ctx.createBuffer(1, 1, 22050);
+          var unlock = function(e) {
+            while (self._html5AudioPool.length < self.html5PoolSize) {
+              try {
+                var audioNode = new Audio();
+                audioNode._unlocked = true;
+                self._releaseHtml5Audio(audioNode);
+              } catch (e2) {
+                self.noAudio = true;
+                break;
+              }
+            }
+            for (var i = 0; i < self._howls.length; i++) {
+              if (!self._howls[i]._webAudio) {
+                var ids = self._howls[i]._getSoundIds();
+                for (var j = 0; j < ids.length; j++) {
+                  var sound = self._howls[i]._soundById(ids[j]);
+                  if (sound && sound._node && !sound._node._unlocked) {
+                    sound._node._unlocked = true;
+                    sound._node.load();
+                  }
+                }
+              }
+            }
+            self._autoResume();
+            var source = self.ctx.createBufferSource();
+            source.buffer = self._scratchBuffer;
+            source.connect(self.ctx.destination);
+            if (typeof source.start === "undefined") {
+              source.noteOn(0);
+            } else {
+              source.start(0);
+            }
+            if (typeof self.ctx.resume === "function") {
+              self.ctx.resume();
+            }
+            source.onended = function() {
+              source.disconnect(0);
+              self._audioUnlocked = true;
+              document.removeEventListener("touchstart", unlock, true);
+              document.removeEventListener("touchend", unlock, true);
+              document.removeEventListener("click", unlock, true);
+              document.removeEventListener("keydown", unlock, true);
+              for (var i2 = 0; i2 < self._howls.length; i2++) {
+                self._howls[i2]._emit("unlock");
+              }
+            };
+          };
+          document.addEventListener("touchstart", unlock, true);
+          document.addEventListener("touchend", unlock, true);
+          document.addEventListener("click", unlock, true);
+          document.addEventListener("keydown", unlock, true);
+          return self;
+        },
+        /**
+         * Get an unlocked HTML5 Audio object from the pool. If none are left,
+         * return a new Audio object and throw a warning.
+         * @return {Audio} HTML5 Audio object.
+         */
+        _obtainHtml5Audio: function() {
+          var self = this || Howler2;
+          if (self._html5AudioPool.length) {
+            return self._html5AudioPool.pop();
+          }
+          var testPlay = new Audio().play();
+          if (testPlay && typeof Promise !== "undefined" && (testPlay instanceof Promise || typeof testPlay.then === "function")) {
+            testPlay.catch(function() {
+              console.warn("HTML5 Audio pool exhausted, returning potentially locked audio object.");
+            });
+          }
+          return new Audio();
+        },
+        /**
+         * Return an activated HTML5 Audio object to the pool.
+         * @return {Howler}
+         */
+        _releaseHtml5Audio: function(audio) {
+          var self = this || Howler2;
+          if (audio._unlocked) {
+            self._html5AudioPool.push(audio);
+          }
+          return self;
+        },
+        /**
+         * Automatically suspend the Web Audio AudioContext after no sound has played for 30 seconds.
+         * This saves processing/energy and fixes various browser-specific bugs with audio getting stuck.
+         * @return {Howler}
+         */
+        _autoSuspend: function() {
+          var self = this;
+          if (!self.autoSuspend || !self.ctx || typeof self.ctx.suspend === "undefined" || !Howler2.usingWebAudio) {
+            return;
+          }
+          for (var i = 0; i < self._howls.length; i++) {
+            if (self._howls[i]._webAudio) {
+              for (var j = 0; j < self._howls[i]._sounds.length; j++) {
+                if (!self._howls[i]._sounds[j]._paused) {
+                  return self;
+                }
+              }
+            }
+          }
+          if (self._suspendTimer) {
+            clearTimeout(self._suspendTimer);
+          }
+          self._suspendTimer = setTimeout(function() {
+            if (!self.autoSuspend) {
+              return;
+            }
+            self._suspendTimer = null;
+            self.state = "suspending";
+            var handleSuspension = function() {
+              self.state = "suspended";
+              if (self._resumeAfterSuspend) {
+                delete self._resumeAfterSuspend;
+                self._autoResume();
+              }
+            };
+            self.ctx.suspend().then(handleSuspension, handleSuspension);
+          }, 3e4);
+          return self;
+        },
+        /**
+         * Automatically resume the Web Audio AudioContext when a new sound is played.
+         * @return {Howler}
+         */
+        _autoResume: function() {
+          var self = this;
+          if (!self.ctx || typeof self.ctx.resume === "undefined" || !Howler2.usingWebAudio) {
+            return;
+          }
+          if (self.state === "running" && self.ctx.state !== "interrupted" && self._suspendTimer) {
+            clearTimeout(self._suspendTimer);
+            self._suspendTimer = null;
+          } else if (self.state === "suspended" || self.state === "running" && self.ctx.state === "interrupted") {
+            self.ctx.resume().then(function() {
+              self.state = "running";
+              for (var i = 0; i < self._howls.length; i++) {
+                self._howls[i]._emit("resume");
+              }
+            });
+            if (self._suspendTimer) {
+              clearTimeout(self._suspendTimer);
+              self._suspendTimer = null;
+            }
+          } else if (self.state === "suspending") {
+            self._resumeAfterSuspend = true;
+          }
+          return self;
+        }
+      };
+      var Howler2 = new HowlerGlobal2();
+      var Howl2 = function(o2) {
+        var self = this;
+        if (!o2.src || o2.src.length === 0) {
+          console.error("An array of source files must be passed with any new Howl.");
+          return;
+        }
+        self.init(o2);
+      };
+      Howl2.prototype = {
+        /**
+         * Initialize a new Howl group object.
+         * @param  {Object} o Passed in properties for this group.
+         * @return {Howl}
+         */
+        init: function(o2) {
+          var self = this;
+          if (!Howler2.ctx) {
+            setupAudioContext();
+          }
+          self._autoplay = o2.autoplay || false;
+          self._format = typeof o2.format !== "string" ? o2.format : [o2.format];
+          self._html5 = o2.html5 || false;
+          self._muted = o2.mute || false;
+          self._loop = o2.loop || false;
+          self._pool = o2.pool || 5;
+          self._preload = typeof o2.preload === "boolean" || o2.preload === "metadata" ? o2.preload : true;
+          self._rate = o2.rate || 1;
+          self._sprite = o2.sprite || {};
+          self._src = typeof o2.src !== "string" ? o2.src : [o2.src];
+          self._volume = o2.volume !== void 0 ? o2.volume : 1;
+          self._xhr = {
+            method: o2.xhr && o2.xhr.method ? o2.xhr.method : "GET",
+            headers: o2.xhr && o2.xhr.headers ? o2.xhr.headers : null,
+            withCredentials: o2.xhr && o2.xhr.withCredentials ? o2.xhr.withCredentials : false
+          };
+          self._duration = 0;
+          self._state = "unloaded";
+          self._sounds = [];
+          self._endTimers = {};
+          self._queue = [];
+          self._playLock = false;
+          self._onend = o2.onend ? [{ fn: o2.onend }] : [];
+          self._onfade = o2.onfade ? [{ fn: o2.onfade }] : [];
+          self._onload = o2.onload ? [{ fn: o2.onload }] : [];
+          self._onloaderror = o2.onloaderror ? [{ fn: o2.onloaderror }] : [];
+          self._onplayerror = o2.onplayerror ? [{ fn: o2.onplayerror }] : [];
+          self._onpause = o2.onpause ? [{ fn: o2.onpause }] : [];
+          self._onplay = o2.onplay ? [{ fn: o2.onplay }] : [];
+          self._onstop = o2.onstop ? [{ fn: o2.onstop }] : [];
+          self._onmute = o2.onmute ? [{ fn: o2.onmute }] : [];
+          self._onvolume = o2.onvolume ? [{ fn: o2.onvolume }] : [];
+          self._onrate = o2.onrate ? [{ fn: o2.onrate }] : [];
+          self._onseek = o2.onseek ? [{ fn: o2.onseek }] : [];
+          self._onunlock = o2.onunlock ? [{ fn: o2.onunlock }] : [];
+          self._onresume = [];
+          self._webAudio = Howler2.usingWebAudio && !self._html5;
+          if (typeof Howler2.ctx !== "undefined" && Howler2.ctx && Howler2.autoUnlock) {
+            Howler2._unlockAudio();
+          }
+          Howler2._howls.push(self);
+          if (self._autoplay) {
+            self._queue.push({
+              event: "play",
+              action: function() {
+                self.play();
+              }
+            });
+          }
+          if (self._preload && self._preload !== "none") {
+            self.load();
+          }
+          return self;
+        },
+        /**
+         * Load the audio file.
+         * @return {Howler}
+         */
+        load: function() {
+          var self = this;
+          var url = null;
+          if (Howler2.noAudio) {
+            self._emit("loaderror", null, "No audio support.");
+            return;
+          }
+          if (typeof self._src === "string") {
+            self._src = [self._src];
+          }
+          for (var i = 0; i < self._src.length; i++) {
+            var ext, str;
+            if (self._format && self._format[i]) {
+              ext = self._format[i];
+            } else {
+              str = self._src[i];
+              if (typeof str !== "string") {
+                self._emit("loaderror", null, "Non-string found in selected audio sources - ignoring.");
+                continue;
+              }
+              ext = /^data:audio\/([^;,]+);/i.exec(str);
+              if (!ext) {
+                ext = /\.([^.]+)$/.exec(str.split("?", 1)[0]);
+              }
+              if (ext) {
+                ext = ext[1].toLowerCase();
+              }
+            }
+            if (!ext) {
+              console.warn('No file extension was found. Consider using the "format" property or specify an extension.');
+            }
+            if (ext && Howler2.codecs(ext)) {
+              url = self._src[i];
+              break;
+            }
+          }
+          if (!url) {
+            self._emit("loaderror", null, "No codec support for selected audio sources.");
+            return;
+          }
+          self._src = url;
+          self._state = "loading";
+          if (window.location.protocol === "https:" && url.slice(0, 5) === "http:") {
+            self._html5 = true;
+            self._webAudio = false;
+          }
+          new Sound2(self);
+          if (self._webAudio) {
+            loadBuffer(self);
+          }
+          return self;
+        },
+        /**
+         * Play a sound or resume previous playback.
+         * @param  {String/Number} sprite   Sprite name for sprite playback or sound id to continue previous.
+         * @param  {Boolean} internal Internal Use: true prevents event firing.
+         * @return {Number}          Sound ID.
+         */
+        play: function(sprite, internal) {
+          var self = this;
+          var id = null;
+          if (typeof sprite === "number") {
+            id = sprite;
+            sprite = null;
+          } else if (typeof sprite === "string" && self._state === "loaded" && !self._sprite[sprite]) {
+            return null;
+          } else if (typeof sprite === "undefined") {
+            sprite = "__default";
+            if (!self._playLock) {
+              var num = 0;
+              for (var i = 0; i < self._sounds.length; i++) {
+                if (self._sounds[i]._paused && !self._sounds[i]._ended) {
+                  num++;
+                  id = self._sounds[i]._id;
+                }
+              }
+              if (num === 1) {
+                sprite = null;
+              } else {
+                id = null;
+              }
+            }
+          }
+          var sound = id ? self._soundById(id) : self._inactiveSound();
+          if (!sound) {
+            return null;
+          }
+          if (id && !sprite) {
+            sprite = sound._sprite || "__default";
+          }
+          if (self._state !== "loaded") {
+            sound._sprite = sprite;
+            sound._ended = false;
+            var soundId = sound._id;
+            self._queue.push({
+              event: "play",
+              action: function() {
+                self.play(soundId);
+              }
+            });
+            return soundId;
+          }
+          if (id && !sound._paused) {
+            if (!internal) {
+              self._loadQueue("play");
+            }
+            return sound._id;
+          }
+          if (self._webAudio) {
+            Howler2._autoResume();
+          }
+          var seek = Math.max(0, sound._seek > 0 ? sound._seek : self._sprite[sprite][0] / 1e3);
+          var duration = Math.max(0, (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3 - seek);
+          var timeout = duration * 1e3 / Math.abs(sound._rate);
+          var start = self._sprite[sprite][0] / 1e3;
+          var stop = (self._sprite[sprite][0] + self._sprite[sprite][1]) / 1e3;
+          sound._sprite = sprite;
+          sound._ended = false;
+          var setParams = function() {
+            sound._paused = false;
+            sound._seek = seek;
+            sound._start = start;
+            sound._stop = stop;
+            sound._loop = !!(sound._loop || self._sprite[sprite][2]);
+          };
+          if (seek >= stop) {
+            self._ended(sound);
+            return;
+          }
+          var node = sound._node;
+          if (self._webAudio) {
+            var playWebAudio = function() {
+              self._playLock = false;
+              setParams();
+              self._refreshBuffer(sound);
+              var vol = sound._muted || self._muted ? 0 : sound._volume;
+              node.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+              sound._playStart = Howler2.ctx.currentTime;
+              if (typeof node.bufferSource.start === "undefined") {
+                sound._loop ? node.bufferSource.noteGrainOn(0, seek, 86400) : node.bufferSource.noteGrainOn(0, seek, duration);
+              } else {
+                sound._loop ? node.bufferSource.start(0, seek, 86400) : node.bufferSource.start(0, seek, duration);
+              }
+              if (timeout !== Infinity) {
+                self._endTimers[sound._id] = setTimeout(self._ended.bind(self, sound), timeout);
+              }
+              if (!internal) {
+                setTimeout(function() {
+                  self._emit("play", sound._id);
+                  self._loadQueue();
+                }, 0);
+              }
+            };
+            if (Howler2.state === "running" && Howler2.ctx.state !== "interrupted") {
+              playWebAudio();
+            } else {
+              self._playLock = true;
+              self.once("resume", playWebAudio);
+              self._clearTimer(sound._id);
+            }
+          } else {
+            var playHtml5 = function() {
+              node.currentTime = seek;
+              node.muted = sound._muted || self._muted || Howler2._muted || node.muted;
+              node.volume = sound._volume * Howler2.volume();
+              node.playbackRate = sound._rate;
+              try {
+                var play = node.play();
+                if (play && typeof Promise !== "undefined" && (play instanceof Promise || typeof play.then === "function")) {
+                  self._playLock = true;
+                  setParams();
+                  play.then(function() {
+                    self._playLock = false;
+                    node._unlocked = true;
+                    if (!internal) {
+                      self._emit("play", sound._id);
+                    } else {
+                      self._loadQueue();
+                    }
+                  }).catch(function() {
+                    self._playLock = false;
+                    self._emit("playerror", sound._id, "Playback was unable to start. This is most commonly an issue on mobile devices and Chrome where playback was not within a user interaction.");
+                    sound._ended = true;
+                    sound._paused = true;
+                  });
+                } else if (!internal) {
+                  self._playLock = false;
+                  setParams();
+                  self._emit("play", sound._id);
+                }
+                node.playbackRate = sound._rate;
+                if (node.paused) {
+                  self._emit("playerror", sound._id, "Playback was unable to start. This is most commonly an issue on mobile devices and Chrome where playback was not within a user interaction.");
+                  return;
+                }
+                if (sprite !== "__default" || sound._loop) {
+                  self._endTimers[sound._id] = setTimeout(self._ended.bind(self, sound), timeout);
+                } else {
+                  self._endTimers[sound._id] = function() {
+                    self._ended(sound);
+                    node.removeEventListener("ended", self._endTimers[sound._id], false);
+                  };
+                  node.addEventListener("ended", self._endTimers[sound._id], false);
+                }
+              } catch (err) {
+                self._emit("playerror", sound._id, err);
+              }
+            };
+            if (node.src === "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA") {
+              node.src = self._src;
+              node.load();
+            }
+            var loadedNoReadyState = window && window.ejecta || !node.readyState && Howler2._navigator.isCocoonJS;
+            if (node.readyState >= 3 || loadedNoReadyState) {
+              playHtml5();
+            } else {
+              self._playLock = true;
+              self._state = "loading";
+              var listener = function() {
+                self._state = "loaded";
+                playHtml5();
+                node.removeEventListener(Howler2._canPlayEvent, listener, false);
+              };
+              node.addEventListener(Howler2._canPlayEvent, listener, false);
+              self._clearTimer(sound._id);
+            }
+          }
+          return sound._id;
+        },
+        /**
+         * Pause playback and save current position.
+         * @param  {Number} id The sound ID (empty to pause all in group).
+         * @return {Howl}
+         */
+        pause: function(id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "pause",
+              action: function() {
+                self.pause(id);
+              }
+            });
+            return self;
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            self._clearTimer(ids[i]);
+            var sound = self._soundById(ids[i]);
+            if (sound && !sound._paused) {
+              sound._seek = self.seek(ids[i]);
+              sound._rateSeek = 0;
+              sound._paused = true;
+              self._stopFade(ids[i]);
+              if (sound._node) {
+                if (self._webAudio) {
+                  if (!sound._node.bufferSource) {
+                    continue;
+                  }
+                  if (typeof sound._node.bufferSource.stop === "undefined") {
+                    sound._node.bufferSource.noteOff(0);
+                  } else {
+                    sound._node.bufferSource.stop(0);
+                  }
+                  self._cleanBuffer(sound._node);
+                } else if (!isNaN(sound._node.duration) || sound._node.duration === Infinity) {
+                  sound._node.pause();
+                }
+              }
+            }
+            if (!arguments[1]) {
+              self._emit("pause", sound ? sound._id : null);
+            }
+          }
+          return self;
+        },
+        /**
+         * Stop playback and reset to start.
+         * @param  {Number} id The sound ID (empty to stop all in group).
+         * @param  {Boolean} internal Internal Use: true prevents event firing.
+         * @return {Howl}
+         */
+        stop: function(id, internal) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "stop",
+              action: function() {
+                self.stop(id);
+              }
+            });
+            return self;
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            self._clearTimer(ids[i]);
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._seek = sound._start || 0;
+              sound._rateSeek = 0;
+              sound._paused = true;
+              sound._ended = true;
+              self._stopFade(ids[i]);
+              if (sound._node) {
+                if (self._webAudio) {
+                  if (sound._node.bufferSource) {
+                    if (typeof sound._node.bufferSource.stop === "undefined") {
+                      sound._node.bufferSource.noteOff(0);
+                    } else {
+                      sound._node.bufferSource.stop(0);
+                    }
+                    self._cleanBuffer(sound._node);
+                  }
+                } else if (!isNaN(sound._node.duration) || sound._node.duration === Infinity) {
+                  sound._node.currentTime = sound._start || 0;
+                  sound._node.pause();
+                  if (sound._node.duration === Infinity) {
+                    self._clearSound(sound._node);
+                  }
+                }
+              }
+              if (!internal) {
+                self._emit("stop", sound._id);
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Mute/unmute a single sound or all sounds in this Howl group.
+         * @param  {Boolean} muted Set to true to mute and false to unmute.
+         * @param  {Number} id    The sound ID to update (omit to mute/unmute all).
+         * @return {Howl}
+         */
+        mute: function(muted, id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "mute",
+              action: function() {
+                self.mute(muted, id);
+              }
+            });
+            return self;
+          }
+          if (typeof id === "undefined") {
+            if (typeof muted === "boolean") {
+              self._muted = muted;
+            } else {
+              return self._muted;
+            }
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._muted = muted;
+              if (sound._interval) {
+                self._stopFade(sound._id);
+              }
+              if (self._webAudio && sound._node) {
+                sound._node.gain.setValueAtTime(muted ? 0 : sound._volume, Howler2.ctx.currentTime);
+              } else if (sound._node) {
+                sound._node.muted = Howler2._muted ? true : muted;
+              }
+              self._emit("mute", sound._id);
+            }
+          }
+          return self;
+        },
+        /**
+         * Get/set the volume of this sound or of the Howl group. This method can optionally take 0, 1 or 2 arguments.
+         *   volume() -> Returns the group's volume value.
+         *   volume(id) -> Returns the sound id's current volume.
+         *   volume(vol) -> Sets the volume of all sounds in this Howl group.
+         *   volume(vol, id) -> Sets the volume of passed sound id.
+         * @return {Howl/Number} Returns self or current volume.
+         */
+        volume: function() {
+          var self = this;
+          var args = arguments;
+          var vol, id;
+          if (args.length === 0) {
+            return self._volume;
+          } else if (args.length === 1 || args.length === 2 && typeof args[1] === "undefined") {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else {
+              vol = parseFloat(args[0]);
+            }
+          } else if (args.length >= 2) {
+            vol = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          var sound;
+          if (typeof vol !== "undefined" && vol >= 0 && vol <= 1) {
+            if (self._state !== "loaded" || self._playLock) {
+              self._queue.push({
+                event: "volume",
+                action: function() {
+                  self.volume.apply(self, args);
+                }
+              });
+              return self;
+            }
+            if (typeof id === "undefined") {
+              self._volume = vol;
+            }
+            id = self._getSoundIds(id);
+            for (var i = 0; i < id.length; i++) {
+              sound = self._soundById(id[i]);
+              if (sound) {
+                sound._volume = vol;
+                if (!args[2]) {
+                  self._stopFade(id[i]);
+                }
+                if (self._webAudio && sound._node && !sound._muted) {
+                  sound._node.gain.setValueAtTime(vol, Howler2.ctx.currentTime);
+                } else if (sound._node && !sound._muted) {
+                  sound._node.volume = vol * Howler2.volume();
+                }
+                self._emit("volume", sound._id);
+              }
+            }
+          } else {
+            sound = id ? self._soundById(id) : self._sounds[0];
+            return sound ? sound._volume : 0;
+          }
+          return self;
+        },
+        /**
+         * Fade a currently playing sound between two volumes (if no id is passed, all sounds will fade).
+         * @param  {Number} from The value to fade from (0.0 to 1.0).
+         * @param  {Number} to   The volume to fade to (0.0 to 1.0).
+         * @param  {Number} len  Time in milliseconds to fade.
+         * @param  {Number} id   The sound id (omit to fade all sounds).
+         * @return {Howl}
+         */
+        fade: function(from, to, len, id) {
+          var self = this;
+          if (self._state !== "loaded" || self._playLock) {
+            self._queue.push({
+              event: "fade",
+              action: function() {
+                self.fade(from, to, len, id);
+              }
+            });
+            return self;
+          }
+          from = Math.min(Math.max(0, parseFloat(from)), 1);
+          to = Math.min(Math.max(0, parseFloat(to)), 1);
+          len = parseFloat(len);
+          self.volume(from, id);
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            var sound = self._soundById(ids[i]);
+            if (sound) {
+              if (!id) {
+                self._stopFade(ids[i]);
+              }
+              if (self._webAudio && !sound._muted) {
+                var currentTime = Howler2.ctx.currentTime;
+                var end = currentTime + len / 1e3;
+                sound._volume = from;
+                sound._node.gain.setValueAtTime(from, currentTime);
+                sound._node.gain.linearRampToValueAtTime(to, end);
+              }
+              self._startFadeInterval(sound, from, to, len, ids[i], typeof id === "undefined");
+            }
+          }
+          return self;
+        },
+        /**
+         * Starts the internal interval to fade a sound.
+         * @param  {Object} sound Reference to sound to fade.
+         * @param  {Number} from The value to fade from (0.0 to 1.0).
+         * @param  {Number} to   The volume to fade to (0.0 to 1.0).
+         * @param  {Number} len  Time in milliseconds to fade.
+         * @param  {Number} id   The sound id to fade.
+         * @param  {Boolean} isGroup   If true, set the volume on the group.
+         */
+        _startFadeInterval: function(sound, from, to, len, id, isGroup) {
+          var self = this;
+          var vol = from;
+          var diff = to - from;
+          var steps = Math.abs(diff / 0.01);
+          var stepLen = Math.max(4, steps > 0 ? len / steps : len);
+          var lastTick = Date.now();
+          sound._fadeTo = to;
+          sound._interval = setInterval(function() {
+            var tick = (Date.now() - lastTick) / len;
+            lastTick = Date.now();
+            vol += diff * tick;
+            vol = Math.round(vol * 100) / 100;
+            if (diff < 0) {
+              vol = Math.max(to, vol);
+            } else {
+              vol = Math.min(to, vol);
+            }
+            if (self._webAudio) {
+              sound._volume = vol;
+            } else {
+              self.volume(vol, sound._id, true);
+            }
+            if (isGroup) {
+              self._volume = vol;
+            }
+            if (to < from && vol <= to || to > from && vol >= to) {
+              clearInterval(sound._interval);
+              sound._interval = null;
+              sound._fadeTo = null;
+              self.volume(to, sound._id);
+              self._emit("fade", sound._id);
+            }
+          }, stepLen);
+        },
+        /**
+         * Internal method that stops the currently playing fade when
+         * a new fade starts, volume is changed or the sound is stopped.
+         * @param  {Number} id The sound id.
+         * @return {Howl}
+         */
+        _stopFade: function(id) {
+          var self = this;
+          var sound = self._soundById(id);
+          if (sound && sound._interval) {
+            if (self._webAudio) {
+              sound._node.gain.cancelScheduledValues(Howler2.ctx.currentTime);
+            }
+            clearInterval(sound._interval);
+            sound._interval = null;
+            self.volume(sound._fadeTo, id);
+            sound._fadeTo = null;
+            self._emit("fade", id);
+          }
+          return self;
+        },
+        /**
+         * Get/set the loop parameter on a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   loop() -> Returns the group's loop value.
+         *   loop(id) -> Returns the sound id's loop value.
+         *   loop(loop) -> Sets the loop value for all sounds in this Howl group.
+         *   loop(loop, id) -> Sets the loop value of passed sound id.
+         * @return {Howl/Boolean} Returns self or current loop value.
+         */
+        loop: function() {
+          var self = this;
+          var args = arguments;
+          var loop, id, sound;
+          if (args.length === 0) {
+            return self._loop;
+          } else if (args.length === 1) {
+            if (typeof args[0] === "boolean") {
+              loop = args[0];
+              self._loop = loop;
+            } else {
+              sound = self._soundById(parseInt(args[0], 10));
+              return sound ? sound._loop : false;
+            }
+          } else if (args.length === 2) {
+            loop = args[0];
+            id = parseInt(args[1], 10);
+          }
+          var ids = self._getSoundIds(id);
+          for (var i = 0; i < ids.length; i++) {
+            sound = self._soundById(ids[i]);
+            if (sound) {
+              sound._loop = loop;
+              if (self._webAudio && sound._node && sound._node.bufferSource) {
+                sound._node.bufferSource.loop = loop;
+                if (loop) {
+                  sound._node.bufferSource.loopStart = sound._start || 0;
+                  sound._node.bufferSource.loopEnd = sound._stop;
+                  if (self.playing(ids[i])) {
+                    self.pause(ids[i], true);
+                    self.play(ids[i], true);
+                  }
+                }
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Get/set the playback rate of a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   rate() -> Returns the first sound node's current playback rate.
+         *   rate(id) -> Returns the sound id's current playback rate.
+         *   rate(rate) -> Sets the playback rate of all sounds in this Howl group.
+         *   rate(rate, id) -> Sets the playback rate of passed sound id.
+         * @return {Howl/Number} Returns self or the current playback rate.
+         */
+        rate: function() {
+          var self = this;
+          var args = arguments;
+          var rate, id;
+          if (args.length === 0) {
+            id = self._sounds[0]._id;
+          } else if (args.length === 1) {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else {
+              rate = parseFloat(args[0]);
+            }
+          } else if (args.length === 2) {
+            rate = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          var sound;
+          if (typeof rate === "number") {
+            if (self._state !== "loaded" || self._playLock) {
+              self._queue.push({
+                event: "rate",
+                action: function() {
+                  self.rate.apply(self, args);
+                }
+              });
+              return self;
+            }
+            if (typeof id === "undefined") {
+              self._rate = rate;
+            }
+            id = self._getSoundIds(id);
+            for (var i = 0; i < id.length; i++) {
+              sound = self._soundById(id[i]);
+              if (sound) {
+                if (self.playing(id[i])) {
+                  sound._rateSeek = self.seek(id[i]);
+                  sound._playStart = self._webAudio ? Howler2.ctx.currentTime : sound._playStart;
+                }
+                sound._rate = rate;
+                if (self._webAudio && sound._node && sound._node.bufferSource) {
+                  sound._node.bufferSource.playbackRate.setValueAtTime(rate, Howler2.ctx.currentTime);
+                } else if (sound._node) {
+                  sound._node.playbackRate = rate;
+                }
+                var seek = self.seek(id[i]);
+                var duration = (self._sprite[sound._sprite][0] + self._sprite[sound._sprite][1]) / 1e3 - seek;
+                var timeout = duration * 1e3 / Math.abs(sound._rate);
+                if (self._endTimers[id[i]] || !sound._paused) {
+                  self._clearTimer(id[i]);
+                  self._endTimers[id[i]] = setTimeout(self._ended.bind(self, sound), timeout);
+                }
+                self._emit("rate", sound._id);
+              }
+            }
+          } else {
+            sound = self._soundById(id);
+            return sound ? sound._rate : self._rate;
+          }
+          return self;
+        },
+        /**
+         * Get/set the seek position of a sound. This method can optionally take 0, 1 or 2 arguments.
+         *   seek() -> Returns the first sound node's current seek position.
+         *   seek(id) -> Returns the sound id's current seek position.
+         *   seek(seek) -> Sets the seek position of the first sound node.
+         *   seek(seek, id) -> Sets the seek position of passed sound id.
+         * @return {Howl/Number} Returns self or the current seek position.
+         */
+        seek: function() {
+          var self = this;
+          var args = arguments;
+          var seek, id;
+          if (args.length === 0) {
+            if (self._sounds.length) {
+              id = self._sounds[0]._id;
+            }
+          } else if (args.length === 1) {
+            var ids = self._getSoundIds();
+            var index = ids.indexOf(args[0]);
+            if (index >= 0) {
+              id = parseInt(args[0], 10);
+            } else if (self._sounds.length) {
+              id = self._sounds[0]._id;
+              seek = parseFloat(args[0]);
+            }
+          } else if (args.length === 2) {
+            seek = parseFloat(args[0]);
+            id = parseInt(args[1], 10);
+          }
+          if (typeof id === "undefined") {
+            return 0;
+          }
+          if (typeof seek === "number" && (self._state !== "loaded" || self._playLock)) {
+            self._queue.push({
+              event: "seek",
+              action: function() {
+                self.seek.apply(self, args);
+              }
+            });
+            return self;
+          }
+          var sound = self._soundById(id);
+          if (sound) {
+            if (typeof seek === "number" && seek >= 0) {
+              var playing = self.playing(id);
+              if (playing) {
+                self.pause(id, true);
+              }
+              sound._seek = seek;
+              sound._ended = false;
+              self._clearTimer(id);
+              if (!self._webAudio && sound._node && !isNaN(sound._node.duration)) {
+                sound._node.currentTime = seek;
+              }
+              var seekAndEmit = function() {
+                if (playing) {
+                  self.play(id, true);
+                }
+                self._emit("seek", id);
+              };
+              if (playing && !self._webAudio) {
+                var emitSeek = function() {
+                  if (!self._playLock) {
+                    seekAndEmit();
+                  } else {
+                    setTimeout(emitSeek, 0);
+                  }
+                };
+                setTimeout(emitSeek, 0);
+              } else {
+                seekAndEmit();
+              }
+            } else {
+              if (self._webAudio) {
+                var realTime = self.playing(id) ? Howler2.ctx.currentTime - sound._playStart : 0;
+                var rateSeek = sound._rateSeek ? sound._rateSeek - sound._seek : 0;
+                return sound._seek + (rateSeek + realTime * Math.abs(sound._rate));
+              } else {
+                return sound._node.currentTime;
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Check if a specific sound is currently playing or not (if id is provided), or check if at least one of the sounds in the group is playing or not.
+         * @param  {Number}  id The sound id to check. If none is passed, the whole sound group is checked.
+         * @return {Boolean} True if playing and false if not.
+         */
+        playing: function(id) {
+          var self = this;
+          if (typeof id === "number") {
+            var sound = self._soundById(id);
+            return sound ? !sound._paused : false;
+          }
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (!self._sounds[i]._paused) {
+              return true;
+            }
+          }
+          return false;
+        },
+        /**
+         * Get the duration of this sound. Passing a sound id will return the sprite duration.
+         * @param  {Number} id The sound id to check. If none is passed, return full source duration.
+         * @return {Number} Audio duration in seconds.
+         */
+        duration: function(id) {
+          var self = this;
+          var duration = self._duration;
+          var sound = self._soundById(id);
+          if (sound) {
+            duration = self._sprite[sound._sprite][1] / 1e3;
+          }
+          return duration;
+        },
+        /**
+         * Returns the current loaded state of this Howl.
+         * @return {String} 'unloaded', 'loading', 'loaded'
+         */
+        state: function() {
+          return this._state;
+        },
+        /**
+         * Unload and destroy the current Howl object.
+         * This will immediately stop all sound instances attached to this group.
+         */
+        unload: function() {
+          var self = this;
+          var sounds = self._sounds;
+          for (var i = 0; i < sounds.length; i++) {
+            if (!sounds[i]._paused) {
+              self.stop(sounds[i]._id);
+            }
+            if (!self._webAudio) {
+              self._clearSound(sounds[i]._node);
+              sounds[i]._node.removeEventListener("error", sounds[i]._errorFn, false);
+              sounds[i]._node.removeEventListener(Howler2._canPlayEvent, sounds[i]._loadFn, false);
+              sounds[i]._node.removeEventListener("ended", sounds[i]._endFn, false);
+              Howler2._releaseHtml5Audio(sounds[i]._node);
+            }
+            delete sounds[i]._node;
+            self._clearTimer(sounds[i]._id);
+          }
+          var index = Howler2._howls.indexOf(self);
+          if (index >= 0) {
+            Howler2._howls.splice(index, 1);
+          }
+          var remCache = true;
+          for (i = 0; i < Howler2._howls.length; i++) {
+            if (Howler2._howls[i]._src === self._src || self._src.indexOf(Howler2._howls[i]._src) >= 0) {
+              remCache = false;
+              break;
+            }
+          }
+          if (cache && remCache) {
+            delete cache[self._src];
+          }
+          Howler2.noAudio = false;
+          self._state = "unloaded";
+          self._sounds = [];
+          self = null;
+          return null;
+        },
+        /**
+         * Listen to a custom event.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to call.
+         * @param  {Number}   id    (optional) Only listen to events for this sound.
+         * @param  {Number}   once  (INTERNAL) Marks event to fire only once.
+         * @return {Howl}
+         */
+        on: function(event, fn, id, once) {
+          var self = this;
+          var events = self["_on" + event];
+          if (typeof fn === "function") {
+            events.push(once ? { id, fn, once } : { id, fn });
+          }
+          return self;
+        },
+        /**
+         * Remove a custom event. Call without parameters to remove all events.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to remove. Leave empty to remove all.
+         * @param  {Number}   id    (optional) Only remove events for this sound.
+         * @return {Howl}
+         */
+        off: function(event, fn, id) {
+          var self = this;
+          var events = self["_on" + event];
+          var i = 0;
+          if (typeof fn === "number") {
+            id = fn;
+            fn = null;
+          }
+          if (fn || id) {
+            for (i = 0; i < events.length; i++) {
+              var isId = id === events[i].id;
+              if (fn === events[i].fn && isId || !fn && isId) {
+                events.splice(i, 1);
+                break;
+              }
+            }
+          } else if (event) {
+            self["_on" + event] = [];
+          } else {
+            var keys = Object.keys(self);
+            for (i = 0; i < keys.length; i++) {
+              if (keys[i].indexOf("_on") === 0 && Array.isArray(self[keys[i]])) {
+                self[keys[i]] = [];
+              }
+            }
+          }
+          return self;
+        },
+        /**
+         * Listen to a custom event and remove it once fired.
+         * @param  {String}   event Event name.
+         * @param  {Function} fn    Listener to call.
+         * @param  {Number}   id    (optional) Only listen to events for this sound.
+         * @return {Howl}
+         */
+        once: function(event, fn, id) {
+          var self = this;
+          self.on(event, fn, id, 1);
+          return self;
+        },
+        /**
+         * Emit all events of a specific type and pass the sound id.
+         * @param  {String} event Event name.
+         * @param  {Number} id    Sound ID.
+         * @param  {Number} msg   Message to go with event.
+         * @return {Howl}
+         */
+        _emit: function(event, id, msg) {
+          var self = this;
+          var events = self["_on" + event];
+          for (var i = events.length - 1; i >= 0; i--) {
+            if (!events[i].id || events[i].id === id || event === "load") {
+              setTimeout((function(fn) {
+                fn.call(this, id, msg);
+              }).bind(self, events[i].fn), 0);
+              if (events[i].once) {
+                self.off(event, events[i].fn, events[i].id);
+              }
+            }
+          }
+          self._loadQueue(event);
+          return self;
+        },
+        /**
+         * Queue of actions initiated before the sound has loaded.
+         * These will be called in sequence, with the next only firing
+         * after the previous has finished executing (even if async like play).
+         * @return {Howl}
+         */
+        _loadQueue: function(event) {
+          var self = this;
+          if (self._queue.length > 0) {
+            var task = self._queue[0];
+            if (task.event === event) {
+              self._queue.shift();
+              self._loadQueue();
+            }
+            if (!event) {
+              task.action();
+            }
+          }
+          return self;
+        },
+        /**
+         * Fired when playback ends at the end of the duration.
+         * @param  {Sound} sound The sound object to work with.
+         * @return {Howl}
+         */
+        _ended: function(sound) {
+          var self = this;
+          var sprite = sound._sprite;
+          if (!self._webAudio && sound._node && !sound._node.paused && !sound._node.ended && sound._node.currentTime < sound._stop) {
+            setTimeout(self._ended.bind(self, sound), 100);
+            return self;
+          }
+          var loop = !!(sound._loop || self._sprite[sprite][2]);
+          self._emit("end", sound._id);
+          if (!self._webAudio && loop) {
+            self.stop(sound._id, true).play(sound._id);
+          }
+          if (self._webAudio && loop) {
+            self._emit("play", sound._id);
+            sound._seek = sound._start || 0;
+            sound._rateSeek = 0;
+            sound._playStart = Howler2.ctx.currentTime;
+            var timeout = (sound._stop - sound._start) * 1e3 / Math.abs(sound._rate);
+            self._endTimers[sound._id] = setTimeout(self._ended.bind(self, sound), timeout);
+          }
+          if (self._webAudio && !loop) {
+            sound._paused = true;
+            sound._ended = true;
+            sound._seek = sound._start || 0;
+            sound._rateSeek = 0;
+            self._clearTimer(sound._id);
+            self._cleanBuffer(sound._node);
+            Howler2._autoSuspend();
+          }
+          if (!self._webAudio && !loop) {
+            self.stop(sound._id, true);
+          }
+          return self;
+        },
+        /**
+         * Clear the end timer for a sound playback.
+         * @param  {Number} id The sound ID.
+         * @return {Howl}
+         */
+        _clearTimer: function(id) {
+          var self = this;
+          if (self._endTimers[id]) {
+            if (typeof self._endTimers[id] !== "function") {
+              clearTimeout(self._endTimers[id]);
+            } else {
+              var sound = self._soundById(id);
+              if (sound && sound._node) {
+                sound._node.removeEventListener("ended", self._endTimers[id], false);
+              }
+            }
+            delete self._endTimers[id];
+          }
+          return self;
+        },
+        /**
+         * Return the sound identified by this ID, or return null.
+         * @param  {Number} id Sound ID
+         * @return {Object}    Sound object or null.
+         */
+        _soundById: function(id) {
+          var self = this;
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (id === self._sounds[i]._id) {
+              return self._sounds[i];
+            }
+          }
+          return null;
+        },
+        /**
+         * Return an inactive sound from the pool or create a new one.
+         * @return {Sound} Sound playback object.
+         */
+        _inactiveSound: function() {
+          var self = this;
+          self._drain();
+          for (var i = 0; i < self._sounds.length; i++) {
+            if (self._sounds[i]._ended) {
+              return self._sounds[i].reset();
+            }
+          }
+          return new Sound2(self);
+        },
+        /**
+         * Drain excess inactive sounds from the pool.
+         */
+        _drain: function() {
+          var self = this;
+          var limit = self._pool;
+          var cnt = 0;
+          var i = 0;
+          if (self._sounds.length < limit) {
+            return;
+          }
+          for (i = 0; i < self._sounds.length; i++) {
+            if (self._sounds[i]._ended) {
+              cnt++;
+            }
+          }
+          for (i = self._sounds.length - 1; i >= 0; i--) {
+            if (cnt <= limit) {
+              return;
+            }
+            if (self._sounds[i]._ended) {
+              if (self._webAudio && self._sounds[i]._node) {
+                self._sounds[i]._node.disconnect(0);
+              }
+              self._sounds.splice(i, 1);
+              cnt--;
+            }
+          }
+        },
+        /**
+         * Get all ID's from the sounds pool.
+         * @param  {Number} id Only return one ID if one is passed.
+         * @return {Array}    Array of IDs.
+         */
+        _getSoundIds: function(id) {
+          var self = this;
+          if (typeof id === "undefined") {
+            var ids = [];
+            for (var i = 0; i < self._sounds.length; i++) {
+              ids.push(self._sounds[i]._id);
+            }
+            return ids;
+          } else {
+            return [id];
+          }
+        },
+        /**
+         * Load the sound back into the buffer source.
+         * @param  {Sound} sound The sound object to work with.
+         * @return {Howl}
+         */
+        _refreshBuffer: function(sound) {
+          var self = this;
+          sound._node.bufferSource = Howler2.ctx.createBufferSource();
+          sound._node.bufferSource.buffer = cache[self._src];
+          if (sound._panner) {
+            sound._node.bufferSource.connect(sound._panner);
+          } else {
+            sound._node.bufferSource.connect(sound._node);
+          }
+          sound._node.bufferSource.loop = sound._loop;
+          if (sound._loop) {
+            sound._node.bufferSource.loopStart = sound._start || 0;
+            sound._node.bufferSource.loopEnd = sound._stop || 0;
+          }
+          sound._node.bufferSource.playbackRate.setValueAtTime(sound._rate, Howler2.ctx.currentTime);
+          return self;
+        },
+        /**
+         * Prevent memory leaks by cleaning up the buffer source after playback.
+         * @param  {Object} node Sound's audio node containing the buffer source.
+         * @return {Howl}
+         */
+        _cleanBuffer: function(node) {
+          var self = this;
+          var isIOS = Howler2._navigator && Howler2._navigator.vendor.indexOf("Apple") >= 0;
+          if (!node.bufferSource) {
+            return self;
+          }
+          if (Howler2._scratchBuffer && node.bufferSource) {
+            node.bufferSource.onended = null;
+            node.bufferSource.disconnect(0);
+            if (isIOS) {
+              try {
+                node.bufferSource.buffer = Howler2._scratchBuffer;
+              } catch (e) {
+              }
+            }
+          }
+          node.bufferSource = null;
+          return self;
+        },
+        /**
+         * Set the source to a 0-second silence to stop any downloading (except in IE).
+         * @param  {Object} node Audio node to clear.
+         */
+        _clearSound: function(node) {
+          var checkIE = /MSIE |Trident\//.test(Howler2._navigator && Howler2._navigator.userAgent);
+          if (!checkIE) {
+            node.src = "data:audio/wav;base64,UklGRigAAABXQVZFZm10IBIAAAABAAEARKwAAIhYAQACABAAAABkYXRhAgAAAAEA";
+          }
+        }
+      };
+      var Sound2 = function(howl) {
+        this._parent = howl;
+        this.init();
+      };
+      Sound2.prototype = {
+        /**
+         * Initialize a new Sound object.
+         * @return {Sound}
+         */
+        init: function() {
+          var self = this;
+          var parent = self._parent;
+          self._muted = parent._muted;
+          self._loop = parent._loop;
+          self._volume = parent._volume;
+          self._rate = parent._rate;
+          self._seek = 0;
+          self._paused = true;
+          self._ended = true;
+          self._sprite = "__default";
+          self._id = ++Howler2._counter;
+          parent._sounds.push(self);
+          self.create();
+          return self;
+        },
+        /**
+         * Create and setup a new sound object, whether HTML5 Audio or Web Audio.
+         * @return {Sound}
+         */
+        create: function() {
+          var self = this;
+          var parent = self._parent;
+          var volume = Howler2._muted || self._muted || self._parent._muted ? 0 : self._volume;
+          if (parent._webAudio) {
+            self._node = typeof Howler2.ctx.createGain === "undefined" ? Howler2.ctx.createGainNode() : Howler2.ctx.createGain();
+            self._node.gain.setValueAtTime(volume, Howler2.ctx.currentTime);
+            self._node.paused = true;
+            self._node.connect(Howler2.masterGain);
+          } else if (!Howler2.noAudio) {
+            self._node = Howler2._obtainHtml5Audio();
+            self._errorFn = self._errorListener.bind(self);
+            self._node.addEventListener("error", self._errorFn, false);
+            self._loadFn = self._loadListener.bind(self);
+            self._node.addEventListener(Howler2._canPlayEvent, self._loadFn, false);
+            self._endFn = self._endListener.bind(self);
+            self._node.addEventListener("ended", self._endFn, false);
+            self._node.src = parent._src;
+            self._node.preload = parent._preload === true ? "auto" : parent._preload;
+            self._node.volume = volume * Howler2.volume();
+            self._node.load();
+          }
+          return self;
+        },
+        /**
+         * Reset the parameters of this sound to the original state (for recycle).
+         * @return {Sound}
+         */
+        reset: function() {
+          var self = this;
+          var parent = self._parent;
+          self._muted = parent._muted;
+          self._loop = parent._loop;
+          self._volume = parent._volume;
+          self._rate = parent._rate;
+          self._seek = 0;
+          self._rateSeek = 0;
+          self._paused = true;
+          self._ended = true;
+          self._sprite = "__default";
+          self._id = ++Howler2._counter;
+          return self;
+        },
+        /**
+         * HTML5 Audio error listener callback.
+         */
+        _errorListener: function() {
+          var self = this;
+          self._parent._emit("loaderror", self._id, self._node.error ? self._node.error.code : 0);
+          self._node.removeEventListener("error", self._errorFn, false);
+        },
+        /**
+         * HTML5 Audio canplaythrough listener callback.
+         */
+        _loadListener: function() {
+          var self = this;
+          var parent = self._parent;
+          parent._duration = Math.ceil(self._node.duration * 10) / 10;
+          if (Object.keys(parent._sprite).length === 0) {
+            parent._sprite = { __default: [0, parent._duration * 1e3] };
+          }
+          if (parent._state !== "loaded") {
+            parent._state = "loaded";
+            parent._emit("load");
+            parent._loadQueue();
+          }
+          self._node.removeEventListener(Howler2._canPlayEvent, self._loadFn, false);
+        },
+        /**
+         * HTML5 Audio ended listener callback.
+         */
+        _endListener: function() {
+          var self = this;
+          var parent = self._parent;
+          if (parent._duration === Infinity) {
+            parent._duration = Math.ceil(self._node.duration * 10) / 10;
+            if (parent._sprite.__default[1] === Infinity) {
+              parent._sprite.__default[1] = parent._duration * 1e3;
+            }
+            parent._ended(self);
+          }
+          self._node.removeEventListener("ended", self._endFn, false);
+        }
+      };
+      var cache = {};
+      var loadBuffer = function(self) {
+        var url = self._src;
+        if (cache[url]) {
+          self._duration = cache[url].duration;
+          loadSound(self);
+          return;
+        }
+        if (/^data:[^;]+;base64,/.test(url)) {
+          var data = atob(url.split(",")[1]);
+          var dataView = new Uint8Array(data.length);
+          for (var i = 0; i < data.length; ++i) {
+            dataView[i] = data.charCodeAt(i);
+          }
+          decodeAudioData(dataView.buffer, self);
+        } else {
+          var xhr = new XMLHttpRequest();
+          xhr.open(self._xhr.method, url, true);
+          xhr.withCredentials = self._xhr.withCredentials;
+          xhr.responseType = "arraybuffer";
+          if (self._xhr.headers) {
+            Object.keys(self._xhr.headers).forEach(function(key) {
+              xhr.setRequestHeader(key, self._xhr.headers[key]);
+            });
+          }
+          xhr.onload = function() {
+            var code = (xhr.status + "")[0];
+            if (code !== "0" && code !== "2" && code !== "3") {
+              self._emit("loaderror", null, "Failed loading audio file with status: " + xhr.status + ".");
+              return;
+            }
+            decodeAudioData(xhr.response, self);
+          };
+          xhr.onerror = function() {
+            if (self._webAudio) {
+              self._html5 = true;
+              self._webAudio = false;
+              self._sounds = [];
+              delete cache[url];
+              self.load();
+            }
+          };
+          safeXhrSend(xhr);
+        }
+      };
+      var safeXhrSend = function(xhr) {
+        try {
+          xhr.send();
+        } catch (e) {
+          xhr.onerror();
+        }
+      };
+      var decodeAudioData = function(arraybuffer, self) {
+        var error = function() {
+          self._emit("loaderror", null, "Decoding audio data failed.");
+        };
+        var success = function(buffer) {
+          if (buffer && self._sounds.length > 0) {
+            cache[self._src] = buffer;
+            loadSound(self, buffer);
+          } else {
+            error();
+          }
+        };
+        if (typeof Promise !== "undefined" && Howler2.ctx.decodeAudioData.length === 1) {
+          Howler2.ctx.decodeAudioData(arraybuffer).then(success).catch(error);
+        } else {
+          Howler2.ctx.decodeAudioData(arraybuffer, success, error);
+        }
+      };
+      var loadSound = function(self, buffer) {
+        if (buffer && !self._duration) {
+          self._duration = buffer.duration;
+        }
+        if (Object.keys(self._sprite).length === 0) {
+          self._sprite = { __default: [0, self._duration * 1e3] };
+        }
+        if (self._state !== "loaded") {
+          self._state = "loaded";
+          self._emit("load");
+          self._loadQueue();
+        }
+      };
+      var setupAudioContext = function() {
+        if (!Howler2.usingWebAudio) {
+          return;
+        }
+        try {
+          if (typeof AudioContext !== "undefined") {
+            Howler2.ctx = new AudioContext();
+          } else if (typeof webkitAudioContext !== "undefined") {
+            Howler2.ctx = new webkitAudioContext();
+          } else {
+            Howler2.usingWebAudio = false;
+          }
+        } catch (e) {
+          Howler2.usingWebAudio = false;
+        }
+        if (!Howler2.ctx) {
+          Howler2.usingWebAudio = false;
+        }
+        var iOS = /iP(hone|od|ad)/.test(Howler2._navigator && Howler2._navigator.platform);
+        var appVersion = Howler2._navigator && Howler2._navigator.appVersion.match(/OS (\d+)_(\d+)_?(\d+)?/);
+        var version = appVersion ? parseInt(appVersion[1], 10) : null;
+        if (iOS && version && version < 9) {
+          var safari = /safari/.test(Howler2._navigator && Howler2._navigator.userAgent.toLowerCase());
+          if (Howler2._navigator && !safari) {
+            Howler2.usingWebAudio = false;
+          }
+        }
+        if (Howler2.usingWebAudio) {
+          Howler2.masterGain = typeof Howler2.ctx.createGain === "undefined" ? Howler2.ctx.createGainNode() : Howler2.ctx.createGain();
+          Howler2.masterGain.gain.setValueAtTime(Howler2._muted ? 0 : Howler2._volume, Howler2.ctx.currentTime);
+          Howler2.masterGain.connect(Howler2.ctx.destination);
+        }
+        Howler2._setup();
+      };
+      {
+        exports$1.Howler = Howler2;
+        exports$1.Howl = Howl2;
+      }
+      if (typeof commonjsGlobal !== "undefined") {
+        commonjsGlobal.HowlerGlobal = HowlerGlobal2;
+        commonjsGlobal.Howler = Howler2;
+        commonjsGlobal.Howl = Howl2;
+        commonjsGlobal.Sound = Sound2;
+      } else if (typeof window !== "undefined") {
+        window.HowlerGlobal = HowlerGlobal2;
+        window.Howler = Howler2;
+        window.Howl = Howl2;
+        window.Sound = Sound2;
+      }
+    })();
+    /*!
+     *  Spatial Plugin - Adds support for stereo and 3D audio where Web Audio is supported.
+     *  
+     *  howler.js v2.2.4
+     *  howlerjs.com
+     *
+     *  (c) 2013-2020, James Simpson of GoldFire Studios
+     *  goldfirestudios.com
+     *
+     *  MIT License
+     */
+    (function() {
+      HowlerGlobal.prototype._pos = [0, 0, 0];
+      HowlerGlobal.prototype._orientation = [0, 0, -1, 0, 1, 0];
+      HowlerGlobal.prototype.stereo = function(pan) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        for (var i = self._howls.length - 1; i >= 0; i--) {
+          self._howls[i].stereo(pan);
+        }
+        return self;
+      };
+      HowlerGlobal.prototype.pos = function(x, y2, z) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        y2 = typeof y2 !== "number" ? self._pos[1] : y2;
+        z = typeof z !== "number" ? self._pos[2] : z;
+        if (typeof x === "number") {
+          self._pos = [x, y2, z];
+          if (typeof self.ctx.listener.positionX !== "undefined") {
+            self.ctx.listener.positionX.setTargetAtTime(self._pos[0], Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.positionY.setTargetAtTime(self._pos[1], Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.positionZ.setTargetAtTime(self._pos[2], Howler.ctx.currentTime, 0.1);
+          } else {
+            self.ctx.listener.setPosition(self._pos[0], self._pos[1], self._pos[2]);
+          }
+        } else {
+          return self._pos;
+        }
+        return self;
+      };
+      HowlerGlobal.prototype.orientation = function(x, y2, z, xUp, yUp, zUp) {
+        var self = this;
+        if (!self.ctx || !self.ctx.listener) {
+          return self;
+        }
+        var or = self._orientation;
+        y2 = typeof y2 !== "number" ? or[1] : y2;
+        z = typeof z !== "number" ? or[2] : z;
+        xUp = typeof xUp !== "number" ? or[3] : xUp;
+        yUp = typeof yUp !== "number" ? or[4] : yUp;
+        zUp = typeof zUp !== "number" ? or[5] : zUp;
+        if (typeof x === "number") {
+          self._orientation = [x, y2, z, xUp, yUp, zUp];
+          if (typeof self.ctx.listener.forwardX !== "undefined") {
+            self.ctx.listener.forwardX.setTargetAtTime(x, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.forwardY.setTargetAtTime(y2, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.forwardZ.setTargetAtTime(z, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upX.setTargetAtTime(xUp, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upY.setTargetAtTime(yUp, Howler.ctx.currentTime, 0.1);
+            self.ctx.listener.upZ.setTargetAtTime(zUp, Howler.ctx.currentTime, 0.1);
+          } else {
+            self.ctx.listener.setOrientation(x, y2, z, xUp, yUp, zUp);
+          }
+        } else {
+          return or;
+        }
+        return self;
+      };
+      Howl.prototype.init = /* @__PURE__ */ (function(_super) {
+        return function(o2) {
+          var self = this;
+          self._orientation = o2.orientation || [1, 0, 0];
+          self._stereo = o2.stereo || null;
+          self._pos = o2.pos || null;
+          self._pannerAttr = {
+            coneInnerAngle: typeof o2.coneInnerAngle !== "undefined" ? o2.coneInnerAngle : 360,
+            coneOuterAngle: typeof o2.coneOuterAngle !== "undefined" ? o2.coneOuterAngle : 360,
+            coneOuterGain: typeof o2.coneOuterGain !== "undefined" ? o2.coneOuterGain : 0,
+            distanceModel: typeof o2.distanceModel !== "undefined" ? o2.distanceModel : "inverse",
+            maxDistance: typeof o2.maxDistance !== "undefined" ? o2.maxDistance : 1e4,
+            panningModel: typeof o2.panningModel !== "undefined" ? o2.panningModel : "HRTF",
+            refDistance: typeof o2.refDistance !== "undefined" ? o2.refDistance : 1,
+            rolloffFactor: typeof o2.rolloffFactor !== "undefined" ? o2.rolloffFactor : 1
+          };
+          self._onstereo = o2.onstereo ? [{ fn: o2.onstereo }] : [];
+          self._onpos = o2.onpos ? [{ fn: o2.onpos }] : [];
+          self._onorientation = o2.onorientation ? [{ fn: o2.onorientation }] : [];
+          return _super.call(this, o2);
+        };
+      })(Howl.prototype.init);
+      Howl.prototype.stereo = function(pan, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "stereo",
+            action: function() {
+              self.stereo(pan, id);
+            }
+          });
+          return self;
+        }
+        var pannerType = typeof Howler.ctx.createStereoPanner === "undefined" ? "spatial" : "stereo";
+        if (typeof id === "undefined") {
+          if (typeof pan === "number") {
+            self._stereo = pan;
+            self._pos = [pan, 0, 0];
+          } else {
+            return self._stereo;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof pan === "number") {
+              sound._stereo = pan;
+              sound._pos = [pan, 0, 0];
+              if (sound._node) {
+                sound._pannerAttr.panningModel = "equalpower";
+                if (!sound._panner || !sound._panner.pan) {
+                  setupPanner(sound, pannerType);
+                }
+                if (pannerType === "spatial") {
+                  if (typeof sound._panner.positionX !== "undefined") {
+                    sound._panner.positionX.setValueAtTime(pan, Howler.ctx.currentTime);
+                    sound._panner.positionY.setValueAtTime(0, Howler.ctx.currentTime);
+                    sound._panner.positionZ.setValueAtTime(0, Howler.ctx.currentTime);
+                  } else {
+                    sound._panner.setPosition(pan, 0, 0);
+                  }
+                } else {
+                  sound._panner.pan.setValueAtTime(pan, Howler.ctx.currentTime);
+                }
+              }
+              self._emit("stereo", sound._id);
+            } else {
+              return sound._stereo;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.pos = function(x, y2, z, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "pos",
+            action: function() {
+              self.pos(x, y2, z, id);
+            }
+          });
+          return self;
+        }
+        y2 = typeof y2 !== "number" ? 0 : y2;
+        z = typeof z !== "number" ? -0.5 : z;
+        if (typeof id === "undefined") {
+          if (typeof x === "number") {
+            self._pos = [x, y2, z];
+          } else {
+            return self._pos;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof x === "number") {
+              sound._pos = [x, y2, z];
+              if (sound._node) {
+                if (!sound._panner || sound._panner.pan) {
+                  setupPanner(sound, "spatial");
+                }
+                if (typeof sound._panner.positionX !== "undefined") {
+                  sound._panner.positionX.setValueAtTime(x, Howler.ctx.currentTime);
+                  sound._panner.positionY.setValueAtTime(y2, Howler.ctx.currentTime);
+                  sound._panner.positionZ.setValueAtTime(z, Howler.ctx.currentTime);
+                } else {
+                  sound._panner.setPosition(x, y2, z);
+                }
+              }
+              self._emit("pos", sound._id);
+            } else {
+              return sound._pos;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.orientation = function(x, y2, z, id) {
+        var self = this;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (self._state !== "loaded") {
+          self._queue.push({
+            event: "orientation",
+            action: function() {
+              self.orientation(x, y2, z, id);
+            }
+          });
+          return self;
+        }
+        y2 = typeof y2 !== "number" ? self._orientation[1] : y2;
+        z = typeof z !== "number" ? self._orientation[2] : z;
+        if (typeof id === "undefined") {
+          if (typeof x === "number") {
+            self._orientation = [x, y2, z];
+          } else {
+            return self._orientation;
+          }
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          var sound = self._soundById(ids[i]);
+          if (sound) {
+            if (typeof x === "number") {
+              sound._orientation = [x, y2, z];
+              if (sound._node) {
+                if (!sound._panner) {
+                  if (!sound._pos) {
+                    sound._pos = self._pos || [0, 0, -0.5];
+                  }
+                  setupPanner(sound, "spatial");
+                }
+                if (typeof sound._panner.orientationX !== "undefined") {
+                  sound._panner.orientationX.setValueAtTime(x, Howler.ctx.currentTime);
+                  sound._panner.orientationY.setValueAtTime(y2, Howler.ctx.currentTime);
+                  sound._panner.orientationZ.setValueAtTime(z, Howler.ctx.currentTime);
+                } else {
+                  sound._panner.setOrientation(x, y2, z);
+                }
+              }
+              self._emit("orientation", sound._id);
+            } else {
+              return sound._orientation;
+            }
+          }
+        }
+        return self;
+      };
+      Howl.prototype.pannerAttr = function() {
+        var self = this;
+        var args = arguments;
+        var o2, id, sound;
+        if (!self._webAudio) {
+          return self;
+        }
+        if (args.length === 0) {
+          return self._pannerAttr;
+        } else if (args.length === 1) {
+          if (typeof args[0] === "object") {
+            o2 = args[0];
+            if (typeof id === "undefined") {
+              if (!o2.pannerAttr) {
+                o2.pannerAttr = {
+                  coneInnerAngle: o2.coneInnerAngle,
+                  coneOuterAngle: o2.coneOuterAngle,
+                  coneOuterGain: o2.coneOuterGain,
+                  distanceModel: o2.distanceModel,
+                  maxDistance: o2.maxDistance,
+                  refDistance: o2.refDistance,
+                  rolloffFactor: o2.rolloffFactor,
+                  panningModel: o2.panningModel
+                };
+              }
+              self._pannerAttr = {
+                coneInnerAngle: typeof o2.pannerAttr.coneInnerAngle !== "undefined" ? o2.pannerAttr.coneInnerAngle : self._coneInnerAngle,
+                coneOuterAngle: typeof o2.pannerAttr.coneOuterAngle !== "undefined" ? o2.pannerAttr.coneOuterAngle : self._coneOuterAngle,
+                coneOuterGain: typeof o2.pannerAttr.coneOuterGain !== "undefined" ? o2.pannerAttr.coneOuterGain : self._coneOuterGain,
+                distanceModel: typeof o2.pannerAttr.distanceModel !== "undefined" ? o2.pannerAttr.distanceModel : self._distanceModel,
+                maxDistance: typeof o2.pannerAttr.maxDistance !== "undefined" ? o2.pannerAttr.maxDistance : self._maxDistance,
+                refDistance: typeof o2.pannerAttr.refDistance !== "undefined" ? o2.pannerAttr.refDistance : self._refDistance,
+                rolloffFactor: typeof o2.pannerAttr.rolloffFactor !== "undefined" ? o2.pannerAttr.rolloffFactor : self._rolloffFactor,
+                panningModel: typeof o2.pannerAttr.panningModel !== "undefined" ? o2.pannerAttr.panningModel : self._panningModel
+              };
+            }
+          } else {
+            sound = self._soundById(parseInt(args[0], 10));
+            return sound ? sound._pannerAttr : self._pannerAttr;
+          }
+        } else if (args.length === 2) {
+          o2 = args[0];
+          id = parseInt(args[1], 10);
+        }
+        var ids = self._getSoundIds(id);
+        for (var i = 0; i < ids.length; i++) {
+          sound = self._soundById(ids[i]);
+          if (sound) {
+            var pa = sound._pannerAttr;
+            pa = {
+              coneInnerAngle: typeof o2.coneInnerAngle !== "undefined" ? o2.coneInnerAngle : pa.coneInnerAngle,
+              coneOuterAngle: typeof o2.coneOuterAngle !== "undefined" ? o2.coneOuterAngle : pa.coneOuterAngle,
+              coneOuterGain: typeof o2.coneOuterGain !== "undefined" ? o2.coneOuterGain : pa.coneOuterGain,
+              distanceModel: typeof o2.distanceModel !== "undefined" ? o2.distanceModel : pa.distanceModel,
+              maxDistance: typeof o2.maxDistance !== "undefined" ? o2.maxDistance : pa.maxDistance,
+              refDistance: typeof o2.refDistance !== "undefined" ? o2.refDistance : pa.refDistance,
+              rolloffFactor: typeof o2.rolloffFactor !== "undefined" ? o2.rolloffFactor : pa.rolloffFactor,
+              panningModel: typeof o2.panningModel !== "undefined" ? o2.panningModel : pa.panningModel
+            };
+            var panner = sound._panner;
+            if (!panner) {
+              if (!sound._pos) {
+                sound._pos = self._pos || [0, 0, -0.5];
+              }
+              setupPanner(sound, "spatial");
+              panner = sound._panner;
+            }
+            panner.coneInnerAngle = pa.coneInnerAngle;
+            panner.coneOuterAngle = pa.coneOuterAngle;
+            panner.coneOuterGain = pa.coneOuterGain;
+            panner.distanceModel = pa.distanceModel;
+            panner.maxDistance = pa.maxDistance;
+            panner.refDistance = pa.refDistance;
+            panner.rolloffFactor = pa.rolloffFactor;
+            panner.panningModel = pa.panningModel;
+          }
+        }
+        return self;
+      };
+      Sound.prototype.init = /* @__PURE__ */ (function(_super) {
+        return function() {
+          var self = this;
+          var parent = self._parent;
+          self._orientation = parent._orientation;
+          self._stereo = parent._stereo;
+          self._pos = parent._pos;
+          self._pannerAttr = parent._pannerAttr;
+          _super.call(this);
+          if (self._stereo) {
+            parent.stereo(self._stereo);
+          } else if (self._pos) {
+            parent.pos(self._pos[0], self._pos[1], self._pos[2], self._id);
+          }
+        };
+      })(Sound.prototype.init);
+      Sound.prototype.reset = /* @__PURE__ */ (function(_super) {
+        return function() {
+          var self = this;
+          var parent = self._parent;
+          self._orientation = parent._orientation;
+          self._stereo = parent._stereo;
+          self._pos = parent._pos;
+          self._pannerAttr = parent._pannerAttr;
+          if (self._stereo) {
+            parent.stereo(self._stereo);
+          } else if (self._pos) {
+            parent.pos(self._pos[0], self._pos[1], self._pos[2], self._id);
+          } else if (self._panner) {
+            self._panner.disconnect(0);
+            self._panner = void 0;
+            parent._refreshBuffer(self);
+          }
+          return _super.call(this);
+        };
+      })(Sound.prototype.reset);
+      var setupPanner = function(sound, type) {
+        type = type || "spatial";
+        if (type === "spatial") {
+          sound._panner = Howler.ctx.createPanner();
+          sound._panner.coneInnerAngle = sound._pannerAttr.coneInnerAngle;
+          sound._panner.coneOuterAngle = sound._pannerAttr.coneOuterAngle;
+          sound._panner.coneOuterGain = sound._pannerAttr.coneOuterGain;
+          sound._panner.distanceModel = sound._pannerAttr.distanceModel;
+          sound._panner.maxDistance = sound._pannerAttr.maxDistance;
+          sound._panner.refDistance = sound._pannerAttr.refDistance;
+          sound._panner.rolloffFactor = sound._pannerAttr.rolloffFactor;
+          sound._panner.panningModel = sound._pannerAttr.panningModel;
+          if (typeof sound._panner.positionX !== "undefined") {
+            sound._panner.positionX.setValueAtTime(sound._pos[0], Howler.ctx.currentTime);
+            sound._panner.positionY.setValueAtTime(sound._pos[1], Howler.ctx.currentTime);
+            sound._panner.positionZ.setValueAtTime(sound._pos[2], Howler.ctx.currentTime);
+          } else {
+            sound._panner.setPosition(sound._pos[0], sound._pos[1], sound._pos[2]);
+          }
+          if (typeof sound._panner.orientationX !== "undefined") {
+            sound._panner.orientationX.setValueAtTime(sound._orientation[0], Howler.ctx.currentTime);
+            sound._panner.orientationY.setValueAtTime(sound._orientation[1], Howler.ctx.currentTime);
+            sound._panner.orientationZ.setValueAtTime(sound._orientation[2], Howler.ctx.currentTime);
+          } else {
+            sound._panner.setOrientation(sound._orientation[0], sound._orientation[1], sound._orientation[2]);
+          }
+        } else {
+          sound._panner = Howler.ctx.createStereoPanner();
+          sound._panner.pan.setValueAtTime(sound._stereo, Howler.ctx.currentTime);
+        }
+        sound._panner.connect(sound._node);
+        if (!sound._paused) {
+          sound._parent.pause(sound._id, true).play(sound._id, true);
+        }
+      };
+    })();
+  })(howler);
+  return howler;
+}
+var howlerExports = requireHowler();
+var y = Object.defineProperty, b = Object.defineProperties;
+var S = Object.getOwnPropertyDescriptors;
+var p = Object.getOwnPropertySymbols;
+var g = Object.prototype.hasOwnProperty, P = Object.prototype.propertyIsEnumerable;
+var f = (l, e, t) => e in l ? y(l, e, { enumerable: true, configurable: true, writable: true, value: t }) : l[e] = t, o = (l, e) => {
+  for (var t in e || (e = {})) g.call(e, t) && f(l, t, e[t]);
+  if (p) for (var t of p(e)) P.call(e, t) && f(l, t, e[t]);
+  return l;
+}, s = (l, e) => b(l, S(e));
+var d = class {
+  constructor() {
+    this._cache = /* @__PURE__ */ new Map();
+  }
+  create(e) {
+    let t = e.src;
+    if (this._cache.has(t)) return this._cache.get(t);
+    let a = new howlerExports.Howl(e);
+    return this._cache.set(t, a), a;
+  }
+  set(e, t) {
+    this._cache.set(e, t);
+  }
+  get(e) {
+    return this._cache.get(e);
+  }
+  clear(e) {
+    this._cache.delete(e);
+  }
+  destroy(e) {
+    let t = this.get(e);
+    t && (t.unload(), this.clear(e));
+  }
+  reset() {
+    this._cache.values().forEach((e) => e.unload()), this._cache.clear();
+  }
+}, v = new d(), c = v;
+var n = { isUnloaded: true, isLoading: false, isReady: false, isLooping: false, isPlaying: false, isStopped: false, isPaused: false, duration: 0, rate: 1, volume: 1, isMuted: false, error: void 0 }, h = class {
+  updateSnapshot(e) {
+    this.snapshot = o(o({}, this.snapshot), e), this.subscriptions.forEach((t) => t());
+  }
+  updateSnapshotFromHowlState(e) {
+    this.updateSnapshot(o({}, this.getSnapshotFromHowl(e)));
+  }
+  initHowl(e) {
+    var a, u;
+    let t = c.create(e);
+    this.src = e.src, this.howl = t, this.updateSnapshot(s(o({}, this.getSnapshotFromHowl(t)), { error: void 0 })), t._html5 && ((a = t._sounds[0]) != null && a._node) && ((u = t._sounds[0]) == null ? void 0 : u._node).addEventListener("canplaythrough", () => {
+      this.updateSnapshotFromHowlState(t);
+    }), t.on("load", () => this.updateSnapshotFromHowlState(t)), t.on("play", () => this.updateSnapshotFromHowlState(t)), t.on("end", () => this.updateSnapshotFromHowlState(t)), t.on("pause", () => this.updateSnapshotFromHowlState(t)), t.on("stop", () => this.updateSnapshotFromHowlState(t)), t.on("mute", () => this.updateSnapshotFromHowlState(t)), t.on("volume", () => this.updateSnapshotFromHowlState(t)), t.on("rate", () => this.updateSnapshotFromHowlState(t)), t.on("seek", () => this.updateSnapshotFromHowlState(t)), t.on("fade", () => this.updateSnapshotFromHowlState(t)), t.on("loaderror", (i, r) => {
+      console.error(`Howl load error: ${r}`), this.updateSnapshotFromHowlState(t), this.updateSnapshot({ error: "Failed to load audio source" });
+    }), t.on("playerror", (i, r) => {
+      console.error(`Howl playback error: ${r}`), this.updateSnapshotFromHowlState(t), this.updateSnapshot({ error: "Failed to play audio source" });
+    });
+  }
+  getSnapshotFromHowl(e) {
+    if (e.state() === "unloaded") return n;
+    let t = e.state(), a = e.playing(), u = e.mute();
+    return { isUnloaded: t === "unloaded", isLoading: t === "loading", isReady: t === "loaded", isLooping: e.loop(), isPlaying: a, isStopped: !a && e.seek() === 0, isPaused: !a && e.seek() > 0, duration: e.duration(), rate: e.rate(), volume: e.volume(), isMuted: typeof u == "object" ? false : u };
+  }
+  constructor(e) {
+    this.howl = null, this.src = null, this.subscriptions = /* @__PURE__ */ new Set(), this.snapshot = n, e !== void 0 && this.initHowl(e);
+  }
+  load(e) {
+    this.howl !== null && this.destroy(), this.initHowl(e);
+  }
+  destroy() {
+    this.src && this.howl && (this.howl.off("load"), this.howl.off("play"), this.howl.off("end"), this.howl.off("pause"), this.howl.off("stop"), this.howl.off("mute"), this.howl.off("volume"), this.howl.off("rate"), this.howl.off("seek"), this.howl.off("fade"), this.howl.off("loaderror"), this.howl.off("playerror"), c.destroy(this.src), this.src = null, this.howl = null);
+  }
+  subscribe(e) {
+    return this.subscriptions.add(e), () => this.subscriptions.delete(e);
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  play() {
+    if (this.howl) {
+      if (this.howl.playing()) return;
+      this.howl.play();
+    }
+  }
+  pause() {
+    this.howl && this.howl.pause();
+  }
+  togglePlayPause() {
+    this.snapshot.isPlaying ? this.pause() : this.play();
+  }
+  stop() {
+    this.howl && this.howl.stop();
+  }
+  setVolume(e) {
+    this.howl && this.howl.volume(e);
+  }
+  setRate(e) {
+    this.howl && this.howl.rate(e);
+  }
+  loopOn() {
+    this.howl && (this.howl.loop(true), this.updateSnapshotFromHowlState(this.howl));
+  }
+  loopOff() {
+    this.howl && (this.howl.loop(false), this.updateSnapshotFromHowlState(this.howl));
+  }
+  toggleLoop() {
+    this.snapshot.isLooping ? this.loopOff() : this.loopOn();
+  }
+  mute() {
+    this.howl && this.howl.mute(true);
+  }
+  unmute() {
+    this.howl && this.howl.mute(false);
+  }
+  toggleMute() {
+    this.snapshot.isMuted ? this.unmute() : this.mute();
+  }
+  seek(e) {
+    this.howl && this.snapshot.duration !== 1 / 0 && this.howl.seek(e);
+  }
+  getPosition() {
+    return this.howl ? this.howl.seek() : 0;
+  }
+  fade(e, t, a) {
+    this.howl && this.howl.fade(e, t, a);
+  }
+};
+function m(l, e) {
+  let t = useRef(new h());
+  let a = useSyncExternalStore(t.current.subscribe.bind(t.current), t.current.getSnapshot.bind(t.current), () => n);
+  useEffect(() => (() => {
+    t.current && t.current.destroy();
+  }), []);
+  let u = useCallback((i, r) => {
+    t.current.load(o({ src: i, format: r == null ? void 0 : r.format, html5: r == null ? void 0 : r.html5, autoplay: r == null ? void 0 : r.autoplay, loop: r == null ? void 0 : r.loop, volume: r == null ? void 0 : r.initialVolume, mute: r == null ? void 0 : r.initialMute, rate: r == null ? void 0 : r.initialRate }, r));
+  }, []);
+  return s(o({}, a), { player: t.current.howl, src: t.current.src, load: u, play: t.current.play.bind(t.current), pause: t.current.pause.bind(t.current), togglePlayPause: t.current.togglePlayPause.bind(t.current), stop: t.current.stop.bind(t.current), setVolume: t.current.setVolume.bind(t.current), fade: t.current.fade.bind(t.current), mute: t.current.mute.bind(t.current), unmute: t.current.unmute.bind(t.current), toggleMute: t.current.toggleMute.bind(t.current), setRate: t.current.setRate.bind(t.current), seek: t.current.seek.bind(t.current), loopOn: t.current.loopOn.bind(t.current), loopOff: t.current.loopOff.bind(t.current), toggleLoop: t.current.toggleLoop.bind(t.current), getPosition: t.current.getPosition.bind(t.current), cleanup: t.current.destroy.bind(t.current) });
+}
+createContext(null);
+const PLAYER_INSTANCE_QUERY_PARAM = "wixAudioPlayerInstanceId";
+function getAudioLoadUrlForPlayerInstance(audioUrl, instanceId) {
+  if (!audioUrl || !instanceId) {
+    return audioUrl;
+  }
+  if (audioUrl.startsWith("data:") || audioUrl.startsWith("blob:")) {
+    return audioUrl;
+  }
+  try {
+    const resolved = new URL(audioUrl);
+    resolved.searchParams.set(PLAYER_INSTANCE_QUERY_PARAM, instanceId);
+    return resolved.toString();
+  } catch {
+    return audioUrl;
+  }
+}
+const useAudioPlayer = ({
+  instanceId,
+  audioUrl,
+  loop,
+  volume,
+  onPlay,
+  onPause,
+  onEnded,
+  onTimeupdate
+}) => {
+  const player = m();
+  const playerRef = useRef(player);
+  playerRef.current = player;
+  const loadUrl = useMemo(
+    () => getAudioLoadUrlForPlayerInstance(audioUrl, instanceId),
+    [audioUrl, instanceId]
+  );
+  const onEndedRef = useRef(onEnded);
+  onEndedRef.current = onEnded;
+  useEffect(() => {
+    if (loadUrl) {
+      playerRef.current.load(loadUrl, {
+        loop,
+        initialVolume: volume / 100,
+        onend: () => {
+          var _a;
+          return (_a = onEndedRef.current) == null ? void 0 : _a.call(onEndedRef);
+        }
+      });
+    } else {
+      playerRef.current.cleanup();
+      setCurrentTime(0);
+    }
+  }, [loadUrl]);
+  useEffect(() => {
+    if (loop) {
+      playerRef.current.loopOn();
+    } else {
+      playerRef.current.loopOff();
+    }
+  }, [loop]);
+  const prevIsPlayingRef = useRef(player.isPlaying);
+  useEffect(() => {
+    const wasPlaying = prevIsPlayingRef.current;
+    const nowPlaying = player.isPlaying;
+    prevIsPlayingRef.current = nowPlaying;
+    if (!wasPlaying && nowPlaying) {
+      onPlay == null ? void 0 : onPlay();
+    } else if (wasPlaying && !nowPlaying) {
+      onPause == null ? void 0 : onPause();
+    }
+  }, [player.isPlaying, onPlay, onPause]);
+  const [currentTime, setCurrentTime] = useState(0);
+  const frameRef = useRef();
+  const onTimeupdateRef = useRef(onTimeupdate);
+  onTimeupdateRef.current = onTimeupdate;
+  useEffect(() => {
+    let lastTime = 0;
+    const animate = () => {
+      var _a;
+      const pos = playerRef.current.getPosition();
+      setCurrentTime(pos);
+      if (pos !== lastTime) {
+        (_a = onTimeupdateRef.current) == null ? void 0 : _a.call(onTimeupdateRef);
+        lastTime = pos;
+      }
+      frameRef.current = requestAnimationFrame(animate);
+    };
+    frameRef.current = requestAnimationFrame(animate);
+    return () => {
+      if (frameRef.current) {
+        cancelAnimationFrame(frameRef.current);
+      }
+    };
+  }, []);
+  const [currentVolume, setCurrentVolume] = useState(volume);
+  useEffect(() => {
+    setCurrentVolume(volume);
+    playerRef.current.setVolume(volume / 100);
+  }, [volume]);
+  const setVolume = useCallback((value) => {
+    setCurrentVolume(value);
+    playerRef.current.setVolume(value / 100);
+    if (value > 0 && playerRef.current.isMuted) {
+      playerRef.current.unmute();
+    }
+  }, []);
+  const seekTo = useCallback((value) => {
+    playerRef.current.seek(value);
+    setCurrentTime(value);
+  }, []);
+  const togglePlay = useCallback(() => {
+    if (playerRef.current.error) {
+      return;
+    }
+    playerRef.current.togglePlayPause();
+  }, []);
+  const toggleMute = useCallback(() => {
+    playerRef.current.toggleMute();
+  }, []);
+  const duration = loadUrl ? player.duration : 0;
+  return {
+    isPlaying: player.isPlaying,
+    currentTime,
+    duration,
+    currentVolume,
+    isMuted: player.isMuted,
+    hasError: !!player.error,
+    togglePlay,
+    toggleMute,
+    seekTo,
+    setVolume
+  };
+};
+const root = "root__hYTL-";
+const coverMediaWrapper = "coverMediaWrapper__4WJv-";
+const audioTitle = "audioTitle__sraj4";
+const artistName = "artistName__m1VFK";
+const controls = "controls__CVIRI";
+const playIcon = "playIcon__ix-Gs";
+const progressBar = "progressBar__JKVlY";
+const progressTrack = "progressTrack__bm5K-";
+const progressFill = "progressFill__hUBX1";
+const progressThumb = "progressThumb__aGPAS";
+const timeDisplay = "timeDisplay__Pw7f0";
+const volumeControls = "volumeControls__-atKQ";
+const muteIcon = "muteIcon__n7APk";
+const volumeSliderWrapper = "volumeSliderWrapper__JyspH";
+const volumeSlider = "volumeSlider__e8CHL";
+const volumeTrack = "volumeTrack__hQIXf";
+const volumeFill = "volumeFill__BxwCt";
+const volumeThumb = "volumeThumb__3tTpu";
+const seoLink = "seoLink__azehx";
+const styles = {
+  root,
+  coverMediaWrapper,
+  audioTitle,
+  artistName,
+  controls,
+  playIcon,
+  progressBar,
+  progressTrack,
+  progressFill,
+  progressThumb,
+  timeDisplay,
+  volumeControls,
+  muteIcon,
+  volumeSliderWrapper,
+  volumeSlider,
+  volumeTrack,
+  volumeFill,
+  volumeThumb,
+  seoLink
+};
+const PlayButton = ({
+  isPlaying,
+  hasError,
+  onTogglePlay
+}) => {
+  const PlaybackIcon = isPlaying ? PauseFilled_default : PlayFilled_default;
+  return /* @__PURE__ */ jsx(
+    $d2b4bc8c273e7be6$export$353f5b6fc5456de1,
+    {
+      className: selectors.playButton,
+      onPress: onTogglePlay,
+      isDisabled: hasError,
+      "aria-label": isPlaying ? ARIA_LABELS.pauseButton : ARIA_LABELS.playButton,
+      children: /* @__PURE__ */ jsx(
+        PlaybackIcon,
+        {
+          className: clsx(selectors.playIcon, styles.playIcon)
+        }
+      )
+    }
+  );
+};
+const formatTime = (seconds) => {
+  if (isNaN(seconds)) {
+    return "0:00";
+  }
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${secs.toString().padStart(2, "0")}`;
+};
+const ProgressSlider = ({
+  currentTime,
+  duration,
+  hasError,
+  onSeek
+}) => {
+  const timeText = `${formatTime(currentTime)} / ${formatTime(duration)}`;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      $6f909507e6374d18$export$472062a354075cee,
+      {
+        className: clsx(selectors.progressBar, styles.progressBar),
+        minValue: 0,
+        maxValue: duration || 1,
+        value: currentTime,
+        onChange: onSeek,
+        isDisabled: hasError || duration === 0,
+        "aria-label": ARIA_LABELS.progressBar,
+        children: /* @__PURE__ */ jsx(
+          $6f909507e6374d18$export$105594979f116971,
+          {
+            className: clsx(selectors.progressTrack, styles.progressTrack),
+            children: ({ state }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  style: {
+                    "--progress-percent": `${state.getThumbPercent(0) * 100}%`
+                  },
+                  className: styles.progressFill
+                }
+              ),
+              /* @__PURE__ */ jsx($6f909507e6374d18$export$2c1b491743890dec, { className: styles.progressThumb })
+            ] })
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx("span", { className: clsx(selectors.timeDisplay, styles.timeDisplay), children: timeText })
+  ] });
+};
+const SoundOn = (props) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "24",
+    height: "24",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        fillRule: "evenodd",
+        clipRule: "evenodd",
+        d: "M13.5193 5.11294C13.648 4.99656 13.8343 4.96769 13.9901 5.03769C14.1485 5.10769 14.25 5.26519 14.25 5.43756V18.5625C14.25 18.7349 14.1485 18.8924 13.9901 18.9624C13.9332 18.9878 13.8728 19 13.8125 19C13.7066 19 13.6016 18.9615 13.5193 18.8871L9.27211 15.0608L6.81249 15.0625C6.08887 15.0625 5.5 14.4736 5.5 13.75V10.25C5.5 9.52642 6.08887 8.93755 6.81249 8.93755H9.27561L13.5193 5.11294ZM17.7439 7.76094C18.8762 8.89318 19.5 10.3991 19.5 12.0003C19.5 13.6015 18.8762 15.1074 17.7439 16.2388L17.1253 15.6202C18.0922 14.6533 18.625 13.367 18.625 12.0003C18.625 10.6327 18.0922 9.34643 17.1253 8.37956L17.7439 7.76094ZM16.2383 9.28361C16.9313 10.023 17.3128 10.9872 17.3128 11.9996C17.3128 13.0128 16.9313 13.9771 16.2392 14.7165L15.6004 14.118C16.1403 13.5422 16.4378 12.7897 16.4378 11.9996C16.4378 11.2103 16.1403 10.4587 15.6004 9.8821L16.2383 9.28361Z",
+        fill: "currentColor"
+      }
+    )
+  }
+);
+const SoundOff = (props) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "24",
+    height: "24",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    ...props,
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        fillRule: "evenodd",
+        clipRule: "evenodd",
+        d: "M13.0875 5.11294C13.2172 4.99656 13.4043 4.96769 13.5623 5.03769C13.722 5.10769 13.8244 5.26519 13.8244 5.43756V18.5625C13.8244 18.7349 13.722 18.8924 13.5623 18.9624C13.5049 18.9878 13.444 19 13.3831 19C13.2764 19 13.1705 18.9615 13.0875 18.8871L8.80418 15.0608L6.32365 15.0625C5.59388 15.0625 5 14.4736 5 13.75V10.25C5 9.52642 5.59388 8.93755 6.32365 8.93755H8.80771L13.0875 5.11294ZM19.3761 9.81429L20 10.4329L18.4187 12L20 13.5671L19.3761 14.1858L17.7948 12.6187L16.2143 14.1858L15.5905 13.5671L17.1709 12L15.5905 10.4329L16.2143 9.81429L17.7948 11.3814L19.3761 9.81429Z",
+        fill: "currentColor"
+      }
+    )
+  }
+);
+const VolumeFill = ({ percent }) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    style: { "--volume-percent": `${percent}%` },
+    className: styles.volumeFill
+  }
+);
+const VolumeControls = ({
+  currentVolume,
+  isMuted,
+  onToggleMute,
+  onVolumeChange
+}) => /* @__PURE__ */ jsxs(
+  $a049562f99e7db0e$export$eb2fcfdbd7ba97d4,
+  {
+    className: clsx(selectors.volumeControls, styles.volumeControls),
+    "aria-label": ARIA_LABELS.volumeControls,
+    children: [
+      /* @__PURE__ */ jsx(
+        $d2b4bc8c273e7be6$export$353f5b6fc5456de1,
+        {
+          className: selectors.muteButton,
+          onPress: onToggleMute,
+          "aria-label": isMuted ? ARIA_LABELS.unmuteButton : ARIA_LABELS.muteButton,
+          children: isMuted ? /* @__PURE__ */ jsx(SoundOff, { className: styles.muteIcon }) : /* @__PURE__ */ jsx(SoundOn, { className: styles.muteIcon })
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: styles.volumeSliderWrapper, children: /* @__PURE__ */ jsx(
+        $6f909507e6374d18$export$472062a354075cee,
+        {
+          className: clsx(selectors.volumeSlider, styles.volumeSlider),
+          minValue: 0,
+          maxValue: 100,
+          value: isMuted ? 0 : currentVolume,
+          onChange: onVolumeChange,
+          "aria-label": ARIA_LABELS.volumeSlider,
+          orientation: "vertical",
+          children: /* @__PURE__ */ jsx(
+            $6f909507e6374d18$export$105594979f116971,
+            {
+              className: clsx(selectors.volumeTrack, styles.volumeTrack),
+              children: ({ state }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(VolumeFill, { percent: state.getThumbPercent(0) * 100 }),
+                /* @__PURE__ */ jsx($6f909507e6374d18$export$2c1b491743890dec, { className: styles.volumeThumb })
+              ] })
+            }
+          )
+        }
+      ) })
+    ]
+  }
+);
+const AudioPlayer = (props) => {
+  var _a;
+  const {
+    id,
+    className,
+    direction,
+    a11y,
+    audio,
+    coverImage,
+    displayMode,
+    loop = dataDefaults.loop,
+    volume = dataDefaults.volume,
+    onPlay: onPlayCallback,
+    onPause: onPauseCallback,
+    onEnded,
+    onTimeupdate,
+    onMouseIn,
+    onMouseOut
+  } = props;
+  const audioUrl = audio == null ? void 0 : audio.url;
+  const title = audio == null ? void 0 : audio.title;
+  const artist = audio == null ? void 0 : audio.artist;
+  const environment = useService(definitionExports.EnvironmentDefinition);
+  const isSSR = ((_a = environment == null ? void 0 : environment.isSSR) == null ? void 0 : _a.call(environment)) ?? false;
+  const fallbackInstanceId = useRef(
+    `audio-player-${Math.random().toString(36).slice(2)}`
+  );
+  const audioInstanceId = id ?? fallbackInstanceId.current;
+  const {
+    isPlaying,
+    currentTime,
+    duration,
+    currentVolume,
+    isMuted,
+    hasError,
+    togglePlay,
+    toggleMute,
+    seekTo,
+    setVolume
+  } = useAudioPlayer({
+    instanceId: audioInstanceId,
+    audioUrl,
+    loop,
+    volume,
+    onPlay: onPlayCallback,
+    onPause: onPauseCallback,
+    onEnded,
+    onTimeupdate
+  });
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      id,
+      ...direction && { dir: direction },
+      ...a11y && convertA11yKeysToHtmlFormat(a11y),
+      onMouseEnter: onMouseIn,
+      onMouseLeave: onMouseOut,
+      className: clsx(
+        selectors.root,
+        styles.root,
+        className,
+        directionStyles.fallbackDirection
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          Image3,
+          {
+            id: `${id}-cover`,
+            className: clsx(selectors.coverMedia, styles.coverMediaWrapper),
+            image: coverImage,
+            displayMode
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: clsx(selectors.audioTitle, styles.audioTitle), children: [
+          /* @__PURE__ */ jsx("span", { className: selectors.title, children: title }),
+          isSSR && /* @__PURE__ */ jsx(
+            "a",
+            {
+              href: audioUrl,
+              className: styles.seoLink,
+              "aria-hidden": "true",
+              tabIndex: -1,
+              children: title
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: clsx(selectors.artistName, styles.artistName), children: artist })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: clsx(selectors.controls, styles.controls), children: [
+          /* @__PURE__ */ jsx(
+            PlayButton,
+            {
+              isPlaying,
+              hasError,
+              onTogglePlay: togglePlay
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            ProgressSlider,
+            {
+              currentTime,
+              duration,
+              hasError,
+              onSeek: seekTo
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            VolumeControls,
+            {
+              currentVolume,
+              isMuted,
+              onToggleMute: toggleMute,
+              onVolumeChange: setVolume
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+export {
+  AudioPlayer as default
+};