@basmilius/apple-audio-source 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Bas Milius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/const.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_BYTES_PER_CHANNEL = 2;
+export declare const DEFAULT_CHANNELS = 2;
+export declare const DEFAULT_SAMPLE_RATE = 44100;
+export declare const FFMPEG_FRAMES_PER_PACKET = 352;

package/dist/decoder/codec.d.ts

@@ -0,0 +1,3 @@
+export declare function isMp3(buffer: Buffer): boolean;
+export declare function isOgg(buffer: Buffer): boolean;
+export declare function isWav(buffer: Buffer): boolean;

package/dist/decoder/decode.d.ts

@@ -0,0 +1 @@
+export default function(buffer: Buffer): Promise<Buffer>;

package/dist/decoder/index.d.ts

@@ -0,0 +1,3 @@
+export { isMp3, isOgg, isWav } from "./codec";
+export { default as decode } from "./decode";
+export * from "./pcm";

package/dist/decoder/pcm.d.ts

@@ -0,0 +1,8 @@
+export declare function convertPcm(input: Buffer, options: ConvertPcmOptions): Buffer;
+type ConvertPcmOptions = {
+	readonly inputChannels: number;
+	readonly inputSampleRate: number;
+	readonly inputBitsPerSample: number;
+	readonly inputEndian: "little" | "big";
+};
+export {};

package/dist/ffmpeg.d.ts

@@ -0,0 +1,10 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Ffmpeg implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(filePath: string, duration: number, sampleRate?: number, channels?: number, bytesPerChannel?: number);
+	start(): Promise<void>;
+	reset(): Promise<void>;
+	stop(): Promise<void>;
+	readFrames(count: number): Promise<Buffer | null>;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Ffmpeg } from "./ffmpeg";
+export { default as Mp3 } from "./mp3";
+export { default as Ogg } from "./ogg";
+export { default as Pcm } from "./pcm";
+export { default as SineWave } from "./sineWave";
+export { default as Url } from "./url";
+export { default as Wav } from "./wav";

package/dist/index.js

