@cartesia/cartesia-js 1.3.0 → 2.0.0

package/wrapper/source.js

@@ -0,0 +1,179 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Source_instances, _Source_emitter, _Source_buffer, _Source_readIndex, _Source_writeIndex, _Source_closed, _Source_sampleRate, _Source_encoding, _Source_container, _Source_createBuffer;
+Object.defineProperty(exports, "__esModule", { value: true });
+const emittery_1 = __importDefault(require("emittery"));
+const utils_1 = require("./utils");
+class Source {
+    /**
+     * Create a new Source.
+     *
+     * @param options - Options for the Source.
+     * @param options.sampleRate - The sample rate of the audio.
+     */
+    constructor({ sampleRate, encoding, container }) {
+        _Source_instances.add(this);
+        _Source_emitter.set(this, new emittery_1.default());
+        _Source_buffer.set(this, void 0);
+        _Source_readIndex.set(this, 0);
+        _Source_writeIndex.set(this, 0);
+        _Source_closed.set(this, false);
+        _Source_sampleRate.set(this, void 0);
+        _Source_encoding.set(this, void 0);
+        _Source_container.set(this, void 0);
+        this.on = __classPrivateFieldGet(this, _Source_emitter, "f").on.bind(__classPrivateFieldGet(this, _Source_emitter, "f"));
+        this.once = __classPrivateFieldGet(this, _Source_emitter, "f").once.bind(__classPrivateFieldGet(this, _Source_emitter, "f"));
+        this.events = __classPrivateFieldGet(this, _Source_emitter, "f").events.bind(__classPrivateFieldGet(this, _Source_emitter, "f"));
+        this.off = __classPrivateFieldGet(this, _Source_emitter, "f").off.bind(__classPrivateFieldGet(this, _Source_emitter, "f"));
+        __classPrivateFieldSet(this, _Source_sampleRate, sampleRate, "f");
+        __classPrivateFieldSet(this, _Source_encoding, encoding, "f");
+        __classPrivateFieldSet(this, _Source_container, container, "f");
+        __classPrivateFieldSet(this, _Source_buffer, __classPrivateFieldGet(this, _Source_instances, "m", _Source_createBuffer).call(this, 1024), "f"); // Initial size, can be adjusted
+    }
+    get sampleRate() {
+        return __classPrivateFieldGet(this, _Source_sampleRate, "f");
+    }
+    get encoding() {
+        return __classPrivateFieldGet(this, _Source_encoding, "f");
+    }
+    get container() {
+        return __classPrivateFieldGet(this, _Source_container, "f");
+    }
+    /**
+     * Append audio to the buffer.
+     *
+     * @param src The audio to append.
+     */
+    enqueue(src) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requiredCapacity = __classPrivateFieldGet(this, _Source_writeIndex, "f") + src.length;
+            // Resize buffer if necessary
+            if (requiredCapacity > __classPrivateFieldGet(this, _Source_buffer, "f").length) {
+                let newCapacity = __classPrivateFieldGet(this, _Source_buffer, "f").length;
+                while (newCapacity < requiredCapacity) {
+                    newCapacity *= 2; // Double the buffer size
+                }
+                const newBuffer = __classPrivateFieldGet(this, _Source_instances, "m", _Source_createBuffer).call(this, newCapacity);
+                newBuffer.set(__classPrivateFieldGet(this, _Source_buffer, "f"));
+                __classPrivateFieldSet(this, _Source_buffer, newBuffer, "f");
+            }
+            // Append the audio to the buffer.
+            __classPrivateFieldGet(this, _Source_buffer, "f").set(src, __classPrivateFieldGet(this, _Source_writeIndex, "f"));
+            __classPrivateFieldSet(this, _Source_writeIndex, __classPrivateFieldGet(this, _Source_writeIndex, "f") + src.length, "f");
+            yield __classPrivateFieldGet(this, _Source_emitter, "f").emit("enqueue");
+        });
+    }
+    /**
+     * Read audio from the buffer.
+     *
+     * @param dst The buffer to read the audio into.
+     * @returns The number of samples read. If the source is closed, this will be
+     * less than the length of the provided buffer.
+     */
+    read(dst) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Read the buffer into the provided buffer.
+            const targetReadIndex = __classPrivateFieldGet(this, _Source_readIndex, "f") + dst.length;
+            while (!__classPrivateFieldGet(this, _Source_closed, "f") && targetReadIndex > __classPrivateFieldGet(this, _Source_writeIndex, "f")) {
+                // Wait for more audio to be enqueued.
+                yield __classPrivateFieldGet(this, _Source_emitter, "f").emit("wait");
+                yield Promise.race([__classPrivateFieldGet(this, _Source_emitter, "f").once("enqueue"), __classPrivateFieldGet(this, _Source_emitter, "f").once("close")]);
+                yield __classPrivateFieldGet(this, _Source_emitter, "f").emit("read");
+            }
+            const read = Math.min(dst.length, __classPrivateFieldGet(this, _Source_writeIndex, "f") - __classPrivateFieldGet(this, _Source_readIndex, "f"));
+            dst.set(__classPrivateFieldGet(this, _Source_buffer, "f").subarray(__classPrivateFieldGet(this, _Source_readIndex, "f"), __classPrivateFieldGet(this, _Source_readIndex, "f") + read));
+            __classPrivateFieldSet(this, _Source_readIndex, __classPrivateFieldGet(this, _Source_readIndex, "f") + read, "f");
+            return read;
+        });
+    }
+    /**
+     * Seek in the buffer.
+     *
+     * @param offset The offset to seek to.
+     * @param whence The position to seek from.
+     * @returns The new position in the buffer.
+     * @throws {Error} If the seek is invalid.
+     */
+    seek(offset, whence) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let position = __classPrivateFieldGet(this, _Source_readIndex, "f");
+            switch (whence) {
+                case "start":
+                    position = offset;
+                    break;
+                case "current":
+                    position += offset;
+                    break;
+                case "end":
+                    position = __classPrivateFieldGet(this, _Source_writeIndex, "f") + offset;
+                    break;
+                default:
+                    throw new Error(`Invalid seek mode: ${whence}`);
+            }
+            if (position < 0 || position > __classPrivateFieldGet(this, _Source_writeIndex, "f")) {
+                throw new Error("Seek out of bounds");
+            }
+            __classPrivateFieldSet(this, _Source_readIndex, position, "f");
+            return position;
+        });
+    }
+    /**
+     * Get the number of samples in a given duration.
+     *
+     * @param durationSecs The duration in seconds.
+     * @returns The number of samples.
+     */
+    durationToSampleCount(durationSecs) {
+        return Math.trunc(durationSecs * __classPrivateFieldGet(this, _Source_sampleRate, "f"));
+    }
+    get buffer() {
+        return __classPrivateFieldGet(this, _Source_buffer, "f");
+    }
+    get readIndex() {
+        return __classPrivateFieldGet(this, _Source_readIndex, "f");
+    }
+    get writeIndex() {
+        return __classPrivateFieldGet(this, _Source_writeIndex, "f");
+    }
+    /**
+     * Close the source. This signals that no more audio will be enqueued.
+     *
+     * This will emit a "close" event.
+     *
+     * @returns A promise that resolves when the source is closed.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _Source_closed, true, "f");
+            yield __classPrivateFieldGet(this, _Source_emitter, "f").emit("close");
+            __classPrivateFieldGet(this, _Source_emitter, "f").clearListeners();
+        });
+    }
+}
+exports.default = Source;
+_Source_emitter = new WeakMap(), _Source_buffer = new WeakMap(), _Source_readIndex = new WeakMap(), _Source_writeIndex = new WeakMap(), _Source_closed = new WeakMap(), _Source_sampleRate = new WeakMap(), _Source_encoding = new WeakMap(), _Source_container = new WeakMap(), _Source_instances = new WeakSet(), _Source_createBuffer = function _Source_createBuffer(size) {
+    const { arrayType: ArrayType } = utils_1.ENCODING_MAP[__classPrivateFieldGet(this, _Source_encoding, "f")];
+    return new ArrayType(size);
+};

package/wrapper/utils.d.ts

@@ -0,0 +1,105 @@
+import type Emittery from "emittery";
+import type { OutputFormat, RawEncoding, WebSocketResponse } from "../api";
+export declare type EmitteryCallbacks<T> = {
+    on: Emittery<T>["on"];
+    off: Emittery<T>["off"];
+    once: Emittery<T>["once"];
+    events: Emittery<T>["events"];
+};
+export declare type ConnectionEventData = {
+    open: never;
+    close: never;
+};
+export declare type SourceEventData = {
+    enqueue: never;
+    close: never;
+    wait: never;
+    read: never;
+};
+export declare type TypedArray = Float32Array | Int16Array | Uint8Array;
+export declare type Sentinel = null;
+export declare type Chunk = string | Sentinel;
+export declare type WebSocketOptions = {
+    container?: string;
+    encoding?: string;
+    sampleRate: number;
+};
+export declare type Language = "en" | "es" | "fr" | "de" | "ja" | "zh" | "pt" | (string & {});
+export declare type EncodingInfo = {
+    arrayType: Float32ArrayConstructor | Int16ArrayConstructor | Uint8ArrayConstructor;
+    bytesPerElement: number;
+};
+export declare const ENCODING_MAP: Record<RawEncoding, EncodingInfo>;
+/**
+ * Resolve the output format for a WebSocket request.
+ *
+ * @param container - The container type for the output.
+ * @param encoding - The encoding of the audio.
+ * @param sampleRate - The sample rate of the audio.
+ * @returns The output format for the WebSocket request.
+ */
+export declare function resolveOutputFormat(container: "raw" | "wav" | "mp3", encoding: RawEncoding, sampleRate: number): OutputFormat;
+/**
+ * Convert base64-encoded audio buffer(s) to a TypedArray.
+ *
+ * @param b64 The base64-encoded audio buffer, or an array of base64-encoded
+ * audio buffers.
+ * @param encoding The encoding of the audio buffer(s).
+ * @returns The audio buffer(s) as a TypedArray.
+ */
+export declare function base64ToArray(b64: Chunk[], encoding: string): TypedArray;
+/**
+ * Schedule an audio buffer to play at a given time in the passed context.
+ *
+ * @param floats The audio buffer to play.
+ * @param context The audio context to play the buffer in.
+ * @param startAt The time to start playing the buffer at.
+ * @param sampleRate The sample rate of the audio.
+ * @returns A promise that resolves when the audio has finished playing.
+ */
+export declare function playAudioBuffer(floats: Float32Array, context: AudioContext, startAt: number, sampleRate: number): Promise<void>;
+/**
+ * Unwraps a chunk of audio data from a message event and calls the
+ * handler with it if the context ID matches.
+ *
+ * @param contextId The context ID to listen for.
+ * @param handler The handler to call with the chunk of audio data.
+ * @returns A message event handler.
+ */
+export declare function createMessageHandlerForContextId(contextId: string, handler: ({ chunk, message }: {
+    chunk?: Chunk;
+    message: string;
+    data: WebSocketResponse;
+}) => void): (event: MessageEvent) => void;
+/**
+ * Get a sentinel value that indicates the end of a stream.
+ * @returns A sentinel value to indicate the end of a stream.
+ */
+export declare function getSentinel(): Sentinel;
+/**
+ * Check if a chunk is a sentinel value (i.e. null).
+ *
+ * @param chunk
+ * @returns Whether the chunk is a sentinel value.
+ */
+export declare function isSentinel(x: unknown): x is Sentinel;
+/**
+ * Filter out null values from a collection.
+ *
+ * @param collection The collection to filter.
+ * @returns The collection with null values removed.
+ */
+export declare function filterSentinel<T>(collection: T[]): Exclude<T, Sentinel>[];
+/**
+ * Check if an array of chunks is complete by testing if the last chunk is a sentinel
+ * value (i.e. null).
+ * @param chunk
+ * @returns Whether the array of chunks is complete.
+ */
+export declare function isComplete(chunks: Chunk[]): boolean;
+/**
+ * Get user-facing emitter callbacks for an Emittery instance.
+ * @param emitter The Emittery instance to get callbacks for.
+ * @returns User-facing emitter callbacks.
+ */
+export declare function getEmitteryCallbacks<T>(emitter: Emittery<T>): EmitteryCallbacks<T>;

