osu-beatmap-renderer 0.1.0

package/dist/osu-beatmap-renderer.js

@@ -0,0 +1,2389 @@
+import * as PIXI from "pixi.js";
+import { Application, Assets } from "pixi.js";
+function parseOsuText(text) {
+  try {
+    const lines = text.split(/\r?\n/);
+    const result = {};
+    let currentSection = "";
+    let comboIndex = 0;
+    let comboColorIndex = 0;
+    lines.forEach((line) => {
+      if (line.startsWith("[") && line.endsWith("]")) {
+        currentSection = line.slice(1, -1);
+        result[currentSection] = currentSection === "Colours" ? [] : {};
+      } else {
+        if (currentSection === "TimingPoints" || currentSection === "HitObjects") {
+          if (currentSection === "TimingPoints") {
+            const timingPoint = line.split(",");
+            const offset = timingPoint[0];
+            const beatLength = timingPoint[1];
+            const meter = timingPoint[2];
+            const sampleset = parseInt(timingPoint[3]);
+            const sampleIndex = timingPoint[4];
+            const volume = timingPoint[5];
+            const inherited = timingPoint[6];
+            const kiai = timingPoint[7];
+            if (!offset || !beatLength) {
+              return;
+            }
+            if (!result[currentSection][offset]) {
+              result[currentSection][offset] = [];
+            }
+            if (!result[currentSection][offset][inherited]) {
+              result[currentSection][offset][inherited] = [];
+            }
+            result[currentSection][offset][inherited].push(beatLength);
+            result[currentSection][offset][inherited].push(sampleset);
+          } else {
+            const hitObject = line.split(",");
+            const x = hitObject[0];
+            const y = hitObject[1];
+            const time = hitObject[2];
+            const type = parseHitObjectType(hitObject[3]);
+            const hitSound = hitObject[4];
+            const extras = type.includes("Circle") ? hitObject[5] : hitObject.slice(5);
+            if (type.includes("New Combo")) {
+              comboIndex = 1;
+              comboColorIndex++;
+            }
+            const combo = comboIndex;
+            const comboColor = comboColorIndex;
+            var sliderInfo;
+            if (type.includes("Slider")) {
+              sliderInfo = parseSliderInfo(hitObject.slice(5));
+              sliderInfo.anchorPositions.unshift({
+                x: Number(x),
+                y: Number(y)
+              });
+            }
+            result[currentSection][time] = {
+              x,
+              y,
+              time,
+              type,
+              hitSound,
+              extras
+            };
+            result[currentSection][time].combo = combo;
+            result[currentSection][time].comboColor = comboColor;
+            result[currentSection][time].hitsound = {};
+            comboIndex++;
+            if (sliderInfo) {
+              result[currentSection][time].sliderInfo = sliderInfo;
+            }
+          }
+        } else {
+          if (!currentSection || !result[currentSection]) {
+            return;
+          }
+          const [key, value] = line.split(":").map((part) => part.trim());
+          if (key && value) {
+            if (value.includes(",")) {
+              result[currentSection][key] = value.split(",").map((v) => v.trim());
+            } else {
+              result[currentSection][key] = value;
+            }
+          }
+        }
+      }
+    });
+    if (!result["Difficulty"]["ApproachRate"]) {
+      result["Difficulty"]["ApproachRate"] = result["Difficulty"]["OverallDifficulty"];
+    }
+    return result;
+  } catch (error) {
+    console.error("Error parsing .osu text:", error);
+    return null;
+  }
+}
+async function fetchAndParseOsu(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const text = await response.text();
+    return parseOsuText(text);
+  } catch (error) {
+    console.error("Error downloading or parsing the file:", error);
+    return null;
+  }
+}
+function parseHitObjectType(type) {
+  const hitObjectTypes = {
+    0: "Circle",
+    1: "Slider",
+    2: "New Combo",
+    3: "Spinner"
+  };
+  let parsedTypes = [];
+  let typeValue = parseInt(type, 10);
+  if (typeValue & 1) parsedTypes.push(hitObjectTypes[0]);
+  if (typeValue & 2) parsedTypes.push(hitObjectTypes[1]);
+  if (typeValue & 4) parsedTypes.push(hitObjectTypes[2]);
+  if (typeValue & 8) parsedTypes.push(hitObjectTypes[3]);
+  return parsedTypes.length > 0 ? parsedTypes : "Unknown";
+}
+function parseSliderInfo(extras) {
+  const sliderInfo = extras[0];
+  const parts = sliderInfo.split("|");
+  const sliderType = parts[0];
+  const anchorPositions = parts.slice(1).map((pos) => {
+    const [x, y] = pos.split(":").map(Number);
+    return { x, y };
+  });
+  let deepCopyAnchorPositions = JSON.parse(
+    JSON.stringify(anchorPositions[anchorPositions.length - 1])
+  );
+  anchorPositions.push(deepCopyAnchorPositions);
+  const sliderRepeat = extras[1];
+  const sliderLength = extras[2];
+  const edgeSounds = extras[3];
+  const edgeSets = extras[4];
+  return {
+    sliderType,
+    sliderRepeat,
+    sliderLength,
+    anchorPositions,
+    edgeSounds,
+    edgeSets
+  };
+}
+const DEFAULT_BUNDLED_ASSET_BASE = "https://raw.githubusercontent.com/inix1257/osu-beatmap-renderer/main/assets";
+const HITSOUND_SAMPLE_FILES = [
+  "normal-hitnormal.wav",
+  "normal-hitwhistle.wav",
+  "normal-hitfinish.wav",
+  "normal-hitclap.wav",
+  "soft-hitnormal.wav",
+  "soft-hitwhistle.wav",
+  "soft-hitfinish.wav",
+  "soft-hitclap.wav",
+  "drum-hitnormal.wav",
+  "drum-hitwhistle.wav",
+  "drum-hitfinish.wav",
+  "drum-hitclap.wav"
+];
+function lowerBound$1(arr, target) {
+  let left = 0;
+  let right = arr.length;
+  while (left < right) {
+    const mid = left + right >> 1;
+    if (arr[mid] < target) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  return left;
+}
+function fileBaseName(file) {
+  return file.replace(/\.[^/.]+$/, "");
+}
+class HitsoundPlayer {
+  constructor({
+    hitsoundVolume = 0.3,
+    schedulerIntervalMs = 20,
+    schedulerLookaheadMs = 120,
+    assetBaseUrl = DEFAULT_BUNDLED_ASSET_BASE
+  } = {}) {
+    this.hitsoundVolume = hitsoundVolume;
+    this.assetBaseUrl = assetBaseUrl.replace(/\/$/, "");
+    this.schedulerIntervalMs = schedulerIntervalMs;
+    this.schedulerLookaheadMs = schedulerLookaheadMs;
+    this.audioContext = null;
+    this.hitsoundBuffers = /* @__PURE__ */ new Map();
+    this.schedulerTimer = null;
+    this.hitsoundEvents = [];
+    this.hitsoundEventTimes = [];
+    this.hitsoundEventCursor = 0;
+    this.activeScheduledSources = /* @__PURE__ */ new Set();
+    this.isPlayingRef = () => false;
+    this.getTransportCurrentTimeMsRef = () => 0;
+  }
+  async init() {
+    try {
+      this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      await Promise.all(
+        HITSOUND_SAMPLE_FILES.map(async (file) => {
+          const name = fileBaseName(file);
+          const url = `${this.assetBaseUrl}/${file}`;
+          const response = await fetch(url);
+          if (!response.ok) {
+            throw new Error(`Hitsound fetch failed ${response.status}: ${url}`);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const audioBuffer = await this.audioContext.decodeAudioData(
+            arrayBuffer.slice(0)
+          );
+          this.hitsoundBuffers.set(name, audioBuffer);
+        })
+      );
+    } catch (_error) {
+      this.hitsoundBuffers.clear();
+    }
+  }
+  destroy() {
+    this.stopScheduler();
+    this.clearScheduledSources();
+    if (this.audioContext) {
+      this.audioContext.close().catch(() => {
+      });
+      this.audioContext = null;
+    }
+    this.hitsoundBuffers.clear();
+    this.hitsoundEvents = [];
+    this.hitsoundEventTimes = [];
+    this.hitsoundEventCursor = 0;
+  }
+  setVolume(volume) {
+    const v = Math.max(0, Math.min(1, Number(volume) || 0));
+    this.hitsoundVolume = v;
+  }
+  buildHitsoundEvents(hitObjectEntries, { getCachedTimingPoint, getSliderDurationCached, getHitObjectEndTime }) {
+    this.hitsoundEvents = [];
+    for (const [hitTime, hitObject] of hitObjectEntries) {
+      const timingPoint = getCachedTimingPoint(hitTime);
+      if (!timingPoint) continue;
+      if (hitObject.type.includes("Slider")) {
+        const sliderDuration = getSliderDurationCached(hitObject, hitTime);
+        const sliderInfo = hitObject.sliderInfo;
+        const repeat = Number(sliderInfo?.sliderRepeat || 1);
+        this.hitsoundEvents.push(
+          this.resolveSliderEdgeEvent(
+            hitObject,
+            timingPoint,
+            hitTime,
+            0,
+            hitTime
+          )
+        );
+        for (let i = 1; i < repeat; i++) {
+          const repeatTime = hitTime + sliderDuration * i / repeat;
+          this.hitsoundEvents.push(
+            this.resolveSliderEdgeEvent(
+              hitObject,
+              timingPoint,
+              hitTime,
+              i,
+              repeatTime
+            )
+          );
+        }
+        const endTime = hitTime + sliderDuration;
+        this.hitsoundEvents.push(
+          this.resolveSliderEdgeEvent(
+            hitObject,
+            timingPoint,
+            hitTime,
+            repeat,
+            endTime
+          )
+        );
+      } else if (hitObject.type.includes("Spinner")) {
+        this.hitsoundEvents.push(
+          this.resolveSpinnerEndEvent(
+            hitObject,
+            timingPoint,
+            hitTime,
+            getHitObjectEndTime
+          )
+        );
+      } else {
+        this.hitsoundEvents.push(
+          this.resolveCircleEvent(hitObject, timingPoint, hitTime)
+        );
+      }
+    }
+    this.hitsoundEvents = this.hitsoundEvents.filter((e) => e && Number.isFinite(e.time)).sort((a, b) => a.time - b.time);
+    this.hitsoundEventTimes = this.hitsoundEvents.map((e) => e.time);
+    this.hitsoundEventCursor = 0;
+  }
+  startScheduler({ isPlaying, getTransportCurrentTimeMs }) {
+    if (this.schedulerTimer) return;
+    this.isPlayingRef = isPlaying;
+    this.getTransportCurrentTimeMsRef = getTransportCurrentTimeMs;
+    this.tickScheduler();
+    this.schedulerTimer = window.setInterval(
+      () => this.tickScheduler(),
+      this.schedulerIntervalMs
+    );
+  }
+  stopScheduler() {
+    if (!this.schedulerTimer) return;
+    window.clearInterval(this.schedulerTimer);
+    this.schedulerTimer = null;
+  }
+  tickScheduler() {
+    if (!this.isPlayingRef() || !this.audioContext || this.hitsoundEvents.length === 0)
+      return;
+    if (this.audioContext.state === "suspended") return;
+    const transportNow = this.getTransportCurrentTimeMsRef();
+    const scheduleUntil = transportNow + this.schedulerLookaheadMs;
+    while (this.hitsoundEventCursor < this.hitsoundEvents.length) {
+      const event = this.hitsoundEvents[this.hitsoundEventCursor];
+      if (event.time > scheduleUntil) break;
+      if (event.time >= transportNow - 25) {
+        const when = this.audioContext.currentTime + Math.max(0, (event.time - transportNow) / 1e3);
+        this.playHitsoundAt(
+          event.normalSet,
+          event.additionSet,
+          event.hitsound,
+          when
+        );
+      }
+      this.hitsoundEventCursor += 1;
+    }
+  }
+  resetFromCurrentTime(currentTime) {
+    this.clearScheduledSources();
+    this.hitsoundEventCursor = lowerBound$1(this.hitsoundEventTimes, currentTime);
+  }
+  clearScheduledSources() {
+    for (const source of this.activeScheduledSources) {
+      try {
+        source.stop();
+      } catch (_e) {
+      }
+    }
+    this.activeScheduledSources.clear();
+  }
+  playHitsoundAt(normalset, additionSet, hitsound, when) {
+    const normal = Number.parseInt(normalset, 10);
+    let addition = Number.parseInt(additionSet, 10);
+    const soundMask = Number.parseInt(hitsound, 10);
+    if (Number.isNaN(normal) || Number.isNaN(soundMask)) return;
+    if (normal === 1) this.playHitsoundBufferAt("normal-hitnormal", when);
+    if (normal === 2) this.playHitsoundBufferAt("soft-hitnormal", when);
+    if (normal === 3) this.playHitsoundBufferAt("drum-hitnormal", when);
+    if (addition === 0) addition = normal;
+    if (addition === 1) {
+      if (soundMask & 2) this.playHitsoundBufferAt("normal-hitwhistle", when);
+      if (soundMask & 4) this.playHitsoundBufferAt("normal-hitfinish", when);
+      if (soundMask & 8) this.playHitsoundBufferAt("normal-hitclap", when);
+    }
+    if (addition === 2) {
+      if (soundMask & 2) this.playHitsoundBufferAt("soft-hitwhistle", when);
+      if (soundMask & 4) this.playHitsoundBufferAt("soft-hitfinish", when);
+      if (soundMask & 8) this.playHitsoundBufferAt("soft-hitclap", when);
+    }
+    if (addition === 3) {
+      if (soundMask & 2) this.playHitsoundBufferAt("drum-hitwhistle", when);
+      if (soundMask & 4) this.playHitsoundBufferAt("drum-hitfinish", when);
+      if (soundMask & 8) this.playHitsoundBufferAt("drum-hitclap", when);
+    }
+  }
+  playHitsoundBufferAt(key, when) {
+    if (!this.audioContext || !this.hitsoundBuffers.has(key)) return;
+    const source = this.audioContext.createBufferSource();
+    const gain = this.audioContext.createGain();
+    gain.gain.value = this.hitsoundVolume;
+    source.buffer = this.hitsoundBuffers.get(key);
+    source.connect(gain);
+    gain.connect(this.audioContext.destination);
+    source.onended = () => {
+      this.activeScheduledSources.delete(source);
+    };
+    this.activeScheduledSources.add(source);
+    source.start(when);
+  }
+  resolveCircleEvent(hitObject, timingPoint, hitTime) {
+    const extrasParts = this.getDelimitedParts(hitObject?.extras, ":");
+    const rawNormalSet = extrasParts[0];
+    const rawAdditionSet = extrasParts[1];
+    const normalSet = rawNormalSet && rawNormalSet !== "0" ? rawNormalSet : String(timingPoint.sampleSet || 1);
+    const additionSet = rawAdditionSet && rawAdditionSet !== "0" ? rawAdditionSet : normalSet;
+    return {
+      time: hitTime,
+      normalSet,
+      additionSet,
+      hitsound: String(hitObject.hitSound || "0")
+    };
+  }
+  resolveSliderEdgeEvent(hitObject, timingPoint, _hitTime, edgeIndex, eventTime) {
+    const sliderInfo = hitObject.sliderInfo;
+    if (sliderInfo?.edgeSounds && sliderInfo?.edgeSets) {
+      const edgeSounds = this.getDelimitedParts(sliderInfo.edgeSounds, "|");
+      const edgeSets = this.getDelimitedParts(sliderInfo.edgeSets, "|");
+      const hitsound = edgeSounds[edgeIndex] || "0";
+      const edgeSetParts = this.getDelimitedParts(
+        edgeSets[edgeIndex] || "0:0",
+        ":"
+      );
+      const normalSet = edgeSetParts[0] === "0" ? String(timingPoint.sampleSet || 1) : edgeSetParts[0] || String(timingPoint.sampleSet || 1);
+      const additionSet = edgeSetParts[1] === "0" ? normalSet : edgeSetParts[1] || normalSet;
+      return { time: eventTime, normalSet, additionSet, hitsound };
+    }
+    const set = String(timingPoint.sampleSet || 1);
+    return { time: eventTime, normalSet: set, additionSet: set, hitsound: "0" };
+  }
+  resolveSpinnerEndEvent(hitObject, timingPoint, hitTime, getHitObjectEndTime) {
+    const spinnerEndTime = getHitObjectEndTime(hitObject, hitTime);
+    const extras = hitObject?.extras;
+    const hitSampleRaw = Array.isArray(extras) ? extras[1] : null;
+    const hitSampleParts = this.getDelimitedParts(hitSampleRaw, ":");
+    const rawNormalSet = hitSampleParts[0];
+    const rawAdditionSet = hitSampleParts[1];
+    const normalSet = rawNormalSet && rawNormalSet !== "0" ? rawNormalSet : String(timingPoint.sampleSet || 1);
+    const additionSet = rawAdditionSet && rawAdditionSet !== "0" ? rawAdditionSet : normalSet;
+    return {
+      time: spinnerEndTime,
+      normalSet,
+      additionSet,
+      hitsound: String(hitObject.hitSound || "0")
+    };
+  }
+  getDelimitedParts(value, delimiter) {
+    if (typeof value === "string") {
+      return value.split(delimiter);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => String(item ?? ""));
+    }
+    if (value == null) {
+      return [];
+    }
+    return String(value).split(delimiter);
+  }
+}
+class PathPoint {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  static compare(point1, point2) {
+    return point1.x === point2.x && point1.y === point2.y;
+  }
+}
+class Bezier {
+  constructor() {
+    this.arrPn = [];
+    this.mu = 0;
+    this.resultPoint = new PathPoint();
+    this.initResultPoint();
+    this.arcLength = 0;
+    this.arcLengthTable = [];
+  }
+  setBezierN(arrPn) {
+    this.arrPn = arrPn.slice();
+    this.calculateArcLength();
+  }
+  bezierCalc() {
+    let k, kn, nn, nkn;
+    let blend, muk, munk;
+    const n = this.arrPn.length - 1;
+    this.initResultPoint();
+    muk = 1;
+    munk = Math.pow(1 - this.mu, n);
+    for (k = 0; k <= n; k++) {
+      nn = n;
+      kn = k;
+      nkn = n - k;
+      blend = muk * munk;
+      muk *= this.mu;
+      munk /= 1 - this.mu;
+      while (nn >= 1) {
+        blend *= nn;
+        nn--;
+        if (kn > 1) {
+          blend /= kn;
+          kn--;
+        }
+        if (nkn > 1) {
+          blend /= nkn;
+          nkn--;
+        }
+      }
+      this.resultPoint.x += this.arrPn[k].x * blend;
+      this.resultPoint.y += this.arrPn[k].y * blend;
+    }
+  }
+  initResultPoint() {
+    this.resultPoint.x = 0;
+    this.resultPoint.y = 0;
+  }
+  setMu(mu) {
+    this.mu = mu;
+  }
+  getResult() {
+    return this.resultPoint;
+  }
+  calculateArcLength() {
+    this.arcLength = 0;
+    this.arcLengthTable = [];
+    let prevPoint = this.arrPn[0];
+    for (let t = 0; t <= 1; t += 0.01) {
+      this.setMu(t);
+      this.bezierCalc();
+      const currPoint = this.getResult();
+      const segmentLength = Math.sqrt(Math.pow(currPoint.x - prevPoint.x, 2) + Math.pow(currPoint.y - prevPoint.y, 2));
+      this.arcLength += segmentLength;
+      this.arcLengthTable.push({ t, length: this.arcLength });
+      prevPoint = { ...currPoint };
+    }
+  }
+  getMuForArcLength(targetLength) {
+    for (let i = 0; i < this.arcLengthTable.length - 1; i++) {
+      const curr = this.arcLengthTable[i];
+      const next = this.arcLengthTable[i + 1];
+      if (targetLength >= curr.length && targetLength <= next.length) {
+        const ratio = (targetLength - curr.length) / (next.length - curr.length);
+        return curr.t + ratio * (next.t - curr.t);
+      }
+    }
+    return 1;
+  }
+}
+function getTimingPointAt(givenTime, beatmap) {
+  const timingPoints = beatmap["TimingPoints"];
+  let closestBPM = null;
+  let closestSV = null;
+  let sampleSet = null;
+  Object.entries(timingPoints).forEach(([time, beatLengths]) => {
+    const timeInt = parseInt(time);
+    beatLengths.forEach((beatLength) => {
+      const beatLengthValue = parseFloat(beatLength[0]);
+      if (!sampleSet) sampleSet = parseInt(beatLength[1]);
+      if (timeInt <= givenTime) {
+        if (beatLengthValue > 0) {
+          const bpm = 6e4 / beatLengthValue;
+          if (!closestBPM || timeInt > closestBPM.time) {
+            closestBPM = { time: timeInt, bpm, beatLengthValue };
+          }
+        } else {
+          if (!closestSV || timeInt > closestSV.time) {
+            closestSV = { time: timeInt, sv: beatLengthValue };
+            sampleSet = parseInt(beatLength[1]);
+          }
+        }
+      }
+    });
+  });
+  return { closestBPM, closestSV, sampleSet };
+}
+function getFollowPosition(hitObject, hitTime, currentTime, grid_unit) {
+  const rawProgress = (currentTime - hitTime) / hitObject.sliderDuration * hitObject.sliderRepeat;
+  let sliderInfo = hitObject.sliderInfo;
+  if (!sliderInfo || !sliderInfo.anchorPositions || sliderInfo.anchorPositions.length === 0) {
+    return {
+      x: sliderInfo?.anchorPositions?.[0]?.x || hitObject.hitCircleSprite?.x || 0,
+      y: sliderInfo?.anchorPositions?.[0]?.y || hitObject.hitCircleSprite?.y || 0
+    };
+  }
+  const maxProgress = Number(hitObject.sliderRepeat) || 0;
+  const clampedProgress = Math.max(0, Math.min(maxProgress, rawProgress));
+  let wrappedProgress = clampedProgress % 2;
+  if (wrappedProgress < 0) {
+    wrappedProgress += 2;
+  }
+  const sliderProgress = wrappedProgress > 1 ? 2 - wrappedProgress : wrappedProgress;
+  let anchorPositions = sliderInfo.anchorPositions;
+  const targetLength = sliderProgress * (hitObject.sliderLength * grid_unit);
+  const startPos = anchorPositions[0];
+  const endPos = sliderInfo.sliderEndPos || anchorPositions[anchorPositions.length - 1] || startPos;
+  const EDGE_EPSILON = 1e-4;
+  if (sliderProgress <= EDGE_EPSILON) {
+    return { x: startPos.x, y: startPos.y };
+  }
+  if (sliderProgress >= 1 - EDGE_EPSILON) {
+    return { x: endPos.x, y: endPos.y };
+  }
+  let position = {
+    x: startPos.x,
+    y: startPos.y
+  };
+  let accumulatedLength = 0;
+  switch (sliderInfo.sliderType) {
+    case "P": {
+      try {
+        const circleCenter = getCircleCenter(
+          anchorPositions[0],
+          anchorPositions[1],
+          anchorPositions[2]
+        );
+        const radius = Math.sqrt(
+          Math.pow(circleCenter.x - anchorPositions[0].x, 2) + Math.pow(circleCenter.y - anchorPositions[0].y, 2)
+        );
+        let yDeltaA = anchorPositions[1].y - anchorPositions[0].y;
+        let xDeltaA = anchorPositions[1].x - anchorPositions[0].x;
+        let yDeltaB = anchorPositions[2].y - anchorPositions[1].y;
+        let xDeltaB = anchorPositions[2].x - anchorPositions[1].x;
+        const angleA = Math.atan2(
+          anchorPositions[0].y - circleCenter.y,
+          anchorPositions[0].x - circleCenter.x
+        );
+        const angleC = Math.atan2(
+          anchorPositions[2].y - circleCenter.y,
+          anchorPositions[2].x - circleCenter.x
+        );
+        const anticlockwise = xDeltaB * yDeltaA - xDeltaA * yDeltaB > 0;
+        const startAngle = angleA;
+        let endAngle = angleC;
+        if (!anticlockwise && endAngle - startAngle < 0) {
+          endAngle += 2 * Math.PI;
+        }
+        if (anticlockwise && endAngle - startAngle > 0) {
+          endAngle -= 2 * Math.PI;
+        }
+        let angleStep = (endAngle - startAngle) / 100;
+        let prevX = anchorPositions[0].x;
+        let prevY = anchorPositions[0].y;
+        let totalLength = 0;
+        for (let i = 0; i <= 100; i++) {
+          const currentAngle = startAngle + angleStep * i;
+          const x = circleCenter.x + radius * Math.cos(currentAngle);
+          const y = circleCenter.y + radius * Math.sin(currentAngle);
+          if (i > 0) {
+            totalLength += Math.sqrt(
+              Math.pow(Math.abs(x - prevX), 2) + Math.pow(Math.abs(y - prevY), 2)
+            );
+            if (totalLength >= targetLength) {
+              position = { x, y };
+              return position;
+            }
+          }
+          prevX = x;
+          prevY = y;
+        }
+        position = { x: prevX, y: prevY };
+      } catch (e) {
+        console.error("Error calculating perfect curve position", e);
+      }
+      break;
+    }
+    default: {
+      try {
+        let arrPn = [];
+        let bezier = new Bezier();
+        arrPn.push(new PathPoint(anchorPositions[0].x, anchorPositions[0].y));
+        for (let i = 1; i < anchorPositions.length; i++) {
+          let prevPos = anchorPositions[i - 1];
+          let currPos = anchorPositions[i];
+          if (i === anchorPositions.length - 1 || PathPoint.compare(prevPos, currPos)) {
+            if (i === anchorPositions.length - 1) {
+              let p = new PathPoint();
+              p.x = anchorPositions[i].x;
+              p.y = anchorPositions[i].y;
+              arrPn.push(p);
+            }
+            bezier.setBezierN(arrPn);
+            const segmentLength = bezier.arcLength;
+            if (accumulatedLength + segmentLength >= targetLength) {
+              const segmentTargetLength = targetLength - accumulatedLength;
+              const mu = bezier.getMuForArcLength(segmentTargetLength);
+              bezier.setMu(mu);
+              bezier.bezierCalc();
+              const result = bezier.getResult();
+              if (result && result.x !== void 0 && result.y !== void 0) {
+                position = result;
+                break;
+              }
+            }
+            accumulatedLength += segmentLength;
+            arrPn = [];
+            bezier = new Bezier();
+            if (i < anchorPositions.length - 1) {
+              let p = new PathPoint();
+              p.x = prevPos.x;
+              p.y = prevPos.y;
+              arrPn.push(p);
+            }
+          } else {
+            let p = new PathPoint();
+            p.x = anchorPositions[i].x;
+            p.y = anchorPositions[i].y;
+            arrPn.push(p);
+          }
+        }
+      } catch (e) {
+        console.error("Error calculating bezier curve position", e);
+      }
+      if (!Number.isFinite(position.x) || !Number.isFinite(position.y) || position.x === startPos.x && position.y === startPos.y && sliderProgress > 0.5) {
+        position = sliderProgress > 0.5 ? { x: endPos.x, y: endPos.y } : { x: startPos.x, y: startPos.y };
+      }
+      break;
+    }
+  }
+  return position;
+}
+function getCircleCenter(p1, p2, p3) {
+  const mid1 = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
+  const mid2 = { x: (p2.x + p3.x) / 2, y: (p2.y + p3.y) / 2 };
+  const slope1 = (p2.y - p1.y) / (p2.x - p1.x);
+  const slope2 = (p3.y - p2.y) / (p3.x - p2.x);
+  let perpSlope1 = -1 / slope1;
+  let perpSlope2 = -1 / slope2;
+  if (p1.x === p2.x) {
+    perpSlope1 = 0;
+  }
+  if (p2.x === p3.x) {
+    perpSlope2 = 0;
+  }
+  if (p1.y === p2.y) {
+    perpSlope1 = -1e3;
+  }
+  if (p2.y === p3.y) {
+    perpSlope2 = -1e3;
+  }
+  const centerX = (perpSlope1 * mid1.x - perpSlope2 * mid2.x + mid2.y - mid1.y) / (perpSlope1 - perpSlope2);
+  const centerY = perpSlope1 * (centerX - mid1.x) + mid1.y;
+  return { x: centerX, y: centerY };
+}
+function getReverseArrowAngle(sliderInfo) {
+  const anchorPositions = sliderInfo.anchorPositions;
+  const endPos = sliderInfo.sliderEndPos;
+  if (!anchorPositions || anchorPositions.length < 2 || !endPos) {
+    return 0;
+  }
+  const secondLastPoint = anchorPositions[Math.max(0, anchorPositions.length - 2)];
+  return Math.atan2(secondLastPoint.y - endPos.y, secondLastPoint.x - endPos.x) + Math.PI;
+}
+function bezierCurve(sliderInfo, layout) {
+  const anchorPositions = sliderInfo.anchorPositions;
+  if (!sliderInfo.adjusted) {
+    adjustAnchorPositions(anchorPositions, layout);
+    sliderInfo.adjusted = true;
+  }
+  const sliderTotalLength = Number(sliderInfo.sliderLength) * layout.gridUnit;
+  let totalLength = 0;
+  let arrPn = [new PathPoint(anchorPositions[0].x, anchorPositions[0].y)];
+  let bezier = new Bezier();
+  const sliderPath = new PIXI.Graphics();
+  sliderPath.moveTo(anchorPositions[0].x, anchorPositions[0].y);
+  for (let i = 1; i < anchorPositions.length; i++) {
+    const prevPos = anchorPositions[i - 1];
+    const currPos = anchorPositions[i];
+    if (i === anchorPositions.length - 1 || PathPoint.compare(prevPos, currPos)) {
+      if (i === anchorPositions.length - 1) {
+        arrPn.push(new PathPoint(anchorPositions[i].x, anchorPositions[i].y));
+      }
+      bezier.setBezierN(arrPn);
+      const muGap = 10 / Math.max(1, sliderTotalLength);
+      const startP = new PathPoint();
+      const endP = new PathPoint();
+      for (let mu = 0; mu <= 1; mu += muGap) {
+        startP.x = bezier.getResult().x;
+        startP.y = bezier.getResult().y;
+        bezier.setMu(mu);
+        bezier.bezierCalc();
+        endP.x = bezier.getResult().x;
+        endP.y = bezier.getResult().y;
+        sliderInfo.sliderEndPos = startP;
+        if (Number.isFinite(endP.x) && Number.isFinite(endP.y)) {
+          sliderPath.lineTo(endP.x, endP.y);
+          sliderInfo.sliderEndPos = endP;
+        }
+        if (mu === 0) continue;
+        totalLength += Math.hypot(startP.x - endP.x, startP.y - endP.y);
+        if (totalLength >= sliderTotalLength) break;
+      }
+      arrPn = [];
+      bezier = new Bezier();
+      if (i < anchorPositions.length - 1) {
+        arrPn.push(new PathPoint(prevPos.x, prevPos.y));
+      } else {
+        arrPn.push(new PathPoint(currPos.x, currPos.y));
+      }
+    }
+    arrPn.push(new PathPoint(anchorPositions[i].x, anchorPositions[i].y));
+  }
+  return sliderPath;
+}
+function perfectCurve(sliderInfo, layout) {
+  const anchorPositions = sliderInfo.anchorPositions;
+  if (!sliderInfo.adjusted) {
+    adjustAnchorPositions(anchorPositions, layout);
+    sliderInfo.adjusted = true;
+  }
+  const sliderTotalLength = Number(sliderInfo.sliderLength) * layout.gridUnit;
+  let totalLength = 0;
+  const sliderPath = new PIXI.Graphics();
+  sliderPath.moveTo(anchorPositions[0].x, anchorPositions[0].y);
+  const circleCenter = getCircleCenter(anchorPositions[0], anchorPositions[1], anchorPositions[2]);
+  const radius = Math.hypot(circleCenter.x - anchorPositions[0].x, circleCenter.y - anchorPositions[0].y);
+  const angleA = Math.atan2(anchorPositions[0].y - circleCenter.y, anchorPositions[0].x - circleCenter.x);
+  const angleC = Math.atan2(anchorPositions[2].y - circleCenter.y, anchorPositions[2].x - circleCenter.x);
+  const yDeltaA = anchorPositions[1].y - anchorPositions[0].y;
+  const xDeltaA = anchorPositions[1].x - anchorPositions[0].x;
+  const yDeltaB = anchorPositions[2].y - anchorPositions[1].y;
+  const xDeltaB = anchorPositions[2].x - anchorPositions[1].x;
+  const anticlockwise = xDeltaB * yDeltaA - xDeltaA * yDeltaB > 0;
+  const startAngle = angleA;
+  let endAngle = angleC;
+  if (!anticlockwise && endAngle - startAngle < 0) endAngle += Math.PI * 2;
+  if (anticlockwise && endAngle - startAngle > 0) endAngle -= Math.PI * 2;
+  const angleStep = (endAngle - startAngle) / 100;
+  let prevX;
+  let prevY;
+  for (let i = 0; i <= 100; i++) {
+    const angle = startAngle + angleStep * i;
+    const x = circleCenter.x + radius * Math.cos(angle);
+    const y = circleCenter.y + radius * Math.sin(angle);
+    sliderPath.lineTo(x, y);
+    if (i !== 0) {
+      totalLength += Math.hypot(x - prevX, y - prevY);
+      if (totalLength >= sliderTotalLength) {
+        prevX = x;
+        prevY = y;
+        break;
+      }
+    }
+    prevX = x;
+    prevY = y;
+  }
+  sliderInfo.sliderEndPos = { x: prevX, y: prevY };
+  return sliderPath;
+}
+function adjustAnchorPositions(anchorPositions, layout) {
+  for (const anchor of anchorPositions) {
+    anchor.x = layout.topLeftX + anchor.x * layout.gridUnit;
+    anchor.y = layout.topLeftY + anchor.y * layout.gridUnit;
+  }
+}
+const DEFAULT_AUDIO_OFFSET_MS = 200;
+let globalAudioOffsetMs = DEFAULT_AUDIO_OFFSET_MS;
+const listeners = /* @__PURE__ */ new Set();
+function getGlobalAudioOffsetMs() {
+  return globalAudioOffsetMs;
+}
+function setGlobalAudioOffsetMs(ms) {
+  const next = Number(ms) || 0;
+  if (next === globalAudioOffsetMs) {
+    return;
+  }
+  globalAudioOffsetMs = next;
+  for (const listener of listeners) {
+    listener(globalAudioOffsetMs);
+  }
+}
+function subscribeGlobalAudioOffset(listener) {
+  if (typeof listener !== "function") {
+    return () => {
+    };
+  }
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+const BASE_WIDTH = 1280;
+const BASE_HEIGHT = 720;
+const BASE_ASPECT_RATIO = BASE_WIDTH / BASE_HEIGHT;
+const LOOKBACK_MS = 1e4;
+const LOOKAHEAD_MS = 200;
+const FADE_OUT_MS = 250;
+const AUDIO_SYNC_SAMPLE_INTERVAL_MS = 200;
+const SLIDER_BODY_ALPHA = 0.9;
+const APPROACH_CIRCLE_Z_BASE = 1e9;
+const SLIDER_BODY_DARKEN_FACTOR = 0.7;
+const SLIDER_RT_OVERSAMPLE = 2;
+class BeatmapEngine {
+  /**
+   * @param {HTMLElement|string} container - DOM element or element ID to mount the renderer into.
+   * @param {object} [options]
+   * @param {string} [options.baseUrl=''] - Base URL prefix for legacy updateBeatmap/updateBeatmapBypass
+   *   token-based endpoints (e.g. '' for same-origin, 'https://example.com').
+   * @param {string} [options.assetBaseUrl] - Base URL for bundled skin/hitsound assets (default: GitHub raw `assets/`).
+   * @param {number} [options.audioOffsetMs] - Initial audio offset in ms (default: global value from AudioTimingConfig).
+   */
+  constructor(container, options = {}) {
+    if (typeof container === "string") {
+      this.containerEl = document.getElementById(container);
+      if (!this.containerEl) {
+        throw new Error(`Container element not found: ${container}`);
+      }
+    } else if (container instanceof HTMLElement) {
+      this.containerEl = container;
+    } else {
+      throw new Error(
+        "BeatmapEngine requires an HTMLElement or element ID as first argument"
+      );
+    }
+    this.baseUrl = options.baseUrl ?? "";
+    this.assetBaseUrl = options.assetBaseUrl ?? DEFAULT_BUNDLED_ASSET_BASE;
+    this.app = null;
+    this.textures = null;
+    this.backgroundSprite = null;
+    this.resizeHandler = () => this.resize();
+    this.beatmap = null;
+    this.hitObjectEntries = [];
+    this.hitObjectTimes = [];
+    this.activeHitObjects = /* @__PURE__ */ new Set();
+    this.timingPointCache = /* @__PURE__ */ new Map();
+    this.currentLayout = null;
+    this.hitsoundPlayer = null;
+    this.audioContext = null;
+    this.musicVolume = 0.3;
+    this.hitsoundVolume = 0.3;
+    this.transportStartMs = 0;
+    this.transportStartPerfTime = 0;
+    this.transportStartAudioTime = 0;
+    this.currentTime = 0;
+    this.isPlaying = false;
+    this.resumeOnGestureListenerAttached = false;
+    this.lastTickTime = null;
+    this.previewAudio = null;
+    this.beatmapDurationMs = 0;
+    this.previewTimeMs = 0;
+    this.audioOffsetMs = options.audioOffsetMs !== void 0 ? Number(options.audioOffsetMs) || 0 : getGlobalAudioOffsetMs();
+    this.audioSyncOffsetMs = 0;
+    this.lastAudioSyncSamplePerfMs = 0;
+  }
+  async init() {
+    const { width, height } = this.getDisplayDimensions();
+    const dpr = Math.max(1, window.devicePixelRatio || 1);
+    this.app = new Application();
+    await this.app.init({
+      background: "#000000",
+      width,
+      height,
+      antialias: true,
+      resolution: dpr,
+      autoDensity: true
+    });
+    this.app.stage.sortableChildren = true;
+    this.containerEl.innerHTML = "";
+    this.containerEl.appendChild(this.app.canvas);
+    this.backgroundSprite = new PIXI.Sprite();
+    this.backgroundSprite.zIndex = -999999;
+    this.app.stage.addChild(this.backgroundSprite);
+    this.textures = await this.loadAssets();
+    this.hitsoundPlayer = new HitsoundPlayer({
+      hitsoundVolume: this.hitsoundVolume,
+      assetBaseUrl: this.assetBaseUrl
+    });
+    await this.hitsoundPlayer.init();
+    this.audioContext = this.hitsoundPlayer.audioContext;
+    window.addEventListener("resize", this.resizeHandler);
+    this.app.ticker.add(() => this.updateFrame());
+    this.resize();
+  }
+  destroy() {
+    window.removeEventListener("resize", this.resizeHandler);
+    this.pause();
+    this.hitsoundPlayer?.destroy();
+    this.hitsoundPlayer = null;
+    if (this.previewAudio) {
+      this.previewAudio.pause();
+      this.previewAudio.src = "";
+      this.previewAudio = null;
+    }
+    if (this.app) {
+      this.app.ticker.stop();
+      this.app.destroy(true, { children: true, texture: false });
+      this.app = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Beatmap loading
+  // ---------------------------------------------------------------------------
+  /**
+   * Load a beatmap from various sources.
+   *
+   * @param {object} params
+   * @param {string} [params.osuText]       - Raw .osu file content (preferred).
+   * @param {string} [params.osuUrl]        - URL to fetch the .osu file from.
+   * @param {string} [params.audioUrl]      - URL for the audio track.
+   * @param {string} [params.backgroundUrl] - URL for the background image.
+   */
+  async loadBeatmap({ osuText, osuUrl, audioUrl, backgroundUrl } = {}) {
+    this.pause();
+    this.setCurrentTime(0);
+    if (osuText) {
+      this.beatmap = parseOsuText(osuText);
+    } else if (osuUrl) {
+      this.beatmap = await fetchAndParseOsu(osuUrl);
+    } else {
+      throw new Error("Either osuText or osuUrl must be provided");
+    }
+    this.rebuildHitObjectCache();
+    if (backgroundUrl) {
+      await this.updateBackgroundFromUrl(backgroundUrl);
+    }
+    if (audioUrl) {
+      this.updateAudioTrackFromUrl(audioUrl);
+    }
+    const previewTime = Number.parseInt(
+      this.beatmap?.General?.PreviewTime || "0",
+      10
+    );
+    const safePreviewTime = Number.isFinite(previewTime) ? Math.max(0, previewTime) : 0;
+    this.previewTimeMs = safePreviewTime;
+    this.setCurrentTime(safePreviewTime);
+  }
+  /**
+   * Legacy method for omqWeb: load beatmap using token-based endpoints.
+   * Requires baseUrl to be set in constructor options if running cross-origin.
+   */
+  async updateBeatmap(beatmapId, imageToken = beatmapId, audioToken = beatmapId) {
+    this.pause();
+    this.setCurrentTime(0);
+    this.beatmap = await fetchAndParseOsu(
+      `${this.baseUrl}/beatmap/${beatmapId}`
+    );
+    this.rebuildHitObjectCache();
+    await this.updateBackgroundFromUrl(
+      `${this.baseUrl}/image/${imageToken}`
+    );
+    if (audioToken) {
+      this.updateAudioTrackFromUrl(`${this.baseUrl}/audio/${audioToken}`);
+    }
+    const previewTime = Number.parseInt(
+      this.beatmap?.General?.PreviewTime || "0",
+      10
+    );
+    const safePreviewTime = Number.isFinite(previewTime) ? Math.max(0, previewTime) : 0;
+    this.previewTimeMs = safePreviewTime;
+    this.setCurrentTime(safePreviewTime);
+  }
+  /**
+   * Legacy method for omqWeb debug: load beatmap bypassing normal endpoint.
+   */
+  async updateBeatmapBypass(beatmapId) {
+    this.pause();
+    this.setCurrentTime(0);
+    this.beatmap = await fetchAndParseOsu(
+      `${this.baseUrl}/beatmapbp/${beatmapId}`
+    );
+    this.rebuildHitObjectCache();
+    const previewTime = Number.parseInt(
+      this.beatmap?.General?.PreviewTime || "0",
+      10
+    );
+    const safePreviewTime = Number.isFinite(previewTime) ? Math.max(0, previewTime) : 0;
+    this.previewTimeMs = safePreviewTime;
+    this.setCurrentTime(safePreviewTime);
+  }
+  // ---------------------------------------------------------------------------
+  // Audio
+  // ---------------------------------------------------------------------------
+  updateAudioTrackFromUrl(audioUrl) {
+    if (this.previewAudio) {
+      this.previewAudio.pause();
+      this.previewAudio.src = "";
+    }
+    this.previewAudio = new Audio(audioUrl);
+    this.previewAudio.preload = "auto";
+    this.previewAudio.volume = this.musicVolume;
+    this.previewAudio.crossOrigin = "anonymous";
+  }
+  /** @deprecated Use updateAudioTrackFromUrl */
+  updateAudioTrack(audioToken) {
+    this.updateAudioTrackFromUrl(`${this.baseUrl}/audio/${audioToken}`);
+  }
+  // ---------------------------------------------------------------------------
+  // Background
+  // ---------------------------------------------------------------------------
+  async updateBackgroundFromUrl(imageUrl) {
+    if (!this.app || !this.backgroundSprite) return;
+    if (!imageUrl) {
+      this.backgroundSprite.texture = PIXI.Texture.EMPTY;
+      this.backgroundSprite.scale.set(1);
+      this.backgroundSprite.x = 0;
+      this.backgroundSprite.y = 0;
+      return;
+    }
+    try {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      await new Promise((resolve, reject) => {
+        img.onload = resolve;
+        img.onerror = reject;
+        img.src = imageUrl;
+      });
+      const texture = PIXI.Texture.from(img);
+      this.applyLinearTextureFiltering(texture);
+      const { width, height } = this.getDisplayDimensions();
+      const scaleX = width / texture.width;
+      const scaleY = height / texture.height;
+      const scale = Math.max(scaleX, scaleY);
+      this.backgroundSprite.texture = texture;
+      this.backgroundSprite.scale.set(scale);
+      this.backgroundSprite.x = (width - texture.width * scale) / 2;
+      this.backgroundSprite.y = (height - texture.height * scale) / 2;
+    } catch (_error) {
+      this.backgroundSprite.texture = null;
+    }
+  }
+  /** @deprecated Use updateBackgroundFromUrl */
+  async updateBackground(imageToken) {
+    await this.updateBackgroundFromUrl(
+      `${this.baseUrl}/image/${imageToken}`
+    );
+  }
+  async setBackground(imageUrl) {
+    await this.updateBackgroundFromUrl(imageUrl);
+  }
+  // ---------------------------------------------------------------------------
+  // Playback controls
+  // ---------------------------------------------------------------------------
+  play(options = {}) {
+    if (this.isPlaying) {
+      return;
+    }
+    const enableMusic = options.enableAudio ?? options.audio ?? options.withAudio ?? true;
+    const enableHitsounds = options.enableHitsounds ?? true;
+    this.transportStartMs = this.currentTime;
+    this.transportStartPerfTime = performance.now();
+    this.transportStartAudioTime = this.audioContext ? this.audioContext.currentTime : 0;
+    this.isPlaying = true;
+    this.audioSyncOffsetMs = 0;
+    this.lastAudioSyncSamplePerfMs = 0;
+    this.lastTickTime = performance.now();
+    const shouldResumeAudioContext = enableMusic || enableHitsounds;
+    if (shouldResumeAudioContext && this.audioContext?.state === "suspended") {
+      this.audioContext.resume().catch(() => {
+      });
+      if (!this.resumeOnGestureListenerAttached) {
+        this.resumeOnGestureListenerAttached = true;
+        const resumeOnGesture = () => {
+          this.resumeOnGestureListenerAttached = false;
+          this.audioContext?.resume().catch(() => {
+          });
+          if (enableMusic) {
+            this.previewAudio?.play().catch(() => {
+            });
+          }
+        };
+        document.addEventListener("pointerdown", resumeOnGesture, {
+          once: true
+        });
+      }
+    }
+    if (this.previewAudio) {
+      const shiftedMs = this.getPreviewAudioTimeMsForBeatmapTime(
+        this.currentTime
+      );
+      this.previewAudio.currentTime = Math.max(0, shiftedMs) / 1e3;
+      if (enableMusic) {
+        this.previewAudio.play().catch(() => {
+        });
+      } else {
+        this.previewAudio.pause();
+      }
+    }
+    if (enableHitsounds) {
+      this.hitsoundPlayer?.startScheduler({
+        isPlaying: () => this.isPlaying,
+        getTransportCurrentTimeMs: () => this.getTransportCurrentTimeMs()
+      });
+    } else {
+      this.hitsoundPlayer?.stopScheduler();
+      this.hitsoundPlayer?.clearScheduledSources();
+    }
+  }
+  pause() {
+    if (!this.isPlaying) {
+      return;
+    }
+    this.currentTime = this.getTransportCurrentTimeMs();
+    this.isPlaying = false;
+    this.hitsoundPlayer?.stopScheduler();
+    this.hitsoundPlayer?.clearScheduledSources();
+    if (this.previewAudio) {
+      this.previewAudio.pause();
+    }
+  }
+  getCurrentTime() {
+    if (this.isPlaying) {
+      return this.getTransportCurrentTimeMs();
+    }
+    return this.currentTime;
+  }
+  getDuration() {
+    if (this.previewAudio && Number.isFinite(this.previewAudio.duration) && this.previewAudio.duration > 0) {
+      return Math.max(
+        this.beatmapDurationMs,
+        this.previewAudio.duration * 1e3
+      );
+    }
+    return Math.max(0, this.beatmapDurationMs);
+  }
+  setCurrentTime(ms) {
+    if (!Number.isFinite(ms)) {
+      return;
+    }
+    this.currentTime = Math.max(0, ms);
+    this.transportStartMs = this.currentTime;
+    this.transportStartPerfTime = performance.now();
+    this.transportStartAudioTime = this.audioContext ? this.audioContext.currentTime : 0;
+    this.lastAudioSyncSamplePerfMs = 0;
+    if (this.previewAudio) {
+      const shiftedMs = this.getPreviewAudioTimeMsForBeatmapTime(
+        this.currentTime
+      );
+      this.previewAudio.currentTime = Math.max(0, shiftedMs) / 1e3;
+      if (this.isPlaying && !this.previewAudio.paused) {
+        const audioDerivedVisualMs = this.getBeatmapTimeMsForPreviewAudioTime(
+          this.previewAudio.currentTime * 1e3
+        );
+        if (Number.isFinite(audioDerivedVisualMs)) {
+          this.currentTime = Math.max(0, audioDerivedVisualMs);
+          this.transportStartMs = this.currentTime;
+          this.transportStartPerfTime = performance.now();
+          this.transportStartAudioTime = this.audioContext ? this.audioContext.currentTime : 0;
+          this.audioSyncOffsetMs = 0;
+          this.lastAudioSyncSamplePerfMs = 0;
+        }
+      }
+    }
+    this.resetHitsoundPlaybackFlags();
+    this.hitsoundPlayer?.resetFromCurrentTime(this.currentTime);
+    this.resetActiveObjects();
+  }
+  seek(ms) {
+    this.setCurrentTime(ms);
+  }
+  seekToPreview() {
+    this.seek(this.previewTimeMs || 0);
+  }
+  // ---------------------------------------------------------------------------
+  // Volume
+  // ---------------------------------------------------------------------------
+  setVolume(volume) {
+    const v = Math.max(0, Math.min(1, Number(volume) || 0));
+    this.musicVolume = v;
+    this.hitsoundVolume = v;
+    if (this.previewAudio) {
+      this.previewAudio.volume = v;
+    }
+    this.hitsoundPlayer?.setVolume(v);
+  }
+  setMusicVolume(volume) {
+    const v = Math.max(0, Math.min(1, Number(volume) || 0));
+    this.musicVolume = v;
+    if (this.previewAudio) {
+      this.previewAudio.volume = v;
+    }
+  }
+  setHitsoundVolume(volume) {
+    const v = Math.max(0, Math.min(1, Number(volume) || 0));
+    this.hitsoundVolume = v;
+    this.hitsoundPlayer?.setVolume(v);
+  }
+  setBackgroundVisible(visible) {
+    if (!this.backgroundSprite) return;
+    this.backgroundSprite.alpha = visible ? 1 : 0;
+  }
+  setAudioOffsetMs(ms) {
+    const v = Number(ms) || 0;
+    this.audioOffsetMs = v;
+    this.audioSyncOffsetMs = 0;
+    this.lastAudioSyncSamplePerfMs = 0;
+    if (this.previewAudio) {
+      const shiftedMs = this.getPreviewAudioTimeMsForBeatmapTime(
+        this.currentTime
+      );
+      this.previewAudio.currentTime = Math.max(0, shiftedMs) / 1e3;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: hit object cache
+  // ---------------------------------------------------------------------------
+  rebuildHitObjectCache() {
+    this.resetActiveObjects();
+    this.timingPointCache.clear();
+    if (!this.beatmap || !this.beatmap.HitObjects) {
+      this.hitObjectEntries = [];
+      this.hitObjectTimes = [];
+      this.beatmapDurationMs = 0;
+      return;
+    }
+    this.hitObjectEntries = Object.entries(this.beatmap.HitObjects).map(([time, obj]) => [Number.parseInt(time, 10), obj]).filter(([time]) => Number.isFinite(time)).sort((a, b) => a[0] - b[0]);
+    this.hitObjectTimes = this.hitObjectEntries.map(([time]) => time);
+    for (const [time, hitObject] of this.hitObjectEntries) {
+      this.prepareHitObject(hitObject, time);
+    }
+    this.beatmapDurationMs = this.computeBeatmapDurationMs();
+    this.hitsoundPlayer?.buildHitsoundEvents(this.hitObjectEntries, {
+      getCachedTimingPoint: (hitTime) => this.getCachedTimingPoint(hitTime),
+      getSliderDurationCached: (hitObject, hitTime) => this.getSliderDurationCached(hitObject, hitTime),
+      getHitObjectEndTime: (hitObject, hitTime) => this.getHitObjectEndTime(hitObject, hitTime)
+    });
+    this.hitsoundPlayer?.resetFromCurrentTime(this.currentTime);
+  }
+  resetActiveObjects() {
+    for (const hitObject of this.activeHitObjects) {
+      this.removeHitObject(hitObject);
+    }
+    this.activeHitObjects.clear();
+  }
+  resetHitsoundPlaybackFlags() {
+    for (const [, hitObject] of this.hitObjectEntries) {
+      hitObject._hitsoundHeadPlayed = false;
+      hitObject._hitsoundSliderEndPlayed = false;
+      hitObject._hitsoundSliderRepeatPlayed = {};
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: resize
+  // ---------------------------------------------------------------------------
+  resize() {
+    if (!this.app) {
+      return;
+    }
+    const { width, height } = this.getDisplayDimensions();
+    const dpr = Math.max(1, window.devicePixelRatio || 1);
+    if (this.app.renderer.resolution !== dpr) {
+      this.app.renderer.resolution = dpr;
+    }
+    this.app.renderer.resize(width, height);
+    if (this.backgroundSprite?.texture) {
+      const scaleX = width / this.backgroundSprite.texture.width;
+      const scaleY = height / this.backgroundSprite.texture.height;
+      const scale = Math.max(scaleX, scaleY);
+      this.backgroundSprite.scale.set(scale);
+      this.backgroundSprite.x = (width - this.backgroundSprite.texture.width * scale) / 2;
+      this.backgroundSprite.y = (height - this.backgroundSprite.texture.height * scale) / 2;
+    }
+    this.rebuildHitObjectVisualsForResize();
+  }
+  rebuildHitObjectVisualsForResize() {
+    this.resetActiveObjects();
+    if (!this.hitObjectEntries?.length) {
+      return;
+    }
+    for (const [, hitObject] of this.hitObjectEntries) {
+      this.destroyHitObjectVisuals(hitObject);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: rendering frame loop
+  // ---------------------------------------------------------------------------
+  updateFrame() {
+    if (!this.app || !this.beatmap || !this.beatmap.HitObjects) {
+      return;
+    }
+    this.currentTime = this.isPlaying ? this.getTransportCurrentTimeMs() : this.currentTime;
+    const { preempt, fadeIn } = this.calculateARValues();
+    this.currentLayout = this.getLayout();
+    const rangeStart = lowerBound(
+      this.hitObjectTimes,
+      this.currentTime - LOOKBACK_MS
+    );
+    const rangeEnd = upperBound(
+      this.hitObjectTimes,
+      this.currentTime + preempt + LOOKAHEAD_MS
+    );
+    const nextActive = /* @__PURE__ */ new Set();
+    for (let i = rangeStart; i < rangeEnd; i++) {
+      const [, hitObject] = this.hitObjectEntries[i];
+      const hitTime = Number(hitObject.time);
+      const timeDiff = hitTime - this.currentTime;
+      const alpha = Math.min(1, Math.max(0, (preempt - timeDiff) / fadeIn));
+      if (hitObject.type.includes("Spinner")) {
+        const spinnerEndTime = this.getHitObjectEndTime(hitObject, hitTime);
+        if (this.currentTime >= hitTime && this.currentTime <= spinnerEndTime) {
+          this.addOrUpdateHitObject(hitObject, alpha, preempt, timeDiff);
+          nextActive.add(hitObject);
+        }
+      } else if (timeDiff < preempt && !hitObject.type.includes("Slider") && timeDiff > -FADE_OUT_MS) {
+        this.addOrUpdateHitObject(hitObject, alpha, preempt, timeDiff);
+        nextActive.add(hitObject);
+      } else if (hitObject.type.includes("Slider")) {
+        const sliderDuration = this.getSliderDurationCached(hitObject, hitTime);
+        const sliderEndTime = hitTime + sliderDuration;
+        if (timeDiff < preempt && this.currentTime <= sliderEndTime + FADE_OUT_MS * 2) {
+          this.addOrUpdateHitObject(hitObject, alpha, preempt, timeDiff);
+          nextActive.add(hitObject);
+        }
+      }
+    }
+    for (const hitObject of this.activeHitObjects) {
+      if (!nextActive.has(hitObject)) {
+        this.removeHitObject(hitObject);
+      }
+    }
+    this.activeHitObjects = nextActive;
+  }
+  addOrUpdateHitObject(hitObject, alpha, preempt, timeDiff) {
+    const { centerX, centerY, gridUnit, topLeftX, topLeftY } = this.currentLayout || this.getLayout();
+    const hitTime = Number(hitObject.time);
+    const zIndex = -hitTime;
+    const approachZIndex = APPROACH_CIRCLE_Z_BASE - hitTime;
+    if (hitObject.type.includes("Spinner")) {
+      if (!hitObject.approachSprite) {
+        const approachSprite = new PIXI.Sprite(this.textures.texture_approach);
+        approachSprite.anchor.set(0.5);
+        approachSprite.x = centerX;
+        approachSprite.y = centerY;
+        approachSprite.width = gridUnit * 512;
+        approachSprite.height = gridUnit * 512;
+        approachSprite.zIndex = approachZIndex;
+        this.app.stage.addChild(approachSprite);
+        hitObject.approachSprite = approachSprite;
+      }
+      const spinnerEndTime = this.getHitObjectEndTime(hitObject, hitTime);
+      const spinnerDuration = Math.max(1, spinnerEndTime - hitTime);
+      const progress = Math.max(
+        0,
+        Math.min(1, (this.currentTime - hitTime) / spinnerDuration)
+      );
+      const spinnerScale = 1 - progress;
+      const spinnerBaseSize = gridUnit * 512;
+      this.showHitObject(hitObject);
+      hitObject.approachSprite.alpha = 1;
+      hitObject.approachSprite.width = spinnerBaseSize * spinnerScale;
+      hitObject.approachSprite.height = spinnerBaseSize * spinnerScale;
+      return;
+    }
+    if (!hitObject.hitCircleSprite) {
+      const posX = topLeftX + Number(hitObject.x) * gridUnit;
+      const posY = topLeftY + Number(hitObject.y) * gridUnit;
+      const circleSize = this.getCircleSize(gridUnit);
+      const comboColor = this.getComboColor(hitObject.comboColor);
+      hitObject.hitCircleSprite = new PIXI.Sprite(
+        this.textures.texture_hitcircle
+      );
+      hitObject.hitCircleSprite.anchor.set(0.5);
+      hitObject.hitCircleSprite.x = posX;
+      hitObject.hitCircleSprite.y = posY;
+      hitObject.hitCircleSprite.width = circleSize;
+      hitObject.hitCircleSprite.height = circleSize;
+      hitObject.hitCircleSprite.tint = comboColor;
+      hitObject.hitCircleSprite.zIndex = zIndex + 3;
+      hitObject.hitCircleOverlaySprite = new PIXI.Sprite(
+        this.textures.texture_hitcircleoverlay
+      );
+      hitObject.hitCircleOverlaySprite.anchor.set(0.5);
+      hitObject.hitCircleOverlaySprite.x = posX;
+      hitObject.hitCircleOverlaySprite.y = posY;
+      hitObject.hitCircleOverlaySprite.width = circleSize;
+      hitObject.hitCircleOverlaySprite.height = circleSize;
+      hitObject.hitCircleOverlaySprite.zIndex = zIndex + 4;
+      hitObject.approachSprite = new PIXI.Sprite(
+        this.textures.texture_approach
+      );
+      hitObject.approachSprite.anchor.set(0.5);
+      hitObject.approachSprite.x = posX;
+      hitObject.approachSprite.y = posY;
+      hitObject.approachSprite.tint = comboColor;
+      hitObject.approachSprite.zIndex = approachZIndex;
+      hitObject.comboText = new PIXI.Text({
+        text: hitObject.combo || "",
+        style: {
+          fill: 16777215
+        }
+      });
+      hitObject.comboText.anchor.set(0.5);
+      hitObject.comboText.x = posX;
+      hitObject.comboText.y = posY;
+      hitObject.comboText.zIndex = zIndex + 6;
+      const textScale = Math.min(
+        circleSize / (hitObject.comboText.width || 1),
+        circleSize / (hitObject.comboText.height || 1)
+      ) * 0.4;
+      hitObject.comboText.scale.set(textScale);
+      hitObject._comboBaseScale = textScale;
+      this.app.stage.addChild(hitObject.approachSprite);
+      this.app.stage.addChild(hitObject.hitCircleSprite);
+      this.app.stage.addChild(hitObject.hitCircleOverlaySprite);
+      this.app.stage.addChild(hitObject.comboText);
+      if (hitObject.type.includes("Slider")) {
+        this.addSlider(hitObject, posX, posY, circleSize, zIndex, comboColor);
+      }
+    }
+    this.showHitObject(hitObject);
+    const scale = 0.9 + timeDiff / preempt * 3;
+    if (hitObject.approachSprite) {
+      if (scale > 1) {
+        hitObject.approachSprite.width = hitObject.hitCircleSprite.width * scale;
+        hitObject.approachSprite.height = hitObject.hitCircleSprite.height * scale;
+        hitObject.approachSprite.alpha = Math.max(0, Math.min(1, alpha));
+      } else {
+        hitObject.approachSprite.alpha = 0;
+      }
+    }
+    if (hitObject.hitCircleSprite && !hitObject.type.includes("Slider")) {
+      const circleSize = this.getCircleSize(gridUnit);
+      if (timeDiff <= 0) {
+        const fadeProgress = this.getHitBurstProgress(timeDiff);
+        const fadeAlpha = this.getHitBurstAlpha(fadeProgress);
+        hitObject.hitCircleSprite.alpha = fadeAlpha;
+        hitObject.hitCircleOverlaySprite.alpha = fadeAlpha;
+        hitObject.comboText.alpha = fadeAlpha;
+        const grownSize = this.getHitBurstSize(circleSize, fadeProgress);
+        const comboScale = this.getHitBurstScale(
+          hitObject._comboBaseScale,
+          fadeProgress
+        );
+        hitObject.hitCircleSprite.width = grownSize;
+        hitObject.hitCircleSprite.height = grownSize;
+        hitObject.hitCircleOverlaySprite.width = grownSize;
+        hitObject.hitCircleOverlaySprite.height = grownSize;
+        hitObject.comboText.scale.set(comboScale);
+      } else {
+        hitObject.hitCircleSprite.width = circleSize;
+        hitObject.hitCircleSprite.height = circleSize;
+        hitObject.hitCircleOverlaySprite.width = circleSize;
+        hitObject.hitCircleOverlaySprite.height = circleSize;
+        hitObject.hitCircleSprite.alpha = Math.max(0, Math.min(1, alpha));
+        hitObject.hitCircleOverlaySprite.alpha = Math.max(
+          0,
+          Math.min(1, alpha)
+        );
+        hitObject.comboText.alpha = Math.max(0, Math.min(1, alpha));
+        hitObject.comboText.scale.set(hitObject._comboBaseScale || 1);
+      }
+    }
+    if (hitObject.sliderSprite) {
+      const hitTimeMs = Number(hitObject.time);
+      const sliderDuration = this.getSliderDurationCached(hitObject, hitTimeMs);
+      const sliderEndTime = hitTimeMs + sliderDuration;
+      const sliderRepeat = Number(hitObject.sliderInfo?.sliderRepeat || 1);
+      const isPreHit = this.currentTime < hitTimeMs;
+      const inPostSliderFade = sliderDuration > 0 && this.currentTime > sliderEndTime;
+      const sliderAlpha = isPreHit ? Math.max(0.02, Math.min(1, alpha)) : 1;
+      const { gridUnit: sliderGridUnit } = this.currentLayout || this.getLayout();
+      const sliderHeadBaseSize = this.getCircleSize(sliderGridUnit);
+      if (inPostSliderFade) {
+        const fadeProgress = Math.min(
+          1,
+          (this.currentTime - sliderEndTime) / FADE_OUT_MS
+        );
+        const fadeAlpha = Math.max(0, 1 - fadeProgress);
+        hitObject.sliderSprite.alpha = fadeAlpha;
+        hitObject.hitCircleSprite_sliderend.alpha = fadeAlpha;
+        hitObject.hitCircleOverlaySprite_sliderend.alpha = fadeAlpha;
+        if (hitObject.reverseSprite) {
+          hitObject.reverseSprite.visible = this.hasRemainingSliderRepeatsAtEdge(
+            this.currentTime,
+            hitTimeMs,
+            sliderDuration,
+            sliderRepeat,
+            "end"
+          );
+          hitObject.reverseSprite.alpha = fadeAlpha;
+        }
+        if (hitObject.reverseSpriteHead) {
+          hitObject.reverseSpriteHead.visible = this.currentTime >= hitTimeMs && this.hasRemainingSliderRepeatsAtEdge(
+            this.currentTime,
+            hitTimeMs,
+            sliderDuration,
+            sliderRepeat,
+            "start"
+          );
+          hitObject.reverseSpriteHead.alpha = fadeAlpha;
+        }
+        if (hitObject.followCircle) {
+          hitObject.followCircle.alpha = fadeAlpha * 0.7;
+        }
+      } else {
+        hitObject.sliderSprite.alpha = sliderAlpha;
+        hitObject.hitCircleSprite_sliderend.alpha = sliderAlpha;
+        hitObject.hitCircleOverlaySprite_sliderend.alpha = sliderAlpha;
+        if (hitObject.reverseSprite) {
+          hitObject.reverseSprite.visible = this.hasRemainingSliderRepeatsAtEdge(
+            this.currentTime,
+            hitTimeMs,
+            sliderDuration,
+            sliderRepeat,
+            "end"
+          );
+          hitObject.reverseSprite.alpha = sliderAlpha;
+        }
+        if (hitObject.reverseSpriteHead) {
+          hitObject.reverseSpriteHead.visible = this.currentTime >= hitTimeMs && this.hasRemainingSliderRepeatsAtEdge(
+            this.currentTime,
+            hitTimeMs,
+            sliderDuration,
+            sliderRepeat,
+            "start"
+          );
+          hitObject.reverseSpriteHead.alpha = sliderAlpha;
+        }
+      }
+      if (timeDiff <= 0 && -timeDiff <= FADE_OUT_MS) {
+        const headFadeProgress = this.getHitBurstProgress(timeDiff);
+        const headFadeAlpha = this.getHitBurstAlpha(headFadeProgress);
+        const grownSize = this.getHitBurstSize(
+          sliderHeadBaseSize,
+          headFadeProgress
+        );
+        const comboScale = this.getHitBurstScale(
+          hitObject._comboBaseScale,
+          headFadeProgress
+        );
+        hitObject.hitCircleSprite.alpha = headFadeAlpha;
+        hitObject.hitCircleOverlaySprite.alpha = headFadeAlpha;
+        hitObject.comboText.alpha = headFadeAlpha;
+        hitObject.hitCircleSprite.width = grownSize;
+        hitObject.hitCircleSprite.height = grownSize;
+        hitObject.hitCircleOverlaySprite.width = grownSize;
+        hitObject.hitCircleOverlaySprite.height = grownSize;
+        hitObject.comboText.scale.set(comboScale);
+      } else if (timeDiff <= 0) {
+        hitObject.hitCircleSprite.width = sliderHeadBaseSize;
+        hitObject.hitCircleSprite.height = sliderHeadBaseSize;
+        hitObject.hitCircleOverlaySprite.width = sliderHeadBaseSize;
+        hitObject.hitCircleOverlaySprite.height = sliderHeadBaseSize;
+        hitObject.hitCircleSprite.alpha = 0;
+        hitObject.hitCircleOverlaySprite.alpha = 0;
+        hitObject.comboText.alpha = 0;
+        hitObject.comboText.scale.set(hitObject._comboBaseScale || 1);
+      } else {
+        hitObject.hitCircleSprite.width = sliderHeadBaseSize;
+        hitObject.hitCircleSprite.height = sliderHeadBaseSize;
+        hitObject.hitCircleOverlaySprite.width = sliderHeadBaseSize;
+        hitObject.hitCircleOverlaySprite.height = sliderHeadBaseSize;
+        hitObject.hitCircleSprite.alpha = sliderAlpha;
+        hitObject.hitCircleOverlaySprite.alpha = sliderAlpha;
+        hitObject.comboText.alpha = sliderAlpha;
+        hitObject.comboText.scale.set(hitObject._comboBaseScale || 1);
+      }
+      this.updateSliderFollowCircle(hitObject, hitTime, timeDiff);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: slider follow circle & repeat bursts
+  // ---------------------------------------------------------------------------
+  updateSliderFollowCircle(hitObject, hitTime, timeDiff) {
+    if (!hitObject.followCircle || !hitObject.sliderInfo || timeDiff > 0) {
+      if (hitObject.followCircle) {
+        hitObject.followCircle.alpha = 0;
+      }
+      return;
+    }
+    const timingPoint = this.getCachedTimingPoint(hitTime);
+    if (!timingPoint?.closestBPM) {
+      hitObject.followCircle.alpha = 0;
+      return;
+    }
+    const sliderDuration = this.getSliderDurationCached(hitObject, hitTime);
+    if (!Number.isFinite(sliderDuration) || sliderDuration <= 0) {
+      hitObject.followCircle.alpha = 0;
+      return;
+    }
+    const sliderRepeat = Number(hitObject.sliderInfo.sliderRepeat || 1);
+    const sliderLength = Number(hitObject.sliderInfo.sliderLength || 0);
+    hitObject.sliderRepeat = sliderRepeat;
+    hitObject.sliderLength = sliderLength;
+    hitObject.sliderDuration = sliderDuration;
+    if (this.currentTime > hitTime + sliderDuration) {
+      hitObject.followCircle.alpha = 0;
+      this.updateSliderRepeatBursts(
+        hitObject,
+        hitTime,
+        sliderDuration,
+        sliderRepeat
+      );
+      return;
+    }
+    const { gridUnit } = this.currentLayout || this.getLayout();
+    const followPosition = getFollowPosition(
+      hitObject,
+      hitTime,
+      this.currentTime,
+      gridUnit
+    );
+    if (followPosition && Number.isFinite(followPosition.x) && Number.isFinite(followPosition.y)) {
+      hitObject.followCircle.x = followPosition.x;
+      hitObject.followCircle.y = followPosition.y;
+    }
+    hitObject.followCircle.alpha = 0.7;
+    this.updateSliderRepeatBursts(
+      hitObject,
+      hitTime,
+      sliderDuration,
+      sliderRepeat
+    );
+  }
+  hasRemainingSliderRepeatsAtEdge(currentTime, hitTime, sliderDuration, sliderRepeat, edgeType) {
+    if (!Number.isFinite(currentTime) || !Number.isFinite(hitTime) || !Number.isFinite(sliderDuration) || sliderDuration <= 0 || !Number.isFinite(sliderRepeat) || sliderRepeat <= 1) {
+      return false;
+    }
+    const spanDuration = sliderDuration / sliderRepeat;
+    if (!Number.isFinite(spanDuration) || spanDuration <= 0) {
+      return false;
+    }
+    for (let repeatIndex = 1; repeatIndex < sliderRepeat; repeatIndex += 1) {
+      const repeatTime = hitTime + spanDuration * repeatIndex;
+      if (repeatTime <= currentTime) {
+        continue;
+      }
+      const repeatEdge = repeatIndex % 2 === 1 ? "end" : "start";
+      if (repeatEdge === edgeType) {
+        return true;
+      }
+    }
+    return false;
+  }
+  updateSliderRepeatBursts(hitObject, hitTime, sliderDuration, sliderRepeat) {
+    if (!Number.isFinite(sliderDuration) || sliderDuration <= 0) {
+      this.cleanupSliderRepeatBursts(hitObject);
+      return;
+    }
+    if (!hitObject._repeatBurstMap) {
+      hitObject._repeatBurstMap = {};
+    }
+    if (!hitObject._repeatBurstTriggered) {
+      hitObject._repeatBurstTriggered = {};
+    }
+    const spanDuration = sliderDuration / sliderRepeat;
+    if (!Number.isFinite(spanDuration) || spanDuration <= 0) {
+      this.cleanupSliderRepeatBursts(hitObject);
+      return;
+    }
+    const { gridUnit } = this.currentLayout || this.getLayout();
+    const circleBaseSize = this.getCircleSize(gridUnit);
+    const baseArrowSize = this.getCircleSize(gridUnit) * 0.6;
+    if (sliderRepeat > 1) {
+      for (let repeatIndex = 1; repeatIndex < sliderRepeat; repeatIndex += 1) {
+        const repeatTime = hitTime + spanDuration * repeatIndex;
+        if (this.currentTime < repeatTime) {
+          continue;
+        }
+        if (!hitObject._repeatBurstMap[repeatIndex] && !hitObject._repeatBurstTriggered[repeatIndex]) {
+          const burstEffect = this.createSliderEdgeBurstEffect(
+            hitObject,
+            repeatIndex % 2 === 1 ? "end" : "start",
+            true,
+            circleBaseSize,
+            baseArrowSize
+          );
+          if (burstEffect) {
+            hitObject._repeatBurstMap[repeatIndex] = {
+              effect: burstEffect,
+              startedAtMs: this.currentTime
+            };
+            hitObject._repeatBurstTriggered[repeatIndex] = true;
+          }
+        }
+      }
+    }
+    const sliderEndTime = hitTime + sliderDuration;
+    if (this.currentTime >= sliderEndTime && !hitObject._repeatBurstMap.end && !hitObject._repeatBurstTriggered.end) {
+      const endEffect = this.createSliderEdgeBurstEffect(
+        hitObject,
+        sliderRepeat % 2 === 1 ? "end" : "start",
+        false,
+        circleBaseSize,
+        baseArrowSize
+      );
+      if (endEffect) {
+        hitObject._repeatBurstMap.end = {
+          effect: endEffect,
+          startedAtMs: this.currentTime
+        };
+        hitObject._repeatBurstTriggered.end = true;
+      }
+    }
+    for (const [repeatKey, burstState] of Object.entries(
+      hitObject._repeatBurstMap
+    )) {
+      const burstEffect = burstState?.effect;
+      if (!burstEffect) {
+        delete hitObject._repeatBurstMap[repeatKey];
+        continue;
+      }
+      const burstProgress = (this.currentTime - (Number(burstState.startedAtMs) || this.currentTime)) / FADE_OUT_MS;
+      if (burstProgress < 0) continue;
+      if (burstProgress > 1) {
+        this.destroySliderBurstEffect(burstEffect);
+        delete hitObject._repeatBurstMap[repeatKey];
+        continue;
+      }
+      const alpha = this.getHitBurstAlpha(burstProgress);
+      const circleSize = this.getHitBurstSize(
+        Number(burstEffect.baseCircleSize) || circleBaseSize,
+        burstProgress
+      );
+      burstEffect.hitCircle.alpha = alpha;
+      burstEffect.hitCircle.width = circleSize;
+      burstEffect.hitCircle.height = circleSize;
+      burstEffect.hitCircleOverlay.alpha = alpha;
+      burstEffect.hitCircleOverlay.width = circleSize;
+      burstEffect.hitCircleOverlay.height = circleSize;
+      if (burstEffect.arrowSprite) {
+        const arrowSize = this.getHitBurstSize(
+          Number(burstEffect.baseArrowSize) || baseArrowSize,
+          burstProgress
+        );
+        burstEffect.arrowSprite.alpha = alpha;
+        burstEffect.arrowSprite.width = arrowSize;
+        burstEffect.arrowSprite.height = arrowSize;
+      }
+    }
+  }
+  createSliderEdgeBurstEffect(hitObject, edgeType, includeArrow, baseCircleSize, baseArrowSize) {
+    const sliderInfo = hitObject.sliderInfo;
+    const anchorPositions = sliderInfo?.anchorPositions || [];
+    if (!sliderInfo || !Array.isArray(anchorPositions) || anchorPositions.length < 2) {
+      return null;
+    }
+    const effectContainer = new PIXI.Container();
+    effectContainer.zIndex = Number.isFinite(hitObject.hitCircleSprite?.zIndex) ? hitObject.hitCircleSprite.zIndex + 10 : 0;
+    const hitCircle = new PIXI.Sprite(this.textures.texture_hitcircle);
+    hitCircle.anchor.set(0.5);
+    hitCircle.width = baseCircleSize;
+    hitCircle.height = baseCircleSize;
+    hitCircle.tint = hitObject.hitCircleSprite?.tint ?? 16777215;
+    const hitCircleOverlay = new PIXI.Sprite(
+      this.textures.texture_hitcircleoverlay
+    );
+    hitCircleOverlay.anchor.set(0.5);
+    hitCircleOverlay.width = baseCircleSize;
+    hitCircleOverlay.height = baseCircleSize;
+    effectContainer.addChild(hitCircle);
+    effectContainer.addChild(hitCircleOverlay);
+    let x = 0;
+    let y = 0;
+    let rotation = 0;
+    if (edgeType === "end") {
+      x = sliderInfo.sliderEndPos?.x ?? hitObject.hitCircleSprite?.x ?? 0;
+      y = sliderInfo.sliderEndPos?.y ?? hitObject.hitCircleSprite?.y ?? 0;
+      rotation = getReverseArrowAngle(sliderInfo);
+    } else {
+      x = hitObject.hitCircleSprite?.x ?? anchorPositions[0].x;
+      y = hitObject.hitCircleSprite?.y ?? anchorPositions[0].y;
+      const first = anchorPositions[0];
+      const second = anchorPositions[1];
+      rotation = Math.atan2(second.y - first.y, second.x - first.x);
+    }
+    hitCircle.x = x;
+    hitCircle.y = y;
+    hitCircleOverlay.x = x;
+    hitCircleOverlay.y = y;
+    let arrowSprite = null;
+    if (includeArrow) {
+      arrowSprite = new PIXI.Sprite(this.textures.texture_reverse);
+      arrowSprite.anchor.set(0.5);
+      arrowSprite.width = baseArrowSize;
+      arrowSprite.height = baseArrowSize;
+      arrowSprite.x = x;
+      arrowSprite.y = y;
+      arrowSprite.rotation = rotation;
+      effectContainer.addChild(arrowSprite);
+    }
+    this.app.stage.addChild(effectContainer);
+    return {
+      container: effectContainer,
+      hitCircle,
+      hitCircleOverlay,
+      arrowSprite,
+      baseCircleSize,
+      baseArrowSize: includeArrow ? baseArrowSize : 0
+    };
+  }
+  destroySliderBurstEffect(effect) {
+    if (!effect?.container) {
+      return;
+    }
+    this.app.stage.removeChild(effect.container);
+    if (typeof effect.container.destroy === "function") {
+      effect.container.destroy({ children: true });
+    }
+  }
+  cleanupSliderRepeatBursts(hitObject) {
+    if (!hitObject?._repeatBurstMap) {
+      return;
+    }
+    for (const burstEntry of Object.values(hitObject._repeatBurstMap)) {
+      const burstEffect = burstEntry?.effect;
+      if (!burstEffect) {
+        continue;
+      }
+      this.destroySliderBurstEffect(burstEffect);
+    }
+    hitObject._repeatBurstMap = {};
+    hitObject._repeatBurstTriggered = {};
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: slider creation
+  // ---------------------------------------------------------------------------
+  addSlider(hitObject, posX, posY, circleSize, zIndex, comboColor) {
+    const sliderInfo = hitObject.sliderInfo;
+    const sliderBodyPath = sliderInfo.sliderType === "P" ? perfectCurve(sliderInfo, this.currentLayout || this.getLayout()) : bezierCurve(sliderInfo, this.currentLayout || this.getLayout());
+    const sliderBorderPath = sliderInfo.sliderType === "P" ? perfectCurve(sliderInfo, this.currentLayout || this.getLayout()) : bezierCurve(sliderInfo, this.currentLayout || this.getLayout());
+    const sliderBorderWidth = circleSize * 0.92;
+    const sliderBodyWidth = sliderBorderWidth * 0.88;
+    sliderBorderPath.stroke({
+      width: sliderBorderWidth,
+      color: 16777215,
+      join: "round",
+      cap: "round"
+    });
+    sliderBodyPath.stroke({
+      width: sliderBodyWidth,
+      color: darkenColor(comboColor, SLIDER_BODY_DARKEN_FACTOR),
+      join: "round",
+      cap: "round"
+    });
+    const bounds = sliderBodyPath.getLocalBounds();
+    const padding = Math.ceil(circleSize * 0.75);
+    const texW = Math.max(1, Math.ceil(bounds.width + padding * 2));
+    const texH = Math.max(1, Math.ceil(bounds.height + padding * 2));
+    const renderResolution = Math.max(1, this.app?.renderer?.resolution || 1) * SLIDER_RT_OVERSAMPLE;
+    const multisample = PIXI.MSAA_QUALITY?.HIGH;
+    const sliderBodyTexture = PIXI.RenderTexture.create({
+      width: texW,
+      height: texH,
+      resolution: renderResolution,
+      multisample
+    });
+    const sliderBorderTexture = PIXI.RenderTexture.create({
+      width: texW,
+      height: texH,
+      resolution: renderResolution,
+      multisample
+    });
+    sliderBodyPath.x = padding - bounds.x;
+    sliderBodyPath.y = padding - bounds.y;
+    sliderBorderPath.x = padding - bounds.x;
+    sliderBorderPath.y = padding - bounds.y;
+    const bodyRenderContainer = new PIXI.Container();
+    bodyRenderContainer.addChild(sliderBodyPath);
+    this.app.renderer.render({
+      container: bodyRenderContainer,
+      target: sliderBodyTexture,
+      clear: true,
+      clearColor: [0, 0, 0, 0]
+    });
+    bodyRenderContainer.removeChild(sliderBodyPath);
+    bodyRenderContainer.destroy({ children: false });
+    const borderRenderContainer = new PIXI.Container();
+    borderRenderContainer.addChild(sliderBorderPath);
+    this.app.renderer.render({
+      container: borderRenderContainer,
+      target: sliderBorderTexture,
+      clear: true,
+      clearColor: [0, 0, 0, 0]
+    });
+    borderRenderContainer.removeChild(sliderBorderPath);
+    borderRenderContainer.destroy({ children: false });
+    const sliderBorderSprite = new PIXI.Sprite(sliderBorderTexture);
+    sliderBorderSprite.x = 0;
+    sliderBorderSprite.y = 0;
+    const sliderBodySprite = new PIXI.Sprite(sliderBodyTexture);
+    sliderBodySprite.x = 0;
+    sliderBodySprite.y = 0;
+    sliderBodySprite.alpha = SLIDER_BODY_ALPHA;
+    const sliderSprite = new PIXI.Container();
+    sliderSprite.sortableChildren = false;
+    sliderSprite.x = bounds.x - padding;
+    sliderSprite.y = bounds.y - padding;
+    sliderSprite.zIndex = zIndex + 1;
+    sliderSprite.addChild(sliderBorderSprite);
+    sliderSprite.addChild(sliderBodySprite);
+    this.app.stage.addChild(sliderSprite);
+    hitObject.sliderBorderSprite = null;
+    hitObject.sliderSprite = sliderSprite;
+    hitObject.hitCircleSprite_sliderend = new PIXI.Sprite(
+      this.textures.texture_hitcircle
+    );
+    hitObject.hitCircleSprite_sliderend.anchor.set(0.5);
+    hitObject.hitCircleSprite_sliderend.x = sliderInfo.sliderEndPos.x;
+    hitObject.hitCircleSprite_sliderend.y = sliderInfo.sliderEndPos.y;
+    hitObject.hitCircleSprite_sliderend.width = circleSize;
+    hitObject.hitCircleSprite_sliderend.height = circleSize;
+    hitObject.hitCircleSprite_sliderend.tint = comboColor;
+    hitObject.hitCircleSprite_sliderend.zIndex = zIndex + 2;
+    hitObject.hitCircleOverlaySprite_sliderend = new PIXI.Sprite(
+      this.textures.texture_hitcircleoverlay
+    );
+    hitObject.hitCircleOverlaySprite_sliderend.anchor.set(0.5);
+    hitObject.hitCircleOverlaySprite_sliderend.x = sliderInfo.sliderEndPos.x;
+    hitObject.hitCircleOverlaySprite_sliderend.y = sliderInfo.sliderEndPos.y;
+    hitObject.hitCircleOverlaySprite_sliderend.width = circleSize;
+    hitObject.hitCircleOverlaySprite_sliderend.height = circleSize;
+    hitObject.hitCircleOverlaySprite_sliderend.zIndex = zIndex + 2;
+    this.app.stage.addChild(hitObject.hitCircleSprite_sliderend);
+    this.app.stage.addChild(hitObject.hitCircleOverlaySprite_sliderend);
+    if (Number(sliderInfo.sliderRepeat) > 1) {
+      const reverseSprite = new PIXI.Sprite(this.textures.texture_reverse);
+      reverseSprite.anchor.set(0.5);
+      reverseSprite.x = sliderInfo.sliderEndPos.x;
+      reverseSprite.y = sliderInfo.sliderEndPos.y;
+      reverseSprite.width = circleSize * 0.6;
+      reverseSprite.height = circleSize * 0.6;
+      reverseSprite.rotation = getReverseArrowAngle(sliderInfo);
+      reverseSprite.zIndex = zIndex + 2;
+      this.app.stage.addChild(reverseSprite);
+      hitObject.reverseSprite = reverseSprite;
+    }
+    if (Number(sliderInfo.sliderRepeat) > 2) {
+      const reverseSpriteHead = new PIXI.Sprite(this.textures.texture_reverse);
+      reverseSpriteHead.anchor.set(0.5);
+      reverseSpriteHead.x = posX;
+      reverseSpriteHead.y = posY;
+      reverseSpriteHead.width = circleSize * 0.6;
+      reverseSpriteHead.height = circleSize * 0.6;
+      const anchorPositions = sliderInfo.anchorPositions || [];
+      if (anchorPositions.length >= 2) {
+        const first = anchorPositions[0];
+        const second = anchorPositions[1];
+        reverseSpriteHead.rotation = Math.atan2(
+          second.y - first.y,
+          second.x - first.x
+        );
+      } else {
+        reverseSpriteHead.rotation = 0;
+      }
+      reverseSpriteHead.zIndex = zIndex + 2;
+      reverseSpriteHead.visible = false;
+      this.app.stage.addChild(reverseSpriteHead);
+      hitObject.reverseSpriteHead = reverseSpriteHead;
+    }
+    const followCircle = new PIXI.Graphics();
+    followCircle.beginFill(15658734);
+    followCircle.drawCircle(0, 0, circleSize / 2.4);
+    followCircle.endFill();
+    followCircle.x = posX;
+    followCircle.y = posY;
+    followCircle.alpha = 0;
+    followCircle.zIndex = zIndex + 2;
+    this.app.stage.addChild(followCircle);
+    hitObject.followCircle = followCircle;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: display object helpers
+  // ---------------------------------------------------------------------------
+  destroyDisplayObject(displayObject) {
+    if (!displayObject) {
+      return;
+    }
+    if (displayObject.parent) {
+      displayObject.parent.removeChild(displayObject);
+    }
+    if (typeof displayObject.destroy === "function") {
+      displayObject.destroy({ children: true });
+    }
+  }
+  destroyHitObjectVisuals(hitObject) {
+    if (!hitObject) {
+      return;
+    }
+    this.cleanupSliderRepeatBursts(hitObject);
+    this.destroyDisplayObject(hitObject.approachSprite);
+    this.destroyDisplayObject(hitObject.hitCircleSprite);
+    this.destroyDisplayObject(hitObject.hitCircleOverlaySprite);
+    this.destroyDisplayObject(hitObject.comboText);
+    this.destroyDisplayObject(hitObject.sliderSprite);
+    this.destroyDisplayObject(hitObject.sliderBorderSprite);
+    this.destroyDisplayObject(hitObject.hitCircleSprite_sliderend);
+    this.destroyDisplayObject(hitObject.hitCircleOverlaySprite_sliderend);
+    this.destroyDisplayObject(hitObject.reverseSprite);
+    this.destroyDisplayObject(hitObject.reverseSpriteHead);
+    this.destroyDisplayObject(hitObject.followCircle);
+    hitObject.approachSprite = null;
+    hitObject.hitCircleSprite = null;
+    hitObject.hitCircleOverlaySprite = null;
+    hitObject.comboText = null;
+    hitObject.sliderSprite = null;
+    hitObject.sliderBorderSprite = null;
+    hitObject.hitCircleSprite_sliderend = null;
+    hitObject.hitCircleOverlaySprite_sliderend = null;
+    hitObject.reverseSprite = null;
+    hitObject.reverseSpriteHead = null;
+    hitObject.followCircle = null;
+  }
+  removeHitObject(hitObject) {
+    if (!this.app) {
+      return;
+    }
+    this.cleanupSliderRepeatBursts(hitObject);
+    this.hideHitObject(hitObject);
+  }
+  showHitObject(hitObject) {
+    if (hitObject.hitCircleSprite) hitObject.hitCircleSprite.visible = true;
+    if (hitObject.approachSprite) hitObject.approachSprite.visible = true;
+    if (hitObject.hitCircleOverlaySprite)
+      hitObject.hitCircleOverlaySprite.visible = true;
+    if (hitObject.reverseSprite) hitObject.reverseSprite.visible = true;
+    if (hitObject.reverseSpriteHead)
+      hitObject.reverseSpriteHead.visible = false;
+    if (hitObject.comboText) hitObject.comboText.visible = true;
+    if (hitObject.sliderSprite) hitObject.sliderSprite.visible = true;
+    if (hitObject.sliderBorderSprite)
+      hitObject.sliderBorderSprite.visible = true;
+    if (hitObject.hitCircleOverlaySprite_sliderend)
+      hitObject.hitCircleOverlaySprite_sliderend.visible = true;
+    if (hitObject.hitCircleSprite_sliderend)
+      hitObject.hitCircleSprite_sliderend.visible = true;
+    if (hitObject.followCircle) hitObject.followCircle.visible = true;
+  }
+  hideHitObject(hitObject) {
+    if (hitObject.hitCircleSprite) hitObject.hitCircleSprite.visible = false;
+    if (hitObject.approachSprite) hitObject.approachSprite.visible = false;
+    if (hitObject.hitCircleOverlaySprite)
+      hitObject.hitCircleOverlaySprite.visible = false;
+    if (hitObject.reverseSprite) hitObject.reverseSprite.visible = false;
+    if (hitObject.reverseSpriteHead)
+      hitObject.reverseSpriteHead.visible = false;
+    if (hitObject.comboText) hitObject.comboText.visible = false;
+    if (hitObject.sliderSprite) hitObject.sliderSprite.visible = false;
+    if (hitObject.sliderBorderSprite)
+      hitObject.sliderBorderSprite.visible = false;
+    if (hitObject.hitCircleOverlaySprite_sliderend)
+      hitObject.hitCircleOverlaySprite_sliderend.visible = false;
+    if (hitObject.hitCircleSprite_sliderend)
+      hitObject.hitCircleSprite_sliderend.visible = false;
+    if (hitObject.followCircle) hitObject.followCircle.visible = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: asset loading
+  // ---------------------------------------------------------------------------
+  async loadAssets() {
+    const base = this.assetBaseUrl.replace(/\/$/, "");
+    const texture_approach = await Assets.load(`${base}/approachcircle.png`);
+    const texture_hitcircle = await Assets.load(`${base}/hitcircle.png`);
+    const texture_hitcircleoverlay = await Assets.load(
+      `${base}/hitcircleoverlay.png`
+    );
+    const texture_reverse = await Assets.load(`${base}/reversearrow.png`);
+    this.applyLinearTextureFiltering(texture_approach);
+    this.applyLinearTextureFiltering(texture_hitcircle);
+    this.applyLinearTextureFiltering(texture_hitcircleoverlay);
+    this.applyLinearTextureFiltering(texture_reverse);
+    return {
+      texture_approach,
+      texture_hitcircle,
+      texture_hitcircleoverlay,
+      texture_reverse
+    };
+  }
+  applyLinearTextureFiltering(texture) {
+    if (!texture) {
+      return;
+    }
+    const sourceStyle = texture.source?.style;
+    if (sourceStyle) {
+      sourceStyle.scaleMode = "linear";
+      return;
+    }
+    if (texture.baseTexture && PIXI.SCALE_MODES?.LINEAR != null) {
+      texture.baseTexture.scaleMode = PIXI.SCALE_MODES.LINEAR;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: calculations
+  // ---------------------------------------------------------------------------
+  calculateARValues() {
+    const AR = Number(this.beatmap?.Difficulty?.ApproachRate || 5);
+    let preempt;
+    let fadeIn;
+    if (AR < 5) {
+      preempt = 1200 + 600 * (5 - AR) / 5;
+      fadeIn = 800 + 400 * (5 - AR) / 5;
+    } else if (AR === 5) {
+      preempt = 1200;
+      fadeIn = 800;
+    } else {
+      preempt = 1200 - 750 * (AR - 5) / 5;
+      fadeIn = 800 - 500 * (AR - 5) / 5;
+    }
+    return { preempt, fadeIn };
+  }
+  getDisplayDimensions() {
+    const containerWidth = this.containerEl?.clientWidth || 1280;
+    const containerHeight = this.containerEl?.clientHeight || 720;
+    const containerAspect = containerWidth / containerHeight;
+    if (containerAspect > BASE_ASPECT_RATIO) {
+      const height = containerHeight;
+      return { width: height * BASE_ASPECT_RATIO, height };
+    }
+    const width = containerWidth;
+    return { width, height: width / BASE_ASPECT_RATIO };
+  }
+  getLayout() {
+    const { width, height } = this.getDisplayDimensions();
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const gridUnit = height * 0.8 / 384;
+    return {
+      centerX,
+      centerY,
+      gridUnit,
+      topLeftX: centerX - 256 * gridUnit,
+      topLeftY: centerY - 192 * gridUnit
+    };
+  }
+  getCircleSize(gridUnit) {
+    const cs = Number(this.beatmap?.Difficulty?.CircleSize || 4);
+    return (54.4 - 4.48 * cs) * gridUnit * 2;
+  }
+  getComboColor(comboColorIndex) {
+    const comboColors = [16750848, 16711680, 3381759, 3407616];
+    return comboColors[(comboColorIndex || 0) % comboColors.length];
+  }
+  getSliderDuration(hitObject, hitTime) {
+    if (!hitObject?.sliderInfo) {
+      return 0;
+    }
+    const timingPoint = this.getCachedTimingPoint(hitTime);
+    if (!timingPoint?.closestBPM) {
+      return 0;
+    }
+    const beatLength = timingPoint.closestBPM.beatLengthValue;
+    const baseSV = Number(this.beatmap?.Difficulty?.SliderMultiplier || 1);
+    const hasInheritedSVAfterBpm = timingPoint.closestSV && Number.isFinite(timingPoint.closestSV.time) && Number.isFinite(timingPoint.closestBPM.time) && timingPoint.closestSV.time >= timingPoint.closestBPM.time;
+    const speed = hasInheritedSVAfterBpm ? timingPoint.closestSV.sv : -100;
+    const sliderRepeat = Number(hitObject.sliderInfo.sliderRepeat || 1);
+    const sliderLength = Number(hitObject.sliderInfo.sliderLength || 0);
+    const svFormulaDuration = sliderLength / (100 * baseSV * (-100 / speed)) * beatLength * sliderRepeat;
+    const fallbackDuration = beatLength * sliderRepeat * sliderLength / 100;
+    const duration = Number.isFinite(svFormulaDuration) && svFormulaDuration > 0 ? svFormulaDuration : fallbackDuration;
+    return Number.isFinite(duration) && duration > 0 ? duration : 0;
+  }
+  getSliderDurationCached(hitObject, hitTime) {
+    if (Number.isFinite(hitObject._sliderDuration) && hitObject._sliderDuration > 0) {
+      return hitObject._sliderDuration;
+    }
+    const duration = this.getSliderDuration(hitObject, hitTime);
+    hitObject._sliderDuration = duration > 0 ? duration : 2e3;
+    return hitObject._sliderDuration;
+  }
+  getCachedTimingPoint(hitTime) {
+    if (this.timingPointCache.has(hitTime)) {
+      return this.timingPointCache.get(hitTime);
+    }
+    const timingPoint = getTimingPointAt(hitTime, this.beatmap);
+    this.timingPointCache.set(hitTime, timingPoint);
+    return timingPoint;
+  }
+  prepareHitObject(hitObject, hitTime) {
+    hitObject.time = hitTime;
+    hitObject._hitsoundHeadPlayed = false;
+    hitObject._hitsoundSliderEndPlayed = false;
+    hitObject._hitsoundSliderRepeatPlayed = {};
+    hitObject._sliderDuration = this.getSliderDuration(hitObject, hitTime) || 2e3;
+    hitObject._repeatBurstMap = {};
+    hitObject._repeatBurstTriggered = {};
+  }
+  getHitBurstProgress(timeDiff) {
+    return Math.max(0, Math.min(1, -timeDiff / FADE_OUT_MS));
+  }
+  getHitBurstAlpha(progress) {
+    return Math.max(0, 1 - (Number(progress) || 0));
+  }
+  getHitBurstSize(baseSize, progress) {
+    const safeBaseSize = Number(baseSize) || 0;
+    const safeProgress = Number(progress) || 0;
+    return safeBaseSize + safeProgress * safeBaseSize * 0.3;
+  }
+  getHitBurstScale(baseScale, progress) {
+    const safeBaseScale = Number(baseScale) || 1;
+    const safeProgress = Number(progress) || 0;
+    return safeBaseScale + safeProgress * safeBaseScale * 0.3;
+  }
+  getDelimitedParts(value, delimiter) {
+    if (typeof value === "string") {
+      return value.split(delimiter);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => String(item ?? ""));
+    }
+    if (value == null) {
+      return [];
+    }
+    return String(value).split(delimiter);
+  }
+  computeBeatmapDurationMs() {
+    if (!this.hitObjectEntries.length) {
+      return 0;
+    }
+    let maxEndTime = 0;
+    for (const [hitTime, hitObject] of this.hitObjectEntries) {
+      const endTime = this.getHitObjectEndTime(hitObject, hitTime);
+      if (Number.isFinite(endTime) && endTime > maxEndTime) {
+        maxEndTime = endTime;
+      }
+    }
+    return Math.max(0, maxEndTime);
+  }
+  getHitObjectEndTime(hitObject, hitTime) {
+    if (!hitObject) {
+      return hitTime;
+    }
+    if (hitObject.type?.includes("Slider")) {
+      const sliderDuration = this.getSliderDurationCached(hitObject, hitTime);
+      return hitTime + Math.max(0, sliderDuration);
+    }
+    if (hitObject.type?.includes("Spinner")) {
+      const extrasParts = this.getDelimitedParts(hitObject.extras, ":");
+      const spinnerEndTime = Number.parseInt(extrasParts[0], 10);
+      if (Number.isFinite(spinnerEndTime) && spinnerEndTime > hitTime) {
+        return spinnerEndTime;
+      }
+    }
+    return hitTime;
+  }
+  getTransportCurrentTimeMs() {
+    if (!this.isPlaying) {
+      return this.currentTime;
+    }
+    const nowPerfMs = performance.now();
+    const elapsedMs = nowPerfMs - this.transportStartPerfTime;
+    const perfVisualMs = this.transportStartMs + Math.max(0, elapsedMs);
+    if (this.previewAudio && !this.previewAudio.paused && Number.isFinite(this.previewAudio.currentTime)) {
+      if (!this.lastAudioSyncSamplePerfMs || nowPerfMs - this.lastAudioSyncSamplePerfMs >= AUDIO_SYNC_SAMPLE_INTERVAL_MS) {
+        this.lastAudioSyncSamplePerfMs = nowPerfMs;
+        const audioDerivedVisualMs = this.getBeatmapTimeMsForPreviewAudioTime(
+          this.previewAudio.currentTime * 1e3
+        );
+        if (Number.isFinite(audioDerivedVisualMs)) {
+          const targetOffsetMs = audioDerivedVisualMs - perfVisualMs;
+          if (Math.abs(targetOffsetMs) > 120) {
+            this.audioSyncOffsetMs = targetOffsetMs;
+          } else {
+            this.audioSyncOffsetMs = this.audioSyncOffsetMs + (targetOffsetMs - this.audioSyncOffsetMs) * 0.35;
+          }
+        }
+      }
+    }
+    return perfVisualMs + this.audioSyncOffsetMs;
+  }
+  getPreviewAudioTimeMsForBeatmapTime(beatmapTimeMs) {
+    return beatmapTimeMs - this.previewTimeMs + this.audioOffsetMs;
+  }
+  getBeatmapTimeMsForPreviewAudioTime(previewAudioTimeMs) {
+    return previewAudioTimeMs + this.previewTimeMs - this.audioOffsetMs;
+  }
+  /** @deprecated No-op, kept for backward compatibility. */
+  async initHitsounds() {
+  }
+}
+function lowerBound(arr, target) {
+  let left = 0;
+  let right = arr.length;
+  while (left < right) {
+    const mid = left + right >> 1;
+    if (arr[mid] < target) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  return left;
+}
+function upperBound(arr, target) {
+  let left = 0;
+  let right = arr.length;
+  while (left < right) {
+    const mid = left + right >> 1;
+    if (arr[mid] <= target) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  return left;
+}
+function darkenColor(color, factor) {
+  const normalized = Math.max(0, Math.min(1, Number(factor) || 0));
+  const r = color >> 16 & 255;
+  const g = color >> 8 & 255;
+  const b = color & 255;
+  const dr = Math.round(r * normalized);
+  const dg = Math.round(g * normalized);
+  const db = Math.round(b * normalized);
+  return dr << 16 | dg << 8 | db;
+}
+export {
+  BeatmapEngine,
+  fetchAndParseOsu,
+  getGlobalAudioOffsetMs,
+  parseOsuText,
+  setGlobalAudioOffsetMs,
+  subscribeGlobalAudioOffset
+};