lrc-audio-player 0.1.2 → 0.1.3

package/README.md

@@ -1,9 +1,9 @@
 # lrc-audio-player
 
 Sync LRC (and word-level "enhanced" LRC) lyrics to an `HTMLAudioElement`
-from a single constructor. Gives you the current line, the next line,
-word-level highlighting, seeking by line, and change events — without
-re-scanning the whole lyric file on every `timeupdate`.
+with accurate seeking. Automatically converts variable-bitrate (VBR)
+audio to constant bitrate (CBR) for precise `currentTime` synchronization
+— critical for lyrics that must stay locked to the audio.
 
 ## Install
 
@@ -11,6 +11,16 @@ re-scanning the whole lyric file on every `timeupdate`.
 npm install lrc-audio-player
 ```
 
+**Optional:** If you need CBR conversion (recommended), also install:
+
+```bash
+npm install @ffmpeg/ffmpeg @ffmpeg/util
+```
+
+> `ffmpeg.wasm` is loaded on-demand and only when needed. If you skip
+> installing it, you must set `skipCBR: true` and provide CBR-encoded
+> audio files yourself.
+
 ## Quick start
 
 ```ts
@@ -18,7 +28,8 @@ import { LyricPlayer } from 'lrc-audio-player';
 
 const lrcText = await fetch('/song.lrc').then((r) => r.text());
 
