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

package/dist/e30037b8/native-video-worker.global.js

@@ -1,1960 +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';
-
-    function YUVToRGB(buffer, image, alpha = 255) {
-        const { width, height, chromaWidth, chromaHeight, dataY, dataU, dataV, strideY, strideU, strideV, } = buffer;
-        const output = image.data;
-        const hdec = depower(width / chromaWidth) | 0;
-        const vdec = depower(height / chromaHeight) | 0;
-        const outStride = width << 2;
-        let YPtr = 0;
-        let Y0Ptr = 0;
-        let Y1Ptr = 0;
-        let CbPtr = 0;
-        let CrPtr = 0;
-        let outPtr = 0;
-        let outPtr0 = 0;
-        let outPtr1 = 0;
-        let colorCb = 0;
-        let colorCr = 0;
-        let multY = 0;
-        let multCrR = 0;
-        let multCbCrG = 0;
-        let multCbB = 0;
-        let x = 0;
-        let y = 0;
-        let xdec = 0;
-        let ydec = 0;
-        // eslint-disable-next-line no-constant-condition
-        if (hdec === 1 && vdec === 1) {
-            // Optimize for 4:2:0, which is most common
-            outPtr0 = 0;
-            outPtr1 = outStride;
-            ydec = 0;
-            for (y = 0; y < height; y += 2) {
-                Y0Ptr = (y * strideY) | 0;
-                Y1Ptr = (Y0Ptr + strideY) | 0;
-                CbPtr = (ydec * strideU) | 0;
-                CrPtr = (ydec * strideV) | 0;
-                for (x = 0; x < width; x += 2) {
-                    colorCb = dataU[CbPtr++] | 0;
-                    colorCr = dataV[CrPtr++] | 0;
-                    // Quickie YUV conversion
-                    // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.2020_conversion
-                    // multiplied by 256 for integer-friendliness
-                    multCrR = (((409 * colorCr) | 0) - 57088) | 0;
-                    multCbCrG = (((100 * colorCb) | 0) + ((208 * colorCr) | 0) - 34816) | 0;
-                    multCbB = (((516 * colorCb) | 0) - 70912) | 0;
-                    multY = (298 * dataY[Y0Ptr++]) | 0;
-                    output[outPtr0] = (multY + multCrR) >> 8;
-                    output[outPtr0 + 1] = (multY - multCbCrG) >> 8;
-                    output[outPtr0 + 2] = (multY + multCbB) >> 8;
-                    output[outPtr0 + 3] = alpha;
-                    outPtr0 += 4;
-                    multY = (298 * dataY[Y0Ptr++]) | 0;
-                    output[outPtr0] = (multY + multCrR) >> 8;
-                    output[outPtr0 + 1] = (multY - multCbCrG) >> 8;
-                    output[outPtr0 + 2] = (multY + multCbB) >> 8;
-                    output[outPtr0 + 3] = alpha;
-                    outPtr0 += 4;
-                    multY = (298 * dataY[Y1Ptr++]) | 0;
-                    output[outPtr1] = (multY + multCrR) >> 8;
-                    output[outPtr1 + 1] = (multY - multCbCrG) >> 8;
-                    output[outPtr1 + 2] = (multY + multCbB) >> 8;
-                    output[outPtr1 + 3] = alpha;
-                    outPtr1 += 4;
-                    multY = (298 * dataY[Y1Ptr++]) | 0;
-                    output[outPtr1] = (multY + multCrR) >> 8;
-                    output[outPtr1 + 1] = (multY - multCbCrG) >> 8;
-                    output[outPtr1 + 2] = (multY + multCbB) >> 8;
-                    output[outPtr1 + 3] = alpha;
-                    outPtr1 += 4;
-                }
-                outPtr0 += outStride;
-                outPtr1 += outStride;
-                ydec++;
-            }
-        }
-        else {
-            outPtr = 0;
-            for (y = 0; y < height; y++) {
-                xdec = 0;
-                ydec = y >> vdec;
-                YPtr = (y * strideY) | 0;
-                CbPtr = (ydec * strideU) | 0;
-                CrPtr = (ydec * strideV) | 0;
-                for (x = 0; x < width; x++) {
-                    xdec = x >> hdec;
-                    colorCb = dataU[CbPtr + xdec] | 0;
-                    colorCr = dataV[CrPtr + xdec] | 0;
-                    // Quickie YUV conversion
-                    // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.2020_conversion
-                    // multiplied by 256 for integer-friendliness
-                    multCrR = (((409 * colorCr) | 0) - 57088) | 0;
-                    multCbCrG = (((100 * colorCb) | 0) + ((208 * colorCr) | 0) - 34816) | 0;
-                    multCbB = (((516 * colorCb) | 0) - 70912) | 0;
-                    multY = (298 * dataY[YPtr++]) | 0;
-                    output[outPtr] = (multY + multCrR) >> 8;
-                    output[outPtr + 1] = (multY - multCbCrG) >> 8;
-                    output[outPtr + 2] = (multY + multCbB) >> 8;
-                    // const Y = dataY[YPtr++];
-                    // const U = dataU[CbPtr + xdec];
-                    // const V = dataV[CrPtr + xdec];
-                    // const [R, G, B] = YUV2RGB([Y, U, V]);
-                    // const R = YUVToR(Y, U, V);
-                    // const G = YUVToG(Y, U, V);
-                    // const B = YUVToB(Y, U, V);
-                    // output[outPtr] = R;
-                    // output[outPtr + 1] = G;
-                    // output[outPtr + 2] = B;
-                    output[outPtr + 3] = alpha;
-                    outPtr += 4;
-                }
-            }
-        }
-    }
-    function depower(ratio) {
-        let shiftCount = 0;
-        let n = ratio >> 1;
-        while (n !== 0) {
-            n >>= 1;
-            shiftCount++;
-        }
-        if (ratio !== 1 << shiftCount) {
-            throw Error(`chroma plane dimensions must be power of 2 ratio to luma plane dimensions; got ${ratio}`);
-        }
-        return shiftCount;
-    }
-
-    // export const enum VideoFrameBufferType {
-    var VideoFrameBufferType;
-    (function (VideoFrameBufferType) {
-        VideoFrameBufferType[VideoFrameBufferType["kNative"] = 0] = "kNative";
-        VideoFrameBufferType[VideoFrameBufferType["kRGBA"] = 1] = "kRGBA";
-        VideoFrameBufferType[VideoFrameBufferType["kABGR"] = 2] = "kABGR";
-        VideoFrameBufferType[VideoFrameBufferType["kI420"] = 3] = "kI420";
-        VideoFrameBufferType[VideoFrameBufferType["kI420A"] = 4] = "kI420A";
-        VideoFrameBufferType[VideoFrameBufferType["kI444"] = 5] = "kI444";
-    })(VideoFrameBufferType || (VideoFrameBufferType = {}));
-    function I420DataSize(height, strideY, strideU, strideV) {
-        return strideY * height + (strideU + strideV) * ((height + 1) / 2);
-    }
-    class I420Buffer {
-        constructor(builder) {
-            this.type = VideoFrameBufferType.kI420;
-            this.width = builder.width;
-            this.height = builder.height;
-            this.strideY = builder.strideY || this.width;
-            this.strideU = builder.strideU || this.chromaWidth;
-            this.strideV = builder.strideV || this.chromaWidth;
-            const hasdata = builder.dataY && builder.dataU && builder.dataV;
-            // @ts-ignore
-            this.data =
-                !hasdata &&
-                    AlignedMalloc(I420DataSize(this.height, this.strideY, this.strideU, this.strideV));
-            this.dataY = builder.dataY || new Uint8ClampedArray(this.data, 0, this.strideY * this.height);
-            this.dataU =
-                builder.dataU ||
-                    new Uint8ClampedArray(this.data, this.strideY * this.height, this.strideU * this.chromaHeight);
-            this.dataV =
-                builder.dataV ||
-                    new Uint8ClampedArray(this.data, this.strideY * this.height + this.strideU * this.chromaHeight, this.strideV * this.chromaHeight);
-            // this.dataY = builder.dataY || AlignedMalloc(this.strideY * this.height);
-            // this.dataU =
-            //   builder.dataU ||
-            //   AlignedMalloc(this.strideU * this.chromaHeight);
-            // this.dataV =
-            //   builder.dataV ||
-            //   AlignedMalloc(this.strideV * this.chromaHeight);
-        }
-        get chromaWidth() {
-            return Math.floor((this.width + 1) / 2);
-        }
-        get chromaHeight() {
-            return Math.floor((this.height + 1) / 2);
-        }
-        toI420() {
-            return this;
-        }
-        getI420() {
-            return this;
-        }
-        getI420A() {
-            return undefined;
-        }
-        getI444() {
-            return undefined;
-        }
-    }
-    // Aligning pointer to 64 bytes for improved performance, e.g. use SIMD.
-    const kBufferAlignment = 64;
-    function AlignedSize(size, alignment = kBufferAlignment) {
-        const remainder = size % alignment;
-        const aligned = remainder === 0 ? size : size + alignment - remainder;
-        return aligned;
-    }
-    function AlignedMalloc(size, alignment = kBufferAlignment) {
-        return new ArrayBuffer(AlignedSize(size, alignment));
-    }
-
-    class VideoFrame {
-        constructor(builder) {
-            this.buffer = builder.buffer;
-        }
-        get width() {
-            return this.buffer.width;
-        }
-        get height() {
-            return this.buffer.height;
-        }
-    }
-
-    let suspended = false;
-    if (typeof document !== 'undefined' && typeof __INVISIBLE_SUSPEND__ !== 'undefined') {
-        document.addEventListener('visibilitychange', () => {
-            suspended = document.visibilityState === 'hidden';
-        });
-    }
-    class VideoRenderer {
-        constructor() {
-            this.frameCounts = 0;
-            this.droppedFrameCounts = 0;
-            this.pending = false;
-        }
-        clear() {
-             console.log('abstract clear()');
-        }
-        render(frame) {
-             console.log('abstract render()', frame);
-        }
-        onFrame(frame, immediate = false) {
-            // fps reduction
-            if (!this.pending && !suspended) {
-                if (immediate) {
-                    this.render(frame);
-                }
-                else {
-                    requestAnimationFrame(() => this.render(frame));
-                }
-                requestAnimationFrame(() => (this.pending = false));
-                this.pending = true;
-            }
-            else {
-                this.droppedFrameCounts++;
-                
-                    !(this.droppedFrameCounts % 600) &&
-                    console.log(`renderer drop frame due to fps reduction: ${this.droppedFrameCounts}`);
-            }
-            this.frameCounts++;
-        }
-    }
-
-    class CanvasVideoRenderer extends VideoRenderer {
-        constructor(canvas) {
-            super();
-            this.canvas = canvas;
-            this.width = canvas.width;
-            this.height = canvas.height;
-            // this.canvas.style.display = 'block';
-            this.context = this.canvas.getContext('2d');
-            // this.context.setTransform(1, 0, 0, 1, 0, 0);
-        }
-        setSize(width, height) {
-            this.canvas.width = width;
-            this.canvas.height = height;
-            this.width = width;
-            this.height = height;
-        }
-        clear() {
-            this.context.clearRect(0, 0, this.width, this.height);
-        }
-        render(frame) {
-            const { width, height, buffer } = frame;
-            if (width !== this.width || height !== this.height) {
-                this.setSize(width, height);
-            }
-            this.clear();
-            let image;
-            switch (buffer.type) {
-                case VideoFrameBufferType.kI420:
-                    image = this.context.createImageData(width, height);
-                    YUVToRGB(buffer, image);
-                    break;
-                case VideoFrameBufferType.kABGR:
-                    image = buffer.toImage(this.context);
-                    break;
-                case VideoFrameBufferType.kNative:
-                    image = buffer.image;
-                    break;
-                default:
-                     console.warn(`Frame type: ${buffer.type} is not supported.`);
-                    return;
-            }
-            this.context.putImageData(image, 0, 0, 0, 0, width, height);
-        }
-    }
-
-    const VS = `
-precision mediump float;
-
-attribute vec2 aVertexPosition;
-attribute vec2 aTextureCoord;
-
-uniform vec2 uResolution;
-
-varying vec2 vTextureCoord;
-
-void main(void) {
-  // convert the rectangle from pixels to 0.0 to 1.0
-  vec2 zeroToOne = aVertexPosition / uResolution;
-  
-  // convert from 0 -> 1 to 0 -> 2
-  vec2 zeroToTwo = zeroToOne * 2.0;
-  
-  // convert from 0 -> 2 to -1 -> +1 (clipspace)
-  vec2 clipSpace = zeroToTwo - 1.0;
-
-  gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
-
-  vTextureCoord = aTextureCoord;
-}
-`;
-    const FS = `
-precision mediump float;
-
-uniform sampler2D uTextureY;
-uniform sampler2D uTextureU;
-uniform sampler2D uTextureV;
-
-varying vec2 vTextureCoord;
-
-const mat4 YUV2RGB = mat4( 
-   1.1643828125, 0, 1.59602734375, -.87078515625,
-   1.1643828125, -.39176171875, -.81296875, .52959375,
-   1.1643828125, 2.017234375, 0, -1.081390625,
-   0, 0, 0, 1
-);
-
-void main(void) {
-  gl_FragColor = vec4(
-    texture2D(uTextureY, vTextureCoord).x,
-    texture2D(uTextureU, vTextureCoord).x,
-    texture2D(uTextureV, vTextureCoord).x,
-    1
-  ) * YUV2RGB;
-}
-`;
-    function buildProgram(gl) {
-        // Create the program and shaders
-        const program = gl.createProgram();
-        const vertexShader = buildShader(gl, gl.VERTEX_SHADER, VS);
-        const fragmentShader = buildShader(gl, gl.FRAGMENT_SHADER, FS);
-        if (!program || !vertexShader || !fragmentShader) {
-            return null;
-        }
-        // Attach an link the shader
-        gl.attachShader(program, vertexShader);
-        gl.attachShader(program, fragmentShader);
-        gl.linkProgram(program);
-        // Add error handling
-        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-            const error = gl.getError();
-            const status = gl.getProgramParameter(program, gl.VALIDATE_STATUS);
-            
-                console.error(`Could not initialise shader.\n` + `VALIDATE_STATUS: ${status}\n` + `ERROR: ${error}`);
-            return null;
-        }
-        // Delete the shader
-        gl.deleteShader(fragmentShader);
-        gl.deleteShader(vertexShader);
-        // Enable program
-        gl.useProgram(program);
-        return program;
-    }
-    function buildShader(gl, type, source) {
-        const shader = gl.createShader(type);
-        if (!shader) {
-             console.error(`WebGL createShader(type: ${type}) failed.`);
-            return null;
-        }
-        // Add shader source
-        gl.shaderSource(shader, source);
-        // Compile shader
-        gl.compileShader(shader);
-        // Add error handling
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-             console.error(`WebGL compileShader() failed.\n` + `${gl.getShaderInfoLog(shader)}`);
-            return null;
-        }
-        return shader;
-    }
-    function buildBuffer(gl, program, type, identifier, size, structure, count) {
-        const buffer = {
-            buffer: gl.createBuffer(),
-            location: -1,
-            identifier,
-            size,
-            structure,
-            count,
-        };
-        // Set the location
-        switch (type) {
-            case 'attribute':
-                buffer.location = gl.getAttribLocation(program, identifier);
-                break;
-            case 'uniform':
-                buffer.location = gl.getUniformLocation(program, identifier);
-                break;
-        }
-        // Create the buffer if count is provided
-        if (count) {
-            buffer.data = new Float32Array(count * size);
-        }
-        // Return the buffer
-        return buffer;
-    }
-    function buildTexture(gl, program, type, identifier, textureId, unit) {
-        const texture = {
-            texture: gl.createTexture(),
-            textureId,
-            location: gl.getUniformLocation(program, identifier),
-            identifier,
-            unit,
-        };
-        // Bind texture
-        gl.activeTexture(textureId);
-        gl.bindTexture(gl.TEXTURE_2D, texture.texture);
-        // Set the parameters.
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-        gl.uniform1i(texture.location, unit);
-        return texture;
-    }
-    function setBufferData(index, buffer, value) {
-        if (isNumber(value)) {
-            buffer.data[index * buffer.size] = value;
-        }
-        else {
-            for (let i = value.length - 1; i >= 0; i--) {
-                buffer.data[index * buffer.size + i] = value[i];
-            }
-        }
-    }
-    function setTextureData(gl, texture, data, width, height) {
-        gl.activeTexture(texture.textureId);
-        gl.bindTexture(gl.TEXTURE_2D, texture.texture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.LUMINANCE, width, height, 0, gl.LUMINANCE, gl.UNSIGNED_BYTE, data);
-        const error = gl.getError();
-        if (error !== gl.NO_ERROR) {
-             console.log('WebGL texImage2D() failed.', error);
-        }
-    }
-    function setAttribBuffer(gl, buffer) {
-        gl.enableVertexAttribArray(buffer.location);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, buffer.data, gl.STATIC_DRAW);
-        gl.vertexAttribPointer(buffer.location, buffer.size, gl.FLOAT, false, 0, 0);
-    }
-    function setUniformBuffer(gl, buffer) {
-        const location = buffer.location;
-        const data = buffer.data;
-        switch (buffer.structure) {
-            case '2f':
-                gl.uniform2f(location, data[0], data[1]);
-                break;
-            case '2fv':
-                gl.uniform2fv(location, data);
-                break;
-            case '3f':
-                gl.uniform3f(location, data[0], data[1], data[2]);
-                break;
-            case '3fv':
-                gl.uniform3fv(location, data);
-                break;
-            case '4f':
-                gl.uniform4f(location, data[0], data[1], data[2], data[3]);
-                break;
-            case '4fv':
-                gl.uniform4fv(location, data);
-                break;
-        }
-    }
-    function isNumber(value) {
-        return !Number.isNaN(parseFloat(value)) && Number.isFinite(value);
-    }
-
-    class WebGLVideoRenderer extends VideoRenderer {
-        constructor(canvas) {
-            super();
-            this.attributes = null;
-            this.uniforms = null;
-            this.textures = null;
-            this.parameters = {
-                alpha: true,
-                antialias: true,
-                depth: true,
-                desynchronized: true,
-                // Don't try to use software GL rendering!
-                failIfMajorPerformanceCaveat: true,
-                // Don't trigger discrete GPU in multi-GPU systems
-                powerPreference: 'low-power',
-                premultipliedAlpha: true,
-                // In case we need to capture the resulting output.
-                preserveDrawingBuffer: false,
-                stencil: true,
-            };
-            // canvas.style.display = 'block';
-            this.canvas = canvas;
-            this.width = canvas.width;
-            this.height = canvas.height;
-            this.gl = this.canvas.getContext('webgl');
-            // this.context.setTransform(1, 0, 0, 1, 0, 0);
-            this.gl.clearColor(0.0, 0.0, 0.0, 0.0);
-            this.gl.enable(this.gl.DEPTH_TEST);
-            this.gl.depthFunc(this.gl.LEQUAL);
-        }
-        setSize(width, height) {
-            this.canvas.width = width;
-            this.canvas.height = height;
-            this.width = width;
-            this.height = height;
-            this.gl.viewport(0, 0, width, height);
-        }
-        clear() {
-            this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);
-        }
-        grab() {
-            if (isOffscreenCanvas(this.canvas)) {
-                return this.canvas.transferToImageBitmap();
-            }
-        }
-        dispose() {
-            // eslint-disable-next-line camelcase
-            let context;
-            if ((context = this.gl.getExtension('WEBGL_lose_context'))) {
-                context.loseContext();
-            }
-        }
-        render(frame) {
-            const { width, height, 
-            // chromaWidth,
-            chromaHeight, dataY, dataU, dataV, strideY, strideU, strideV, } = frame.buffer;
-            if (this.gl.isContextLost()) {
-                this.gl = this.canvas.getContext('webgl');
-            }
-            if (width !== this.width || height !== this.height) {
-                this.setSize(width, height);
-            }
-            this.clear();
-            if (!this.program) {
-                this.program = buildProgram(this.gl);
-                // Add the program attributes
-                this.attributes = {
-                    position: buildBuffer(this.gl, this.program, 'attribute', 'aVertexPosition', 2, 'v2'),
-                    texcoord: buildBuffer(this.gl, this.program, 'attribute', 'aTextureCoord', 2, 'v2'),
-                };
-                // Add the program uniforms
-                this.uniforms = {
-                    resolution: buildBuffer(this.gl, this.program, 'uniform', 'uResolution', 2, '2f', 1),
-                };
-                // Add the program texture
-                this.textures = {
-                    y: buildTexture(this.gl, this.program, 'uniform', 'uTextureY', this.gl.TEXTURE0, 0),
-                    u: buildTexture(this.gl, this.program, 'uniform', 'uTextureU', this.gl.TEXTURE1, 1),
-                    v: buildTexture(this.gl, this.program, 'uniform', 'uTextureV', this.gl.TEXTURE2, 2),
-                };
-            }
-            let buffer;
-            let texture;
-            const cropLeft = 0;
-            const cropTop = 0;
-            const cropWidth = width;
-            const cropHeight = height;
-            const textureX0 = cropLeft;
-            const textureX1 = cropLeft + cropWidth;
-            const textureY0 = cropTop + cropHeight;
-            const textureY1 = cropTop;
-            // 4 vertex, 1(x0,y0), 2(x1,y0), 3(x1,y1), 4(x0,y1)
-            //  0: 1,2,4/4,2,3
-            // 90: 2,3,1/1,3,4
-            // 180: 3,4,2/2,4,1
-            // 270: 4,1,3/3,1,2
-            // top-left (0, 0)
-            // top-right (1, 0)
-            // bottom-right (1, 1)
-            // bottom-left (0, 1)
-            const position = new Float32Array([
-                textureX0,
-                textureY0,
-                textureX1,
-                textureY0,
-                textureX0,
-                textureY1,
-                textureX0,
-                textureY1,
-                textureX1,
-                textureY0,
-                textureX1,
-                textureY1,
-            ]);
-            // top-left (0, 1)
-            // top-right (1, 1)
-            // bottom-right (1, 0)
-            // bottom-left (0, 0)
-            const textureX = width / strideY;
-            const texcoord = new Float32Array([0, 1, textureX, 1, 0, 0, 0, 0, textureX, 1, textureX, 0]);
-            // Build attribute buffers
-            const attributes = Object.keys(this.attributes);
-            attributes.forEach((attribute) => {
-                buffer = this.attributes[attribute];
-                // Update attribute buffer data
-                switch (attribute) {
-                    case 'position':
-                        buffer.data = new Float32Array(position.length);
-                        setBufferData(0, buffer, position);
-                        break;
-                    case 'texcoord':
-                        buffer.data = new Float32Array(texcoord.length);
-                        setBufferData(0, buffer, texcoord);
-                        break;
-                    default:
-                        return;
-                }
-                setAttribBuffer(this.gl, buffer);
-            });
-            // Build uniform buffers
-            setBufferData(0, this.uniforms.resolution, [width, height]);
-            // Update uniforms
-            const uniforms = Object.keys(this.uniforms);
-            uniforms.forEach((uniform) => {
-                buffer = this.uniforms[uniform];
-                // Update uniform buffer data
-                setUniformBuffer(this.gl, buffer);
-            });
-            // Update textures
-            const textures = Object.keys(this.textures);
-            textures.forEach((name) => {
-                texture = this.textures[name];
-                switch (name) {
-                    case 'y':
-                        setTextureData(this.gl, texture, dataY, strideY, height);
-                        break;
-                    case 'u':
-                        setTextureData(this.gl, texture, dataU, strideU, chromaHeight);
-                        break;
-                    case 'v':
-                        setTextureData(this.gl, texture, dataV, strideV, chromaHeight);
-                        break;
-                }
-            });
-            // Draw those lovely triangles
-            this.gl.drawArrays(this.gl.TRIANGLES, 0, position.length / 2); // in vec2
-        }
-    }
-    function isOffscreenCanvas(val) {
-        return typeof OffscreenCanvas !== 'undefined' && val instanceof OffscreenCanvas;
-    }
-
-    /// <reference types="emscripten" />
-    const DEFAULT_HEAP_TYPE = 'HEAPU8';
-    function createMemoryAllocator(native, type) {
-        return (length) => {
-            const { BYTES_PER_ELEMENT } = native[type || DEFAULT_HEAP_TYPE];
-            const bytes = length * BYTES_PER_ELEMENT;
-            const pointer = native._malloc(bytes);
-            const tuple = () => [pointer, bytes];
-            // malloc() might cause wasm memory growth, which will detach 'heap' buffer
-            const view = (normalize = true) => {
-                const v = native[type || DEFAULT_HEAP_TYPE].subarray(pointer / BYTES_PER_ELEMENT, pointer + length);
-                if (normalize && typeof v.constructor !== 'undefined') {
-                    return new v.constructor(v.buffer, v.byteOffset, length);
-                }
-                 console.log('unnormalized array view has unexpected length');
-                return v;
-            };
-            const free = () => native._free(pointer);
-            return {
-                BYTES_PER_ELEMENT,
-                pointer,
-                length,
-                bytes,
-                tuple,
-                view,
-                free,
-            };
-        };
-    }
-    function createMemoryViewer(native, type) {
-        return (begin, length, normalize = true) => {
-            const heap = native[type || DEFAULT_HEAP_TYPE];
-            const { BYTES_PER_ELEMENT } = heap;
-            const view = heap.subarray(begin / BYTES_PER_ELEMENT, begin + length);
-            if (normalize && typeof view.constructor !== 'undefined') {
-                return new view.constructor(view.buffer, view.byteOffset, length);
-            }
-             console.log('unnormalized array view has unexpected length');
-            return view;
-        };
-    }
-
-    function open(name, store) {
-        const request = indexedDB.open(name);
-        request.onupgradeneeded = () => request.result.createObjectStore(store);
-        const promise = make(request);
-        return (mode, callback) => promise.then((db) => callback(db.transaction(store, mode).objectStore(store)));
-    }
-    const LAZY_INSTANCE = (factory) => {
-        let instance;
-        return (...args) => {
-            if (!instance) {
-                instance = factory();
-            }
-            return instance(...args);
-        };
-    };
-    const LAZY_GLOBAL_STORE = LAZY_INSTANCE(() => open('LINE-UI', 'key-value'));
-    function get(key, store = LAZY_GLOBAL_STORE) {
-        return store('readonly', (store) => make(store.get(key)));
-    }
-    function clear(store = LAZY_GLOBAL_STORE) {
-        return store('readwrite', (store) => {
-            store.clear();
-            return make(store.transaction);
-        });
-    }
-    function make(request) {
-        return new Promise((resolve, reject) => {
-            // @ts-ignore - file size hacks
-            request.oncomplete = request.onsuccess = () => resolve(request.result);
-            // @ts-ignore - file size hacks
-            request.onabort = request.onerror = () => reject(request.error);
-        });
-    }
-
-    /// <reference types="emscripten" />
-    var SFUTransportType;
-    (function (SFUTransportType) {
-        SFUTransportType[SFUTransportType["kAudio"] = 1] = "kAudio";
-        SFUTransportType[SFUTransportType["kVideo"] = 2] = "kVideo";
-        SFUTransportType[SFUTransportType["kData"] = 3] = "kData";
-        SFUTransportType[SFUTransportType["kAnnotation"] = 4] = "kAnnotation";
-        SFUTransportType[SFUTransportType["kMessage"] = 5] = "kMessage";
-    })(SFUTransportType || (SFUTransportType = {}));
-    var SFUTransportOrient;
-    (function (SFUTransportOrient) {
-        SFUTransportOrient[SFUTransportOrient["kSend"] = 1] = "kSend";
-        SFUTransportOrient[SFUTransportOrient["kRecv"] = 2] = "kRecv";
-        SFUTransportOrient[SFUTransportOrient["kBoth"] = 3] = "kBoth";
-    })(SFUTransportOrient || (SFUTransportOrient = {}));
-    var SFUUserRole;
-    (function (SFUUserRole) {
-        SFUUserRole[SFUUserRole["kInteractive"] = 1] = "kInteractive";
-        SFUUserRole[SFUUserRole["kBroadcast"] = 2] = "kBroadcast";
-    })(SFUUserRole || (SFUUserRole = {}));
-    var SFUReason;
-    (function (SFUReason) {
-        SFUReason[SFUReason["kOK"] = 0] = "kOK";
-        SFUReason[SFUReason["kError"] = 320200] = "kError";
-        SFUReason[SFUReason["kExisted"] = 320201] = "kExisted";
-        SFUReason[SFUReason["kNetworkError"] = 320202] = "kNetworkError";
-        SFUReason[SFUReason["kMCFailed"] = 320203] = "kMCFailed";
-        SFUReason[SFUReason["kMSSFailed"] = 320204] = "kMSSFailed";
-        SFUReason[SFUReason["kMSSLost"] = 320205] = "kMSSLost";
-        SFUReason[SFUReason["kAuthFailed"] = 320206] = "kAuthFailed";
-        SFUReason[SFUReason["kLoadFailed"] = 320207] = "kLoadFailed";
-        SFUReason[SFUReason["kNoImplemented"] = 320208] = "kNoImplemented";
-    })(SFUReason || (SFUReason = {}));
-    var SFUTransportStatus;
-    (function (SFUTransportStatus) {
-        SFUTransportStatus[SFUTransportStatus["kReconnecting"] = 320100] = "kReconnecting";
-        SFUTransportStatus[SFUTransportStatus["kReconnectOK"] = 320101] = "kReconnectOK";
-        SFUTransportStatus[SFUTransportStatus["kReconnectNG"] = 320102] = "kReconnectNG";
-    })(SFUTransportStatus || (SFUTransportStatus = {}));
-    var SFUEndpointStatus;
-    (function (SFUEndpointStatus) {
-        SFUEndpointStatus[SFUEndpointStatus["kHandshakeOK"] = 100] = "kHandshakeOK";
-        SFUEndpointStatus[SFUEndpointStatus["kHandshakeNG"] = 101] = "kHandshakeNG";
-        SFUEndpointStatus[SFUEndpointStatus["kConnectOK"] = 102] = "kConnectOK";
-        SFUEndpointStatus[SFUEndpointStatus["kConnectNG"] = 103] = "kConnectNG";
-    })(SFUEndpointStatus || (SFUEndpointStatus = {}));
-    var TransportType;
-    (function (TransportType) {
-        TransportType[TransportType["kSignal"] = 0] = "kSignal";
-        TransportType[TransportType["kData"] = 1] = "kData";
-    })(TransportType || (TransportType = {}));
-    var VideoEncodeMode;
-    (function (VideoEncodeMode) {
-        VideoEncodeMode[VideoEncodeMode["kVeryfast"] = 0] = "kVeryfast";
-        VideoEncodeMode[VideoEncodeMode["kUltrafast"] = 1] = "kUltrafast";
-        VideoEncodeMode[VideoEncodeMode["kUltrafastPlus"] = 2] = "kUltrafastPlus";
-    })(VideoEncodeMode || (VideoEncodeMode = {}));
-    // SFUTransportType
-    // type VideoChannelType = SFUTransportType;
-    var VideoChannelType;
-    (function (VideoChannelType) {
-        // kAudio = 1,
-        VideoChannelType[VideoChannelType["kVideo"] = 2] = "kVideo";
-        VideoChannelType[VideoChannelType["kData"] = 3] = "kData";
-        VideoChannelType[VideoChannelType["kAnnotation"] = 4] = "kAnnotation";
-        VideoChannelType[VideoChannelType["kMessage"] = 5] = "kMessage";
-    })(VideoChannelType || (VideoChannelType = {}));
-    // SFUTransportOrient
-    // type VideoChannelOrient = SFUTransportOrient;
-    var VideoChannelOrient;
-    (function (VideoChannelOrient) {
-        VideoChannelOrient[VideoChannelOrient["kInactive"] = 0] = "kInactive";
-        VideoChannelOrient[VideoChannelOrient["kSend"] = 1] = "kSend";
-        VideoChannelOrient[VideoChannelOrient["kRecv"] = 2] = "kRecv";
-        VideoChannelOrient[VideoChannelOrient["kBoth"] = 3] = "kBoth";
-    })(VideoChannelOrient || (VideoChannelOrient = {}));
-    var VideoChannelMode;
-    (function (VideoChannelMode) {
-        VideoChannelMode[VideoChannelMode["kNormal"] = 0] = "kNormal";
-        VideoChannelMode[VideoChannelMode["kSmooth"] = 1] = "kSmooth";
-    })(VideoChannelMode || (VideoChannelMode = {}));
-    var VideoRotation;
-    (function (VideoRotation) {
-        VideoRotation[VideoRotation["kRotation_0"] = 0] = "kRotation_0";
-        VideoRotation[VideoRotation["kRotation_90"] = 90] = "kRotation_90";
-        VideoRotation[VideoRotation["kRotation_180"] = 180] = "kRotation_180";
-        VideoRotation[VideoRotation["kRotation_270"] = 270] = "kRotation_270";
-    })(VideoRotation || (VideoRotation = {}));
-    var DataType;
-    (function (DataType) {
-        DataType[DataType["kCoopration"] = 1] = "kCoopration";
-        DataType[DataType["kRemoteControl"] = 2] = "kRemoteControl";
-        DataType[DataType["kSubtitleRealtime"] = 3] = "kSubtitleRealtime";
-        DataType[DataType["kSubtitleRecord"] = 4] = "kSubtitleRecord";
-    })(DataType || (DataType = {}));
-    var SubtitleSentenceAction;
-    (function (SubtitleSentenceAction) {
-        SubtitleSentenceAction[SubtitleSentenceAction["kCommon"] = 0] = "kCommon";
-        SubtitleSentenceAction[SubtitleSentenceAction["kShareStart"] = 1] = "kShareStart";
-        SubtitleSentenceAction[SubtitleSentenceAction["kShareEnd"] = 2] = "kShareEnd";
-        SubtitleSentenceAction[SubtitleSentenceAction["kCoopStart"] = 3] = "kCoopStart";
-        SubtitleSentenceAction[SubtitleSentenceAction["kCoopEnd"] = 4] = "kCoopEnd";
-        SubtitleSentenceAction[SubtitleSentenceAction["kServiceOver"] = 5] = "kServiceOver";
-    })(SubtitleSentenceAction || (SubtitleSentenceAction = {}));
-    var SubtitleSentenceStatus;
-    (function (SubtitleSentenceStatus) {
-        SubtitleSentenceStatus[SubtitleSentenceStatus["kStart"] = 0] = "kStart";
-        SubtitleSentenceStatus[SubtitleSentenceStatus["kChanging"] = 1] = "kChanging";
-        SubtitleSentenceStatus[SubtitleSentenceStatus["kEnd"] = 2] = "kEnd";
-    })(SubtitleSentenceStatus || (SubtitleSentenceStatus = {}));
-
-    let native;
-    let alloc;
-    let view;
-    // visibilityState === 'hidden'
-    let suspended$1 = false;
-    let loglevel = 2;
-    let timer_factory;
-    const DEFAULT_FRAME_RATE = 33;
-    // const supportOffscreen = typeof OffscreenCanvas !== 'undefined';
-    const encode_coef = 0.3;
-    let encode_avg = 0;
-    let encode_busy = false;
-    const isWechatWorker = typeof worker !== 'undefined';
-    if (isWechatWorker) {
-        worker.onMessage((data) => {
-            worker.onmessage && worker.onmessage({ data });
-        });
-    }
-    // eslint-disable-next-line no-restricted-globals
-    const channel = new MojoChannel(isWechatWorker ? worker : self);
-    const engine = channel.receiver('video-engine-host');
-    engine.implement('init', (reply, [url, verbose = false]) => __awaiter(void 0, void 0, void 0, function* () {
-        let factory;
-        let wasmUrl;
-        if (isWechatWorker) {
-            const trailingSlash = (v) => (!v || v.endsWith('/') ? v : `${v}/`);
-            const [scriptUrl, wasmDir = ''] = url.split('?');
-            const scriptName = scriptUrl.substring(scriptUrl.lastIndexOf('/') + 1);
-            factory = require(scriptUrl);
-            wasmUrl = trailingSlash(wasmDir) + scriptName.replace(/\.js$/, '.wasm');
-        }
-        else {
-            importScripts(url);
-            factory = LIBSVC;
-            wasmUrl = url.replace(/\.js$/, '.wasm');
-        }
-        const wasmBinary = isWechatWorker
-            ? wasmUrl
-            : yield get(wasmUrl).catch(() => null);
-        // should clear cache if init failed
-        native = yield factory({ wasmBinary }).catch((error) => {
-            clear();
-            throw error;
-        });
-        alloc = createMemoryAllocator(native);
-        view = createMemoryViewer(native);
-         console.log(`LIBSVC: ${native.VideoChannel.Version()}`);
-        timer_factory = new native.TimerFactory({
-            start: (callback, delay) => setInterval(() => native.TimerFactory.Run(callback), delay),
-            stop: (id) => {
-                clearInterval(id);
-            },
-        });
-        native.VideoChannel.Init(timer_factory, (level, msg) => {
-            if (verbose || (level >= loglevel && true)) {
-                console.log(msg);
-            }
-        });
-        reply.resolve();
-    }));
-    engine.implement('exit', (reply) => {
-        native.VideoChannel.Exit();
-        timer_factory.delete();
-        reply.resolve();
-    });
-    engine.implement('debug', (reply, [level]) => {
-        loglevel = level;
-        reply.resolve();
-    });
-    engine.implement('suspend', (reply) => {
-        suspended$1 = true;
-        reply.resolve();
-    });
-    engine.implement('resume', (reply) => {
-        suspended$1 = false;
-        reply.resolve();
-    });
-    engine.implement('setup', (reply, [transportPR, type = VideoChannelType.kVideo]) => {
-        const cleanup = [];
-        const transport_host = channel.remote(transportPR);
-        const video_channel_host = channel.receiver();
-        cleanup.unshift(() => transport_host.break());
-        // setup transport proxy
-        const sfu_transport_proxy = new native.SFUTransportProxy({
-            Connect: (config) => {
-                const [pointer, length] = config.desc;
-                const desc = view(pointer, length).slice();
-                transport_host
-                    .make('connect')
-                    .transfer(desc.buffer)
-                    .post(Object.assign(Object.assign({}, config), { desc }));
-            },
-            // main thread will disconnect the real sfu transport
-            Disconnect: () => {
-                if (!video_channel_host.valid)
-                    return;
-                transport_host.make('disconnect').post();
-            },
-            Subscribe: (request, remove) => {
-                if (!video_channel_host.valid)
-                    return;
-                const memory = request
-                    .map((v) => v.desc)
-                    .map(([pointer, length]) => view(pointer, length).slice());
-                transport_host
-                    .make('subscribe')
-                    .transfer(...memory.map((v) => v.buffer))
-                    .post(request.map((v, i) => (Object.assign(Object.assign({}, v), { desc: memory[i] }))), remove.map((v) => v.ccid));
-            },
-            SendData: (data, meta) => {
-                const memory = data.map(([pointer, length]) => view(pointer, length).slice());
-                transport_host
-                    .make('senddata')
-                    .transfer(...memory.map((v) => v.buffer))
-                    .post(memory, meta);
-            },
-            SendSingal: (data, length, ccid) => {
-                const memory = view(data, length).slice();
-                transport_host.make('sendsignal').transfer(memory.buffer).post(memory, ccid);
-            },
-        });
-        // setup transport
-        const video_channel = new native.VideoChannel(type);
-        video_channel.SetTransport(sfu_transport_proxy);
-        // setup source
-        const source = new native.FrameSource();
-        video_channel.SetSource(source);
-        let encoding = false;
-        let fps = DEFAULT_FRAME_RATE;
-        const startFrameSource = () => {
-            const id = setInterval(() => {
-                if (!source_host || !source_host.valid)
-                    return;
-                source_host
-                    .make('capture')
-                    .invoke()
-                    .then((buffer) => buffer && encode(buffer));
-            }, 1000 / fps);
-            return () => clearInterval(id);
-        };
-        let stopFrameSource;
-        const onstop = () => {
-            stopFrameSource && stopFrameSource();
-            stopFrameSource = null;
-        };
-        const onstart = () => {
-            fps && (stopFrameSource = startFrameSource());
-        };
-        source.on('onstart', () => {
-            encoding = true;
-            onstop();
-            onstart();
-            source_host && source_host.make('onstart').post();
-        });
-        source.on('onstop', () => {
-            encoding = false;
-            onstop();
-            source_host && source_host.make('onstop').post();
-        });
-        // setup sink
-        const sink = new native.FrameSink();
-        video_channel.SetSink(sink);
-        const toBufferBuilder = (frame, copy = true) => {
-            const { width, height, strideY, strideU, strideV } = frame;
-            const { dataY, dataU, dataV } = frame;
-            const viewY = view(dataY, strideY * height);
-            const viewU = view(dataU, strideU * Math.floor((height + 1) / 2));
-            const viewV = view(dataV, strideV * Math.floor((height + 1) / 2));
-            const builder = {
-                width,
-                height,
-                strideY,
-                strideU,
-                strideV,
-                dataY: copy ? viewY.slice() : viewY,
-                dataU: copy ? viewU.slice() : viewU,
-                dataV: copy ? viewV.slice() : viewV,
-            };
-            return builder;
-        };
-        sink.on('onframe', (ccid, frame) => {
-            if (suspended$1)
-                return;
-            const sink = sink_proxies.get(ccid);
-            if (!sink)
-                return;
-            const { renderer, loadeddata } = sink;
-            if (!loadeddata) {
-                sink.host.make('onloadeddata').post();
-                sink.loadeddata = true;
-            }
-            if (frame.width !== sink.width || frame.height !== sink.height) {
-                sink.width = frame.width;
-                sink.height = frame.height;
-                sink.host.make('onframechanged').post(sink.width, sink.height);
-            }
-            if (renderer) {
-                // YUV format
-                const buffer = new I420Buffer(toBufferBuilder(frame, false));
-                // ABGR format
-                // const { width, height } = frame;
-                // const memory = alloc(width * height * 4);
-                // frame.ToABGR(memory.pointer);
-                // const data = view(memory.pointer, memory.bytes);
-                // const buffer = new RGBBuffer({ width, height, data });
-                // renderer.onFrame(new VideoFrame({ buffer }), true);
-                // memory.free();
-                renderer.onFrame(new VideoFrame({ buffer }), true);
-                return;
-            }
-            // YUV format
-            const builder = toBufferBuilder(frame);
-            sink.host
-                .make('onframe')
-                .transfer(builder.dataY.buffer, builder.dataU.buffer, builder.dataV.buffer)
-                .post(builder);
-        });
-        let source_host;
-        const sink_proxies = new Map();
-        // setup cleanup
-        cleanup.unshift(() => {
-            video_channel.Leave();
-            video_channel.delete();
-            sfu_transport_proxy.delete();
-            source.delete();
-            sink.delete();
-            source_host && source_host.break();
-            source_host = null;
-            sink_proxies.forEach((v) => v.host.break());
-            sink_proxies.clear();
-        });
-        // impl video channel host
-        let channel_config;
-        const pending_actions = [];
-        video_channel_host.implement('mode', (reply, [mode]) => {
-            native.VideoChannel.EncodeMode(mode);
-            reply.resolve();
-        });
-        video_channel_host.implement('open', (reply, [config]) => {
-            channel_config = config;
-            if (channel_config.orient !== VideoChannelOrient.kInactive) {
-                video_channel.Join(config);
-            }
-            reply.resolve();
-        });
-        video_channel_host.implement('subscribe', (reply, [request, remove]) => {
-            if (connecting || channel_config.orient === VideoChannelOrient.kInactive) {
-                pending_actions.push(() => video_channel.Subscribe(request, remove));
-            }
-            else {
-                video_channel.Subscribe(request, remove);
-            }
-            remove.forEach((ccid) => {
-                const sink = sink_proxies.get(ccid);
-                if (!sink)
-                    return;
-                sink.renderer && sink.renderer.clear();
-                sink.host.break();
-                sink_proxies.delete(ccid);
-            });
-            reply.resolve();
-        });
-        video_channel_host.implement('sendstats', (reply) => {
-            reply.resolve(encoding ? video_channel.SendStats() : null);
-        });
-        video_channel_host.implement('recvstats', (reply, [ccid]) => {
-            reply.resolve(video_channel.RecvStats(ccid));
-        });
-        video_channel_host.implement('sendreport', (reply) => {
-            reply.resolve(encoding ? video_channel.SendReport() : null);
-        });
-        video_channel_host.implement('recvreport', (reply, [ccid]) => {
-            reply.resolve(video_channel.RecvReport(ccid));
-        });
-        const encode = (buffer) => {
-            const tick = Date.now();
-            const { width, height, data } = buffer;
-            const stride = width * 4;
-            const memory = alloc(stride * height);
-            // copy memory to wasm
-            memory.view().set(data);
-            // convert ABGR to I420 via libyuv
-            const frame = native.I420Buffer.FromABGR(width, height, memory.pointer, stride);
-            // release ABGR heap
-            memory.free();
-            // pass frame to source
-            source.OnFrame(frame);
-            // release frame
-            frame.delete();
-            const since = Date.now() - tick;
-            encode_avg = encode_coef * since + (1 - encode_coef) * encode_avg;
-            if (!encode_busy && encode_avg > 120) {
-                encode_busy = true;
-                source_host && source_host.make('onbusy').post(encode_busy);
-            }
-            if (encode_busy && encode_avg < 60) {
-                encode_busy = false;
-                source_host && source_host.make('onbusy').post(encode_busy);
-            }
-        };
-        // source & sink related
-        video_channel_host.implement('encode', (reply, [buffer]) => {
-            reply.resolve();
-            encode(buffer);
-        });
-        video_channel_host.implement('setsource', (reply, [sourcePR, frameRate]) => {
-            if (source_host) {
-                source_host.break();
-                source_host = null;
-            }
-            if (sourcePR) {
-                source_host = channel.remote(sourcePR);
-            }
-            onframerate(frameRate);
-            reply.resolve(encoding);
-        });
-        video_channel_host.implement('setsink', (reply, [ccid, sinkPR, id]) => {
-            reply.resolve();
-            let sink = sink_proxies.get(ccid);
-            if (sink) {
-                sink.host.break();
-                sink_proxies.delete(ccid);
-            }
-            if (!sinkPR)
-                return;
-            sink = { host: channel.remote(sinkPR) };
-            sink_proxies.set(ccid, sink);
-            if (!id)
-                return;
-            {
-                const duplicate = Array.from(sink_proxies.entries()).filter(([, value]) => value.renderer === renderers[id - 1]);
-                if (duplicate.length) {
-                    console.warn(`renderer[${id}] is already binded to ${duplicate.map(([key]) => key)}`);
-                }
-            }
-            sink.renderer = renderers[id - 1];
-        });
-        const onframerate = (frameRate = DEFAULT_FRAME_RATE) => {
-            if (fps === frameRate)
-                return;
-            fps = frameRate;
-            if (!stopFrameSource)
-                return;
-            onstop();
-            onstart();
-        };
-        video_channel_host.implement('setframerate', (reply, [frameRate]) => {
-             console.log(`framerate: ${frameRate}`);
-            onframerate(frameRate);
-            reply.resolve();
-        });
-        video_channel_host.implement('setorient', (reply, [orient]) => {
-            reply.resolve();
-             console.log(`orient: ${orient}`);
-            // no change
-            if (channel_config.orient === orient)
-                return;
-            const inactive = channel_config.orient === VideoChannelOrient.kInactive;
-            channel_config.orient = orient;
-            if (orient === VideoChannelOrient.kInactive) {
-                video_channel.Leave();
-            }
-            else if (inactive) {
-                video_channel.Join(channel_config);
-                connecting = true;
-            }
-            else if (connecting) {
-                pending_actions.push(() => video_channel.SetOrient(orient));
-            }
-            else {
-                video_channel.SetOrient(orient);
-            }
-        });
-        cleanup.unshift(() => onstop());
-        const renderers = [];
-        video_channel_host.implement('load', (reply, [canvas, webgl = true]) => {
-            const renderer = webgl ? new WebGLVideoRenderer(canvas) : new CanvasVideoRenderer(canvas);
-            reply.resolve(renderers.push(renderer));
-        });
-        video_channel_host.implement('unload', (reply, [id]) => {
-            reply.resolve();
-            const renderer = renderers[--id];
-            if (!renderer)
-                return;
-            if (renderer.gl) {
-                renderer.dispose();
-            }
-            const sinks = [...sink_proxies.entries()].filter(([, v]) => v.renderer === renderer);
-            if (sinks) {
-                
-                    console.warn(`remove video sink for [${sinks.map(([v]) => v)}] due to renderer[${id}] is unloaded`);
-                sinks.forEach(([v]) => sink_proxies.delete(v));
-            }
-            renderers[id] = null;
-            // shrink renderers
-            if (id === renderers.length - 1) {
-                while (id >= 0 && !renderers[id--]) {
-                    renderers.pop();
-                }
-            }
-        });
-        // sfu transport related
-        let connecting = false;
-        video_channel_host.implement('onjoin', (reply, [reason, data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onjoin(reason, memory.pointer, memory.bytes);
-            memory.free();
-            pending_actions.forEach((v) => v());
-            pending_actions.length = 0;
-            connecting = false;
-            reply.resolve();
-        });
-        video_channel_host.implement('onleave', (reply, [reason]) => {
-            sfu_transport_proxy.onleave(reason);
-            reply.resolve();
-        });
-        video_channel_host.implement('onstatus', (reply, [status, reason]) => {
-            sfu_transport_proxy.onstatus(status, reason);
-            if (status === SFUTransportStatus.kReconnectOK) {
-                pending_actions.forEach((v) => v());
-                pending_actions.length = 0;
-            }
-            else if (status === SFUTransportStatus.kReconnectNG) {
-                video_channel.Leave();
-                video_channel.Join(channel_config);
-            }
-            reply.resolve();
-        });
-        video_channel_host.implement('onsubscribe', (reply, [ccid, reason, data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onsubscribe(ccid, reason, memory.pointer, memory.bytes);
-            memory.free();
-            reply.resolve();
-        });
-        video_channel_host.implement('onsubscribeupdated', (reply, [requests]) => {
-            sfu_transport_proxy.onsubscribeupdated(requests);
-            reply.resolve();
-        });
-        video_channel_host.implement('onbitrate', (reply, [info]) => {
-            sfu_transport_proxy.onbitrate(info);
-            reply.resolve();
-        });
-        video_channel_host.implement('onsendstats', (reply, [stats]) => {
-            sfu_transport_proxy.onsendstats(stats);
-            reply.resolve();
-        });
-        video_channel_host.implement('onrecvstats', (reply, [stats]) => {
-            sfu_transport_proxy.onrecvstats(stats);
-            reply.resolve();
-        });
-        video_channel_host.implement('onsendreport', (reply, [report]) => {
-            sfu_transport_proxy.onsendreport(report);
-            reply.resolve();
-        });
-        video_channel_host.implement('ontimestamps', (reply) => {
-            sfu_transport_proxy.ontimestamps();
-            reply.resolve();
-        });
-        video_channel_host.implement('onmediasync', (reply, [timestamps]) => {
-            sfu_transport_proxy.onmediasync(timestamps);
-            reply.resolve();
-        });
-        video_channel_host.implement('onsignal', (reply, [data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onsignal(memory.pointer, memory.bytes);
-            memory.free();
-            reply.resolve();
-        });
-        video_channel_host.implement('ondata', (reply, [data, ccid, time]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.ondata(memory.pointer, memory.bytes, ccid, time, -1);
-            memory.free();
-            reply.resolve();
-        });
-        // cleanup
-        video_channel_host.onbreak = () => {
-            cleanup.forEach((v) => v());
-            cleanup.length = 0;
-        };
-        reply.resolve(`${video_channel_host}`);
-    });
-    engine.implement('setup2', (reply, [transportPR, type = VideoChannelType.kMessage]) => {
-        const cleanup = [];
-        const transport_host = channel.remote(transportPR);
-        const data_channel_host = channel.receiver();
-        cleanup.unshift(() => transport_host.break());
-        // setup transport proxy
-        const sfu_transport_proxy = new native.SFUTransportProxy({
-            Connect: (config) => {
-                const [pointer, length] = config.desc;
-                const desc = view(pointer, length).slice();
-                transport_host
-                    .make('connect')
-                    .transfer(desc.buffer)
-                    .post(Object.assign(Object.assign({}, config), { desc }));
-            },
-            // main thread will disconnect the real sfu transport
-            Disconnect: () => {
-                if (!data_channel_host.valid)
-                    return;
-                transport_host.make('disconnect').post();
-            },
-            Subscribe: (request, remove) => {
-                if (!data_channel_host.valid)
-                    return;
-                const memory = request
-                    .map((v) => v.desc)
-                    .map(([pointer, length]) => view(pointer, length).slice());
-                transport_host
-                    .make('subscribe')
-                    .transfer(...memory.map((v) => v.buffer))
-                    .post(request.map((v, i) => (Object.assign(Object.assign({}, v), { desc: memory[i] }))), remove.map((v) => v.ccid));
-            },
-            SendData: (data, meta) => {
-                const memory = data.map(([pointer, length]) => view(pointer, length).slice());
-                transport_host
-                    .make('senddata')
-                    .transfer(...memory.map((v) => v.buffer))
-                    .post(memory, meta);
-            },
-            SendSingal: (data, length, ccid) => {
-                const memory = view(data, length).slice();
-                transport_host.make('sendsignal').transfer(memory.buffer).post(memory, ccid);
-            },
-        });
-        // setup transport
-        const data_channel = new native.DataChannel(type);
-        data_channel.SetTransport(sfu_transport_proxy);
-        // sfu transport related
-        data_channel_host.implement('onjoin', (reply, [reason, data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onjoin(reason, memory.pointer, memory.bytes);
-            memory.free();
-            reply.resolve();
-        });
-        data_channel_host.implement('onleave', (reply, [reason]) => {
-            sfu_transport_proxy.onleave(reason);
-            reply.resolve();
-        });
-        data_channel_host.implement('onstatus', (reply, [status, reason]) => {
-            sfu_transport_proxy.onstatus(status, reason);
-            reply.resolve();
-        });
-        data_channel_host.implement('onsubscribe', (reply, [ccid, reason, data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onsubscribe(ccid, reason, memory.pointer, memory.bytes);
-            memory.free();
-            reply.resolve();
-        });
-        data_channel_host.implement('onsubscribeupdated', (reply, [requests]) => {
-            sfu_transport_proxy.onsubscribeupdated(requests);
-            reply.resolve();
-        });
-        data_channel_host.implement('onbitrate', (reply, [info]) => {
-            sfu_transport_proxy.onbitrate(info);
-            reply.resolve();
-        });
-        data_channel_host.implement('onsendstats', (reply, [stats]) => {
-            sfu_transport_proxy.onsendstats(stats);
-            reply.resolve();
-        });
-        data_channel_host.implement('onrecvstats', (reply, [stats]) => {
-            sfu_transport_proxy.onrecvstats(stats);
-            reply.resolve();
-        });
-        data_channel_host.implement('onsendreport', (reply, [report]) => {
-            sfu_transport_proxy.onsendreport(report);
-            reply.resolve();
-        });
-        data_channel_host.implement('ontimestamps', (reply) => {
-            sfu_transport_proxy.ontimestamps();
-            reply.resolve();
-        });
-        data_channel_host.implement('onmediasync', (reply, [timestamps]) => {
-            sfu_transport_proxy.onmediasync(timestamps);
-            reply.resolve();
-        });
-        data_channel_host.implement('onsignal', (reply, [data]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.onsignal(memory.pointer, memory.bytes);
-            memory.free();
-            reply.resolve();
-        });
-        data_channel_host.implement('ondata', (reply, [data, ccid, time]) => {
-            const memory = alloc(data.length);
-            memory.view().set(data);
-            sfu_transport_proxy.ondata(memory.pointer, memory.bytes, ccid, time, -1);
-            memory.free();
-            reply.resolve();
-        });
-        // setup cleanup
-        cleanup.unshift(() => {
-            data_channel.Leave();
-            data_channel.delete();
-            sfu_transport_proxy.delete();
-        });
-        data_channel_host.implement('open', (reply, [config]) => {
-            data_channel.Join(config);
-            reply.resolve();
-        });
-        data_channel_host.implement('datastream', (reply, [type = DataType.kRemoteControl, pendingListener]) => {
-            const listenerHost = channel.remote(pendingListener);
-            const data_stream = data_channel.CreateDataStream(type);
-            data_stream.on('ondata', (pointer, length, from) => {
-                const memory = view(pointer, length).slice();
-                listenerHost.make('ondata').transfer(memory.buffer).post(memory, from);
-            });
-            const data_stream_host = channel.receiver();
-            data_stream_host.implement('write', (reply, [data, dest, traits]) => {
-                const memory = alloc(data.length);
-                memory.view().set(data);
-                data_stream.Write(memory.pointer, memory.bytes, dest, traits);
-                memory.free();
-                reply.resolve();
-            });
-            data_stream_host.implement('subscribe', (reply, [request, remove]) => {
-                data_stream.Subscribe(request, remove);
-                reply.resolve();
-            });
-            data_stream_host.onbreak = () => data_stream.delete();
-            reply.resolve(`${data_stream_host}`);
-        });
-        data_channel_host.implement('subtitlestream', (reply, [type = DataType.kSubtitleRealtime, pendingListener]) => {
-            const subtitle = new native.SubtitleRealtime();
-            const listenerHost = channel.remote(pendingListener);
-            const data_stream = data_channel.CreateDataStream(type);
-            data_stream.on('ondata', (pointer, bytes, from) => {
-                subtitle.decode([pointer, bytes], (info) => {
-                    listenerHost.make('ondata').post(info, from);
-                });
-            });
-            const data_stream_host = channel.receiver();
-            data_stream_host.implement('write', (reply, [data, dest]) => {
-                subtitle.encode(data, ([pointer, bytes]) => {
-                    const traits = { direct: !!dest.length, merge: false };
-                    data_stream.Write(pointer, bytes, dest, traits);
-                });
-                reply.resolve();
-            });
-            data_stream_host.implement('subscribe', (reply, [request, remove]) => {
-                data_stream.Subscribe(request, remove);
-                reply.resolve();
-            });
-            data_stream_host.onbreak = () => data_stream.delete();
-            reply.resolve(`${data_stream_host}`);
-        });
-        // cleanup
-        data_channel_host.onbreak = () => {
-            cleanup.forEach((v) => v());
-            cleanup.length = 0;
-        };
-        reply.resolve(`${data_channel_host}`);
-    });
-     setupBusyDetector();
-    // simple cpu overload detection
-    function setupBusyDetector() {
-        let last = Date.now();
-        let detectTimer;
-        const detectInterval = 1000;
-        const factor = 1.1;
-        const detect = () => {
-            const now = Date.now();
-            const delta = now - last;
-            const tester = detectInterval * factor;
-            if (delta > tester) {
-                console.log(`busy report:\n` +
-                    `delta: ${delta}\n` +
-                    `factor: ${factor}\n` +
-                    `interval: ${detectInterval}\n` +
-                    `delay: ${delta - detectInterval}\n`);
-            }
-            last = now;
-            detectTimer = setTimeout(detect, detectInterval);
-        };
-        detect();
-        return () => clearTimeout(detectTimer);
-    }
-
-}());