@ylink-sdk/mobile-web 0.1.9-beta.1 → 0.1.9-beta.4

package/dist/e30037b8/worklet-audio-worker.global.js

@@ -1,900 +0,0 @@
-(function () {
-    'use strict';
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __awaiter(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());
-        });
-    }
-
-    function pipeline(middleware) {
-        return (context, next) => {
-            // last called middleware
-            let index = -1;
-            const run = (i) => __awaiter(this, void 0, void 0, function* () {
-                if (i <= index) {
-                     console.warn('next() called multiple times');
-                    return;
-                }
-                index = i;
-                let callback = middleware[i];
-                if (i === middleware.length)
-                    callback = next;
-                if (!callback)
-                    return;
-                if (callback.length > 1) {
-                    return callback(context, dispatch);
-                }
-                yield callback(context, dispatch);
-                return dispatch();
-            });
-            const dispatch = () => run(index + 1);
-            return dispatch();
-        };
-    }
-
-    class MojoReceiver {
-        constructor(channel, pipe) {
-            this.middleware = [];
-            this.pipe = pipe || Math.random().toString(36).slice(3);
-            this.channel = channel;
-        }
-        get valid() {
-            return this.channel.has(this.pipe);
-        }
-        implement(key, invoke) {
-            const m = (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-                const { method, params, status, required, attached = {} } = ctx.data;
-                if (key !== method) {
-                    return next();
-                }
-                let handled = false;
-                const transfer = [];
-                const reAttached = {};
-                const done = (payload) => {
-                    if (handled) {
-                         console.warn(`receiver[${this}] - ${method} reply multiple times`);
-                        return;
-                    }
-                    handled = true;
-                    this.channel.send(Object.assign(Object.assign(Object.assign({}, ctx.data), { 
-                        // override params as it may contains un-cloned object
-                        params: undefined, 
-                        // override attached as it may contains un-cloned object
-                        attached: reAttached }), payload), transfer);
-                };
-                const reply = {
-                    transfer: (...args) => {
-                        if (required) {
-                            transfer.push(...args);
-                        }
-                        return reply;
-                    },
-                    resolve: (value) => {
-                        if (!required) {
-                            handled = true;
-                            return;
-                        }
-                        done({ resolve: value, status: status + 1 });
-                    },
-                    reject: (reason) => {
-                        if (!required) {
-                            handled = true;
-                            return;
-                        }
-                        done({ status: status - 1, reject: reason });
-                    },
-                    // attached
-                    set: (key, val) => {
-                        if (required) {
-                            reAttached[key] = val;
-                        }
-                        return reply;
-                    },
-                    get: (key) => attached[key],
-                };
-                try {
-                    const timestamp = Date.now();
-                    yield invoke(reply, params, ctx.ports);
-                    if (true) {
-                        const delta = Date.now() - timestamp;
-                        if (delta > 100) {
-                            console.log(`receiver[${this}] - ${method}() took ${delta}ms`);
-                        }
-                    }
-                }
-                catch (error) {
-                     console.warn(error);
-                    if (!handled) {
-                        reply.reject(`${error}`);
-                    }
-                }
-                ctx.data.touched = true;
-                if (!handled) {
-                    yield next();
-                }
-            });
-            this.middleware.unshift(m);
-            const unload = () => {
-                const index = this.middleware.findIndex((v) => v === m);
-                if (~index) {
-                    this.middleware.splice(index, 1);
-                }
-            };
-            return unload;
-        }
-        reject(msg = '') {
-            this.channel.reject(this, msg);
-        }
-        as() {
-            return this;
-        }
-        callback() {
-            return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-                const { pipe, status } = ctx.data;
-                if (pipe !== this.pipe) {
-                    return next();
-                }
-                if (status) {
-                    return next();
-                }
-                return pipeline(this.middleware)(ctx, next);
-            });
-        }
-        toString() {
-            return `${this.pipe}`;
-        }
-    }
-
-    class MojoRemote {
-        constructor(channel, pipe) {
-            this.sequence = 0;
-            this.pendings = new Map();
-            this.pipe = pipe || Math.random().toString(36).slice(3);
-            this.channel = channel;
-            this.accepted = defer();
-        }
-        get ready() {
-            return this.accepted.promise;
-        }
-        get valid() {
-            return this.channel.has(this.pipe);
-        }
-        make(key) {
-            const transfer = [];
-            const attached = {};
-            const ready = (params) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield this.ready;
-                }
-                catch (error) {
-                     console.warn(`remote[${this}] - ${key}(${params}) failed with '${error}'`);
-                    throw error;
-                }
-            });
-            const send = (params, required) => {
-                this.channel.send({
-                    pipe: this.pipe,
-                    sequence: ++this.sequence,
-                    timestamp: Date.now(),
-                    method: key,
-                    status: 0,
-                    params,
-                    required,
-                    attached,
-                }, transfer);
-            };
-            const invoke = {
-                transfer: (...args) => {
-                    transfer.push(...args);
-                    return invoke;
-                },
-                post: (...params) => __awaiter(this, void 0, void 0, function* () {
-                    yield ready(params);
-                    send(params);
-                }),
-                invoke: (...params) => __awaiter(this, void 0, void 0, function* () {
-                    yield ready(params);
-                    send(params, true);
-                    const d = defer();
-                    this.pendings.set(this.sequence, d);
-                    return d.promise;
-                }),
-                // attached
-                set: (key, val) => {
-                    attached[key] = val;
-                    return invoke;
-                },
-                get: (key) => attached[key],
-            };
-            return invoke;
-        }
-        break(msg = '') {
-            this.channel.break(this, msg);
-            this.pendings.forEach((p) => p.reject('broken'));
-            this.pendings.clear();
-            this.accepted.reject('broken');
-            // eslint-disable-next-line prefer-promise-reject-errors
-            this.accepted.promise = Promise.reject('broken');
-            // handle uncaught promise
-            this.accepted.promise.catch(NOOP);
-        }
-        callback() {
-            return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-                const { pipe, sequence, timestamp, method, status, reject, resolve } = ctx.data;
-                if (pipe !== this.pipe) {
-                    return next();
-                }
-                if (!status) {
-                    return next();
-                }
-                const d = this.pendings.get(sequence);
-                if (!d) {
-                     console.log(`remote[${this}] - receive unknown ${method} reply`);
-                    return;
-                }
-                if (status < 0) {
-                    d.reject(reject);
-                }
-                else {
-                    d.resolve(resolve);
-                }
-                this.pendings.delete(sequence);
-                {
-                    const delta = Date.now() - timestamp;
-                    if (delta > 100) {
-                        console.log(`remote[${this}] - ${method}() took ${delta}ms`);
-                    }
-                }
-            });
-        }
-        toString() {
-            return `${this.pipe}`;
-        }
-    }
-    function defer() {
-        const until = {};
-        until.promise = new Promise((resolve, reject) => {
-            until.resolve = resolve;
-            until.reject = reject;
-        });
-        // handle uncaught promise
-        until.promise.catch(NOOP);
-        if ( typeof setTimeout !== 'undefined') {
-            setTimeout(() => until.reject('timeout'), 10000);
-        }
-        return until;
-    }
-    const NOOP = () => {
-        // nothing
-    };
-
-    class MojoChannel {
-        // fix me
-        // incompatible onmessage ev type
-        constructor(transport) {
-            this.remotes = new Map();
-            this.receivers = new Map();
-            this.pendingReceivers = new Set();
-            const previous = transport.onmessage;
-            this.transport = transport;
-            this.transport.onmessage = (ev) => {
-                const { data, ports = [] } = ev;
-                if (isString(data)) {
-                    if (/^mojo/.test(data)) {
-                        const [, pipe] = data.split(':');
-                        const receiver = this.receivers.get(`${pipe}`);
-                        if (receiver) {
-                            this.send(`accept:${receiver}`);
-                            this.oninvitation && this.oninvitation(pipe, receiver);
-                            receiver.onready && receiver.onready();
-                            return;
-                        }
-                        this.pendingReceivers.add(pipe);
-                        this.oninvitation && this.oninvitation(pipe);
-                        if (this.pendingReceivers.has(pipe)) {
-                            previous && previous.call(this.transport, ev);
-                        }
-                        return;
-                    }
-                    if (/^accept/.test(data)) {
-                        const [, pipe] = data.split(':');
-                        const remote = this.remotes.get(pipe);
-                        if (!remote) {
-                             console.log(`unknown accept:\n${data}`);
-                            return;
-                        }
-                        remote.accepted.resolve();
-                        remote.onaccept && remote.onaccept();
-                        return;
-                    }
-                    if (/^reject/.test(data)) {
-                        const [, pipe, msg = 'rejected'] = data.split(':');
-                        const remote = this.remotes.get(pipe);
-                        if (!remote) {
-                             console.log(`unknown reject:\n${data}`);
-                            return;
-                        }
-                        this.remotes.delete(pipe);
-                        remote.accepted.reject(msg);
-                        remote.onreject && remote.onreject(msg);
-                        return;
-                    }
-                    if (/^break/.test(data)) {
-                        const [, pipe, msg = 'breaked'] = data.split(':');
-                        if (this.pendingReceivers.has(pipe)) {
-                            this.pendingReceivers.delete(pipe);
-                            return;
-                        }
-                        const receiver = this.receivers.get(pipe);
-                        if (!receiver) {
-                             console.log(`unknown break:\n${data}`);
-                            return;
-                        }
-                        this.receivers.delete(pipe);
-                        receiver.onbreak && receiver.onbreak(msg);
-                        return;
-                    }
-                    if (previous) {
-                        previous.call(this.transport, ev);
-                        return;
-                    }
-                     console.log(`unknown invitation:\n${data}`);
-                    return;
-                }
-                const ctx = { data, ports };
-                pipeline([
-                    ...Array.from(this.remotes.values()).map((p) => p.callback()),
-                    ...Array.from(this.receivers.values()).map((p) => p.callback()),
-                ])(ctx, () => {
-                    if (previous) {
-                        previous.call(this.transport, ev);
-                        return;
-                    }
-                    if (data.touched) {
-                        
-                            console.log(`unhandled method: ${data.pipe}::${data.method}\n` +
-                                `forget to call resolve() or reject() in method implement?`);
-                        return;
-                    }
-                     console.log('unknown message', data);
-                });
-            };
-        }
-        fork() {
-            return new MojoChannel(this.transport);
-        }
-        has(pipe) {
-            return this.remotes.has(pipe) || this.receivers.has(pipe);
-        }
-        close() {
-            this.remotes.forEach((v) => v.break());
-            this.remotes.clear();
-            this.receivers.forEach((v) => v.reject());
-            this.receivers.clear();
-            this.transport.onmessage = null;
-            this.transport = null;
-        }
-        send(msg, transfer) {
-            this.transport.postMessage(msg, transfer);
-        }
-        reject(receiver, msg = '') {
-            this.send(`reject:${receiver}:${msg}`);
-            this.receivers.delete(`${receiver}`);
-        }
-        break(remote, msg = '') {
-            if (!this.remotes.has(`${remote}`))
-                return;
-            this.send(`break:${remote}:${msg}`);
-            this.remotes.delete(`${remote}`);
-        }
-        remote(pipe) {
-            const remote = new MojoRemote(this, pipe && `${pipe}`);
-            this.remotes.set(`${remote}`, remote);
-            this.send(`mojo:${remote}`);
-            return remote;
-        }
-        receiver(pipe) {
-            if (pipe && this.receivers.has(`${pipe}`)) {
-                 console.log(`duplicate pipe: ${pipe}`);
-            }
-            const receiver = new MojoReceiver(this, pipe && `${pipe}`);
-            this.receivers.set(`${receiver}`, receiver);
-            if (this.pendingReceivers.has(`${receiver}`)) {
-                this.send(`accept:${receiver}`);
-                this.pendingReceivers.delete(`${receiver}`);
-                receiver.onready && receiver.onready();
-            }
-            return receiver;
-        }
-    }
-    const isString = (val) => typeof val === 'string';
-
-    class AudioFrameBuffer {
-        constructor(builder) {
-            const { length, numberOfChannels: channels = 1, sampleRate } = builder;
-            let { data } = builder;
-            this.length = length;
-            this.numberOfChannels = channels;
-            this.sampleRate = sampleRate;
-            this.duration = length / sampleRate;
-            if (!data || !data.length || !data[0].length) {
-                // AudioBuffer do not store data as a planar sequence
-                data = [...Array(channels)].map(() => new Float32Array(length));
-            }
-            if (data.length < channels) {
-                 console.warn(`invalid buffer channels ${channels} vs ${data.length}`);
-            }
-            if (data[0].length < length) {
-                 console.warn(`invalid buffer length ${length} vs ${data[0].length}`);
-            }
-            this.data = data;
-        }
-        // CopyFrom
-        static From(buffer) {
-            const { sampleRate, numberOfChannels, length } = buffer;
-            const data = [...Array(numberOfChannels).keys()].map((ch) => buffer.getChannelData(ch).slice());
-            return new AudioFrameBuffer({ length, numberOfChannels, sampleRate, data });
-        }
-        static Copy(dst, src) {
-            const { numberOfChannels: channels } = dst;
-            const { numberOfChannels: available } = src;
-            for (let ch = 0; ch < channels; ch++) {
-                dst.copyToChannel(src.getChannelData(Math.min(ch, available - 1)), ch);
-            }
-        }
-        static Clip(buffer, begin, end) {
-            const { sampleRate, numberOfChannels } = buffer;
-            const data = AudioFrameBuffer.Data(buffer, begin, end);
-            const { length } = data[0];
-            return new AudioFrameBuffer({ length, numberOfChannels, sampleRate, data });
-        }
-        static Data(buffer, begin, end) {
-            return [...Array(buffer.numberOfChannels)].map((_, ch) => buffer.getChannelData(ch).subarray(begin, end));
-        }
-        static Builder(buffer) {
-            const { length, numberOfChannels, sampleRate } = buffer;
-            const data = AudioFrameBuffer.Data(buffer);
-            return {
-                length,
-                numberOfChannels,
-                sampleRate,
-                data,
-            };
-        }
-        copyFromChannel(destination, channel = 0, bufferOffset = 0) {
-            if (channel >= this.numberOfChannels) {
-                 console.warn('invalid channel');
-                return;
-            }
-            const data = this.getChannelData(channel);
-            if (bufferOffset >= data.length) {
-                 console.warn('invalid offset');
-                return;
-            }
-            const source = data.subarray(bufferOffset);
-            destination.set(source.subarray(0, Math.min(source.length, destination.length)));
-        }
-        copyToChannel(source, channel = 0, bufferOffset = 0) {
-            if (channel >= this.numberOfChannels) {
-                 console.warn('invalid channel');
-                return;
-            }
-            const data = this.getChannelData(channel);
-            if (bufferOffset >= this.length) {
-                 console.warn('invalid offset');
-                return;
-            }
-            const length = Math.min(this.length - bufferOffset, source.length);
-            const clipped = source.subarray(0, length);
-            data.set(clipped, bufferOffset);
-        }
-        getChannelData(channel) {
-            return this.data[channel];
-        }
-    }
-
-    // export const enum SpeechType {
-    var VADActivity;
-    (function (VADActivity) {
-        VADActivity[VADActivity["kVadActive"] = 0] = "kVadActive";
-        VADActivity[VADActivity["kVadPassive"] = 1] = "kVadPassive";
-        VADActivity[VADActivity["kVadUnknown"] = 2] = "kVadUnknown";
-    })(VADActivity || (VADActivity = {}));
-    // export const enum SpeechType {
-    var SpeechType;
-    (function (SpeechType) {
-        SpeechType[SpeechType["kNormalSpeech"] = 0] = "kNormalSpeech";
-        SpeechType[SpeechType["kPLC"] = 1] = "kPLC";
-        SpeechType[SpeechType["kCNG"] = 2] = "kCNG";
-        SpeechType[SpeechType["kPLCCNG"] = 3] = "kPLCCNG";
-        SpeechType[SpeechType["kCodecPLC"] = 4] = "kCodecPLC";
-        SpeechType[SpeechType["kUndefined"] = 5] = "kUndefined";
-    })(SpeechType || (SpeechType = {}));
-    class AudioFrame {
-        constructor(builder) {
-            this.buffer = builder.buffer;
-            this.timestamp = builder.timestamp;
-            this.elapsedTimeMs = builder.elapsedTimeMs;
-            this.ntpTimeMs = builder.ntpTimeMs;
-            this.vad = builder.vad || VADActivity.kVadUnknown;
-            this.speech = builder.speech || SpeechType.kUndefined;
-        }
-        get sampleRate() {
-            return this.buffer.sampleRate;
-        }
-        get samples() {
-            return this.buffer.length;
-        }
-        get channels() {
-            return this.buffer.numberOfChannels;
-        }
-        get duration() {
-            return this.buffer.duration;
-        }
-    }
-
-    function CopyAudioFrame(output, outputOffset = 0, input, inputOffset = 0, length = input.length) {
-        const { numberOfChannels: channels } = output;
-        const { numberOfChannels: available } = input;
-        for (let channel = 0; channel < channels; channel++) {
-            const source = input
-                .getChannelData(Math.min(channel, available - 1))
-                .subarray(inputOffset, inputOffset + length);
-            output.copyToChannel(source, channel, outputOffset);
-        }
-    }
-
-    function makeAudioReshaper(wanted, callback, factory) {
-        let pending;
-        let offset = 0;
-        return (input) => {
-            const { samples, channels, sampleRate } = input;
-            let current = 0;
-            while (current < samples) {
-                const needed = wanted - offset;
-                const available = samples - current;
-                const total = Math.min(available, needed);
-                if (!needed) {
-                    callback(pending);
-                    pending = null;
-                }
-                if (!pending) {
-                    pending = factory
-                        ? factory(wanted)
-                        : new AudioFrame({
-                            buffer: new AudioFrameBuffer({
-                                length: wanted,
-                                numberOfChannels: channels,
-                                sampleRate,
-                            }),
-                        });
-                    offset = 0;
-                }
-                CopyAudioFrame(pending.buffer, offset, input.buffer, current, total);
-                current += total;
-                offset += total;
-            }
-        };
-    }
-
-    class AudioFrameQueue {
-        constructor() {
-            this.queue = [];
-            // total audio samples
-            this.total = 0;
-            // audio samples offset
-            this.offset = 0;
-        }
-        get length() {
-            return this.total;
-        }
-        clear() {
-            this.queue.length = 0;
-            this.total = 0;
-            this.offset = 0;
-        }
-        shift() {
-            if (!this.total)
-                return;
-            const frame = this.queue[0];
-            const available = frame.samples - this.offset;
-            if (this.offset) {
-                 console.log('maybe unexpected samples');
-            }
-            return this.pull(available);
-        }
-        push(frame) {
-            const input = (frame) => {
-                this.queue.push(frame);
-                this.total += frame.samples;
-            };
-            if (!this.onpush) {
-                input(frame);
-                return;
-            }
-            const { samples, callback, factory, reshape = false } = this.onpush;
-            let { reshaper } = this.onpush;
-            if (reshape) {
-                if (!reshaper) {
-                    reshaper = makeAudioReshaper(samples, input, factory);
-                    this.onpush.reshaper = reshaper;
-                }
-                // reshape & input
-                reshaper(frame);
-            }
-            else {
-                input(frame);
-            }
-            while (this.total - this.offset >= samples) {
-                callback(reshape ? this.shift() : this.pull(samples, factory && factory(samples)));
-            }
-        }
-        pull(wanted, output) {
-            if (wanted <= 0) {
-                 wanted < 0 && console.warn(`invalid samples: ${wanted}`);
-                return;
-            }
-            if (this.onpull) {
-                const { samples, callback, eager } = this.onpull;
-                while (this.total < Math.max(samples, wanted) * (eager ? 2 : 1)) {
-                    const frame = callback(this.total, wanted);
-                    if (!frame) {
-                        break;
-                    }
-                    this.queue.push(frame);
-                    this.total += frame.samples;
-                }
-            }
-            if (this.total < wanted) {
-                 console.warn('audio frame drained');
-                return;
-            }
-            let current = 0;
-            let { offset } = this;
-            while (current < wanted) {
-                const frame = this.queue.shift();
-                const available = frame.samples - offset;
-                const needed = wanted - current;
-                const length = Math.min(available, needed);
-                if (!available) {
-                    continue;
-                }
-                // clip buffer w/o copy
-                if (!output && !current && available >= needed) {
-                    const buffer = AudioFrameBuffer.Clip(frame.buffer, offset, offset + needed);
-                    output = new AudioFrame({ buffer });
-                    if (available > needed) {
-                        offset += length;
-                        this.queue.unshift(frame);
-                    }
-                    else {
-                        offset = 0;
-                    }
-                    break;
-                }
-                // copy needed or available
-                if (!output) {
-                    const buffer = new AudioFrameBuffer({
-                        length: wanted,
-                        numberOfChannels: frame.channels,
-                        sampleRate: frame.sampleRate,
-                    });
-                    output = new AudioFrame({ buffer });
-                }
-                if (output.samples < wanted) {
-                     console.warn('invalid frame buffer length');
-                }
-                CopyAudioFrame(output.buffer, current, frame.buffer, offset, length);
-                current += length;
-                if (available > needed) {
-                    offset += length;
-                    this.queue.unshift(frame);
-                    break;
-                }
-                offset = 0;
-                if (this.onpull) {
-                    // optional chaining
-                    // this.onpull.drain?.(frame);
-                    const { drain } = this.onpull;
-                    drain && drain(frame);
-                }
-            }
-            this.total -= wanted;
-            this.offset = offset;
-            return output;
-        }
-    }
-
-    class WorkletAudioTransport extends AudioWorkletProcessor {
-        constructor({ processorOptions = {} }) {
-            super();
-            this.bufferPool = [];
-            this.bufferSize = processorOptions.bufferSize || (sampleRate / 100) * 3; // 30ms
-            this.channel = new MojoChannel(this.port);
-            this.receiver = this.channel.receiver('worklet-audio-transport-host');
-            this.receiver.implement('setup', (reply, [sinkref = false], [port1, port2]) => {
-                if (!port1) {
-                     console.warn('setup() without host message port');
-                    reply.resolve();
-                    return;
-                }
-                dispose();
-                // processor api
-                if (!port2) {
-                    this.host = new MojoChannel(port1);
-                    this.processor = this.host.remote('worklet-audio-processor-host');
-                    reply.resolve();
-                    return;
-                }
-                this.sinkref = sinkref;
-                // source|sink api
-                this.sourceHost = new MojoChannel(port1);
-                this.source = this.sourceHost.remote('worklet-audio-source-host');
-                this.sinkHost = new MojoChannel(port2);
-                this.sink = this.sinkHost.remote('worklet-audio-sink-host');
-                reply.resolve();
-            });
-            const disable = (remote) => {
-                if (!remote)
-                    return;
-                remote.break();
-            };
-            const close = (host) => {
-                if (!host)
-                    return;
-                host.transport.close();
-                host.close();
-            };
-            const dispose = () => {
-                this.host = close(this.host);
-                this.processor = disable(this.processor);
-                this.sourceHost = close(this.sourceHost);
-                this.source = disable(this.source);
-                this.sinkHost = close(this.sinkHost);
-                this.sink = disable(this.sink);
-            };
-            this.processor = this.channel.remote('worklet-audio-processor-host');
-            this.inputBuffer = new AudioFrameQueue();
-            this.outputBuffer = new AudioFrameQueue();
-            const onpull = (builder) => {
-                if (!builder)
-                    return;
-                const buffer = new AudioFrameBuffer(builder);
-                const frame = new AudioFrame({ buffer });
-                const { outputBuffer, bufferSize, processor } = this;
-                outputBuffer.push(frame);
-                const delay = outputBuffer.total;
-                if (delay > bufferSize * 2) {
-                     console.log(`output delay: ${Math.ceil((delay / sampleRate) * 1000)}ms`);
-                    processor && processor.make('processdelay').post(delay);
-                }
-                if (this.sinkref && this.source) {
-                    this.source.make('onref').post(builder);
-                }
-            };
-            this.inputBuffer.onpush = {
-                samples: this.bufferSize,
-                reshape: true,
-                factory: (length) => {
-                    const frame = this.bufferPool.shift();
-                    if (!frame || frame.buffer.length !== length) {
-                        const buffer = new AudioFrameBuffer({
-                            length,
-                            numberOfChannels: this.channels,
-                            sampleRate,
-                        });
-                        return new AudioFrame({ buffer });
-                    }
-                    if (this.bufferPool.length > 4) {
-                         console.log(`reduce audio buffer pool: ${this.bufferPool.length}`);
-                    }
-                    while (this.bufferPool.length > 4) {
-                        this.bufferPool.pop();
-                    }
-                    return frame;
-                },
-                callback: (frame) => {
-                    const builder = AudioFrameBuffer.Builder(frame.buffer);
-                    const { processor, source } = this;
-                    // processor api
-                    if (processor) {
-                        processor
-                            .make('process')
-                            .transfer(...builder.data.map((d) => d.buffer))
-                            .invoke(builder)
-                            .then(onpull)
-                            .catch(() => {
-                            // ignore
-                        });
-                    }
-                    // source|sink api
-                    if (source) {
-                        source
-                            .make('onpush')
-                            .transfer(...builder.data.map((d) => d.buffer))
-                            .post(builder);
-                    }
-                },
-            };
-            let pulling = false;
-            this.outputBuffer.onpull = {
-                samples: this.bufferSize,
-                callback: () => {
-                    if (pulling)
-                        return;
-                    const { sink, bufferSize, channels } = this;
-                    // source|sink api
-                    if (sink) {
-                        sink
-                            .make('onpull')
-                            .invoke(bufferSize, channels, sampleRate)
-                            .then(onpull)
-                            .finally(() => (pulling = false));
-                        pulling = true;
-                    }
-                },
-                drain: (frame) => {
-                    this.bufferPool.push(frame);
-                },
-            };
-        }
-        process(inputs, outputs) {
-            const input = inputs[0];
-            const output = outputs[0];
-            if (!output.length)
-                return true;
-            const numberOfChannels = output.length;
-            const samples = output[0].length;
-            this.channels = numberOfChannels;
-            // input is reused which means buffer can not be queued.
-            this.inputBuffer.push(new AudioFrame({
-                buffer: new AudioFrameBuffer({
-                    length: samples,
-                    numberOfChannels,
-                    sampleRate,
-                    data: input,
-                }),
-            }));
-            const frame = new AudioFrame({
-                buffer: new AudioFrameBuffer({
-                    length: samples,
-                    numberOfChannels,
-                    sampleRate,
-                    data: output,
-                }),
-            });
-            if (!this.outputBuffer.pull(samples, frame)) {
-                // copy last sample if drained, prevent audio glitches
-                if (this.lastsample) {
-                    output.forEach((data, ch) => data.fill(this.lastsample[ch]));
-                }
-            }
-            else {
-                this.lastsample = output.map((val) => val[val.length - 1]);
-            }
-            return true;
-        }
-    }
-    registerProcessor('worklet-audio-transport', WorkletAudioTransport);
-
-}());