-const player = new LyricPlayer({
+// Async factory — handles CBR conversion in the background
+const player = await LyricPlayer.create({
   audio: '/song.mp3',
   lyrics: lrcText,
 });
@@ -34,9 +45,20 @@ You can also hand it an existing `<audio>` element instead of a URL:
 
 ```ts
 const audioEl = document.querySelector('audio')!;
-const player = new LyricPlayer({ audio: audioEl, lyrics: lrcText });
+const player = await LyricPlayer.create({ audio: audioEl, lyrics: lrcText });
 ```
 
+## Why CBR conversion?
+
+Browsers estimate `audio.currentTime` from average bitrate when seek tables
+are missing. With VBR files, this causes drift — lyrics appear early or
+late after seeking. **CBR guarantees linear time-to-byte mapping**, so
+seeking is sample-accurate.
+
+By default, `lrc-audio-player` detects VBR MP3s and re-encodes them to
+CBR using `ffmpeg.wasm` (all in-browser, no server needed). If your audio
+is already CBR, set `skipCBR: true` to skip conversion.
+
 ## Lyric formats
 
 - **Standard LRC**: `[01:23.45]Some lyric line`
@@ -47,7 +69,7 @@ const player = new LyricPlayer({ audio: audioEl, lyrics: lrcText });
   use `lyrics: { type: 'json', data: [...] }`
 
 ```ts
-new LyricPlayer({
+await LyricPlayer.create({
   audio: '/song.mp3',
   lyrics: [
     { time: 0, text: 'First line' },
@@ -58,13 +80,30 @@ new LyricPlayer({
 
 ## API
 
-### `new LyricPlayer(options)`
+### `LyricPlayer.create(options)` (recommended)
+
+Async factory that waits for CBR conversion (if needed) before returning
+a ready-to-use player.
 
-| Option     | Type                                              | Description                                  |
-| ---------- | ------------------------------------------------- | --------------------------------------------- |
-| `audio`    | `string \| HTMLAudioElement`                      | Audio source URL, or an existing element       |
-| `lyrics`   | `string \| LyricLine[] \| ParsedLyrics \| LyricSource` | LRC text, JSON lines, or pre-parsed lyrics |
-| `offsetMs` | `number` (optional)                               | Extra global offset on top of `[offset:]`      |
+| Option       | Type                                                | Description                                      |
+| ------------ | --------------------------------------------------- | ------------------------------------------------ |
+| `audio`      | `string \| HTMLAudioElement`                        | Audio source URL, or an existing element         |
+| `lyrics`     | `string \| LyricLine[] \| ParsedLyrics \| LyricSource` | LRC text, JSON lines, or pre-parsed lyrics    |
+| `offsetMs`   | `number` (optional)                                 | Extra global offset on top of `[offset:]`        |
+| `skipCBR`    | `boolean` (optional, default `false`)               | Skip CBR conversion if your file is already CBR  |
+| `cbrBitrate` | `string` (optional, default `'128k'`)               | Target bitrate for CBR conversion              |
+
+### `new LyricPlayer(options)` (advanced)
+
+Synchronous constructor. The instance is returned immediately but
+**is not ready until `await player.ready()` resolves**. Use this if you
+need to attach listeners before initialization completes.
+
+```ts
+const player = new LyricPlayer({ audio: '/song.mp3', lyrics: lrcText });
+await player.ready();
+player.play();
+```
 
 ### Playback
 
@@ -90,13 +129,13 @@ new LyricPlayer({
 
 `on(event, handler)` / `off(event, handler)`:
 
-| Event        | Payload                                  |
+| Event        | Payload                                    |
 | ------------ | ------------------------------------------ |
 | `linechange` | `(line: LyricLine \| null, index: number)` |
 | `timeupdate` | `(currentTime: number)`                    |
-| `play`       | —                                           |
-| `pause`      | —                                           |
-| `ended`      | —                                           |
+| `play`       | —                                          |
+| `pause`      | —                                          |
+| `ended`      | —                                          |
 | `error`      | `(event: Event)`                           |
 
 ## Example: word-by-word highlighting
@@ -114,6 +153,16 @@ player.on('timeupdate', () => {
 });
 ```
 
+## Example: skip CBR for already-optimized files
+
+```ts
+const player = await LyricPlayer.create({
+  audio: '/song-cbr.mp3',
+  lyrics: lrcText,
+  skipCBR: true, // No conversion — instant load
+});
+```
+
 ## Development
 
 ```bash
@@ -122,3 +171,7 @@ npm run build      # bundle to dist/ (cjs + esm + types)
 npm test           # run vitest
 npm run typecheck  # tsc --noEmit
 ```
+
+## License
+
+MIT

package/dist/{chunk-O4Y7SZ2V.js → chunk-3A2M5KTA.js}

@@ -90,7 +90,7 @@ function parseJSONLyrics(json) {
 }
 
 // src/player.ts
-var LyricPlayer = class {
+var LyricPlayer = class _LyricPlayer {
   constructor(options) {
     this.currentIndex = -1;
     this.listeners = {};
@@ -103,7 +103,32 @@ var LyricPlayer = class {
       }
       this.emit("timeupdate", time);
     };
-    this.audio = typeof options.audio === "string" ? new Audio(options.audio) : options.audio;
+    this._readyPromise = this.initialize(options);
+  }
+  static async create(options) {
+    const player = new _LyricPlayer(options);
+    await player.ready();
+    return player;
+  }
+  async initialize(options) {
+    const { skipCBR = false, cbrBitrate = "128k" } = options;
+    let audioSrc;
+    let audioEl;
+    if (typeof options.audio === "string") {
+      audioSrc = options.audio;
+      audioEl = new Audio();
+    } else {
+      audioEl = options.audio;
+      audioSrc = options.audio.src || options.audio.currentSrc;
+    }
+    if (!skipCBR && audioSrc) {
+      const needsConversion = await this.detectNeedsCBR(audioSrc);
+      if (needsConversion) {
+        audioSrc = await this.convertToCBR(audioSrc, cbrBitrate);
+      }
+    }
+    audioEl.src = audioSrc;
+    this.audio = audioEl;
     const parsed = this.resolveLyrics(options.lyrics);
     this.metadata = parsed.metadata;
     this.lines = parsed.lines;
@@ -115,6 +140,71 @@ var LyricPlayer = class {
     this.audio.addEventListener("ended", () => this.emit("ended"));
     this.audio.addEventListener("error", (e) => this.emit("error", e));
   }
+  /** Wait for initialization (CBR conversion, etc.) before playing. */
+  ready() {
+    return this._readyPromise;
+  }
+  /** Detect if file is VBR or lacks proper seek tables. */
+  async detectNeedsCBR(src) {
+    try {
+      const response = await fetch(src, { method: "HEAD" });
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("audio/mpeg") || src.endsWith(".mp3")) {
+        const probe = await fetch(src, { headers: { Range: "bytes=0-1023" } });
+        const buffer = new Uint8Array(await probe.arrayBuffer());
+        return this.hasVBRHeader(buffer);
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  hasVBRHeader(buffer) {
+    const decoder = new TextDecoder("latin1");
+    const header = decoder.decode(buffer);
+    return /Xing|Info|VBRI/.test(header);
+  }
+  /** Convert audio to CBR using ffmpeg.wasm. */
+  async convertToCBR(src, bitrate) {
+    const [{ FFmpeg }, { fetchFile }] = await Promise.all([
+      import("@ffmpeg/ffmpeg"),
+      import("@ffmpeg/util")
+    ]);
+    const ffmpeg = new FFmpeg();
+    await ffmpeg.load();
+    await ffmpeg.writeFile("input", await fetchFile(src));
+    await ffmpeg.exec([
+      "-i",
+      "input",
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      bitrate,
+      "-minrate",
+      bitrate,
+      "-maxrate",
+      bitrate,
+      "-bufsize",
+      "256k",
+      "-preset",
+      "ultrafast",
+      "-fflags",
+      "+fastseek",
+      // Optimize for seeking
+      "-id3v2_version",
+      "3",
+      // Better metadata compatibility
+      "output.mp3"
+    ]);
+    const data = await ffmpeg.readFile("output.mp3");
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const blob = new Blob(
+      // @ts-ignore — Uint8Array is valid per spec, TS types are overly strict
+      [bytes],
+      { type: "audio/mpeg" }
+    );
+    return URL.createObjectURL(blob);
+  }
   // ---------------------------------------------------------------------
   // Lyric source resolution
   // ---------------------------------------------------------------------
@@ -156,7 +246,8 @@ var LyricPlayer = class {
   // ---------------------------------------------------------------------
   // Playback controls (thin wrappers over the audio element)
   // ---------------------------------------------------------------------
-  play() {
+  async play() {
+    await this.ready();
     return this.audio.play();
   }
   pause() {

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -118,7 +128,7 @@ function parseJSONLyrics(json) {
 }
 
 // src/player.ts
-var LyricPlayer = class {
+var LyricPlayer = class _LyricPlayer {
   constructor(options) {
     this.currentIndex = -1;
     this.listeners = {};
@@ -131,7 +141,32 @@ var LyricPlayer = class {
       }
       this.emit("timeupdate", time);
     };
-    this.audio = typeof options.audio === "string" ? new Audio(options.audio) : options.audio;
+    this._readyPromise = this.initialize(options);
+  }
+  static async create(options) {
+    const player = new _LyricPlayer(options);
+    await player.ready();
+    return player;
+  }
+  async initialize(options) {
+    const { skipCBR = false, cbrBitrate = "128k" } = options;
+    let audioSrc;
+    let audioEl;
+    if (typeof options.audio === "string") {
+      audioSrc = options.audio;
+      audioEl = new Audio();
+    } else {
+      audioEl = options.audio;
+      audioSrc = options.audio.src || options.audio.currentSrc;
+    }
+    if (!skipCBR && audioSrc) {
+      const needsConversion = await this.detectNeedsCBR(audioSrc);
+      if (needsConversion) {
+        audioSrc = await this.convertToCBR(audioSrc, cbrBitrate);
+      }
+    }
+    audioEl.src = audioSrc;
+    this.audio = audioEl;
     const parsed = this.resolveLyrics(options.lyrics);
     this.metadata = parsed.metadata;
     this.lines = parsed.lines;
@@ -143,6 +178,71 @@ var LyricPlayer = class {
     this.audio.addEventListener("ended", () => this.emit("ended"));
     this.audio.addEventListener("error", (e) => this.emit("error", e));
   }
+  /** Wait for initialization (CBR conversion, etc.) before playing. */
+  ready() {
+    return this._readyPromise;
+  }
+  /** Detect if file is VBR or lacks proper seek tables. */
+  async detectNeedsCBR(src) {
+    try {
+      const response = await fetch(src, { method: "HEAD" });
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("audio/mpeg") || src.endsWith(".mp3")) {
+        const probe = await fetch(src, { headers: { Range: "bytes=0-1023" } });
+        const buffer = new Uint8Array(await probe.arrayBuffer());
+        return this.hasVBRHeader(buffer);
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  hasVBRHeader(buffer) {
+    const decoder = new TextDecoder("latin1");
+    const header = decoder.decode(buffer);
+    return /Xing|Info|VBRI/.test(header);
+  }
+  /** Convert audio to CBR using ffmpeg.wasm. */
+  async convertToCBR(src, bitrate) {
+    const [{ FFmpeg }, { fetchFile }] = await Promise.all([
+      import("@ffmpeg/ffmpeg"),
+      import("@ffmpeg/util")
+    ]);
+    const ffmpeg = new FFmpeg();
+    await ffmpeg.load();
+    await ffmpeg.writeFile("input", await fetchFile(src));
+    await ffmpeg.exec([
+      "-i",
+      "input",
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      bitrate,
+      "-minrate",
+      bitrate,
+      "-maxrate",
+      bitrate,
+      "-bufsize",
+      "256k",
+      "-preset",
+      "ultrafast",
+      "-fflags",
+      "+fastseek",
+      // Optimize for seeking
+      "-id3v2_version",
+      "3",
+      // Better metadata compatibility
+      "output.mp3"
+    ]);
+    const data = await ffmpeg.readFile("output.mp3");
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const blob = new Blob(
+      // @ts-ignore — Uint8Array is valid per spec, TS types are overly strict
+      [bytes],
+      { type: "audio/mpeg" }
+    );
+    return URL.createObjectURL(blob);
+  }
   // ---------------------------------------------------------------------
   // Lyric source resolution
   // ---------------------------------------------------------------------
@@ -184,7 +284,8 @@ var LyricPlayer = class {
   // ---------------------------------------------------------------------
   // Playback controls (thin wrappers over the audio element)
   // ---------------------------------------------------------------------
-  play() {
+  async play() {
+    await this.ready();
     return this.audio.play();
   }
   pause() {

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { L as LyricLine, P as ParsedLyrics } from './player-C3ZCZJVs.cjs';
-export { a as LyricMetadata, b as LyricPlayer, c as LyricPlayerEventName, d as LyricPlayerEvents, e as LyricPlayerOptions, f as LyricSource, g as LyricToken } from './player-C3ZCZJVs.cjs';
+import { L as LyricLine, P as ParsedLyrics } from './player-sLsiwLVO.cjs';
+export { a as LyricMetadata, b as LyricPlayer, c as LyricPlayerEventName, d as LyricPlayerEvents, e as LyricPlayerOptions, f as LyricSource, g as LyricToken } from './player-sLsiwLVO.cjs';
 
 /**
  * Parse an LRC-format lyric file into structured, time-sorted lines plus

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { L as LyricLine, P as ParsedLyrics } from './player-C3ZCZJVs.js';
-export { a as LyricMetadata, b as LyricPlayer, c as LyricPlayerEventName, d as LyricPlayerEvents, e as LyricPlayerOptions, f as LyricSource, g as LyricToken } from './player-C3ZCZJVs.js';
+import { L as LyricLine, P as ParsedLyrics } from './player-sLsiwLVO.js';
+export { a as LyricMetadata, b as LyricPlayer, c as LyricPlayerEventName, d as LyricPlayerEvents, e as LyricPlayerOptions, f as LyricSource, g as LyricToken } from './player-sLsiwLVO.js';
 
 /**
  * Parse an LRC-format lyric file into structured, time-sorted lines plus

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   LyricPlayer,
   parseJSONLyrics,
   parseLRC
-} from "./chunk-O4Y7SZ2V.js";
+} from "./chunk-3A2M5KTA.js";
 export {
   LyricPlayer,
   parseJSONLyrics,

package/dist/{player-C3ZCZJVs.d.cts → player-sLsiwLVO.d.cts}

@@ -88,6 +88,14 @@ interface LyricPlayerOptions {
      * in the LRC file. Positive values shift lyrics later.
      */
     offsetMs?: number;
+    /**
+     * Disable CBR conversion if you know your audio file is already
+     * constant bitrate (e.g., properly encoded MP3/AAC with seek tables).
+     * @default false
+     */
+    skipCBR?: boolean;
+    /** Target bitrate for CBR conversion. @default '128k' */
+    cbrBitrate?: string;
 }
 type Listener<E extends LyricPlayerEventName> = LyricPlayerEvents[E];
 /**
@@ -106,7 +114,17 @@ declare class LyricPlayer {
     private offsetSeconds;
     private currentIndex;
     private listeners;
+    static create(options: LyricPlayerOptions): Promise<LyricPlayer>;
+    private _readyPromise;
     constructor(options: LyricPlayerOptions);
+    private initialize;
+    /** Wait for initialization (CBR conversion, etc.) before playing. */
+    ready(): Promise<void>;
+    /** Detect if file is VBR or lacks proper seek tables. */
+    private detectNeedsCBR;
+    private hasVBRHeader;
+    /** Convert audio to CBR using ffmpeg.wasm. */
+    private convertToCBR;
     private resolveLyrics;
     /** Replace the loaded lyrics at any time (e.g. after fetching a file). */
     setLyrics(lyrics: LyricPlayerOptions["lyrics"]): void;

package/dist/{player-C3ZCZJVs.d.ts → player-sLsiwLVO.d.ts}

@@ -88,6 +88,14 @@ interface LyricPlayerOptions {
      * in the LRC file. Positive values shift lyrics later.
      */
     offsetMs?: number;
+    /**
+     * Disable CBR conversion if you know your audio file is already
+     * constant bitrate (e.g., properly encoded MP3/AAC with seek tables).
+     * @default false
+     */
+    skipCBR?: boolean;
+    /** Target bitrate for CBR conversion. @default '128k' */
+    cbrBitrate?: string;
 }
 type Listener<E extends LyricPlayerEventName> = LyricPlayerEvents[E];
 /**
@@ -106,7 +114,17 @@ declare class LyricPlayer {
     private offsetSeconds;
     private currentIndex;
     private listeners;
+    static create(options: LyricPlayerOptions): Promise<LyricPlayer>;
+    private _readyPromise;
     constructor(options: LyricPlayerOptions);
+    private initialize;
+    /** Wait for initialization (CBR conversion, etc.) before playing. */
+    ready(): Promise<void>;
+    /** Detect if file is VBR or lacks proper seek tables. */
+    private detectNeedsCBR;
+    private hasVBRHeader;
+    /** Convert audio to CBR using ffmpeg.wasm. */
+    private convertToCBR;
     private resolveLyrics;
     /** Replace the loaded lyrics at any time (e.g. after fetching a file). */
     setLyrics(lyrics: LyricPlayerOptions["lyrics"]): void;

package/dist/react.cjs

@@ -1,8 +1,10 @@
 "use strict";
 "use client";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/react.ts
@@ -118,7 +128,7 @@ function parseJSONLyrics(json) {
 }
 
 // src/player.ts
-var LyricPlayer = class {
+var LyricPlayer = class _LyricPlayer {
   constructor(options) {
     this.currentIndex = -1;
     this.listeners = {};
@@ -131,7 +141,32 @@ var LyricPlayer = class {
       }
       this.emit("timeupdate", time);
     };
-    this.audio = typeof options.audio === "string" ? new Audio(options.audio) : options.audio;
+    this._readyPromise = this.initialize(options);
+  }
+  static async create(options) {
+    const player = new _LyricPlayer(options);
+    await player.ready();
+    return player;
+  }
+  async initialize(options) {
+    const { skipCBR = false, cbrBitrate = "128k" } = options;
+    let audioSrc;
+    let audioEl;
+    if (typeof options.audio === "string") {
+      audioSrc = options.audio;
+      audioEl = new Audio();
+    } else {
+      audioEl = options.audio;
+      audioSrc = options.audio.src || options.audio.currentSrc;
+    }
+    if (!skipCBR && audioSrc) {
+      const needsConversion = await this.detectNeedsCBR(audioSrc);
+      if (needsConversion) {
+        audioSrc = await this.convertToCBR(audioSrc, cbrBitrate);
+      }
+    }
+    audioEl.src = audioSrc;
+    this.audio = audioEl;
     const parsed = this.resolveLyrics(options.lyrics);
     this.metadata = parsed.metadata;
     this.lines = parsed.lines;
@@ -143,6 +178,71 @@ var LyricPlayer = class {
     this.audio.addEventListener("ended", () => this.emit("ended"));
     this.audio.addEventListener("error", (e) => this.emit("error", e));
   }
+  /** Wait for initialization (CBR conversion, etc.) before playing. */
+  ready() {
+    return this._readyPromise;
+  }
+  /** Detect if file is VBR or lacks proper seek tables. */
+  async detectNeedsCBR(src) {
+    try {
+      const response = await fetch(src, { method: "HEAD" });
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("audio/mpeg") || src.endsWith(".mp3")) {
+        const probe = await fetch(src, { headers: { Range: "bytes=0-1023" } });
+        const buffer = new Uint8Array(await probe.arrayBuffer());
+        return this.hasVBRHeader(buffer);
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  hasVBRHeader(buffer) {
+    const decoder = new TextDecoder("latin1");
+    const header = decoder.decode(buffer);
+    return /Xing|Info|VBRI/.test(header);
+  }
+  /** Convert audio to CBR using ffmpeg.wasm. */
+  async convertToCBR(src, bitrate) {
+    const [{ FFmpeg }, { fetchFile }] = await Promise.all([
+      import("@ffmpeg/ffmpeg"),
+      import("@ffmpeg/util")
+    ]);
+    const ffmpeg = new FFmpeg();
+    await ffmpeg.load();
+    await ffmpeg.writeFile("input", await fetchFile(src));
+    await ffmpeg.exec([
+      "-i",
+      "input",
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      bitrate,
+      "-minrate",
+      bitrate,
+      "-maxrate",
+      bitrate,
+      "-bufsize",
+      "256k",
+      "-preset",
+      "ultrafast",
+      "-fflags",
+      "+fastseek",
+      // Optimize for seeking
+      "-id3v2_version",
+      "3",
+      // Better metadata compatibility
+      "output.mp3"
+    ]);
+    const data = await ffmpeg.readFile("output.mp3");
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const blob = new Blob(
+      // @ts-ignore — Uint8Array is valid per spec, TS types are overly strict
+      [bytes],
+      { type: "audio/mpeg" }
+    );
+    return URL.createObjectURL(blob);
+  }
   // ---------------------------------------------------------------------
   // Lyric source resolution
   // ---------------------------------------------------------------------
@@ -184,7 +284,8 @@ var LyricPlayer = class {
   // ---------------------------------------------------------------------
   // Playback controls (thin wrappers over the audio element)
   // ---------------------------------------------------------------------
-  play() {
+  async play() {
+    await this.ready();
     return this.audio.play();
   }
   pause() {

package/dist/react.d.cts

@@ -1,5 +1,5 @@
-import { h as LyricPlayerOptions, b as LyricPlayer, L as LyricLine } from './player-C3ZCZJVs.cjs';
-export { f as LyricSource } from './player-C3ZCZJVs.cjs';
+import { h as LyricPlayerOptions, b as LyricPlayer, L as LyricLine } from './player-sLsiwLVO.cjs';
+export { f as LyricSource } from './player-sLsiwLVO.cjs';
 
 interface UseLyricPlayerOptions extends Omit<LyricPlayerOptions, "audio"> {
     /** Audio source URL. Set on the bound <audio> element. */

package/dist/react.d.ts

@@ -1,5 +1,5 @@
-import { h as LyricPlayerOptions, b as LyricPlayer, L as LyricLine } from './player-C3ZCZJVs.js';
-export { f as LyricSource } from './player-C3ZCZJVs.js';
+import { h as LyricPlayerOptions, b as LyricPlayer, L as LyricLine } from './player-sLsiwLVO.js';
+export { f as LyricSource } from './player-sLsiwLVO.js';
 
 interface UseLyricPlayerOptions extends Omit<LyricPlayerOptions, "audio"> {
     /** Audio source URL. Set on the bound <audio> element. */

package/dist/react.js

@@ -1,7 +1,7 @@
 "use client";
 import {
   LyricPlayer
-} from "./chunk-O4Y7SZ2V.js";
+} from "./chunk-3A2M5KTA.js";
 
 // src/react.ts
 import { useEffect, useRef, useState } from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lrc-audio-player",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Sync LRC/word-level lyrics to an HTML audio element with one constructor. Includes an optional React hook at lrc-audio-player/react.",
   "repository": {
     "type": "git",
@@ -33,8 +33,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/react.ts --format cjs,esm --dts --clean",
-    "dev": "tsup src/index.ts src/react.ts --format cjs,esm --dts --watch",
+    "build": "tsup src/index.ts src/react.ts --format cjs,esm --dts --clean --external @ffmpeg/ffmpeg,@ffmpeg/util",
+    "dev": "tsup src/index.ts src/react.ts --format cjs,esm --dts --watch --external @ffmpeg/ffmpeg,@ffmpeg/util",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck && npm run test && npm run build"
@@ -48,15 +48,25 @@
     "sync"
   ],
   "peerDependencies": {
+    "@ffmpeg/ffmpeg": ">=0.12.0",
+    "@ffmpeg/util": ">=0.12.0",
     "react": ">=19"
   },
   "peerDependenciesMeta": {
     "react": {
       "optional": true
+    },
+    "@ffmpeg/ffmpeg": {
+      "optional": true
+    },
+    "@ffmpeg/util": {
+      "optional": true
     }
   },
   "license": "MIT",
   "devDependencies": {
+    "@ffmpeg/ffmpeg": "^0.12.15",
+    "@ffmpeg/util": "^0.12.2",
     "@types/react": "^19.2.17",
     "react": "^19.2.7",
     "tsup": "^8.5.1",