package/wrapper/utils.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmitteryCallbacks = exports.isComplete = exports.filterSentinel = exports.isSentinel = exports.getSentinel = exports.createMessageHandlerForContextId = exports.playAudioBuffer = exports.base64ToArray = exports.resolveOutputFormat = exports.ENCODING_MAP = void 0;
+const base64_js_1 = __importDefault(require("base64-js"));
+exports.ENCODING_MAP = {
+    pcm_f32le: { arrayType: Float32Array, bytesPerElement: 4 },
+    pcm_s16le: { arrayType: Int16Array, bytesPerElement: 2 },
+    pcm_alaw: { arrayType: Uint8Array, bytesPerElement: 1 },
+    pcm_mulaw: { arrayType: Uint8Array, bytesPerElement: 1 },
+};
+/**
+ * Resolve the output format for a WebSocket request.
+ *
+ * @param container - The container type for the output.
+ * @param encoding - The encoding of the audio.
+ * @param sampleRate - The sample rate of the audio.
+ * @returns The output format for the WebSocket request.
+ */
+function resolveOutputFormat(container, encoding, sampleRate) {
+    switch (container) {
+        case "wav":
+            return {
+                container: "wav",
+                encoding,
+                sampleRate,
+            };
+        case "raw":
+            return {
+                container: "raw",
+                encoding,
+                sampleRate,
+            };
+        case "mp3":
+            return {
+                container: "mp3",
+                encoding,
+                sampleRate,
+                bitRate: 128,
+            };
+        default:
+            throw new Error(`Unsupported container type: ${container}`);
+    }
+}
+exports.resolveOutputFormat = resolveOutputFormat;
+/**
+ * Convert base64-encoded audio buffer(s) to a TypedArray.
+ *
+ * @param b64 The base64-encoded audio buffer, or an array of base64-encoded
+ * audio buffers.
+ * @param encoding The encoding of the audio buffer(s).
+ * @returns The audio buffer(s) as a TypedArray.
+ */
+function base64ToArray(b64, encoding) {
+    const byteArrays = filterSentinel(b64).map((b) => base64_js_1.default.toByteArray(b));
+    const { arrayType: ArrayType, bytesPerElement } = exports.ENCODING_MAP[encoding];
+    const totalLength = byteArrays.reduce((acc, arr) => acc + arr.length / bytesPerElement, 0);
+    const result = new ArrayType(totalLength);
+    let offset = 0;
+    for (const arr of byteArrays) {
+        const floats = new ArrayType(arr.buffer);
+        result.set(floats, offset);
+        offset += floats.length;
+    }
+    return result;
+}
+exports.base64ToArray = base64ToArray;
+/**
+ * Schedule an audio buffer to play at a given time in the passed context.
+ *
+ * @param floats The audio buffer to play.
+ * @param context The audio context to play the buffer in.
+ * @param startAt The time to start playing the buffer at.
+ * @param sampleRate The sample rate of the audio.
+ * @returns A promise that resolves when the audio has finished playing.
+ */
+function playAudioBuffer(floats, context, startAt, sampleRate) {
+    const source = context.createBufferSource();
+    const buffer = context.createBuffer(1, floats.length, sampleRate);
+    buffer.getChannelData(0).set(floats);
+    source.buffer = buffer;
+    source.connect(context.destination);
+    source.start(startAt);
+    return new Promise((resolve) => {
+        source.onended = () => {
+            resolve();
+        };
+    });
+}
+exports.playAudioBuffer = playAudioBuffer;
+/**
+ * Unwraps a chunk of audio data from a message event and calls the
+ * handler with it if the context ID matches.
+ *
+ * @param contextId The context ID to listen for.
+ * @param handler The handler to call with the chunk of audio data.
+ * @returns A message event handler.
+ */
+function createMessageHandlerForContextId(contextId, handler) {
+    return (event) => {
+        if (typeof event.data !== "string") {
+            return; // Ignore non-string messages.
+        }
+        const message = JSON.parse(event.data);
+        if (message.context_id !== contextId) {
+            return; // Ignore messages for other contexts.
+        }
+        let chunk;
+        if (message.done) {
+            // Convert the done message to a sentinel value.
+            chunk = getSentinel();
+        }
+        else if (message.type === "chunk") {
+            chunk = message.data;
+        }
+        handler({ chunk, message: event.data, data: message });
+    };
+}
+exports.createMessageHandlerForContextId = createMessageHandlerForContextId;
+/**
+ * Get a sentinel value that indicates the end of a stream.
+ * @returns A sentinel value to indicate the end of a stream.
+ */
+function getSentinel() {
+    return null;
+}
+exports.getSentinel = getSentinel;
+/**
+ * Check if a chunk is a sentinel value (i.e. null).
+ *
+ * @param chunk
+ * @returns Whether the chunk is a sentinel value.
+ */
+function isSentinel(x) {
+    return x === getSentinel();
+}
+exports.isSentinel = isSentinel;
+/**
+ * Filter out null values from a collection.
+ *
+ * @param collection The collection to filter.
+ * @returns The collection with null values removed.
+ */
+function filterSentinel(collection) {
+    return collection.filter((x) => !isSentinel(x));
+}
+exports.filterSentinel = filterSentinel;
+/**
+ * Check if an array of chunks is complete by testing if the last chunk is a sentinel
+ * value (i.e. null).
+ * @param chunk
+ * @returns Whether the array of chunks is complete.
+ */
+function isComplete(chunks) {
+    return isSentinel(chunks[chunks.length - 1]);
+}
+exports.isComplete = isComplete;
+/**
+ * Get user-facing emitter callbacks for an Emittery instance.
+ * @param emitter The Emittery instance to get callbacks for.
+ * @returns User-facing emitter callbacks.
+ */
+function getEmitteryCallbacks(emitter) {
+    return {
+        on: emitter.on.bind(emitter),
+        off: emitter.off.bind(emitter),
+        once: emitter.once.bind(emitter),
+        events: emitter.events.bind(emitter),
+    };
+}
+exports.getEmitteryCallbacks = getEmitteryCallbacks;

