@pipedog/core 0.0.0 → 0.2.0

package/dist/audio/resamplers/resampy_resampler.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/resampy_resampler.py
+/**
+ * Resampy-based audio resampler implementation.
+ *
+ * PORTING NOTE: upstream's only export, `ResampyResampler`, is deprecated
+ * (since 1.2.0, removed in 2.0.0) and is not ported. Use
+ * `SOXRAudioResampler`, `createFileResampler()` or `createStreamResampler()`
+ * instead.
+ */
+export {};
+//# sourceMappingURL=resampy_resampler.js.map

package/dist/audio/resamplers/sinc_engine.d.ts

@@ -0,0 +1,10 @@
+import type { ResamplerEngine } from "./engine.ts";
+/**
+ * Create the pure-TypeScript windowed-sinc engine.
+ *
+ * Applications normally never call this: core falls back to it on its own
+ * when the WASM engine cannot load. It can also be installed explicitly with
+ * `setResamplerEngine(createSincResamplerEngine())`.
+ */
+export declare function createSincResamplerEngine(): ResamplerEngine;
+//# sourceMappingURL=sinc_engine.d.ts.map

package/dist/audio/resamplers/sinc_engine.js

@@ -0,0 +1,235 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+const SPECS = {
+    QQ: { passband: 0.8, attenuation: 50 },
+    LQ: { passband: 0.676, attenuation: 96 },
+    MQ: { passband: 0.91, attenuation: 96 },
+    HQ: { passband: 0.91, attenuation: 120 },
+    VHQ: { passband: 0.91, attenuation: 140 },
+};
+/** Kaiser window design (Kaiser's formulas for beta and length). */
+function design({ passband, attenuation }) {
+    const transition = 1 - passband; // in units of the lower Nyquist frequency
+    const cutoff = (1 + passband) / 2;
+    const beta = attenuation > 50
+        ? 0.1102 * (attenuation - 8.7)
+        : 0.5842 * (attenuation - 21) ** 0.4 + 0.07886 * (attenuation - 21);
+    // Total length in samples of the lower rate, then in zero crossings per side.
+    const length = (attenuation - 7.95) / (2.285 * Math.PI * transition);
+    const zeros = Math.ceil((length / 2) * cutoff);
+    return { zeros, cutoff, beta };
+}
+const PRESETS = Object.fromEntries(Object.entries(SPECS).map(([q, spec]) => [q, design(spec)]));
+/** Table points per zero crossing (linear interpolation error ~ -118 dB). */
+const OVERSAMPLE = 1024;
+/** Zeroth-order modified Bessel function of the first kind. */
+function besselI0(x) {
+    let sum = 1;
+    let term = 1;
+    const q = (x * x) / 4;
+    for (let k = 1; k < 200; k++) {
+        term *= q / (k * k);
+        sum += term;
+        if (term < sum * 1e-17)
+            break;
+    }
+    return sum;
+}
+const TABLES = new Map();
+/** sinc(x) * kaiser(x / zeros) for x in [0, zeros], OVERSAMPLE points per unit (plus guard). */
+function kernelTable(quality) {
+    let table = TABLES.get(quality);
+    if (table)
+        return table;
+    const { zeros, beta } = PRESETS[quality];
+    const n = zeros * OVERSAMPLE;
+    table = new Float32Array(n + 2);
+    const i0b = besselI0(beta);
+    for (let i = 0; i <= n; i++) {
+        const x = i / OVERSAMPLE;
+        const r = x / zeros;
+        const w = besselI0(beta * Math.sqrt(Math.max(0, 1 - r * r))) / i0b;
+        const s = i === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+        table[i] = s * w;
+    }
+    TABLES.set(quality, table);
+    return table;
+}
+function checkRates(inRate, outRate) {
+    if (!(inRate > 0) || !(outRate > 0) || !Number.isFinite(inRate) || !Number.isFinite(outRate)) {
+        throw new Error(`invalid sample rates: ${inRate}->${outRate}`);
+    }
+}
+/** One channel of a streaming windowed-sinc resampler. */
+class SincChannel {
+    #step; // input samples per output sample
+    #scale; // 2 * fc (fc in cycles per input sample)
+    #halfWidth; // kernel half width in input samples
+    #table;
+    #tableScale; // table index per input-sample distance
+    /** Input history; #buf[0] is absolute input index #base. */
+    #buf = new Float64Array(256);
+    #len = 0;
+    #base = 0;
+    /** Total input samples seen and next output index (absolute). */
+    #totalIn = 0;
+    #nextOut = 0;
+    constructor(inRate, outRate, quality) {
+        const preset = PRESETS[quality];
+        this.#step = inRate / outRate;
+        const fc = 0.5 * Math.min(1, outRate / inRate) * preset.cutoff;
+        this.#scale = 2 * fc;
+        this.#halfWidth = preset.zeros / this.#scale;
+        this.#table = kernelTable(quality);
+        this.#tableScale = this.#scale * OVERSAMPLE;
+    }
+    #append(samples, start, stride, count) {
+        if (this.#len + count > this.#buf.length) {
+            const grown = new Float64Array(Math.max(this.#buf.length * 2, this.#len + count));
+            grown.set(this.#buf.subarray(0, this.#len));
+            this.#buf = grown;
+        }
+        for (let i = 0; i < count; i++) {
+            this.#buf[this.#len + i] = samples[start + i * stride];
+        }
+        this.#len += count;
+        this.#totalIn += count;
+    }
+    #sampleAt(t) {
+        const lo = Math.ceil(t - this.#halfWidth);
+        const hi = Math.floor(t + this.#halfWidth);
+        const buf = this.#buf;
+        const base = this.#base;
+        const table = this.#table;
+        const ts = this.#tableScale;
+        const tableMax = table.length - 2;
+        let acc = 0;
+        const from = Math.max(lo, base);
+        const to = Math.min(hi, base + this.#len - 1);
+        for (let n = from; n <= to; n++) {
+            const pos = Math.abs(t - n) * ts;
+            const i = pos | 0;
+            if (i > tableMax)
+                continue;
+            const frac = pos - i;
+            const k = table[i] + (table[i + 1] - table[i]) * frac;
+            acc += buf[n - base] * k;
+        }
+        return acc * this.#scale;
+    }
+    /** Number of outputs computable now (or, with `end`, the remaining outputs of the stream). */
+    #available(end) {
+        if (end) {
+            const total = Math.round(this.#totalIn / this.#step);
+            return Math.max(0, total - this.#nextOut);
+        }
+        // Output k needs inputs up to floor(k*step + halfWidth) < totalIn.
+        const last = Math.floor((this.#totalIn - 1 - this.#halfWidth) / this.#step);
+        return Math.max(0, last + 1 - this.#nextOut);
+    }
+    /** Feed `count` samples (strided) and write the outputs produced to `out` (strided). */
+    process(samples, start, stride, count, end) {
+        if (count > 0)
+            this.#append(samples, start, stride, count);
+        const n = this.#available(end);
+        const out = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            out[i] = this.#sampleAt((this.#nextOut + i) * this.#step);
+        }
+        this.#nextOut += n;
+        if (end) {
+            this.clear();
+        }
+        else {
+            // Drop history no future output can reach.
+            const keepFrom = Math.floor(this.#nextOut * this.#step - this.#halfWidth) - 1;
+            const drop = Math.min(this.#len, keepFrom - this.#base);
+            if (drop > 0) {
+                this.#buf.copyWithin(0, drop, this.#len);
+                this.#len -= drop;
+                this.#base += drop;
+            }
+        }
+        return out;
+    }
+    clear() {
+        this.#len = 0;
+        this.#base = 0;
+        this.#totalIn = 0;
+        this.#nextOut = 0;
+    }
+}
+function toInt16(x) {
+    const r = Math.round(x);
+    return r > 32767 ? 32767 : r < -32768 ? -32768 : r;
+}
+/** A streaming windowed-sinc resampler over interleaved samples. */
+class SincStream {
+    #channels;
+    #numChannels;
+    /** Samples of an incomplete frame carried to the next call. */
+    #pending = [];
+    constructor(options) {
+        checkRates(options.inRate, options.outRate);
+        const numChannels = options.numChannels;
+        if (!Number.isInteger(numChannels) || numChannels < 1) {
+            throw new Error(`invalid channel count: ${numChannels}`);
+        }
+        this.#numChannels = numChannels;
+        this.#channels = Array.from({ length: numChannels }, () => new SincChannel(options.inRate, options.outRate, options.quality));
+    }
+    resampleChunk(chunk, last = false) {
+        const c = this.#numChannels;
+        let input = chunk;
+        if (this.#pending.length > 0) {
+            input = [...this.#pending, ...chunk];
+            this.#pending = [];
+        }
+        const frames = Math.floor(input.length / c);
+        const rest = input.length - frames * c;
+        if (rest > 0 && !last) {
+            this.#pending = Array.from({ length: rest }, (_, i) => input[frames * c + i]);
+        }
+        const outs = this.#channels.map((ch, i) => ch.process(input, i, c, frames, last));
+        const outFrames = outs[0]?.length ?? 0;
+        const isFloat = chunk instanceof Float32Array;
+        const out = isFloat ? new Float32Array(outFrames * c) : new Int16Array(outFrames * c);
+        for (let ch = 0; ch < c; ch++) {
+            const data = outs[ch];
+            for (let f = 0; f < outFrames; f++) {
+                const v = data[f];
+                out[f * c + ch] = isFloat ? v : toInt16(v);
+            }
+        }
+        if (last)
+            this.#pending = [];
+        return out;
+    }
+    clear() {
+        this.#pending = [];
+        for (const ch of this.#channels)
+            ch.clear();
+    }
+    destroy() { }
+}
+/**
+ * Create the pure-TypeScript windowed-sinc engine.
+ *
+ * Applications normally never call this: core falls back to it on its own
+ * when the WASM engine cannot load. It can also be installed explicitly with
+ * `setResamplerEngine(createSincResamplerEngine())`.
+ */
+export function createSincResamplerEngine() {
+    return {
+        resample(audio, inRate, outRate, quality) {
+            if (inRate === outRate)
+                return audio;
+            const stream = new SincStream({ inRate, outRate, numChannels: 1, quality });
+            return stream.resampleChunk(audio, true);
+        },
+        createStream(options) {
+            return new SincStream(options);
+        },
+    };
+}
+//# sourceMappingURL=sinc_engine.js.map

package/dist/audio/resamplers/soxr_resampler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * SoX-based audio resampler implementation.
+ *
+ * Provides an audio resampler that uses the SoX resampler library for very
+ * high-quality audio sample rate conversion.
+ *
+ * When to use the SOXRAudioResampler:
+ * 1. For batch processing of complete audio files
+ * 2. When you have all the audio data available at once
+ *
+ * PORTING NOTE: libsoxr is not used. `soxr.resample()` is replaced by the
+ * resampler engine from `engine.ts`: `@pipedog/resampler-wasm` (rubato
+ * windowed sinc in WebAssembly) by default, a pure-TypeScript windowed-sinc
+ * fallback if that cannot load, or whatever `setResamplerEngine()` installed.
+ * Output lengths follow soxr's; the samples differ slightly because the
+ * filters differ.
+ */
+import { BaseAudioResampler, type SoxrQuality } from "./base_audio_resampler.ts";
+/**
+ * Stand-in for `soxr.resample()`: resample a whole mono signal.
+ *
+ * Synchronous, like soxr's: it uses the engine already loaded (or injected)
+ * and throws if there is none yet. `await getResamplerEngine()` first when
+ * calling it outside `SOXRAudioResampler.resample()`.
+ *
+ * @internal
+ */
+export declare function soxrResample<T extends Int16Array | Float32Array>(audio: T, inRate: number, outRate: number, quality: SoxrQuality): T;
+export interface SOXRAudioResamplerOptions {
+    /**
+     * SOXR quality preset. Higher quality means higher CPU cost. One of "VHQ"
+     * (default, very high quality), "HQ", "MQ", "LQ", or "QQ" (quick, lowest
+     * latency).
+     */
+    quality?: SoxrQuality;
+}
+/**
+ * Audio resampler implementation using the SoX resampler library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ */
+export declare class SOXRAudioResampler extends BaseAudioResampler {
+    protected _quality: SoxrQuality;
+    constructor(options?: SOXRAudioResamplerOptions);
+    /**
+     * Resample audio data using SoX resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    resample(audio: Uint8Array, inRate: number, outRate: number): Promise<Uint8Array>;
+}
+/** View (or copy, if unaligned) 16-bit PCM bytes as samples. @internal */
+export declare function bytesToInt16(audio: Uint8Array): Int16Array;
+//# sourceMappingURL=soxr_resampler.d.ts.map

package/dist/audio/resamplers/soxr_resampler.js

@@ -0,0 +1,79 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/soxr_resampler.py
+/**
+ * SoX-based audio resampler implementation.
+ *
+ * Provides an audio resampler that uses the SoX resampler library for very
+ * high-quality audio sample rate conversion.
+ *
+ * When to use the SOXRAudioResampler:
+ * 1. For batch processing of complete audio files
+ * 2. When you have all the audio data available at once
+ *
+ * PORTING NOTE: libsoxr is not used. `soxr.resample()` is replaced by the
+ * resampler engine from `engine.ts`: `@pipedog/resampler-wasm` (rubato
+ * windowed sinc in WebAssembly) by default, a pure-TypeScript windowed-sinc
+ * fallback if that cannot load, or whatever `setResamplerEngine()` installed.
+ * Output lengths follow soxr's; the samples differ slightly because the
+ * filters differ.
+ */
+import { BaseAudioResampler } from "./base_audio_resampler.js";
+import { getLoadedResamplerEngine, getResamplerEngine } from "./engine.js";
+/**
+ * Stand-in for `soxr.resample()`: resample a whole mono signal.
+ *
+ * Synchronous, like soxr's: it uses the engine already loaded (or injected)
+ * and throws if there is none yet. `await getResamplerEngine()` first when
+ * calling it outside `SOXRAudioResampler.resample()`.
+ *
+ * @internal
+ */
+export function soxrResample(audio, inRate, outRate, quality) {
+    const engine = getLoadedResamplerEngine();
+    if (!engine) {
+        throw new Error("no resampler engine loaded yet: `await getResamplerEngine()` (audio/resamplers/engine) first");
+    }
+    return engine.resample(audio, inRate, outRate, quality);
+}
+/**
+ * Audio resampler implementation using the SoX resampler library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ */
+export class SOXRAudioResampler extends BaseAudioResampler {
+    _quality;
+    constructor(options = {}) {
+        super();
+        this._quality = options.quality ?? "VHQ";
+    }
+    /**
+     * Resample audio data using SoX resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    async resample(audio, inRate, outRate) {
+        if (inRate === outRate) {
+            return audio;
+        }
+        await getResamplerEngine();
+        const audioData = bytesToInt16(audio);
+        const resampledAudio = soxrResample(audioData, inRate, outRate, this._quality);
+        return new Uint8Array(resampledAudio.buffer, resampledAudio.byteOffset, resampledAudio.byteLength);
+    }
+}
+/** View (or copy, if unaligned) 16-bit PCM bytes as samples. @internal */
+export function bytesToInt16(audio) {
+    const length = audio.length >> 1;
+    if (audio.byteOffset % 2 !== 0) {
+        return new Int16Array(audio.slice(0, length * 2).buffer);
+    }
+    return new Int16Array(audio.buffer, audio.byteOffset, length);
+}
+//# sourceMappingURL=soxr_resampler.js.map

package/dist/audio/resamplers/soxr_stream_resampler.d.ts

@@ -0,0 +1,78 @@
+import { BaseAudioResampler, type SoxrQuality } from "./base_audio_resampler.ts";
+import { type ResamplerEngine, type ResamplerStream } from "./engine.ts";
+/**
+ * Stand-in for `soxr.ResampleStream` (mono, int16): a stream of the resampler
+ * engine (the loaded/injected one unless `engine` is given).
+ *
+ * @internal
+ */
+export declare class SoxrResampleStream {
+    protected _stream: ResamplerStream;
+    constructor(options: {
+        inRate: number;
+        outRate: number;
+        numChannels: number;
+        quality: SoxrQuality;
+    }, engine?: ResamplerEngine | null);
+    resampleChunk(chunk: Int16Array, last?: boolean): Int16Array;
+    clear(): void;
+    /** Free the engine's state (WASM memory). */
+    destroy(): void;
+}
+export interface SOXRStreamAudioResamplerOptions {
+    /**
+     * SOXR quality preset. Higher quality means higher CPU cost. One of "VHQ"
+     * (default, very high quality), "HQ", "MQ", "LQ", or "QQ" (quick, lowest
+     * latency).
+     */
+    quality?: SoxrQuality;
+    /**
+     * Seconds of inactivity after which the internal resampler state is
+     * cleared to avoid audio artefacts from stale history. Set to `null` to
+     * never clear (recommended for telephony providers that have irregular gaps
+     * between chunks). Defaults to 0.2.
+     */
+    clearAfterSecs?: number | null;
+}
+/**
+ * Audio resampler implementation using the SoX ResampleStream library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ * It keeps an internal history which avoids clicks at chunk boundaries.
+ *
+ * Notes:
+ * - Only supports mono audio (1 channel).
+ * - Input must be 16-bit signed PCM audio as raw bytes.
+ */
+export declare class SOXRStreamAudioResampler extends BaseAudioResampler {
+    protected _quality: SoxrQuality;
+    protected _clearAfterSecs: number | null;
+    protected _inRate: number | null;
+    protected _outRate: number | null;
+    protected _lastResampleTime: number;
+    protected _soxrStream: SoxrResampleStream | null;
+    constructor(options?: SOXRStreamAudioResamplerOptions);
+    protected _initialize(inRate: number, outRate: number): void;
+    protected _maybeClearInternalState(): void;
+    protected _maybeInitializeSoxStream(inRate: number, outRate: number): SoxrResampleStream;
+    /**
+     * Resample audio data using soxr.ResampleStream resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    resample(audio: Uint8Array, inRate: number, outRate: number): Promise<Uint8Array>;
+    /**
+     * Emit the audio held in the filter and reset it for the next stream.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if no audio
+     *   has been resampled yet.
+     */
+    flush(): Promise<Uint8Array>;
+    /** Discard the audio held in the filter and reset it for the next stream. */
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=soxr_stream_resampler.d.ts.map

package/dist/audio/resamplers/soxr_stream_resampler.js

@@ -0,0 +1,159 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/soxr_stream_resampler.py
+/**
+ * SoX-based audio resampler stream implementation.
+ *
+ * Provides an audio resampler that uses the SoX ResampleStream library for
+ * very high quality audio sample rate conversion.
+ *
+ * When to use the SOXRStreamAudioResampler:
+ * 1. For real-time processing scenarios
+ * 2. When dealing with very long audio signals
+ * 3. When processing audio in chunks or streams
+ * 4. When you need to reuse the same resampler configuration multiple times,
+ *    as it saves initialization overhead
+ *
+ * PORTING NOTE: libsoxr is not used. `soxr.ResampleStream` is replaced by a
+ * stream from the resampler engine (`engine.ts`): `@pipedog/resampler-wasm`
+ * by default, a pure-TypeScript windowed-sinc fallback if that cannot load,
+ * or whatever `setResamplerEngine()` installed. `resample()` loads the engine
+ * on first use.
+ */
+import { time } from "@pipedog/asyncio";
+import { BaseAudioResampler } from "./base_audio_resampler.js";
+import { getLoadedResamplerEngine, getResamplerEngine, } from "./engine.js";
+import { bytesToInt16 } from "./soxr_resampler.js";
+const EMPTY_AUDIO = new Int16Array(0);
+/**
+ * Stand-in for `soxr.ResampleStream` (mono, int16): a stream of the resampler
+ * engine (the loaded/injected one unless `engine` is given).
+ *
+ * @internal
+ */
+export class SoxrResampleStream {
+    _stream;
+    constructor(options, engine = getLoadedResamplerEngine()) {
+        if (!engine) {
+            throw new Error("no resampler engine loaded yet: `await getResamplerEngine()` (audio/resamplers/engine) first");
+        }
+        this._stream = engine.createStream(options);
+    }
+    resampleChunk(chunk, last = false) {
+        return this._stream.resampleChunk(chunk, last);
+    }
+    clear() {
+        this._stream.clear();
+    }
+    /** Free the engine's state (WASM memory). */
+    destroy() {
+        this._stream.destroy?.();
+    }
+}
+function int16ToBytes(samples) {
+    return new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+}
+/**
+ * Audio resampler implementation using the SoX ResampleStream library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ * It keeps an internal history which avoids clicks at chunk boundaries.
+ *
+ * Notes:
+ * - Only supports mono audio (1 channel).
+ * - Input must be 16-bit signed PCM audio as raw bytes.
+ */
+export class SOXRStreamAudioResampler extends BaseAudioResampler {
+    _quality;
+    _clearAfterSecs;
+    _inRate = null;
+    _outRate = null;
+    _lastResampleTime = 0;
+    _soxrStream = null;
+    constructor(options = {}) {
+        super();
+        this._quality = options.quality ?? "VHQ";
+        this._clearAfterSecs = options.clearAfterSecs === undefined ? 0.2 : options.clearAfterSecs;
+    }
+    _initialize(inRate, outRate) {
+        this._inRate = inRate;
+        this._outRate = outRate;
+        this._lastResampleTime = time();
+        this._soxrStream = new SoxrResampleStream({
+            inRate,
+            outRate,
+            numChannels: 1,
+            quality: this._quality,
+        });
+    }
+    _maybeClearInternalState() {
+        const currentTime = time();
+        if (this._clearAfterSecs !== null) {
+            if (currentTime - this._lastResampleTime > this._clearAfterSecs) {
+                if (this._soxrStream) {
+                    this._soxrStream.clear();
+                }
+            }
+        }
+        this._lastResampleTime = currentTime;
+    }
+    _maybeInitializeSoxStream(inRate, outRate) {
+        if (this._soxrStream === null) {
+            this._initialize(inRate, outRate);
+        }
+        else {
+            this._maybeClearInternalState();
+        }
+        if (this._inRate !== inRate || this._outRate !== outRate) {
+            throw new Error(`SOXRStreamAudioResampler cannot be reused with different sample rates: ` +
+                `expected ${this._inRate}->${this._outRate}, got ${inRate}->${outRate}`);
+        }
+        return this._soxrStream;
+    }
+    /**
+     * Resample audio data using soxr.ResampleStream resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    async resample(audio, inRate, outRate) {
+        if (inRate === outRate) {
+            return audio;
+        }
+        if (this._soxrStream === null) {
+            await getResamplerEngine();
+        }
+        const stream = this._maybeInitializeSoxStream(inRate, outRate);
+        const audioData = bytesToInt16(audio);
+        const resampledAudio = stream.resampleChunk(audioData);
+        return int16ToBytes(resampledAudio);
+    }
+    /**
+     * Emit the audio held in the filter and reset it for the next stream.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if no audio
+     *   has been resampled yet.
+     */
+    async flush() {
+        if (!this._soxrStream) {
+            return new Uint8Array(0);
+        }
+        const tail = this._soxrStream.resampleChunk(EMPTY_AUDIO, true);
+        this._soxrStream.clear();
+        this._lastResampleTime = time();
+        return int16ToBytes(tail);
+    }
+    /** Discard the audio held in the filter and reset it for the next stream. */
+    async reset() {
+        if (this._soxrStream) {
+            this._soxrStream.clear();
+            this._lastResampleTime = time();
+        }
+    }
+}
+//# sourceMappingURL=soxr_stream_resampler.js.map