speechflow 1.4.5 → 1.5.0

package/speechflow-cli/src/speechflow-node-a2a-compressor.ts

@@ -0,0 +1,303 @@
+/*
+**  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>
+*/
+
+/*  standard dependencies  */
+import path             from "node:path"
+import Stream           from "node:stream"
+import { EventEmitter } from "node:events"
+
+/*  external dependencies  */
+import { GainNode, AudioWorkletNode } from "node-web-audio-api"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
+import { WebAudio }                        from "./speechflow-utils-audio"
+
+/*  internal types  */
+interface AudioCompressorConfig {
+    thresholdDb?: number
+    ratio?:       number
+    attackMs?:    number
+    releaseMs?:   number
+    kneeDb?:      number
+    makeupDb?:    number
+}
+
+/*  audio compressor class  */
+class AudioCompressor extends WebAudio {
+    /*  internal state  */
+    private type:              "standalone" | "sidechain"
+    private mode:              "compress" | "measure" | "adjust"
+    private config:            Required<AudioCompressorConfig>
+    private compressorNode:    AudioWorkletNode | null = null
+    private gainNode:          GainNode | null = null
+
+    /*  construct object  */
+    constructor(
+        sampleRate: number,
+        channels:   number,
+        type:       "standalone" | "sidechain" = "standalone",
+        mode:       "compress" | "measure" | "adjust" = "compress",
+        config:     AudioCompressorConfig = {}
+    ) {
+        super(sampleRate, channels)
+
+        /*  store type and mode  */
+        this.type = type
+        this.mode = mode
+
+        /*  store configuration  */
+        this.config = {
+            thresholdDb: config.thresholdDb ?? -23,
+            ratio:       config.ratio       ?? 4.0,
+            attackMs:    config.attackMs    ?? 10,
+            releaseMs:   config.releaseMs   ?? 50,
+            kneeDb:      config.kneeDb      ?? 6.0,
+            makeupDb:    config.makeupDb    ?? 0
+        }
+    }
+
+    /*  setup object  */
+    public async setup (): Promise<void> {
+        await super.setup()
+
+        /*  add audio worklet module  */
+        const url = path.resolve(__dirname, "speechflow-node-a2a-compressor-wt.js")
+        await this.audioContext.audioWorklet.addModule(url)
+
+        /*  determine operation modes  */
+        const needsCompressor = (this.type === "standalone" && this.mode === "compress") ||
+                                (this.type === "sidechain"  && this.mode === "measure")
+        const needsGain       = (this.type === "standalone" && this.mode === "compress") ||
+                                (this.type === "sidechain"  && this.mode === "adjust")
+
+        /*  create compressor worklet node  */
+        if (needsCompressor) {
+            this.compressorNode = new AudioWorkletNode(this.audioContext, "compressor", {
+                numberOfInputs:  1,
+                numberOfOutputs: 1,
+                processorOptions: {
+                    sampleRate: this.audioContext.sampleRate
+                }
+            })
+        }
+
+        /*  create gain node  */
+        if (needsGain)
+            this.gainNode = this.audioContext.createGain()
+
+        /*  connect nodes (according to type and mode)  */
+        if (this.type === "standalone" && this.mode === "compress") {
+            this.sourceNode!.connect(this.compressorNode!)
+            this.compressorNode!.connect(this.gainNode!)
+            this.gainNode!.connect(this.captureNode!)
+        }
+        else if (this.type === "sidechain" && this.mode === "measure") {
+            this.sourceNode!.connect(this.compressorNode!)
+        }
+        else if (this.type === "sidechain" && this.mode === "adjust") {
+            this.sourceNode!.connect(this.gainNode!)
+            this.gainNode!.connect(this.captureNode!)
+        }
+
+        /*  configure compressor worklet node  */
+        const currentTime = this.audioContext.currentTime
+        if (needsCompressor) {
+            const node = this.compressorNode!
+            const params = node.parameters as Map<string, AudioParam>
+            params.get("threshold")!.setValueAtTime(this.config.thresholdDb, currentTime)
+            params.get("ratio")!.setValueAtTime(this.config.ratio, currentTime)
+            params.get("attack")!.setValueAtTime(this.config.attackMs / 1000, currentTime)
+            params.get("release")!.setValueAtTime(this.config.releaseMs / 1000, currentTime)
+            params.get("knee")!.setValueAtTime(this.config.kneeDb, currentTime)
+            params.get("makeup")!.setValueAtTime(this.config.makeupDb, currentTime)
+        }
+
+        /*  configure gain node  */
+        if (needsGain) {
+            const gain = Math.pow(10, this.config.makeupDb / 20)
+            this.gainNode!.gain.setValueAtTime(gain, currentTime)
+        }
+    }
+
+    /*  get the current gain reduction  */
+    public getGainReduction (): number {
+        const processor = (this.compressorNode as any)?.port?.processor
+        return processor?.reduction ?? 0
+    }
+
+    /*  set the current gain  */
+    public setGain (decibel: number): void {
+        const gain = Math.pow(10, decibel / 20)
+        this.gainNode?.gain.setTargetAtTime(gain, this.audioContext.currentTime, 0.002)
+    }
+
+    /*  destroy the compressor  */
+    public async destroy (): Promise<void> {
+        await super.destroy()
+
+        /*  destroy nodes  */
+        if (this.compressorNode !== null) {
+            this.compressorNode.disconnect()
+            this.compressorNode = null
+        }
+        if (this.gainNode !== null) {
+            this.gainNode.disconnect()
+            this.gainNode = null
+        }
+    }
+}
+
+/*  SpeechFlow node for compression in audio-to-audio passing  */
+export default class SpeechFlowNodeCompressor extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "compressor"
+
+    /*  internal state  */
+    private destroyed = false
+    private compressor: AudioCompressor | null = null
+    private bus: EventEmitter | null = null
+    private intervalId: ReturnType<typeof setInterval> | null = null
+
+    /*  construct node  */
+    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
+        super(id, cfg, opts, args)
+
+        /*  declare node configuration parameters  */
+        this.configure({
+            type:        { type: "string", val: "standalone", match: /^(?:standalone|sidechain)$/ },
+            mode:        { type: "string", val: "compress",   match: /^(?:compress|measure|adjust)$/ },
+            bus:         { type: "string", val: "compressor", match: /^.+$/ },
+            thresholdDb: { type: "number", val: -23, match: (n: number) => n <= 0   && n >= -100 },
+            ratio:       { type: "number", val: 4.0, match: (n: number) => n >= 1   && n <= 20   },
+            attackMs:    { type: "number", val: 10,  match: (n: number) => n >= 0   && n <= 1000 },
+            releaseMs:   { type: "number", val: 50,  match: (n: number) => n >= 0   && n <= 1000 },
+            kneeDb:      { type: "number", val: 6.0, match: (n: number) => n >= 0   && n <= 40   },
+            makeupDb:    { type: "number", val: 0,   match: (n: number) => n >= -24 && n <= 24   }
+        })
+
+        /*  sanity check mode and role  */
+        if (this.params.type === "standalone" && this.params.mode !== "compress")
+            throw new Error("type \"standalone\" implies mode \"compress\"")
+        if (this.params.type === "sidechain" && this.params.mode === "compress")
+            throw new Error("type \"sidechain\" implies mode \"measure\" or \"adjust\"")
+
+        /*  declare node input/output format  */
+        this.input  = "audio"
+        this.output = "audio"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  clear destruction flag  */
+        this.destroyed = false
+
+        /*  setup compressor  */
+        this.compressor = new AudioCompressor(
+            this.config.audioSampleRate,
+            this.config.audioChannels,
+            this.params.type,
+            this.params.mode, {
+                thresholdDb: this.params.thresholdDb,
+                ratio:       this.params.ratio,
+                attackMs:    this.params.attackMs,
+                releaseMs:   this.params.releaseMs,
+                kneeDb:      this.params.kneeDb,
+                makeupDb:    this.params.makeupDb
+            }
+        )
+        await this.compressor.setup()
+
+        /*  optionally establish sidechain processing  */
+        if (this.params.type === "sidechain") {
+            this.bus = this.accessBus(this.params.bus)
+            if (this.params.mode === "measure") {
+                this.intervalId = setInterval(() => {
+                    const decibel = this.compressor?.getGainReduction()
+                    this.bus?.emit("sidechain-decibel", decibel)
+                }, 10)
+            }
+            else if (this.params.mode === "adjust") {
+                this.bus.on("sidechain-decibel", (decibel: number) => {
+                    this.compressor?.setGain(decibel)
+                })
+            }
+        }
+
+        /*  establish a transform stream  */
+        const self = this
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
+                if (self.destroyed) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
+                if (!Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else {
+                    /*  compress chunk  */
+                    const payload = utils.convertBufToI16(chunk.payload)
+                    self.compressor?.process(payload).then((result) => {
+                        if (self.destroyed)
+                            throw new Error("stream already destroyed")
+                        if ((self.params.type === "standalone" && self.params.mode === "compress") ||
+                            (self.params.type === "sidechain"  && self.params.mode === "adjust")     ) {
+                            /*  take over compressed data  */
+                            const payload = utils.convertI16ToBuf(result)
+                            chunk.payload = payload
+                        }
+                        this.push(chunk)
+                        callback()
+                    }).catch((error) => {
+                        callback(new Error(`compression failed: ${error}`))
+                    })
+                }
+            },
+            final (callback) {
+                if (self.destroyed) {
+                    callback()
+                    return
+                }
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  indicate destruction  */
+        this.destroyed = true
+
+        /*  clear interval  */
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId)
+            this.intervalId = null
+        }
+
+        /*  destroy bus  */
+        if (this.bus !== null) {
+            this.bus.removeAllListeners()
+            this.bus = null
+        }
+
+        /*  destroy compressor  */
+        if (this.compressor !== null) {
+            await this.compressor.destroy()
+            this.compressor = null
+        }
+
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+    }
+}