package/CHANGELOG.md

@@ -1,90 +0,0 @@
-# @cartesia/cartesia-js
-
-## 1.1.0
-
-### Minor Changes
-
-- ed6be65: Add WebSocket continue method for input streaming with contexts
-
-## 1.0.3
-
-### Patch Changes
-
-- 9b157d6: Support Bun by adding socket binaryType
-
-## 1.0.2
-
-### Patch Changes
-
-- Make voice creation and cloning fully compatible with API.
-
-## 1.0.1
-
-### Patch Changes
-
-- cb7adc2: Introduces support for continuations, timestamps, voice control and multiple output formats. Improves typing and error handling for the package.
-
-## 1.0.0
-
-### Major Changes
-
-- 3ee5bfc: Initial release of Cartesia client with voices and WebSocket support
-
-### Minor Changes
-
-- e49f73a: Stabilize audio playback in the browser to support play/pause functionality.
-
-### Patch Changes
-
-- c98a0c7: Fix typo in README
-- 38af01f: Fix how URLs are constructed, solving WebSocket connection failure
-- 8ecf940: Add provisional Node.js support
-- 585d2c9: Makes JS client compatible with the Cartesia Stable API (2024-06-10)
-
-## 1.0.0-alpha.4
-
-### Patch Changes
-
-- c98a0c7: Fix typo in README
-
-## 1.0.0-alpha.3
-
-### Patch Changes
-
-- 38af01f: Fix how URLs are constructed, solving WebSocket connection failure
-
-## 1.0.0-alpha.2
-
-### Patch Changes
-
-- 585d2c9: Makes JS client compatible with the Cartesia Stable API (2024-06-10)
-
-## 1.0.0-alpha.1
-
-### Major Changes
-
-- 3ee5bfc: Initial release of Cartesia client with voices and WebSocket support
-
-## 0.0.4-alpha.0
-
-### Patch Changes
-
-- 8ecf940: Add provisional Node.js support
-
-## 0.0.3
-
-### Patch Changes
-
-- 8b671ff: Revert queuing feature
-
-## 0.0.2
-
-### Patch Changes
-
-- 9a31c66: Improve error handling logic, add connection info, make audio downloadable, add latency metrics, more robust reconnection handling, and misc. changes
-
-## 0.0.1
-
-### Patch Changes
-
-- 0ea132f: Publish Cartesia JS client

