@cartesia/cartesia-js 1.3.0 → 2.0.0

package/dist/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/dist/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/dist/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/environments.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare const CartesiaEnvironment: {
+    readonly Production: "https://api.cartesia.ai";
+};
+export declare type CartesiaEnvironment = typeof CartesiaEnvironment.Production;

package/environments.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaEnvironment = void 0;
+exports.CartesiaEnvironment = {
+    Production: "https://api.cartesia.ai",
+};

package/errors/CartesiaError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class CartesiaError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    constructor({ message, statusCode, body }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+    });
+}

package/errors/CartesiaError.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaError = void 0;
+class CartesiaError extends Error {
+    constructor({ message, statusCode, body }) {
+        super(buildMessage({ message, statusCode, body }));
+        Object.setPrototypeOf(this, CartesiaError.prototype);
+        if (statusCode != null) {
+            this.statusCode = statusCode;
+        }
+        if (body !== undefined) {
+            this.body = body;
+        }
+    }
+}
+exports.CartesiaError = CartesiaError;
+function buildMessage({ message, statusCode, body, }) {
+    let lines = [];
+    if (message != null) {
+        lines.push(message);
+    }
+    if (statusCode != null) {
+        lines.push(`Status code: ${statusCode.toString()}`);
+    }
+    if (body != null) {
+        lines.push(`Body: ${JSON.stringify(body, undefined, 2)}`);
+    }
+    return lines.join("\n");
+}

package/errors/CartesiaTimeoutError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class CartesiaTimeoutError extends Error {
+    constructor();
+}

package/errors/CartesiaTimeoutError.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaTimeoutError = void 0;
+class CartesiaTimeoutError extends Error {
+    constructor() {
+        super("Timeout");
+        Object.setPrototypeOf(this, CartesiaTimeoutError.prototype);
+    }
+}
+exports.CartesiaTimeoutError = CartesiaTimeoutError;

package/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { CartesiaError } from "./CartesiaError";
+export { CartesiaTimeoutError } from "./CartesiaTimeoutError";

package/errors/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaTimeoutError = exports.CartesiaError = void 0;
+var CartesiaError_1 = require("./CartesiaError");
+Object.defineProperty(exports, "CartesiaError", { enumerable: true, get: function () { return CartesiaError_1.CartesiaError; } });
+var CartesiaTimeoutError_1 = require("./CartesiaTimeoutError");
+Object.defineProperty(exports, "CartesiaTimeoutError", { enumerable: true, get: function () { return CartesiaTimeoutError_1.CartesiaTimeoutError; } });

package/index.d.ts

@@ -0,0 +1,4 @@
+export * as Cartesia from "./api";
+export { CartesiaClient } from "./wrapper/Client";
+export { CartesiaEnvironment } from "./environments";
+export { CartesiaError, CartesiaTimeoutError } from "./errors";

package/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesiaTimeoutError = exports.CartesiaError = exports.CartesiaEnvironment = exports.CartesiaClient = exports.Cartesia = void 0;
+exports.Cartesia = __importStar(require("./api"));
+var Client_1 = require("./wrapper/Client");
+Object.defineProperty(exports, "CartesiaClient", { enumerable: true, get: function () { return Client_1.CartesiaClient; } });
+var environments_1 = require("./environments");
+Object.defineProperty(exports, "CartesiaEnvironment", { enumerable: true, get: function () { return environments_1.CartesiaEnvironment; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CartesiaError", { enumerable: true, get: function () { return errors_1.CartesiaError; } });
+Object.defineProperty(exports, "CartesiaTimeoutError", { enumerable: true, get: function () { return errors_1.CartesiaTimeoutError; } });

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('jest').Config} */
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+};