package/speechflow-cli/src/speechflow-node-a2a-expander-wt.ts

@@ -0,0 +1,158 @@
+/*
+**  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>
+*/
+
+import * as utils from "./speechflow-utils"
+
+/*  downward expander with soft knee  */
+class ExpanderProcessor extends AudioWorkletProcessor {
+    /*  internal state  */
+    private env: number[] = []
+    private sampleRate: number
+
+    /*  eslint no-undef: off */
+    static get parameterDescriptors(): AudioParamDescriptor[] {
+        return [
+            { name: "threshold",  defaultValue: -45,   minValue: -100,   maxValue: 0,   automationRate: "k-rate" }, // dBFS
+            { name: "floor",      defaultValue: -64,   minValue: -100,   maxValue: 0,   automationRate: "k-rate" }, // dBFS minimum output level
+            { name: "ratio",      defaultValue: 4.0,   minValue: 1.0,    maxValue: 20,  automationRate: "k-rate" }, // expansion ratio
+            { name: "attack",     defaultValue: 0.010, minValue: 0.0,    maxValue: 1,   automationRate: "k-rate" }, // seconds
+            { name: "release",    defaultValue: 0.050, minValue: 0.0,    maxValue: 1,   automationRate: "k-rate" }, // seconds
+            { name: "knee",       defaultValue: 6.0,   minValue: 0.0,    maxValue: 40,  automationRate: "k-rate" }, // dB
+            { name: "makeup",     defaultValue: 0.0,   minValue: -24,    maxValue: 24,  automationRate: "k-rate" }  // dB
+        ]
+    }
+
+    /*  class constructor for custom option processing  */
+    constructor (options: any) {
+        super()
+        const { sampleRate } = options.processorOptions
+        this.sampleRate = sampleRate as number
+    }
+
+    /*  determine gain difference  */
+    private gainDBFor (levelDB: number, thresholdDB: number, ratio: number, kneeDB: number): number {
+        /*  short-circuit for unreasonable ratio  */
+        if (ratio <= 1.0)
+            return 0
+
+        /*  determine thresholds  */
+        const halfKnee  = kneeDB * 0.5
+        const belowKnee = levelDB < (thresholdDB - halfKnee)
+        const aboveThr  = levelDB >= thresholdDB
+
+        /*  short-circuit for no expansion (above threshold)  */
+        if (aboveThr)
+            return 0
+
+        /*  apply soft-knee  */
+        if (kneeDB > 0 && !belowKnee) {
+            const x = (levelDB - (thresholdDB - halfKnee)) / kneeDB
+            const idealGainDB = (thresholdDB + (levelDB - thresholdDB) * ratio) - levelDB
+            return idealGainDB * x * x
+        }
+
+        /*  determine target level  */
+        const targetOut = thresholdDB + (levelDB - thresholdDB) / ratio
+
+        /*  return gain difference  */
+        return targetOut - levelDB
+    }
+
+    /*  update envelope (smoothed amplitude contour) for single channel  */
+    private updateEnvelopeForChannel (
+        chan:           number,
+        samples:        Float32Array,
+        attack:         number,
+        release:        number
+    ): void {
+        /*  fetch old envelope value  */
+        if (this.env[chan] === undefined)
+            this.env[chan] = 1e-12
+        let env = this.env[chan]
+
+        /*  calculate attack/release alpha values  */
+        const alphaA = Math.exp(-1 / (attack  * this.sampleRate))
+        const alphaR = Math.exp(-1 / (release * this.sampleRate))
+
+        /*  iterate over all samples and calculate RMS  */
+        for (const s of samples) {
+            const x = Math.abs(s)
+            const det = x * x
+            if (det > env)
+                env = alphaA * env + (1 - alphaA) * det
+            else
+                env = alphaR * env + (1 - alphaR) * det
+        }
+        this.env[chan] = Math.sqrt(Math.max(env, 1e-12))
+    }
+
+    /*  process a single sample frame  */
+    process(
+        inputs:     Float32Array[][],
+        outputs:    Float32Array[][],
+        parameters: Record<string, Float32Array>
+    ): boolean {
+        /*  sanity check  */
+        const input  = inputs[0]
+        const output = outputs[0]
+        if (!input || input.length === 0 || !output)
+            return true
+
+        /*  determine number of channels  */
+        const nCh = input.length
+
+        /*  reset envelope array if channel count changed  */
+        if (nCh !== this.env.length)
+            this.env = []
+
+        /*  initially just copy input to output (pass-through)  */
+        for (let c = 0; c < output.length; c++) {
+            if (!output[c] || !input[c])
+                continue
+            output[c].set(input[c])
+        }
+
+        /*  fetch parameters  */
+        const thresholdDB = parameters["threshold"][0]
+        const floorDB     = parameters["floor"][0]
+        const ratio       = parameters["ratio"][0]
+        const kneeDB      = parameters["knee"][0]
+        const attackS     = Math.max(parameters["attack"][0],  1 / this.sampleRate)
+        const releaseS    = Math.max(parameters["release"][0], 1 / this.sampleRate)
+        const makeupDB    = parameters["makeup"][0]
+
+        /*  update envelope per channel  */
+        for (let ch = 0; ch < nCh; ch++)
+            this.updateEnvelopeForChannel(ch, input[ch], attackS, releaseS)
+
+        /*  determine linear value from decibel makeup value */
+        const makeUpLin = utils.dB2lin(makeupDB)
+
+        /*  iterate over all channels  */
+        for (let ch = 0; ch < nCh; ch++) {
+            const levelDB = utils.lin2dB(this.env[ch])
+            const gainDB  = this.gainDBFor(levelDB, thresholdDB, ratio, kneeDB)
+            let gainLin = utils.dB2lin(gainDB) * makeUpLin
+
+            /*  do not attenuate below floor  */
+            const expectedOutLevelDB = levelDB + gainDB + makeupDB
+            if (expectedOutLevelDB < floorDB) {
+                const neededLiftDB = floorDB - expectedOutLevelDB
+                gainLin /= utils.dB2lin(neededLiftDB)
+            }
+
+            /*  apply gain change to channel  */
+            const inp = input[ch]
+            const out = output[ch]
+            for (let i = 0; i < inp.length; i++)
+                out[i] = inp[i] * gainLin
+        }
+        return true
+    }
+}
+
+/*  register the new audio nodes  */
+registerProcessor("expander", ExpanderProcessor)