package/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Cartesia AI, Inc.
-
-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/chunk-2BFEKY3F.js

@@ -1,16 +0,0 @@
-// src/lib/constants.ts
-var BASE_URL = "https://api.cartesia.ai";
-var CARTESIA_VERSION = "2024-06-10";
-var constructApiUrl = (baseUrl, path, { websocket = false } = {}) => {
-  const url = new URL(path, baseUrl);
-  if (websocket) {
-    url.protocol = baseUrl.replace(/^http/, "ws");
-  }
-  return url;
-};
-
-export {
-  BASE_URL,
-  CARTESIA_VERSION,
-  constructApiUrl
-};

package/dist/chunk-5SBAQNWQ.js

@@ -1,86 +0,0 @@
-import {
-  ENCODING_MAP
-} from "./chunk-I5YVYTNK.js";
-
-// src/tts/utils.ts
-import base64 from "base64-js";
-function base64ToArray(b64, encoding) {
-  const byteArrays = filterSentinel(b64).map((b) => base64.toByteArray(b));
-  const { arrayType: ArrayType, bytesPerElement } = ENCODING_MAP[encoding];
-  const totalLength = byteArrays.reduce(
-    (acc, arr) => acc + arr.length / bytesPerElement,
-    0
-  );
-  const result = new ArrayType(totalLength);
-  let offset = 0;
-  for (const arr of byteArrays) {
-    const floats = new ArrayType(arr.buffer);
-    result.set(floats, offset);
-    offset += floats.length;
-  }
-  return result;
-}
-function playAudioBuffer(floats, context, startAt, sampleRate) {
-  const source = context.createBufferSource();
-  const buffer = context.createBuffer(1, floats.length, sampleRate);
-  buffer.getChannelData(0).set(floats);
-  source.buffer = buffer;
-  source.connect(context.destination);
-  source.start(startAt);
-  return new Promise((resolve) => {
-    source.onended = () => {
-      resolve();
-    };
-  });
-}
-function createMessageHandlerForContextId(contextId, handler) {
-  return (event) => {
-    if (typeof event.data !== "string") {
-      return;
-    }
-    const message = JSON.parse(event.data);
-    if (message.context_id !== contextId) {
-      return;
-    }
-    let chunk;
-    if (message.done) {
-      chunk = getSentinel();
-    } else if (message.type === "chunk") {
-      chunk = message.data;
-    }
-    handler({ chunk, message: event.data, data: message });
-  };
-}
-function getSentinel() {
-  return null;
-}
-function isSentinel(x) {
-  return x === getSentinel();
-}
-function filterSentinel(collection) {
-  return collection.filter(
-    (x) => !isSentinel(x)
-  );
-}
-function isComplete(chunks) {
-  return isSentinel(chunks[chunks.length - 1]);
-}
-function getEmitteryCallbacks(emitter) {
-  return {
-    on: emitter.on.bind(emitter),
-    off: emitter.off.bind(emitter),
-    once: emitter.once.bind(emitter),
-    events: emitter.events.bind(emitter)
-  };
-}
-
-export {
-  base64ToArray,
-  playAudioBuffer,
-  createMessageHandlerForContextId,
-  getSentinel,
-  isSentinel,
-  filterSentinel,
-  isComplete,
-  getEmitteryCallbacks
-};