@@ -0,0 +1,436 @@
+// src/ffmpeg.ts
+import { spawn } from "node:child_process";
+
+// src/const.ts
+var DEFAULT_BYTES_PER_CHANNEL = 2;
+var DEFAULT_CHANNELS = 2;
+var DEFAULT_SAMPLE_RATE = 44100;
+var FFMPEG_FRAMES_PER_PACKET = 352;
+
+// src/ffmpeg.ts
+class Ffmpeg {
+  duration;
+  #frameSize;
+  #filePath;
+  #sampleRate;
+  #channels;
+  #ffmpeg = null;
+  #buffer = Buffer.alloc(0);
+  #ended = false;
+  #resolveQueue = [];
+  constructor(filePath, duration, sampleRate = DEFAULT_SAMPLE_RATE, channels = DEFAULT_CHANNELS, bytesPerChannel = DEFAULT_BYTES_PER_CHANNEL) {
+    this.#filePath = filePath;
+    this.duration = duration;
+    this.#sampleRate = sampleRate;
+    this.#channels = channels;
+    this.#frameSize = channels * bytesPerChannel;
+  }
+  async start() {
+    this.#ffmpeg = spawn("ffmpeg", [
+      "-i",
+      this.#filePath,
+      "-f",
+      "s16be",
+      "-acodec",
+      "pcm_s16be",
+      "-ar",
+      String(this.#sampleRate),
+      "-ac",
+      String(this.#channels),
+      "-"
+    ], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    this.#ffmpeg.stdout.on("data", (chunk) => {
+      this.#buffer = Buffer.concat([this.#buffer, chunk]);
+      this.#processQueue();
+    });
+    this.#ffmpeg.stdout.on("end", () => {
+      this.#ended = true;
+      this.#processQueue();
+    });
+    this.#ffmpeg.on("error", (err) => {
+      console.error("ffmpeg error:", err);
+      this.#ended = true;
+      this.#processQueue();
+    });
+  }
+  async reset() {}
+  async stop() {
+    if (!this.#ffmpeg) {
+      return;
+    }
+    while (this.#resolveQueue.length > 0) {
+      this.#resolveQueue.shift()(null);
+    }
+    this.#ffmpeg.stdout?.removeAllListeners();
+    this.#ffmpeg.removeAllListeners();
+    this.#ffmpeg.kill();
+    this.#ffmpeg = null;
+  }
+  async readFrames(count) {
+    const bytesNeeded = count * this.#frameSize;
+    if (this.#buffer.length >= bytesNeeded) {
+      const chunk = this.#buffer.subarray(0, bytesNeeded);
+      this.#buffer = this.#buffer.subarray(bytesNeeded);
+      return chunk;
+    }
+    if (this.#ended) {
+      if (this.#buffer.length > 0) {
+        const chunk = this.#buffer;
+        this.#buffer = Buffer.alloc(0);
+        return chunk;
+      }
+      return null;
+    }
+    return new Promise((resolve) => {
+      this.#resolveQueue.push(resolve);
+    });
+  }
+  #processQueue() {
+    while (this.#resolveQueue.length > 0) {
+      const bytesNeeded = FFMPEG_FRAMES_PER_PACKET * this.#frameSize;
+      if (this.#buffer.length >= bytesNeeded) {
+        const chunk = this.#buffer.subarray(0, bytesNeeded);
+        this.#buffer = this.#buffer.subarray(bytesNeeded);
+        this.#resolveQueue.shift()(chunk);
+      } else if (this.#ended) {
+        if (this.#buffer.length > 0) {
+          const chunk = this.#buffer;
+          this.#buffer = Buffer.alloc(0);
+          this.#resolveQueue.shift()(chunk);
+        } else {
+          this.#resolveQueue.shift()(null);
+        }
+      } else {
+        break;
+      }
+    }
+  }
+}
+// src/decoder/codec.ts
+function isMp3(buffer) {
+  return buffer[0] === 73 && buffer[1] === 68 && buffer[2] === 51 || buffer[0] === 255 && (buffer[1] & 224) === 224;
+}
+function isOgg(buffer) {
+  return buffer.length > 4 && buffer.toString("ascii", 0, 4) === "OggS";
+}
+function isWav(buffer) {
+  return buffer.length > 12 && buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WAVE";
+}
+// src/decoder/pcm.ts
+function convertPcm(input, options) {
+  const { inputChannels, inputSampleRate, inputBitsPerSample, inputEndian } = options;
+  const bytesPerSample = inputBitsPerSample / 8;
+  const inputFrameSize = inputChannels * bytesPerSample;
+  const inputFrames = Math.floor(input.length / inputFrameSize);
+  const outputFrames = Math.floor(inputFrames * DEFAULT_SAMPLE_RATE / inputSampleRate);
+  const output = Buffer.alloc(outputFrames * DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL);
+  for (let i = 0;i < outputFrames; i++) {
+    const srcPos = i * inputSampleRate / DEFAULT_SAMPLE_RATE;
+    const srcIndex = Math.floor(srcPos);
+    const srcFrac = srcPos - srcIndex;
+    for (let ch = 0;ch < DEFAULT_CHANNELS; ch++) {
+      const inputCh = Math.min(ch, inputChannels - 1);
+      const sample1 = readSample(input, srcIndex, inputCh, inputFrameSize, bytesPerSample, inputBitsPerSample, inputEndian);
+      const sample2 = srcIndex + 1 < inputFrames ? readSample(input, srcIndex + 1, inputCh, inputFrameSize, bytesPerSample, inputBitsPerSample, inputEndian) : sample1;
+      const sample = sample1 + (sample2 - sample1) * srcFrac;
+      const outputOffset = (i * DEFAULT_CHANNELS + ch) * DEFAULT_BYTES_PER_CHANNEL;
+      output.writeInt16BE(Math.round(Math.max(-32768, Math.min(32767, sample))), outputOffset);
+    }
+  }
+  return output;
+}
+function readSample(buffer, frame, channel, frameSize, bytesPerSample, bitsPerSample, endian) {
+  const offset = frame * frameSize + channel * bytesPerSample;
+  if (offset + bytesPerSample > buffer.length)
+    return 0;
+  if (bitsPerSample === 16) {
+    return endian === "little" ? buffer.readInt16LE(offset) : buffer.readInt16BE(offset);
+  }
+  if (bitsPerSample === 8) {
+    return (buffer[offset] - 128) * 256;
+  }
+  if (bitsPerSample === 24) {
+    let value;
+    if (endian === "little") {
+      value = buffer[offset] | buffer[offset + 1] << 8 | buffer[offset + 2] << 16;
+    } else {
+      value = buffer[offset] << 16 | buffer[offset + 1] << 8 | buffer[offset + 2];
+    }
+    if (value & 8388608) {
+      value |= ~16777215;
+    }
+    return value / 256;
+  }
+  if (bitsPerSample === 32) {
+    const value = endian === "little" ? buffer.readInt32LE(offset) : buffer.readInt32BE(offset);
+    return value / 65536;
+  }
+  return 0;
+}
+
+// src/decoder/decode.ts
+import audioDecode from "audio-decode";
+async function decode_default(buffer) {
+  const audioBuffer = await audioDecode(buffer);
+  const numChannels = audioBuffer.numberOfChannels;
+  const numFrames = audioBuffer.length;
+  const sampleRate = audioBuffer.sampleRate;
+  const tempBuffer = Buffer.alloc(numFrames * DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL);
+  for (let i = 0;i < numFrames; i++) {
+    for (let ch = 0;ch < DEFAULT_CHANNELS; ch++) {
+      const inputCh = Math.min(ch, numChannels - 1);
+      const channelData = audioBuffer.getChannelData(inputCh);
+      const sample = Math.round(channelData[i] * 32767);
+      const clampedSample = Math.max(-32768, Math.min(32767, sample));
+      tempBuffer.writeInt16BE(clampedSample, (i * DEFAULT_CHANNELS + ch) * DEFAULT_BYTES_PER_CHANNEL);
+    }
+  }
+  if (sampleRate !== DEFAULT_SAMPLE_RATE) {
+    return convertPcm(tempBuffer, {
+      inputChannels: DEFAULT_CHANNELS,
+      inputSampleRate: sampleRate,
+      inputBitsPerSample: 16,
+      inputEndian: "big"
+    });
+  }
+  return tempBuffer;
+}
+// src/mp3.ts
+class Mp3 {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(buffer, duration) {
+    this.#buffer = buffer;
+    this.#frameSize = DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL;
+    this.duration = duration;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+  static async fromBuffer(mp3Buffer) {
+    if (!isMp3(mp3Buffer)) {
+      throw new Error("Invalid MP3 file");
+    }
+    const pcmBuffer = await decode_default(mp3Buffer);
+    const duration = pcmBuffer.length / (DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL) / DEFAULT_SAMPLE_RATE;
+    return new Mp3(pcmBuffer, duration);
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return Mp3.fromBuffer(Buffer.from(arrayBuffer));
+  }
+}
+// src/ogg.ts
+class Ogg {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(buffer, duration) {
+    this.#buffer = buffer;
+    this.#frameSize = DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL;
+    this.duration = duration;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+  static async fromBuffer(oggBuffer) {
+    if (!isOgg(oggBuffer)) {
+      throw new Error("Invalid OGG file");
+    }
+    const pcmBuffer = await decode_default(oggBuffer);
+    const duration = pcmBuffer.length / (DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL) / DEFAULT_SAMPLE_RATE;
+    return new Ogg(pcmBuffer, duration);
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return Ogg.fromBuffer(Buffer.from(arrayBuffer));
+  }
+}
+// src/pcm.ts
+class Pcm {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(pcmBuffer, sampleRate = DEFAULT_SAMPLE_RATE) {
+    this.#buffer = pcmBuffer;
+    this.#frameSize = DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL;
+    this.duration = pcmBuffer.length / this.#frameSize / sampleRate;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+}
+// src/sineWave.ts
+class SineWave {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(durationSeconds, frequency = 440, sampleRate = DEFAULT_SAMPLE_RATE, channels = DEFAULT_CHANNELS, bytesPerChannel = DEFAULT_BYTES_PER_CHANNEL) {
+    this.duration = durationSeconds;
+    this.#frameSize = channels * bytesPerChannel;
+    this.#buffer = this.#generateSineWave(sampleRate, channels, bytesPerChannel, durationSeconds, frequency);
+  }
+  #generateSineWave(sampleRate, channels, bytesPerChannel, durationSeconds, frequency) {
+    const totalSamples = sampleRate * durationSeconds;
+    const buffer = Buffer.alloc(totalSamples * channels * bytesPerChannel);
+    const fadeSamples = Math.floor(sampleRate * 0.05);
+    for (let i = 0;i < totalSamples; i++) {
+      const sample = Math.sin(2 * Math.PI * frequency * i / sampleRate);
+      let envelope = 1;
+      if (i < fadeSamples) {
+        envelope = i / fadeSamples;
+      } else if (i >= totalSamples - fadeSamples) {
+        envelope = (totalSamples - i) / fadeSamples;
+      }
+      const value = Math.round(sample * envelope * 32767);
+      for (let ch = 0;ch < channels; ch++) {
+        const offset = (i * channels + ch) * bytesPerChannel;
+        buffer.writeInt16BE(value, offset);
+      }
+    }
+    return buffer;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+}
+// src/url.ts
+class Url {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(buffer, duration) {
+    this.#buffer = buffer;
+    this.#frameSize = DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL;
+    this.duration = duration;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    let pcmBuffer;
+    if (isMp3(buffer) || isOgg(buffer) || isWav(buffer)) {
+      pcmBuffer = await decode_default(buffer);
+    } else {
+      throw new Error("Unsupported audio format. Please use WAV or MP3.");
+    }
+    const duration = pcmBuffer.length / (DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL) / DEFAULT_SAMPLE_RATE;
+    return new Url(pcmBuffer, duration);
+  }
+}
+// src/wav.ts
+class Wav {
+  duration;
+  #buffer;
+  #frameSize;
+  #offset = 0;
+  constructor(buffer, duration) {
+    this.#buffer = buffer;
+    this.#frameSize = DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL;
+    this.duration = duration;
+  }
+  async readFrames(count) {
+    if (this.#offset >= this.#buffer.length) {
+      return null;
+    }
+    const bytesToRead = count * this.#frameSize;
+    const chunk = this.#buffer.subarray(this.#offset, this.#offset + bytesToRead);
+    this.#offset += bytesToRead;
+    return chunk.length > 0 ? chunk : null;
+  }
+  async reset() {
+    this.#offset = 0;
+  }
+  async start() {}
+  async stop() {}
+  static async fromBuffer(wavBuffer) {
+    if (!isWav(wavBuffer)) {
+      throw new Error("Invalid WAV file");
+    }
+    const pcmBuffer = await decode_default(wavBuffer);
+    const duration = pcmBuffer.length / (DEFAULT_CHANNELS * DEFAULT_BYTES_PER_CHANNEL) / DEFAULT_SAMPLE_RATE;
+    return new Wav(pcmBuffer, duration);
+  }
+  static async fromUrl(url) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    return Wav.fromBuffer(Buffer.from(arrayBuffer));
+  }
+}
+export {
+  Wav,
+  Url,
+  SineWave,
+  Pcm,
+  Ogg,
+  Mp3,
+  Ffmpeg
+};

package/dist/mp3.d.ts

@@ -0,0 +1,12 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Mp3 implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(buffer: Buffer, duration: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	static fromBuffer(mp3Buffer: Buffer): Promise<Mp3>;
+	static fromUrl(url: string): Promise<Mp3>;
+}

package/dist/ogg.d.ts

@@ -0,0 +1,12 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Ogg implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(buffer: Buffer, duration: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	static fromBuffer(oggBuffer: Buffer): Promise<Ogg>;
+	static fromUrl(url: string): Promise<Ogg>;
+}

package/dist/pcm.d.ts

@@ -0,0 +1,10 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Pcm implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(pcmBuffer: Buffer, sampleRate?: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+}

package/dist/sineWave.d.ts

@@ -0,0 +1,10 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class SineWave implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(durationSeconds: number, frequency?: number, sampleRate?: number, channels?: number, bytesPerChannel?: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+}

package/dist/url.d.ts

@@ -0,0 +1,11 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Url implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(buffer: Buffer, duration: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	static fromUrl(url: string): Promise<Url>;
+}

package/dist/wav.d.ts

@@ -0,0 +1,12 @@
+import type { AudioSource } from "@basmilius/apple-common";
+export default class Wav implements AudioSource {
+	#private;
+	readonly duration: number;
+	constructor(buffer: Buffer, duration: number);
+	readFrames(count: number): Promise<Buffer | null>;
+	reset(): Promise<void>;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	static fromBuffer(wavBuffer: Buffer): Promise<Wav>;
+	static fromUrl(url: string): Promise<Wav>;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@basmilius/apple-audio-source",
+    "description": "Different audio sources for use in Apple Streaming Protocols.",
+    "version": "0.6.0",
+    "type": "module",
+    "license": "MIT",
+    "author": {
+        "name": "Bas Milius",
+        "email": "bas@mili.us",
+        "url": "https://bas.dev"
+    },
+    "keywords": [],
+    "files": [
+        "dist",
+        "LICENSE"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "scripts": {
+        "build": "tsc && bun -b build.ts"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "typings": "./dist/index.d.ts",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "dependencies": {
+        "@basmilius/apple-common": "0.6.0",
+        "audio-decode": "^2.2.3"
+    },
+    "devDependencies": {
+        "@basmilius/tools": "^2.23.0",
+        "@types/bun": "^1.3.8"
+    }
+}