package/speechflow-cli/src/speechflow-node-a2a-expander.ts

@@ -0,0 +1,212 @@
+/*
+**  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>
+*/
+
+/*  standard dependencies  */
+import path             from "node:path"
+import Stream           from "node:stream"
+
+/*  external dependencies  */
+import { AudioWorkletNode } from "node-web-audio-api"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as utils                          from "./speechflow-utils"
+import { WebAudio }                        from "./speechflow-utils-audio"
+
+/*  internal types  */
+interface AudioExpanderConfig {
+    thresholdDb?: number
+    floorDb?:     number
+    ratio?:       number
+    attackMs?:    number
+    releaseMs?:   number
+    kneeDb?:      number
+    makeupDb?:    number
+}
+
+/*  audio noise expander class  */
+class AudioExpander extends WebAudio {
+    /*  internal state  */
+    private config:       Required<AudioExpanderConfig>
+    private expanderNode: AudioWorkletNode | null = null
+
+    /*  construct object  */
+    constructor(
+        sampleRate: number,
+        channels:   number,
+        config:     AudioExpanderConfig = {}
+    ) {
+        super(sampleRate, channels)
+
+        /*  store configuration  */
+        this.config = {
+            thresholdDb: config.thresholdDb ?? -45,
+            floorDb:     config.floorDb     ?? -64,
+            ratio:       config.ratio       ?? 4.0,
+            attackMs:    config.attackMs    ?? 10,
+            releaseMs:   config.releaseMs   ?? 50,
+            kneeDb:      config.kneeDb      ?? 6.0,
+            makeupDb:    config.makeupDb    ?? 0
+        }
+    }
+
+    /*  initialize object  */
+    public async setup (): Promise<void> {
+        await super.setup()
+
+        /*  add audio worklet module  */
+        const url = path.resolve(__dirname, "speechflow-node-a2a-expander-wt.js")
+        await this.audioContext.audioWorklet.addModule(url)
+
+        /*  create expander node  */
+        this.expanderNode = new AudioWorkletNode(this.audioContext, "expander", {
+            numberOfInputs:  1,
+            numberOfOutputs: 1,
+            processorOptions: {
+                sampleRate: this.audioContext.sampleRate
+            }
+        })
+
+        /*  configure expander node  */
+        const currentTime = this.audioContext.currentTime
+        const node = this.expanderNode!
+        const params = node.parameters as Map<string, AudioParam>
+        params.get("threshold")!.setValueAtTime(this.config.thresholdDb, currentTime)
+        params.get("floor")!.setValueAtTime(this.config.floorDb, currentTime)
+        params.get("ratio")!.setValueAtTime(this.config.ratio, currentTime)
+        params.get("attack")!.setValueAtTime(this.config.attackMs / 1000, currentTime)
+        params.get("release")!.setValueAtTime(this.config.releaseMs / 1000, currentTime)
+        params.get("knee")!.setValueAtTime(this.config.kneeDb, currentTime)
+        params.get("makeup")!.setValueAtTime(this.config.makeupDb, currentTime)
+
+        /*  connect nodes  */
+        this.sourceNode!.connect(this.expanderNode)
+        this.expanderNode.connect(this.captureNode!)
+    }
+
+    public async destroy (): Promise<void> {
+        await super.destroy()
+
+        /*  destroy expander node  */
+        if (this.expanderNode !== null) {
+            this.expanderNode.disconnect()
+            this.expanderNode = null
+        }
+    }
+}
+
+/*  SpeechFlow node for noise expander in audio-to-audio passing  */
+export default class SpeechFlowNodeExpander extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "expander"
+
+    /*  internal state  */
+    private destroyed = false
+    private expander: AudioExpander | null = null
+
+    /*  construct node  */
+    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
+        super(id, cfg, opts, args)
+
+        /*  declare node configuration parameters  */
+        this.configure({
+            thresholdDb: { type: "number", val: -45, match: (n: number) => n <= 0   && n >= -100 },
+            floorDb:     { type: "number", val: -64, match: (n: number) => n <= 0   && n >= -100 },
+            ratio:       { type: "number", val: 4.0, match: (n: number) => n >= 1   && n <= 20   },
+            attackMs:    { type: "number", val: 10,  match: (n: number) => n >= 0   && n <= 1000 },
+            releaseMs:   { type: "number", val: 50,  match: (n: number) => n >= 0   && n <= 1000 },
+            kneeDb:      { type: "number", val: 6.0, match: (n: number) => n >= 0   && n <= 40   },
+            makeupDb:    { type: "number", val: 0,   match: (n: number) => n >= -24 && n <= 24   }
+        })
+
+        /*  sanity check floor vs threshold  */
+        if (this.params.floorDb >= this.params.thresholdDb)
+            throw new Error("floor dB must be less than threshold dB for proper expansion")
+
+        /*  declare node input/output format  */
+        this.input  = "audio"
+        this.output = "audio"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  clear destruction flag  */
+        this.destroyed = false
+
+        /*  setup expander  */
+        this.expander = new AudioExpander(
+            this.config.audioSampleRate,
+            this.config.audioChannels, {
+                thresholdDb: this.params.thresholdDb,
+                floorDb:     this.params.floorDb,
+                ratio:       this.params.ratio,
+                attackMs:    this.params.attackMs,
+                releaseMs:   this.params.releaseMs,
+                kneeDb:      this.params.kneeDb,
+                makeupDb:    this.params.makeupDb
+            }
+        )
+        await this.expander.setup()
+
+        /*  establish a transform stream  */
+        const self = this
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
+                if (self.destroyed) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
+                if (!Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else {
+                    /*  expand chunk  */
+                    const payload = utils.convertBufToI16(chunk.payload)
+                    self.expander?.process(payload).then((result) => {
+                        if (self.destroyed)
+                            throw new Error("stream already destroyed")
+
+                        /*  take over expanded data  */
+                        const payload = utils.convertI16ToBuf(result)
+                        chunk.payload = payload
+                        this.push(chunk)
+                        callback()
+                    }).catch((error) => {
+                        callback(new Error(`expansion failed: ${error}`))
+                    })
+                }
+            },
+            final (callback) {
+                if (self.destroyed) {
+                    callback()
+                    return
+                }
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  indicate destruction  */
+        this.destroyed = true
+
+        /*  destroy expander  */
+        if (this.expander !== null) {
+            await this.expander.destroy()
+            this.expander = null
+        }
+
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+    }
+}