speechflow 1.6.0 → 1.6.2

package/speechflow-cli/dst/speechflow-utils.js

@@ -1,746 +0,0 @@
-"use strict";
-/*
-**  SpeechFlow - Speech Processing Flow Graph
-**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
-**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
-*/
-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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachedRegExp = exports.AsyncQueue = exports.TimeStore = exports.StreamWrapper = exports.Queue = exports.QueuePointer = exports.DoubleQueue = exports.SingleQueue = void 0;
-exports.ensureError = ensureError;
-exports.ensurePromise = ensurePromise;
-exports.run = run;
-exports.runner = runner;
-exports.importObject = importObject;
-exports.audioBufferDuration = audioBufferDuration;
-exports.audioArrayDuration = audioArrayDuration;
-exports.convertBufToF32 = convertBufToF32;
-exports.convertF32ToBuf = convertF32ToBuf;
-exports.convertBufToI16 = convertBufToI16;
-exports.convertI16ToBuf = convertI16ToBuf;
-exports.createTransformStreamForWritableSide = createTransformStreamForWritableSide;
-exports.createTransformStreamForReadableSide = createTransformStreamForReadableSide;
-exports.ensureStreamChunk = ensureStreamChunk;
-exports.streamChunkEncode = streamChunkEncode;
-exports.streamChunkDecode = streamChunkDecode;
-exports.processInt16ArrayInSegments = processInt16ArrayInSegments;
-exports.lin2dB = lin2dB;
-exports.dB2lin = dB2lin;
-/*  standard dependencies  */
-const node_stream_1 = __importDefault(require("node:stream"));
-const node_events_1 = require("node:events");
-const arktype_1 = require("arktype");
-/*  external dependencies  */
-const luxon_1 = require("luxon");
-const CBOR = __importStar(require("cbor2"));
-const IntervalTree = __importStar(require("node-interval-tree"));
-/*  internal dependencies  */
-const speechflow_node_1 = require("./speechflow-node");
-/*  helper function for retrieving an Error object  */
-function ensureError(error, prefix) {
-    if (error instanceof Error && prefix === undefined)
-        return error;
-    let msg = error instanceof Error ?
-        error.message : String(error);
-    if (prefix)
-        msg = `${prefix}: ${msg}`;
-    return new Error(msg, { cause: error });
-}
-/*  helper function for retrieving a Promise object  */
-function ensurePromise(arg) {
-    if (!(arg instanceof Promise))
-        arg = Promise.resolve(arg);
-    return arg;
-}
-/*  helper function for running the finally code of "run"  */
-function runFinally(onfinally) {
-    if (!onfinally)
-        return;
-    try {
-        onfinally();
-    }
-    catch (_error) { /*  ignored  */ }
-}
-function run(...args) {
-    /*  support overloaded signatures  */
-    let description;
-    let action;
-    let oncatch;
-    let onfinally;
-    if (typeof args[0] === "string") {
-        description = args[0];
-        action = args[1];
-        oncatch = args[2];
-        onfinally = args[3];
-    }
-    else {
-        action = args[0];
-        oncatch = args[1];
-        onfinally = args[2];
-    }
-    /*  perform the action  */
-    let result;
-    try {
-        result = action();
-    }
-    catch (arg) {
-        /*  synchronous case (error branch)  */
-        let error = ensureError(arg, description);
-        if (oncatch) {
-            try {
-                result = oncatch(error);
-            }
-            catch (arg) {
-                error = ensureError(arg, description);
-                runFinally(onfinally);
-                throw error;
-            }
-            runFinally(onfinally);
-            return result;
-        }
-        runFinally(onfinally);
-        throw error;
-    }
-    if (result instanceof Promise) {
-        /*  asynchronous case (result or error branch)  */
-        return result.catch((arg) => {
-            /*  asynchronous case (error branch)  */
-            let error = ensureError(arg, description);
-            if (oncatch) {
-                try {
-                    return oncatch(error);
-                }
-                catch (arg) {
-                    error = ensureError(arg, description);
-                    throw error;
-                }
-            }
-            throw error;
-        }).finally(() => {
-            /*  asynchronous case (result and error branch)  */
-            runFinally(onfinally);
-        });
-    }
-    else {
-        /*  synchronous case (result branch)  */
-        runFinally(onfinally);
-        return result;
-    }
-}
-function runner(...args) {
-    /*  support overloaded signatures  */
-    let description;
-    let action;
-    let oncatch;
-    let onfinally;
-    if (typeof args[0] === "string") {
-        description = args[0];
-        action = args[1];
-        oncatch = args[2];
-        onfinally = args[3];
-    }
-    else {
-        action = args[0];
-        oncatch = args[1];
-        onfinally = args[2];
-    }
-    /*  wrap the "run" operation on "action" into function
-        which exposes the signature of "action"  */
-    return (...args) => {
-        if (description)
-            return run(description, () => action(...args), oncatch, onfinally);
-        else
-            return run(() => action(...args), oncatch, onfinally);
-    };
-}
-/*  import an object with parsing and strict error handling  */
-function importObject(name, arg, validator) {
-    const obj = typeof arg === "string" ?
-        run(`${name}: parsing JSON`, () => JSON.parse(arg)) :
-        arg;
-    const result = validator(obj);
-    if (result instanceof arktype_1.type.errors)
-        throw new Error(`${name}: validation: ${result.summary}`);
-    return result;
-}
-/*  calculate duration of an audio buffer  */
-function audioBufferDuration(buffer, sampleRate = 48000, bitDepth = 16, channels = 1, littleEndian = true) {
-    /*  sanity check parameters  */
-    if (!Buffer.isBuffer(buffer))
-        throw new Error("invalid input (Buffer expected)");
-    if (littleEndian !== true)
-        throw new Error("only Little Endian supported");
-    if (sampleRate <= 0)
-        throw new Error("sample rate must be positive");
-    if (bitDepth <= 0 || bitDepth % 8 !== 0)
-        throw new Error("bit depth must be positive and multiple of 8");
-    if (channels <= 0)
-        throw new Error("channels must be positive");
-    /*  calculate duration  */
-    const bytesPerSample = bitDepth / 8;
-    const totalSamples = buffer.length / (bytesPerSample * channels);
-    return totalSamples / sampleRate;
-}
-/*  calculate duration of an audio array  */
-function audioArrayDuration(arr, sampleRate = 48000, channels = 1) {
-    /*  sanity check parameters  */
-    if (arr.length === 0)
-        return 0;
-    if (sampleRate <= 0)
-        throw new Error("sample rate must be positive");
-    if (channels <= 0)
-        throw new Error("channels must be positive");
-    /*  calculate duration  */
-    const totalSamples = arr.length / channels;
-    return totalSamples / sampleRate;
-}
-/*  helper function: convert Buffer in PCM/I16 to Float32Array in PCM/F32 format  */
-function convertBufToF32(buf, littleEndian = true) {
-    if (buf.length % 2 !== 0)
-        throw new Error("buffer length must be even for 16-bit samples");
-    const dataView = new DataView(buf.buffer);
-    const arr = new Float32Array(buf.length / 2);
-    for (let i = 0; i < arr.length; i++)
-        arr[i] = dataView.getInt16(i * 2, littleEndian) / 32768;
-    return arr;
-}
-/*  helper function: convert Float32Array in PCM/F32 to Buffer in PCM/I16 format  */
-function convertF32ToBuf(arr) {
-    if (arr.length === 0)
-        return Buffer.alloc(0);
-    const int16Array = new Int16Array(arr.length);
-    for (let i = 0; i < arr.length; i++) {
-        let sample = arr[i];
-        if (Number.isNaN(sample))
-            sample = 0;
-        int16Array[i] = Math.max(-32768, Math.min(32767, Math.round(sample * 32768)));
-    }
-    return Buffer.from(int16Array.buffer);
-}
-/*  helper function: convert Buffer in PCM/I16 to Int16Array  */
-function convertBufToI16(buf, littleEndian = true) {
-    if (buf.length % 2 !== 0)
-        throw new Error("buffer length must be even for 16-bit samples");
-    const dataView = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    const arr = new Int16Array(buf.length / 2);
-    for (let i = 0; i < buf.length / 2; i++)
-        arr[i] = dataView.getInt16(i * 2, littleEndian);
-    return arr;
-}
-/*  helper function: convert In16Array in PCM/I16 to Buffer  */
-function convertI16ToBuf(arr, littleEndian = true) {
-    if (arr.length === 0)
-        return Buffer.alloc(0);
-    const buf = Buffer.allocUnsafe(arr.length * 2);
-    for (let i = 0; i < arr.length; i++) {
-        if (littleEndian)
-            buf.writeInt16LE(arr[i], i * 2);
-        else
-            buf.writeInt16BE(arr[i], i * 2);
-    }
-    return buf;
-}
-/*  create a Duplex/Transform stream which has
-    object-mode on Writable side and buffer/string-mode on Readable side  */
-function createTransformStreamForWritableSide() {
-    return new node_stream_1.default.Transform({
-        readableObjectMode: true,
-        writableObjectMode: true,
-        decodeStrings: false,
-        highWaterMark: 1,
-        transform(chunk, encoding, callback) {
-            this.push(chunk.payload);
-            callback();
-        },
-        final(callback) {
-            this.push(null);
-            callback();
-        }
-    });
-}
-/*  create a Duplex/Transform stream which has
-    object-mode on Readable side and buffer/string-mode on Writable side  */
-function createTransformStreamForReadableSide(type, getTimeZero) {
-    return new node_stream_1.default.Transform({
-        readableObjectMode: true,
-        writableObjectMode: true,
-        decodeStrings: false,
-        highWaterMark: (type === "audio" ? 19200 : 65536),
-        transform(chunk, encoding, callback) {
-            if (chunk === null) {
-                this.push(null);
-                callback();
-                return;
-            }
-            const timeZero = getTimeZero();
-            const start = luxon_1.DateTime.now().diff(timeZero);
-            let end = start;
-            if (type === "audio") {
-                const duration = audioBufferDuration(chunk);
-                end = start.plus(duration * 1000);
-            }
-            const payload = ensureStreamChunk(type, chunk);
-            const obj = new speechflow_node_1.SpeechFlowChunk(start, end, "final", type, payload);
-            this.push(obj);
-            callback();
-        },
-        final(callback) {
-            this.push(null);
-            callback();
-        }
-    });
-}
-/*  ensure a chunk is of a certain type and format  */
-function ensureStreamChunk(type, chunk) {
-    if (chunk instanceof speechflow_node_1.SpeechFlowChunk) {
-        if (chunk.type !== type)
-            throw new Error(`invalid payload chunk (expected ${type} type, received ${chunk.type} type)`);
-    }
-    else {
-        if (type === "text" && Buffer.isBuffer(chunk))
-            chunk = chunk.toString("utf8");
-        else if (type === "audio" && !Buffer.isBuffer(chunk))
-            chunk = Buffer.from(chunk);
-    }
-    return chunk;
-}
-/*  encode/serialize chunk of data  */
-function streamChunkEncode(chunk) {
-    let payload;
-    if (Buffer.isBuffer(chunk.payload))
-        payload = new Uint8Array(chunk.payload);
-    else {
-        const encoder = new TextEncoder();
-        payload = encoder.encode(chunk.payload);
-    }
-    const data = {
-        timestampStart: chunk.timestampStart.toMillis(),
-        timestampEnd: chunk.timestampEnd.toMillis(),
-        kind: chunk.kind,
-        type: chunk.type,
-        payload
-    };
-    const _data = CBOR.encode(data);
-    return _data;
-}
-/*  decode/unserialize chunk of data  */
-function streamChunkDecode(_data) {
-    let data;
-    try {
-        data = CBOR.decode(_data);
-    }
-    catch (err) {
-        throw new Error(`CBOR decoding failed: ${err}`);
-    }
-    let payload;
-    if (data.type === "audio")
-        payload = Buffer.from(data.payload);
-    else
-        payload = (new TextDecoder()).decode(data.payload);
-    const chunk = new speechflow_node_1.SpeechFlowChunk(luxon_1.Duration.fromMillis(data.timestampStart), luxon_1.Duration.fromMillis(data.timestampEnd), data.kind, data.type, payload);
-    return chunk;
-}
-/*  helper class for single item queue  */
-class SingleQueue extends node_events_1.EventEmitter {
-    queue = new Array();
-    write(item) {
-        this.queue.unshift(item);
-        this.emit("dequeue");
-    }
-    read() {
-        return new Promise((resolve, reject) => {
-            const consume = () => this.queue.length > 0 ? this.queue.pop() : null;
-            const tryToConsume = () => {
-                const item = consume();
-                if (item !== null)
-                    resolve(item);
-                else
-                    this.once("dequeue", tryToConsume);
-            };
-            tryToConsume();
-        });
-    }
-}
-exports.SingleQueue = SingleQueue;
-/*  helper class for double-item queue  */
-class DoubleQueue extends node_events_1.EventEmitter {
-    queue0 = new Array();
-    queue1 = new Array();
-    notify() {
-        if (this.queue0.length > 0 && this.queue1.length > 0)
-            this.emit("dequeue");
-    }
-    write0(item) {
-        this.queue0.unshift(item);
-        this.notify();
-    }
-    write1(item) {
-        this.queue1.unshift(item);
-        this.notify();
-    }
-    read() {
-        return new Promise((resolve, reject) => {
-            const consume = () => {
-                if (this.queue0.length > 0 && this.queue1.length > 0) {
-                    const item0 = this.queue0.pop();
-                    const item1 = this.queue1.pop();
-                    return [item0, item1];
-                }
-                return null;
-            };
-            const tryToConsume = () => {
-                const items = consume();
-                if (items !== null)
-                    resolve(items);
-                else
-                    this.once("dequeue", tryToConsume);
-            };
-            tryToConsume();
-        });
-    }
-}
-exports.DoubleQueue = DoubleQueue;
-/*  queue pointer  */
-class QueuePointer extends node_events_1.EventEmitter {
-    name;
-    queue;
-    /*  internal state  */
-    index = 0;
-    /*  construction  */
-    constructor(name, queue) {
-        super();
-        this.name = name;
-        this.queue = queue;
-        this.setMaxListeners(100);
-    }
-    /*  positioning operations  */
-    maxPosition() {
-        return this.queue.elements.length;
-    }
-    position(index) {
-        if (index !== undefined) {
-            this.index = Math.max(0, Math.min(index, this.queue.elements.length));
-            this.emit("position", this.index);
-        }
-        return this.index;
-    }
-    walk(num) {
-        const indexOld = this.index;
-        if (num > 0)
-            this.index = Math.min(this.index + num, this.queue.elements.length);
-        else if (num < 0)
-            this.index = Math.max(this.index + num, 0);
-        if (this.index !== indexOld)
-            this.emit("position", { start: this.index });
-    }
-    walkForwardUntil(type) {
-        while (this.index < this.queue.elements.length
-            && this.queue.elements[this.index].type !== type)
-            this.index++;
-        this.emit("position", { start: this.index });
-    }
-    walkBackwardUntil(type) {
-        while (this.index > 0
-            && this.queue.elements[this.index].type !== type)
-            this.index--;
-        this.emit("position", { start: this.index });
-    }
-    /*  search operations  */
-    searchForward(type) {
-        let position = this.index;
-        while (position < this.queue.elements.length
-            && this.queue.elements[position].type !== type)
-            position++;
-        this.emit("search", { start: this.index, end: position });
-        return position;
-    }
-    searchBackward(type) {
-        let position = this.index;
-        while (position > 0
-            && this.queue.elements[position].type !== type)
-            position--;
-        this.emit("search", { start: position, end: this.index });
-        return position;
-    }
-    /*  reading operations  */
-    peek(position) {
-        if (position === undefined)
-            position = this.index;
-        position = Math.max(0, Math.min(position, this.queue.elements.length));
-        const element = this.queue.elements[position];
-        this.queue.emit("read", { start: position, end: position });
-        return element;
-    }
-    read() {
-        const element = this.queue.elements[this.index];
-        if (this.index < this.queue.elements.length)
-            this.index++;
-        this.queue.emit("read", { start: this.index - 1, end: this.index - 1 });
-        return element;
-    }
-    slice(size) {
-        let slice;
-        const start = this.index;
-        if (size !== undefined) {
-            size = Math.max(0, Math.min(size, this.queue.elements.length - this.index));
-            slice = this.queue.elements.slice(this.index, this.index + size);
-            this.index += size;
-        }
-        else {
-            slice = this.queue.elements.slice(this.index);
-            this.index = this.queue.elements.length;
-        }
-        this.queue.emit("read", { start, end: this.index });
-        return slice;
-    }
-    /*  writing operations  */
-    touch() {
-        if (this.index >= this.queue.elements.length)
-            throw new Error("cannot touch after last element");
-        this.queue.emit("write", { start: this.index, end: this.index + 1 });
-    }
-    append(element) {
-        this.queue.elements.push(element);
-        this.index = this.queue.elements.length;
-        this.queue.emit("write", { start: this.index - 1, end: this.index - 1 });
-    }
-    insert(element) {
-        this.queue.elements.splice(this.index, 0, element);
-        this.queue.emit("write", { start: this.index - 1, end: this.index });
-    }
-    delete() {
-        if (this.index >= this.queue.elements.length)
-            throw new Error("cannot delete after last element");
-        this.queue.elements.splice(this.index, 1);
-        this.queue.emit("write", { start: this.index, end: this.index });
-    }
-}
-exports.QueuePointer = QueuePointer;
-/*  queue  */
-class Queue extends node_events_1.EventEmitter {
-    elements = [];
-    pointers = new Map();
-    constructor() {
-        super();
-        this.setMaxListeners(100);
-    }
-    pointerUse(name) {
-        if (!this.pointers.has(name))
-            this.pointers.set(name, new QueuePointer(name, this));
-        return this.pointers.get(name);
-    }
-    pointerDelete(name) {
-        if (!this.pointers.has(name))
-            throw new Error("pointer not exists");
-        this.pointers.delete(name);
-    }
-    trim() {
-        /*  determine minimum pointer position  */
-        let min = this.elements.length;
-        for (const pointer of this.pointers.values())
-            if (min > pointer.position())
-                min = pointer.position();
-        /*  trim the maximum amount of first elements  */
-        if (min > 0) {
-            this.elements.splice(0, min);
-            /*  shift all pointers  */
-            for (const pointer of this.pointers.values())
-                pointer.position(pointer.position() - min);
-        }
-    }
-}
-exports.Queue = Queue;
-/*  utility class for wrapping a custom stream into a regular Transform stream  */
-class StreamWrapper extends node_stream_1.default.Transform {
-    foreignStream;
-    onData = (chunk) => { this.push(chunk); };
-    onError = (err) => { this.emit("error", err); };
-    onEnd = () => { this.push(null); };
-    constructor(foreignStream, options = {}) {
-        options.readableObjectMode = true;
-        options.writableObjectMode = true;
-        super(options);
-        this.foreignStream = foreignStream;
-        if (typeof this.foreignStream.on === "function") {
-            this.foreignStream.on("data", this.onData);
-            this.foreignStream.on("error", this.onError);
-            this.foreignStream.on("end", this.onEnd);
-        }
-    }
-    _transform(chunk, encoding, callback) {
-        if (this.destroyed) {
-            callback(new Error("stream already destroyed"));
-            return;
-        }
-        try {
-            if (typeof this.foreignStream.write === "function") {
-                const canContinue = this.foreignStream.write(chunk);
-                if (canContinue)
-                    callback();
-                else
-                    this.foreignStream.once("drain", callback);
-            }
-            else
-                throw new Error("foreign stream lacks write method");
-        }
-        catch (err) {
-            callback(err);
-        }
-    }
-    _flush(callback) {
-        if (this.destroyed) {
-            callback(new Error("stream already destroyed"));
-            return;
-        }
-        try {
-            if (typeof this.foreignStream.end === "function")
-                this.foreignStream.end();
-            callback();
-        }
-        catch (err) {
-            callback(err);
-        }
-    }
-    _destroy(error, callback) {
-        if (typeof this.foreignStream.removeListener === "function") {
-            this.foreignStream.removeListener("data", this.onData);
-            this.foreignStream.removeListener("error", this.onError);
-            this.foreignStream.removeListener("end", this.onEnd);
-        }
-        super._destroy(error, callback);
-    }
-}
-exports.StreamWrapper = StreamWrapper;
-class TimeStore extends node_events_1.EventEmitter {
-    tree = new IntervalTree.IntervalTree();
-    store(start, end, item) {
-        this.tree.insert({ low: start.toMillis(), high: end.toMillis(), item });
-    }
-    fetch(start, end) {
-        const intervals = this.tree.search(start.toMillis(), end.toMillis());
-        return intervals.map((interval) => interval.item);
-    }
-    prune(_before) {
-        const before = _before.toMillis();
-        const intervals = this.tree.search(0, before - 1);
-        for (const interval of intervals)
-            if (interval.low < before && interval.high < before)
-                this.tree.remove(interval);
-    }
-    clear() {
-        this.tree = new IntervalTree.IntervalTree();
-    }
-}
-exports.TimeStore = TimeStore;
-/*  asynchronous queue  */
-class AsyncQueue {
-    queue = [];
-    resolvers = [];
-    write(v) {
-        const resolve = this.resolvers.shift();
-        if (resolve)
-            resolve(v);
-        else
-            this.queue.push(v);
-    }
-    async read() {
-        if (this.queue.length > 0)
-            return this.queue.shift();
-        else
-            return new Promise((resolve) => this.resolvers.push(resolve));
-    }
-    destroy() {
-        for (const resolve of this.resolvers)
-            resolve(null);
-        this.resolvers = [];
-        this.queue = [];
-    }
-}
-exports.AsyncQueue = AsyncQueue;
-/*  process Int16Array in fixed-size segments  */
-async function processInt16ArrayInSegments(data, segmentSize, processor) {
-    /*  process full segments  */
-    let i = 0;
-    while ((i + segmentSize) <= data.length) {
-        const segment = data.slice(i, i + segmentSize);
-        const result = await processor(segment);
-        data.set(result, i);
-        i += segmentSize;
-    }
-    /*  process final partial segment if it exists  */
-    if (i < data.length) {
-        const len = data.length - i;
-        const segment = new Int16Array(segmentSize);
-        segment.set(data.slice(i), 0);
-        segment.fill(0, len, segmentSize);
-        const result = await processor(segment);
-        data.set(result.slice(0, len), i);
-    }
-    return data;
-}
-/*  cached regular expression class  */
-class CachedRegExp {
-    cache = new Map();
-    compile(pattern) {
-        if (this.cache.has(pattern))
-            return this.cache.get(pattern);
-        try {
-            const regex = new RegExp(pattern);
-            this.cache.set(pattern, regex);
-            return regex;
-        }
-        catch (_error) {
-            return null;
-        }
-    }
-    clear() {
-        this.cache.clear();
-    }
-    size() {
-        return this.cache.size;
-    }
-}
-exports.CachedRegExp = CachedRegExp;
-/*  helper functions for linear/decibel conversions  */
-function lin2dB(x) {
-    return 20 * Math.log10(Math.max(x, 1e-12));
-}
-function dB2lin(db) {
-    return Math.pow(10, db / 20);
-}
-//# sourceMappingURL=speechflow-utils.js.map