@whereby.com/camera-effects 0.0.0-canary-20251107145955

package/dist/index.cjs

@@ -0,0 +1,3693 @@
+'use strict';
+
+var adapter = require('webrtc-adapter');
+var events = require('events');
+var wasmFeatureDetect = require('wasm-feature-detect');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function fixBackgroundUrlPromise(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (params.backgroundUrl && params.backgroundUrl.then) {
+            const src = yield params.backgroundUrl;
+            const candidate = (src === null || src === void 0 ? void 0 : src.default) || src;
+            if (typeof candidate === "string") {
+                try {
+                    if (!/^https?:\/\//.test(candidate) &&
+                        !candidate.startsWith("data:") &&
+                        !candidate.startsWith("blob:")) {
+                        params.backgroundUrl = new URL(candidate, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+                    }
+                    else {
+                        params.backgroundUrl = candidate;
+                    }
+                }
+                catch (_a) {
+                    params.backgroundUrl = candidate;
+                }
+            }
+            else {
+                params.backgroundUrl = candidate;
+            }
+        }
+    });
+}
+function createBackgroundElement(url, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!url)
+            return;
+        let backgroundElement;
+        if (type === "video") {
+            backgroundElement = document.createElement("video");
+            backgroundElement.loop = true;
+            yield new Promise((resolve) => {
+                backgroundElement.addEventListener("playing", resolve);
+                backgroundElement.crossOrigin = "Anonymous";
+                backgroundElement.src = url;
+                backgroundElement.play();
+            });
+            backgroundElement.muted = true;
+        }
+        else {
+            backgroundElement = new Image();
+            yield new Promise((resolve) => {
+                backgroundElement.addEventListener("load", resolve);
+                backgroundElement.crossOrigin = "Anonymous";
+                backgroundElement.src = url;
+            });
+        }
+        return backgroundElement;
+    });
+}
+function createBackgroundProvider(backgroundElement, targetWidth, targetHeight, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!backgroundElement)
+            return () => __awaiter(this, void 0, void 0, function* () { return undefined; });
+        const backgroundWidth = backgroundElement.videoWidth || backgroundElement.naturalWidth || backgroundElement.width;
+        const backgroundHeight = backgroundElement.videoHeight || backgroundElement.naturalHeight || backgroundElement.height;
+        const backgroundAspectRatio = backgroundWidth / backgroundHeight;
+        const targetAspectRatio = targetWidth / targetHeight;
+        if (type === "imagedata") {
+            const backgroundCanvas = document.createElement("canvas");
+            backgroundCanvas.width = targetWidth;
+            backgroundCanvas.height = targetHeight;
+            const backgroundCanvasCtx = backgroundCanvas.getContext("2d");
+            let [sx, sy, sw, sh] = [0, 0, targetWidth, targetHeight];
+            if (backgroundAspectRatio > targetAspectRatio) {
+                const outsideX = targetHeight * backgroundAspectRatio - targetWidth;
+                sx -= Math.round(outsideX / 2);
+                sw += Math.round(outsideX);
+            }
+            else if (backgroundAspectRatio < targetAspectRatio) {
+                const outsideY = targetWidth / backgroundAspectRatio - targetHeight;
+                sy -= Math.round(outsideY / 2);
+                sh += Math.round(outsideY);
+            }
+            return () => __awaiter(this, void 0, void 0, function* () {
+                backgroundCanvasCtx.drawImage(backgroundElement, 0, 0, backgroundWidth, backgroundHeight, sx, sy, sw, sh);
+                return backgroundCanvasCtx.getImageData(0, 0, targetWidth, targetHeight).data.buffer;
+            });
+        }
+        else if (type === "imagebitmap") {
+            let [sx, sy, sw, sh] = [0, 0, backgroundWidth, backgroundHeight];
+            if (backgroundAspectRatio > targetAspectRatio) {
+                const outsideX = backgroundWidth - backgroundHeight * targetAspectRatio;
+                sx += Math.round(outsideX / 2);
+                sw -= Math.round(outsideX);
+            }
+            else if (backgroundAspectRatio < targetAspectRatio) {
+                const outsideY = backgroundHeight - backgroundWidth / targetAspectRatio;
+                sy += Math.round(outsideY / 2);
+                sh -= Math.round(outsideY);
+            }
+            return () => __awaiter(this, void 0, void 0, function* () {
+                return yield createImageBitmap(backgroundElement, sx, sy, sw, sh, {
+                    resizeWidth: targetWidth,
+                    resizeHeight: targetHeight,
+                });
+            });
+        }
+        else if (type === "canvas") {
+            return () => __awaiter(this, void 0, void 0, function* () {
+                return backgroundElement;
+            });
+        }
+    });
+}
+function createCanvas(width, height) {
+    if (self.document) {
+        const canvas = self.document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        return canvas;
+    }
+    else if (self.OffscreenCanvas) {
+        return new OffscreenCanvas(width, height);
+    }
+}
+
+var createTFLiteModule = (function () {
+    var _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : undefined;
+    if (typeof __filename !== "undefined")
+        _scriptDir = _scriptDir || __filename;
+    return function (createTFLiteModule) {
+        createTFLiteModule = createTFLiteModule || {};
+        var Module = typeof createTFLiteModule !== "undefined" ? createTFLiteModule : {};
+        var readyPromiseResolve, readyPromiseReject;
+        Module["ready"] = new Promise(function (resolve, reject) {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+        });
+        var moduleOverrides = {};
+        var key;
+        for (key in Module) {
+            if (Module.hasOwnProperty(key)) {
+                moduleOverrides[key] = Module[key];
+            }
+        }
+        var thisProgram = "./this.program";
+        var quit_ = function (status, toThrow) {
+            throw toThrow;
+        };
+        var ENVIRONMENT_IS_WEB = false;
+        var ENVIRONMENT_IS_WORKER = false;
+        var ENVIRONMENT_IS_NODE = false;
+        var ENVIRONMENT_IS_SHELL = false;
+        ENVIRONMENT_IS_WEB = typeof window === "object";
+        ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+        ENVIRONMENT_IS_NODE =
+            typeof process === "object" &&
+                typeof process.versions === "object" &&
+                typeof process.versions.node === "string";
+        ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+        var scriptDirectory = "";
+        function locateFile(path) {
+            if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+            }
+            return scriptDirectory + path;
+        }
+        var read_, readAsync, readBinary;
+        var nodeFS;
+        var nodePath;
+        if (ENVIRONMENT_IS_NODE) {
+            if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = require("path").dirname(scriptDirectory) + "/";
+            }
+            else {
+                scriptDirectory = __dirname + "/";
+            }
+            read_ = function shell_read(filename, binary) {
+                if (!nodeFS)
+                    nodeFS = require("fs");
+                if (!nodePath)
+                    nodePath = require("path");
+                filename = nodePath["normalize"](filename);
+                return nodeFS["readFileSync"](filename, binary ? null : "utf8");
+            };
+            readBinary = function readBinary(filename) {
+                var ret = read_(filename, true);
+                if (!ret.buffer) {
+                    ret = new Uint8Array(ret);
+                }
+                assert(ret.buffer);
+                return ret;
+            };
+            if (process["argv"].length > 1) {
+                thisProgram = process["argv"][1].replace(/\\/g, "/");
+            }
+            process["argv"].slice(2);
+            process["on"]("uncaughtException", function (ex) {
+                if (!(ex instanceof ExitStatus)) {
+                    throw ex;
+                }
+            });
+            process["on"]("unhandledRejection", abort);
+            quit_ = function (status) {
+                process["exit"](status);
+            };
+            Module["inspect"] = function () {
+                return "[Emscripten Module object]";
+            };
+        }
+        else if (ENVIRONMENT_IS_SHELL) {
+            if (typeof read != "undefined") {
+                read_ = function shell_read(f) {
+                    return read(f);
+                };
+            }
+            readBinary = function readBinary(f) {
+                var data;
+                if (typeof readbuffer === "function") {
+                    return new Uint8Array(readbuffer(f));
+                }
+                data = read(f, "binary");
+                assert(typeof data === "object");
+                return data;
+            };
+            if (typeof scriptArgs != "undefined") {
+                scriptArgs;
+            }
+            if (typeof quit === "function") {
+                quit_ = function (status) {
+                    quit(status);
+                };
+            }
+            if (typeof print !== "undefined") {
+                if (typeof console === "undefined")
+                    console = {};
+                console.log = print;
+                console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
+            }
+        }
+        else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+            if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = self.location.href;
+            }
+            else if (typeof document !== "undefined" && document.currentScript) {
+                scriptDirectory = document.currentScript.src;
+            }
+            if (_scriptDir) {
+                scriptDirectory = _scriptDir;
+            }
+            if (scriptDirectory.indexOf("blob:") !== 0) {
+                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
+            }
+            else {
+                scriptDirectory = "";
+            }
+            {
+                read_ = function (url) {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, false);
+                    xhr.send(null);
+                    return xhr.responseText;
+                };
+                if (ENVIRONMENT_IS_WORKER) {
+                    readBinary = function (url) {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open("GET", url, false);
+                        xhr.responseType = "arraybuffer";
+                        xhr.send(null);
+                        return new Uint8Array(xhr.response);
+                    };
+                }
+                readAsync = function (url, onload, onerror) {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, true);
+                    xhr.responseType = "arraybuffer";
+                    xhr.onload = function () {
+                        if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+                            onload(xhr.response);
+                            return;
+                        }
+                        onerror();
+                    };
+                    xhr.onerror = onerror;
+                    xhr.send(null);
+                };
+            }
+        }
+        else ;
+        var out = Module["print"] || console.log.bind(console);
+        var err = Module["printErr"] || console.warn.bind(console);
+        for (key in moduleOverrides) {
+            if (moduleOverrides.hasOwnProperty(key)) {
+                Module[key] = moduleOverrides[key];
+            }
+        }
+        moduleOverrides = null;
+        if (Module["arguments"])
+            Module["arguments"];
+        if (Module["thisProgram"])
+            thisProgram = Module["thisProgram"];
+        if (Module["quit"])
+            quit_ = Module["quit"];
+        var wasmBinary;
+        if (Module["wasmBinary"])
+            wasmBinary = Module["wasmBinary"];
+        Module["noExitRuntime"] || true;
+        if (typeof WebAssembly !== "object") {
+            abort("no native wasm support detected");
+        }
+        var wasmMemory;
+        var ABORT = false;
+        function assert(condition, text) {
+            if (!condition) {
+                abort("Assertion failed: " + text);
+            }
+        }
+        var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+        function UTF8ArrayToString(heap, idx, maxBytesToRead) {
+            var endIdx = idx + maxBytesToRead;
+            var endPtr = idx;
+            while (heap[endPtr] && !(endPtr >= endIdx))
+                ++endPtr;
+            if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
+                return UTF8Decoder.decode(heap.subarray(idx, endPtr));
+            }
+            else {
+                var str = "";
+                while (idx < endPtr) {
+                    var u0 = heap[idx++];
+                    if (!(u0 & 128)) {
+                        str += String.fromCharCode(u0);
+                        continue;
+                    }
+                    var u1 = heap[idx++] & 63;
+                    if ((u0 & 224) == 192) {
+                        str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                        continue;
+                    }
+                    var u2 = heap[idx++] & 63;
+                    if ((u0 & 240) == 224) {
+                        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+                    }
+                    else {
+                        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
+                    }
+                    if (u0 < 65536) {
+                        str += String.fromCharCode(u0);
+                    }
+                    else {
+                        var ch = u0 - 65536;
+                        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+                    }
+                }
+            }
+            return str;
+        }
+        function UTF8ToString(ptr, maxBytesToRead) {
+            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+        }
+        function writeAsciiToMemory(str, buffer, dontAddNull) {
+            for (var i = 0; i < str.length; ++i) {
+                HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+            }
+            HEAP8[buffer >> 0] = 0;
+        }
+        function alignUp(x, multiple) {
+            if (x % multiple > 0) {
+                x += multiple - (x % multiple);
+            }
+            return x;
+        }
+        var buffer, HEAP8, HEAPU8, HEAP32;
+        function updateGlobalBufferAndViews(buf) {
+            buffer = buf;
+            Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+            Module["HEAP16"] = new Int16Array(buf);
+            Module["HEAP32"] = HEAP32 = new Int32Array(buf);
+            Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+            Module["HEAPU16"] = new Uint16Array(buf);
+            Module["HEAPU32"] = new Uint32Array(buf);
+            Module["HEAPF32"] = new Float32Array(buf);
+            Module["HEAPF64"] = new Float64Array(buf);
+        }
+        Module["INITIAL_MEMORY"] || 16777216;
+        var wasmTable;
+        var __ATPRERUN__ = [];
+        var __ATINIT__ = [];
+        var __ATMAIN__ = [];
+        var __ATPOSTRUN__ = [];
+        __ATINIT__.push({
+            func: function () {
+                ___wasm_call_ctors();
+            },
+        });
+        function preRun() {
+            if (Module["preRun"]) {
+                if (typeof Module["preRun"] == "function")
+                    Module["preRun"] = [Module["preRun"]];
+                while (Module["preRun"].length) {
+                    addOnPreRun(Module["preRun"].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPRERUN__);
+        }
+        function initRuntime() {
+            callRuntimeCallbacks(__ATINIT__);
+        }
+        function preMain() {
+            callRuntimeCallbacks(__ATMAIN__);
+        }
+        function postRun() {
+            if (Module["postRun"]) {
+                if (typeof Module["postRun"] == "function")
+                    Module["postRun"] = [Module["postRun"]];
+                while (Module["postRun"].length) {
+                    addOnPostRun(Module["postRun"].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPOSTRUN__);
+        }
+        function addOnPreRun(cb) {
+            __ATPRERUN__.unshift(cb);
+        }
+        function addOnPostRun(cb) {
+            __ATPOSTRUN__.unshift(cb);
+        }
+        var runDependencies = 0;
+        var dependenciesFulfilled = null;
+        function addRunDependency(id) {
+            runDependencies++;
+            if (Module["monitorRunDependencies"]) {
+                Module["monitorRunDependencies"](runDependencies);
+            }
+        }
+        function removeRunDependency(id) {
+            runDependencies--;
+            if (Module["monitorRunDependencies"]) {
+                Module["monitorRunDependencies"](runDependencies);
+            }
+            if (runDependencies == 0) {
+                if (dependenciesFulfilled) {
+                    var callback = dependenciesFulfilled;
+                    dependenciesFulfilled = null;
+                    callback();
+                }
+            }
+        }
+        Module["preloadedImages"] = {};
+        Module["preloadedAudios"] = {};
+        function abort(what) {
+            if (Module["onAbort"]) {
+                Module["onAbort"](what);
+            }
+            what += "";
+            err(what);
+            ABORT = true;
+            what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
+            var e = new WebAssembly.RuntimeError(what);
+            readyPromiseReject(e);
+            throw e;
+        }
+        function hasPrefix(str, prefix) {
+            return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
+        }
+        var dataURIPrefix = "data:application/octet-stream;base64,";
+        function isDataURI(filename) {
+            return hasPrefix(filename, dataURIPrefix);
+        }
+        var fileURIPrefix = "file://";
+        function isFileURI(filename) {
+            return hasPrefix(filename, fileURIPrefix);
+        }
+        var wasmBinaryFile = "tflite.wasm";
+        if (!isDataURI(wasmBinaryFile)) {
+            wasmBinaryFile = locateFile(wasmBinaryFile);
+        }
+        function getBinary(file) {
+            try {
+                if (file == wasmBinaryFile && wasmBinary) {
+                    return new Uint8Array(wasmBinary);
+                }
+                if (readBinary) {
+                    return readBinary(file);
+                }
+                else {
+                    throw "both async and sync fetching of the wasm failed";
+                }
+            }
+            catch (err) {
+                abort(err);
+            }
+        }
+        function getBinaryPromise() {
+            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+                if (typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
+                    return fetch(wasmBinaryFile, { credentials: "same-origin" })
+                        .then(function (response) {
+                        if (!response["ok"]) {
+                            throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
+                        }
+                        return response["arrayBuffer"]();
+                    })
+                        .catch(function () {
+                        return getBinary(wasmBinaryFile);
+                    });
+                }
+                else {
+                    if (readAsync) {
+                        return new Promise(function (resolve, reject) {
+                            readAsync(wasmBinaryFile, function (response) {
+                                resolve(new Uint8Array(response));
+                            }, reject);
+                        });
+                    }
+                }
+            }
+            return Promise.resolve().then(function () {
+                return getBinary(wasmBinaryFile);
+            });
+        }
+        function createWasm() {
+            var info = { a: asmLibraryArg };
+            function receiveInstance(instance, module) {
+                var exports = instance.exports;
+                Module["asm"] = exports;
+                wasmMemory = Module["asm"]["q"];
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                wasmTable = Module["asm"]["D"];
+                removeRunDependency();
+            }
+            addRunDependency();
+            function receiveInstantiatedSource(output) {
+                receiveInstance(output["instance"]);
+            }
+            function instantiateArrayBuffer(receiver) {
+                return getBinaryPromise()
+                    .then(function (binary) {
+                    return WebAssembly.instantiate(binary, info);
+                })
+                    .then(receiver, function (reason) {
+                    err("failed to asynchronously prepare wasm: " + reason);
+                    abort(reason);
+                });
+            }
+            function instantiateAsync() {
+                if (!wasmBinary &&
+                    typeof WebAssembly.instantiateStreaming === "function" &&
+                    !isDataURI(wasmBinaryFile) &&
+                    !isFileURI(wasmBinaryFile) &&
+                    typeof fetch === "function") {
+                    return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) {
+                        var result = WebAssembly.instantiateStreaming(response, info);
+                        return result.then(receiveInstantiatedSource, function (reason) {
+                            err("wasm streaming compile failed: " + reason);
+                            err("falling back to ArrayBuffer instantiation");
+                            return instantiateArrayBuffer(receiveInstantiatedSource);
+                        });
+                    });
+                }
+                else {
+                    return instantiateArrayBuffer(receiveInstantiatedSource);
+                }
+            }
+            if (Module["instantiateWasm"]) {
+                try {
+                    var exports = Module["instantiateWasm"](info, receiveInstance);
+                    return exports;
+                }
+                catch (e) {
+                    err("Module.instantiateWasm callback failed with error: " + e);
+                    return false;
+                }
+            }
+            instantiateAsync().catch(readyPromiseReject);
+            return {};
+        }
+        function callRuntimeCallbacks(callbacks) {
+            while (callbacks.length > 0) {
+                var callback = callbacks.shift();
+                if (typeof callback == "function") {
+                    callback(Module);
+                    continue;
+                }
+                var func = callback.func;
+                if (typeof func === "number") {
+                    if (callback.arg === undefined) {
+                        wasmTable.get(func)();
+                    }
+                    else {
+                        wasmTable.get(func)(callback.arg);
+                    }
+                }
+                else {
+                    func(callback.arg === undefined ? null : callback.arg);
+                }
+            }
+        }
+        function _abort() {
+            abort();
+        }
+        var _emscripten_get_now;
+        if (ENVIRONMENT_IS_NODE) {
+            _emscripten_get_now = function () {
+                var t = process["hrtime"]();
+                return t[0] * 1e3 + t[1] / 1e6;
+            };
+        }
+        else if (typeof dateNow !== "undefined") {
+            _emscripten_get_now = dateNow;
+        }
+        else
+            _emscripten_get_now = function () {
+                return performance.now();
+            };
+        var _emscripten_get_now_is_monotonic = true;
+        function setErrNo(value) {
+            HEAP32[___errno_location() >> 2] = value;
+            return value;
+        }
+        function _clock_gettime(clk_id, tp) {
+            var now;
+            if (clk_id === 0) {
+                now = Date.now();
+            }
+            else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
+                now = _emscripten_get_now();
+            }
+            else {
+                setErrNo(28);
+                return -1;
+            }
+            HEAP32[tp >> 2] = (now / 1e3) | 0;
+            HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
+            return 0;
+        }
+        function _dlopen(filename, flag) {
+            abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
+        }
+        function _dlsym(handle, symbol) {
+            abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
+        }
+        function _emscripten_memcpy_big(dest, src, num) {
+            HEAPU8.copyWithin(dest, src, src + num);
+        }
+        function _emscripten_get_heap_size() {
+            return HEAPU8.length;
+        }
+        function emscripten_realloc_buffer(size) {
+            try {
+                wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                return 1;
+            }
+            catch (e) { }
+        }
+        function _emscripten_resize_heap(requestedSize) {
+            var oldSize = _emscripten_get_heap_size();
+            var maxHeapSize = 2147483648;
+            if (requestedSize > maxHeapSize) {
+                return false;
+            }
+            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = emscripten_realloc_buffer(newSize);
+                if (replacement) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function _emscripten_thread_sleep(msecs) {
+            var start = _emscripten_get_now();
+            while (_emscripten_get_now() - start < msecs) { }
+        }
+        var ENV = {};
+        function getExecutableName() {
+            return thisProgram || "./this.program";
+        }
+        function getEnvStrings() {
+            if (!getEnvStrings.strings) {
+                var lang = ((typeof navigator === "object" && navigator.languages && navigator.languages[0]) || "C").replace("-", "_") + ".UTF-8";
+                var env = {
+                    USER: "web_user",
+                    LOGNAME: "web_user",
+                    PATH: "/",
+                    PWD: "/",
+                    HOME: "/home/web_user",
+                    LANG: lang,
+                    _: getExecutableName(),
+                };
+                for (var x in ENV) {
+                    env[x] = ENV[x];
+                }
+                var strings = [];
+                for (var x in env) {
+                    strings.push(x + "=" + env[x]);
+                }
+                getEnvStrings.strings = strings;
+            }
+            return getEnvStrings.strings;
+        }
+        var SYSCALLS = {
+            mappings: {},
+            buffers: [null, [], []],
+            printChar: function (stream, curr) {
+                var buffer = SYSCALLS.buffers[stream];
+                if (curr === 0 || curr === 10) {
+                    (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+                    buffer.length = 0;
+                }
+                else {
+                    buffer.push(curr);
+                }
+            },
+            varargs: undefined,
+            get: function () {
+                SYSCALLS.varargs += 4;
+                var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
+                return ret;
+            },
+            getStr: function (ptr) {
+                var ret = UTF8ToString(ptr);
+                return ret;
+            },
+            get64: function (low, high) {
+                return low;
+            },
+        };
+        function _environ_get(__environ, environ_buf) {
+            var bufSize = 0;
+            getEnvStrings().forEach(function (string, i) {
+                var ptr = environ_buf + bufSize;
+                HEAP32[(__environ + i * 4) >> 2] = ptr;
+                writeAsciiToMemory(string, ptr);
+                bufSize += string.length + 1;
+            });
+            return 0;
+        }
+        function _environ_sizes_get(penviron_count, penviron_buf_size) {
+            var strings = getEnvStrings();
+            HEAP32[penviron_count >> 2] = strings.length;
+            var bufSize = 0;
+            strings.forEach(function (string) {
+                bufSize += string.length + 1;
+            });
+            HEAP32[penviron_buf_size >> 2] = bufSize;
+            return 0;
+        }
+        function _exit(status) {
+            exit(status);
+        }
+        function _fd_close(fd) {
+            return 0;
+        }
+        function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { }
+        function _fd_write(fd, iov, iovcnt, pnum) {
+            var num = 0;
+            for (var i = 0; i < iovcnt; i++) {
+                var ptr = HEAP32[(iov + i * 8) >> 2];
+                var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
+                for (var j = 0; j < len; j++) {
+                    SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
+                }
+                num += len;
+            }
+            HEAP32[pnum >> 2] = num;
+            return 0;
+        }
+        function _pthread_create() {
+            return 6;
+        }
+        function _pthread_join() {
+            return 28;
+        }
+        function _sysconf(name) {
+            switch (name) {
+                case 30:
+                    return 16384;
+                case 85:
+                    var maxHeapSize = 2147483648;
+                    return maxHeapSize / 16384;
+                case 132:
+                case 133:
+                case 12:
+                case 137:
+                case 138:
+                case 15:
+                case 235:
+                case 16:
+                case 17:
+                case 18:
+                case 19:
+                case 20:
+                case 149:
+                case 13:
+                case 10:
+                case 236:
+                case 153:
+                case 9:
+                case 21:
+                case 22:
+                case 159:
+                case 154:
+                case 14:
+                case 77:
+                case 78:
+                case 139:
+                case 82:
+                case 68:
+                case 67:
+                case 164:
+                case 11:
+                case 29:
+                case 47:
+                case 48:
+                case 95:
+                case 52:
+                case 51:
+                case 46:
+                    return 200809;
+                case 27:
+                case 246:
+                case 127:
+                case 128:
+                case 23:
+                case 24:
+                case 160:
+                case 161:
+                case 181:
+                case 182:
+                case 242:
+                case 183:
+                case 184:
+                case 243:
+                case 244:
+                case 245:
+                case 165:
+                case 178:
+                case 179:
+                case 49:
+                case 50:
+                case 168:
+                case 169:
+                case 175:
+                case 170:
+                case 171:
+                case 172:
+                case 97:
+                case 76:
+                case 32:
+                case 173:
+                case 35:
+                case 80:
+                case 81:
+                case 79:
+                    return -1;
+                case 176:
+                case 177:
+                case 7:
+                case 155:
+                case 8:
+                case 157:
+                case 125:
+                case 126:
+                case 92:
+                case 93:
+                case 129:
+                case 130:
+                case 131:
+                case 94:
+                case 91:
+                    return 1;
+                case 74:
+                case 60:
+                case 69:
+                case 70:
+                case 4:
+                    return 1024;
+                case 31:
+                case 42:
+                case 72:
+                    return 32;
+                case 87:
+                case 26:
+                case 33:
+                    return 2147483647;
+                case 34:
+                case 1:
+                    return 47839;
+                case 38:
+                case 36:
+                    return 99;
+                case 43:
+                case 37:
+                    return 2048;
+                case 0:
+                    return 2097152;
+                case 3:
+                    return 65536;
+                case 28:
+                    return 32768;
+                case 44:
+                    return 32767;
+                case 75:
+                    return 16384;
+                case 39:
+                    return 1e3;
+                case 89:
+                    return 700;
+                case 71:
+                    return 256;
+                case 40:
+                    return 255;
+                case 2:
+                    return 100;
+                case 180:
+                    return 64;
+                case 25:
+                    return 20;
+                case 5:
+                    return 16;
+                case 6:
+                    return 6;
+                case 73:
+                    return 4;
+                case 84: {
+                    if (typeof navigator === "object")
+                        return navigator["hardwareConcurrency"] || 1;
+                    return 1;
+                }
+            }
+            setErrNo(28);
+            return -1;
+        }
+        var asmLibraryArg = {
+            a: _abort,
+            n: _clock_gettime,
+            i: _dlopen,
+            e: _dlsym,
+            l: _emscripten_memcpy_big,
+            m: _emscripten_resize_heap,
+            o: _emscripten_thread_sleep,
+            p: _environ_get,
+            g: _environ_sizes_get,
+            j: _exit,
+            h: _fd_close,
+            k: _fd_seek,
+            c: _fd_write,
+            d: _pthread_create,
+            f: _pthread_join,
+            b: _sysconf,
+        };
+        createWasm();
+        var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
+            return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["r"]).apply(null, arguments);
+        });
+        (Module["_getModelBufferMemoryOffset"] = function () {
+            return (Module["_getModelBufferMemoryOffset"] = Module["asm"]["s"]).apply(null, arguments);
+        });
+        (Module["_getInputMemoryOffset"] = function () {
+            return (Module["_getInputMemoryOffset"] = Module["asm"]["t"]).apply(null, arguments);
+        });
+        (Module["_getInputHeight"] = function () {
+            return (Module["_getInputHeight"] = Module["asm"]["u"]).apply(null, arguments);
+        });
+        (Module["_getInputWidth"] = function () {
+            return (Module["_getInputWidth"] = Module["asm"]["v"]).apply(null, arguments);
+        });
+        (Module["_getInputChannelCount"] = function () {
+            return (Module["_getInputChannelCount"] = Module["asm"]["w"]).apply(null, arguments);
+        });
+        (Module["_getOutputMemoryOffset"] = function () {
+            return (Module["_getOutputMemoryOffset"] = Module["asm"]["x"]).apply(null, arguments);
+        });
+        (Module["_getOutputHeight"] = function () {
+            return (Module["_getOutputHeight"] = Module["asm"]["y"]).apply(null, arguments);
+        });
+        (Module["_getOutputWidth"] = function () {
+            return (Module["_getOutputWidth"] = Module["asm"]["z"]).apply(null, arguments);
+        });
+        (Module["_getOutputChannelCount"] = function () {
+            return (Module["_getOutputChannelCount"] = Module["asm"]["A"]).apply(null, arguments);
+        });
+        (Module["_loadModel"] = function () {
+            return (Module["_loadModel"] = Module["asm"]["B"]).apply(null, arguments);
+        });
+        (Module["_runInference"] = function () {
+            return (Module["_runInference"] = Module["asm"]["C"]).apply(null, arguments);
+        });
+        var ___errno_location = (Module["___errno_location"] = function () {
+            return (___errno_location = Module["___errno_location"] = Module["asm"]["E"]).apply(null, arguments);
+        });
+        var calledRun;
+        function ExitStatus(status) {
+            this.name = "ExitStatus";
+            this.message = "Program terminated with exit(" + status + ")";
+            this.status = status;
+        }
+        dependenciesFulfilled = function runCaller() {
+            if (!calledRun)
+                run();
+            if (!calledRun)
+                dependenciesFulfilled = runCaller;
+        };
+        function run(args) {
+            if (runDependencies > 0) {
+                return;
+            }
+            preRun();
+            if (runDependencies > 0) {
+                return;
+            }
+            function doRun() {
+                if (calledRun)
+                    return;
+                calledRun = true;
+                Module["calledRun"] = true;
+                if (ABORT)
+                    return;
+                initRuntime();
+                preMain();
+                readyPromiseResolve(Module);
+                if (Module["onRuntimeInitialized"])
+                    Module["onRuntimeInitialized"]();
+                postRun();
+            }
+            if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(function () {
+                    setTimeout(function () {
+                        Module["setStatus"]("");
+                    }, 1);
+                    doRun();
+                }, 1);
+            }
+            else {
+                doRun();
+            }
+        }
+        Module["run"] = run;
+        function exit(status, implicit) {
+            quit_(status, new ExitStatus(status));
+        }
+        if (Module["preInit"]) {
+            if (typeof Module["preInit"] == "function")
+                Module["preInit"] = [Module["preInit"]];
+            while (Module["preInit"].length > 0) {
+                Module["preInit"].pop()();
+            }
+        }
+        run();
+        return createTFLiteModule.ready;
+    };
+})();
+
+const createTFLiteSIMDModule = (function () {
+    let _scriptDir = typeof document !== "undefined" && document.currentScript ? document.currentScript.src : undefined;
+    if (typeof __filename !== "undefined")
+        _scriptDir = _scriptDir || __filename;
+    return function (createTFLiteSIMDModule) {
+        createTFLiteSIMDModule = createTFLiteSIMDModule || {};
+        var Module = typeof createTFLiteSIMDModule !== "undefined" ? createTFLiteSIMDModule : {};
+        var readyPromiseResolve, readyPromiseReject;
+        Module["ready"] = new Promise(function (resolve, reject) {
+            readyPromiseResolve = resolve;
+            readyPromiseReject = reject;
+        });
+        var moduleOverrides = {};
+        var key;
+        for (key in Module) {
+            if (Module.hasOwnProperty(key)) {
+                moduleOverrides[key] = Module[key];
+            }
+        }
+        var thisProgram = "./this.program";
+        var quit_ = function (status, toThrow) {
+            throw toThrow;
+        };
+        var ENVIRONMENT_IS_WEB = false;
+        var ENVIRONMENT_IS_WORKER = false;
+        var ENVIRONMENT_IS_NODE = false;
+        var ENVIRONMENT_IS_SHELL = false;
+        ENVIRONMENT_IS_WEB = typeof window === "object";
+        ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+        ENVIRONMENT_IS_NODE =
+            typeof process === "object" &&
+                typeof process.versions === "object" &&
+                typeof process.versions.node === "string";
+        ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+        var scriptDirectory = "";
+        function locateFile(path) {
+            if (Module["locateFile"]) {
+                return Module["locateFile"](path, scriptDirectory);
+            }
+            return scriptDirectory + path;
+        }
+        var read_, readAsync, readBinary;
+        var nodeFS;
+        var nodePath;
+        if (ENVIRONMENT_IS_NODE) {
+            if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = require("path").dirname(scriptDirectory) + "/";
+            }
+            else {
+                scriptDirectory = __dirname + "/";
+            }
+            read_ = function shell_read(filename, binary) {
+                if (!nodeFS)
+                    nodeFS = require("fs");
+                if (!nodePath)
+                    nodePath = require("path");
+                filename = nodePath["normalize"](filename);
+                return nodeFS["readFileSync"](filename, binary ? null : "utf8");
+            };
+            readBinary = function readBinary(filename) {
+                var ret = read_(filename, true);
+                if (!ret.buffer) {
+                    ret = new Uint8Array(ret);
+                }
+                assert(ret.buffer);
+                return ret;
+            };
+            if (process["argv"].length > 1) {
+                thisProgram = process["argv"][1].replace(/\\/g, "/");
+            }
+            process["argv"].slice(2);
+            process["on"]("uncaughtException", function (ex) {
+                if (!(ex instanceof ExitStatus)) {
+                    throw ex;
+                }
+            });
+            process["on"]("unhandledRejection", abort);
+            quit_ = function (status) {
+                process["exit"](status);
+            };
+            Module["inspect"] = function () {
+                return "[Emscripten Module object]";
+            };
+        }
+        else if (ENVIRONMENT_IS_SHELL) {
+            if (typeof read != "undefined") {
+                read_ = function shell_read(f) {
+                    return read(f);
+                };
+            }
+            readBinary = function readBinary(f) {
+                var data;
+                if (typeof readbuffer === "function") {
+                    return new Uint8Array(readbuffer(f));
+                }
+                data = read(f, "binary");
+                assert(typeof data === "object");
+                return data;
+            };
+            if (typeof scriptArgs != "undefined") {
+                scriptArgs;
+            }
+            if (typeof quit === "function") {
+                quit_ = function (status) {
+                    quit(status);
+                };
+            }
+            if (typeof print !== "undefined") {
+                if (typeof console === "undefined")
+                    console = {};
+                console.log = print;
+                console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
+            }
+        }
+        else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+            if (ENVIRONMENT_IS_WORKER) {
+                scriptDirectory = self.location.href;
+            }
+            else if (typeof document !== "undefined" && document.currentScript) {
+                scriptDirectory = document.currentScript.src;
+            }
+            if (_scriptDir) {
+                scriptDirectory = _scriptDir;
+            }
+            if (scriptDirectory.indexOf("blob:") !== 0) {
+                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
+            }
+            else {
+                scriptDirectory = "";
+            }
+            {
+                read_ = function (url) {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, false);
+                    xhr.send(null);
+                    return xhr.responseText;
+                };
+                if (ENVIRONMENT_IS_WORKER) {
+                    readBinary = function (url) {
+                        var xhr = new XMLHttpRequest();
+                        xhr.open("GET", url, false);
+                        xhr.responseType = "arraybuffer";
+                        xhr.send(null);
+                        return new Uint8Array(xhr.response);
+                    };
+                }
+                readAsync = function (url, onload, onerror) {
+                    var xhr = new XMLHttpRequest();
+                    xhr.open("GET", url, true);
+                    xhr.responseType = "arraybuffer";
+                    xhr.onload = function () {
+                        if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+                            onload(xhr.response);
+                            return;
+                        }
+                        onerror();
+                    };
+                    xhr.onerror = onerror;
+                    xhr.send(null);
+                };
+            }
+        }
+        else ;
+        var out = Module["print"] || console.log.bind(console);
+        var err = Module["printErr"] || console.warn.bind(console);
+        for (key in moduleOverrides) {
+            if (moduleOverrides.hasOwnProperty(key)) {
+                Module[key] = moduleOverrides[key];
+            }
+        }
+        moduleOverrides = null;
+        if (Module["arguments"])
+            Module["arguments"];
+        if (Module["thisProgram"])
+            thisProgram = Module["thisProgram"];
+        if (Module["quit"])
+            quit_ = Module["quit"];
+        var wasmBinary;
+        if (Module["wasmBinary"])
+            wasmBinary = Module["wasmBinary"];
+        Module["noExitRuntime"] || true;
+        if (typeof WebAssembly !== "object") {
+            abort("no native wasm support detected");
+        }
+        var wasmMemory;
+        var ABORT = false;
+        function assert(condition, text) {
+            if (!condition) {
+                abort("Assertion failed: " + text);
+            }
+        }
+        var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+        function UTF8ArrayToString(heap, idx, maxBytesToRead) {
+            var endIdx = idx + maxBytesToRead;
+            var endPtr = idx;
+            while (heap[endPtr] && !(endPtr >= endIdx))
+                ++endPtr;
+            if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
+                return UTF8Decoder.decode(heap.subarray(idx, endPtr));
+            }
+            else {
+                var str = "";
+                while (idx < endPtr) {
+                    var u0 = heap[idx++];
+                    if (!(u0 & 128)) {
+                        str += String.fromCharCode(u0);
+                        continue;
+                    }
+                    var u1 = heap[idx++] & 63;
+                    if ((u0 & 224) == 192) {
+                        str += String.fromCharCode(((u0 & 31) << 6) | u1);
+                        continue;
+                    }
+                    var u2 = heap[idx++] & 63;
+                    if ((u0 & 240) == 224) {
+                        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+                    }
+                    else {
+                        u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
+                    }
+                    if (u0 < 65536) {
+                        str += String.fromCharCode(u0);
+                    }
+                    else {
+                        var ch = u0 - 65536;
+                        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+                    }
+                }
+            }
+            return str;
+        }
+        function UTF8ToString(ptr, maxBytesToRead) {
+            return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+        }
+        function writeAsciiToMemory(str, buffer, dontAddNull) {
+            for (var i = 0; i < str.length; ++i) {
+                HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+            }
+            HEAP8[buffer >> 0] = 0;
+        }
+        function alignUp(x, multiple) {
+            if (x % multiple > 0) {
+                x += multiple - (x % multiple);
+            }
+            return x;
+        }
+        var buffer, HEAP8, HEAPU8, HEAP32;
+        function updateGlobalBufferAndViews(buf) {
+            buffer = buf;
+            Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+            Module["HEAP16"] = new Int16Array(buf);
+            Module["HEAP32"] = HEAP32 = new Int32Array(buf);
+            Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+            Module["HEAPU16"] = new Uint16Array(buf);
+            Module["HEAPU32"] = new Uint32Array(buf);
+            Module["HEAPF32"] = new Float32Array(buf);
+            Module["HEAPF64"] = new Float64Array(buf);
+        }
+        Module["INITIAL_MEMORY"] || 16777216;
+        var wasmTable;
+        var __ATPRERUN__ = [];
+        var __ATINIT__ = [];
+        var __ATMAIN__ = [];
+        var __ATPOSTRUN__ = [];
+        __ATINIT__.push({
+            func: function () {
+                ___wasm_call_ctors();
+            },
+        });
+        function preRun() {
+            if (Module["preRun"]) {
+                if (typeof Module["preRun"] == "function")
+                    Module["preRun"] = [Module["preRun"]];
+                while (Module["preRun"].length) {
+                    addOnPreRun(Module["preRun"].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPRERUN__);
+        }
+        function initRuntime() {
+            callRuntimeCallbacks(__ATINIT__);
+        }
+        function preMain() {
+            callRuntimeCallbacks(__ATMAIN__);
+        }
+        function postRun() {
+            if (Module["postRun"]) {
+                if (typeof Module["postRun"] == "function")
+                    Module["postRun"] = [Module["postRun"]];
+                while (Module["postRun"].length) {
+                    addOnPostRun(Module["postRun"].shift());
+                }
+            }
+            callRuntimeCallbacks(__ATPOSTRUN__);
+        }
+        function addOnPreRun(cb) {
+            __ATPRERUN__.unshift(cb);
+        }
+        function addOnPostRun(cb) {
+            __ATPOSTRUN__.unshift(cb);
+        }
+        var runDependencies = 0;
+        var dependenciesFulfilled = null;
+        function addRunDependency(id) {
+            runDependencies++;
+            if (Module["monitorRunDependencies"]) {
+                Module["monitorRunDependencies"](runDependencies);
+            }
+        }
+        function removeRunDependency(id) {
+            runDependencies--;
+            if (Module["monitorRunDependencies"]) {
+                Module["monitorRunDependencies"](runDependencies);
+            }
+            if (runDependencies == 0) {
+                if (dependenciesFulfilled) {
+                    var callback = dependenciesFulfilled;
+                    dependenciesFulfilled = null;
+                    callback();
+                }
+            }
+        }
+        Module["preloadedImages"] = {};
+        Module["preloadedAudios"] = {};
+        function abort(what) {
+            if (Module["onAbort"]) {
+                Module["onAbort"](what);
+            }
+            what += "";
+            err(what);
+            ABORT = true;
+            what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
+            var e = new WebAssembly.RuntimeError(what);
+            readyPromiseReject(e);
+            throw e;
+        }
+        function hasPrefix(str, prefix) {
+            return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
+        }
+        var dataURIPrefix = "data:application/octet-stream;base64,";
+        function isDataURI(filename) {
+            return hasPrefix(filename, dataURIPrefix);
+        }
+        var fileURIPrefix = "file://";
+        function isFileURI(filename) {
+            return hasPrefix(filename, fileURIPrefix);
+        }
+        var wasmBinaryFile = "tflite-simd.wasm";
+        if (!isDataURI(wasmBinaryFile)) {
+            wasmBinaryFile = locateFile(wasmBinaryFile);
+        }
+        function getBinary(file) {
+            try {
+                if (file == wasmBinaryFile && wasmBinary) {
+                    return new Uint8Array(wasmBinary);
+                }
+                if (readBinary) {
+                    return readBinary(file);
+                }
+                else {
+                    throw "both async and sync fetching of the wasm failed";
+                }
+            }
+            catch (err) {
+                abort(err);
+            }
+        }
+        function getBinaryPromise() {
+            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+                if (typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
+                    return fetch(wasmBinaryFile, { credentials: "same-origin" })
+                        .then(function (response) {
+                        if (!response["ok"]) {
+                            throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
+                        }
+                        return response["arrayBuffer"]();
+                    })
+                        .catch(function () {
+                        return getBinary(wasmBinaryFile);
+                    });
+                }
+                else {
+                    if (readAsync) {
+                        return new Promise(function (resolve, reject) {
+                            readAsync(wasmBinaryFile, function (response) {
+                                resolve(new Uint8Array(response));
+                            }, reject);
+                        });
+                    }
+                }
+            }
+            return Promise.resolve().then(function () {
+                return getBinary(wasmBinaryFile);
+            });
+        }
+        function createWasm() {
+            var info = { a: asmLibraryArg };
+            function receiveInstance(instance, module) {
+                var exports = instance.exports;
+                Module["asm"] = exports;
+                wasmMemory = Module["asm"]["q"];
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                wasmTable = Module["asm"]["D"];
+                removeRunDependency();
+            }
+            addRunDependency();
+            function receiveInstantiatedSource(output) {
+                receiveInstance(output["instance"]);
+            }
+            function instantiateArrayBuffer(receiver) {
+                return getBinaryPromise()
+                    .then(function (binary) {
+                    return WebAssembly.instantiate(binary, info);
+                })
+                    .then(receiver, function (reason) {
+                    err("failed to asynchronously prepare wasm: " + reason);
+                    abort(reason);
+                });
+            }
+            function instantiateAsync() {
+                if (!wasmBinary &&
+                    typeof WebAssembly.instantiateStreaming === "function" &&
+                    !isDataURI(wasmBinaryFile) &&
+                    !isFileURI(wasmBinaryFile) &&
+                    typeof fetch === "function") {
+                    return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function (response) {
+                        var result = WebAssembly.instantiateStreaming(response, info);
+                        return result.then(receiveInstantiatedSource, function (reason) {
+                            err("wasm streaming compile failed: " + reason);
+                            err("falling back to ArrayBuffer instantiation");
+                            return instantiateArrayBuffer(receiveInstantiatedSource);
+                        });
+                    });
+                }
+                else {
+                    return instantiateArrayBuffer(receiveInstantiatedSource);
+                }
+            }
+            if (Module["instantiateWasm"]) {
+                try {
+                    var exports = Module["instantiateWasm"](info, receiveInstance);
+                    return exports;
+                }
+                catch (e) {
+                    err("Module.instantiateWasm callback failed with error: " + e);
+                    return false;
+                }
+            }
+            instantiateAsync().catch(readyPromiseReject);
+            return {};
+        }
+        function callRuntimeCallbacks(callbacks) {
+            while (callbacks.length > 0) {
+                var callback = callbacks.shift();
+                if (typeof callback == "function") {
+                    callback(Module);
+                    continue;
+                }
+                var func = callback.func;
+                if (typeof func === "number") {
+                    if (callback.arg === undefined) {
+                        wasmTable.get(func)();
+                    }
+                    else {
+                        wasmTable.get(func)(callback.arg);
+                    }
+                }
+                else {
+                    func(callback.arg === undefined ? null : callback.arg);
+                }
+            }
+        }
+        function _abort() {
+            abort();
+        }
+        var _emscripten_get_now;
+        if (ENVIRONMENT_IS_NODE) {
+            _emscripten_get_now = function () {
+                var t = process["hrtime"]();
+                return t[0] * 1e3 + t[1] / 1e6;
+            };
+        }
+        else if (typeof dateNow !== "undefined") {
+            _emscripten_get_now = dateNow;
+        }
+        else
+            _emscripten_get_now = function () {
+                return performance.now();
+            };
+        var _emscripten_get_now_is_monotonic = true;
+        function setErrNo(value) {
+            HEAP32[___errno_location() >> 2] = value;
+            return value;
+        }
+        function _clock_gettime(clk_id, tp) {
+            var now;
+            if (clk_id === 0) {
+                now = Date.now();
+            }
+            else if ((clk_id === 1 || clk_id === 4) && _emscripten_get_now_is_monotonic) {
+                now = _emscripten_get_now();
+            }
+            else {
+                setErrNo(28);
+                return -1;
+            }
+            HEAP32[tp >> 2] = (now / 1e3) | 0;
+            HEAP32[(tp + 4) >> 2] = ((now % 1e3) * 1e3 * 1e3) | 0;
+            return 0;
+        }
+        function _dlopen(filename, flag) {
+            abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
+        }
+        function _dlsym(handle, symbol) {
+            abort("To use dlopen, you need to use Emscripten's linking support, see https://github.com/emscripten-core/emscripten/wiki/Linking");
+        }
+        function _emscripten_memcpy_big(dest, src, num) {
+            HEAPU8.copyWithin(dest, src, src + num);
+        }
+        function _emscripten_get_heap_size() {
+            return HEAPU8.length;
+        }
+        function emscripten_realloc_buffer(size) {
+            try {
+                wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+                updateGlobalBufferAndViews(wasmMemory.buffer);
+                return 1;
+            }
+            catch (e) { }
+        }
+        function _emscripten_resize_heap(requestedSize) {
+            var oldSize = _emscripten_get_heap_size();
+            var maxHeapSize = 2147483648;
+            if (requestedSize > maxHeapSize) {
+                return false;
+            }
+            for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = emscripten_realloc_buffer(newSize);
+                if (replacement) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function _emscripten_thread_sleep(msecs) {
+            var start = _emscripten_get_now();
+            while (_emscripten_get_now() - start < msecs) { }
+        }
+        var ENV = {};
+        function getExecutableName() {
+            return thisProgram || "./this.program";
+        }
+        function getEnvStrings() {
+            if (!getEnvStrings.strings) {
+                var lang = ((typeof navigator === "object" && navigator.languages && navigator.languages[0]) || "C").replace("-", "_") + ".UTF-8";
+                var env = {
+                    USER: "web_user",
+                    LOGNAME: "web_user",
+                    PATH: "/",
+                    PWD: "/",
+                    HOME: "/home/web_user",
+                    LANG: lang,
+                    _: getExecutableName(),
+                };
+                for (var x in ENV) {
+                    env[x] = ENV[x];
+                }
+                var strings = [];
+                for (var x in env) {
+                    strings.push(x + "=" + env[x]);
+                }
+                getEnvStrings.strings = strings;
+            }
+            return getEnvStrings.strings;
+        }
+        var SYSCALLS = {
+            mappings: {},
+            buffers: [null, [], []],
+            printChar: function (stream, curr) {
+                var buffer = SYSCALLS.buffers[stream];
+                if (curr === 0 || curr === 10) {
+                    (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+                    buffer.length = 0;
+                }
+                else {
+                    buffer.push(curr);
+                }
+            },
+            varargs: undefined,
+            get: function () {
+                SYSCALLS.varargs += 4;
+                var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
+                return ret;
+            },
+            getStr: function (ptr) {
+                var ret = UTF8ToString(ptr);
+                return ret;
+            },
+            get64: function (low, high) {
+                return low;
+            },
+        };
+        function _environ_get(__environ, environ_buf) {
+            var bufSize = 0;
+            getEnvStrings().forEach(function (string, i) {
+                var ptr = environ_buf + bufSize;
+                HEAP32[(__environ + i * 4) >> 2] = ptr;
+                writeAsciiToMemory(string, ptr);
+                bufSize += string.length + 1;
+            });
+            return 0;
+        }
+        function _environ_sizes_get(penviron_count, penviron_buf_size) {
+            var strings = getEnvStrings();
+            HEAP32[penviron_count >> 2] = strings.length;
+            var bufSize = 0;
+            strings.forEach(function (string) {
+                bufSize += string.length + 1;
+            });
+            HEAP32[penviron_buf_size >> 2] = bufSize;
+            return 0;
+        }
+        function _exit(status) {
+            exit(status);
+        }
+        function _fd_close(fd) {
+            return 0;
+        }
+        function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { }
+        function _fd_write(fd, iov, iovcnt, pnum) {
+            var num = 0;
+            for (var i = 0; i < iovcnt; i++) {
+                var ptr = HEAP32[(iov + i * 8) >> 2];
+                var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
+                for (var j = 0; j < len; j++) {
+                    SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
+                }
+                num += len;
+            }
+            HEAP32[pnum >> 2] = num;
+            return 0;
+        }
+        function _pthread_create() {
+            return 6;
+        }
+        function _pthread_join() {
+            return 28;
+        }
+        function _sysconf(name) {
+            switch (name) {
+                case 30:
+                    return 16384;
+                case 85:
+                    var maxHeapSize = 2147483648;
+                    return maxHeapSize / 16384;
+                case 132:
+                case 133:
+                case 12:
+                case 137:
+                case 138:
+                case 15:
+                case 235:
+                case 16:
+                case 17:
+                case 18:
+                case 19:
+                case 20:
+                case 149:
+                case 13:
+                case 10:
+                case 236:
+                case 153:
+                case 9:
+                case 21:
+                case 22:
+                case 159:
+                case 154:
+                case 14:
+                case 77:
+                case 78:
+                case 139:
+                case 82:
+                case 68:
+                case 67:
+                case 164:
+                case 11:
+                case 29:
+                case 47:
+                case 48:
+                case 95:
+                case 52:
+                case 51:
+                case 46:
+                    return 200809;
+                case 27:
+                case 246:
+                case 127:
+                case 128:
+                case 23:
+                case 24:
+                case 160:
+                case 161:
+                case 181:
+                case 182:
+                case 242:
+                case 183:
+                case 184:
+                case 243:
+                case 244:
+                case 245:
+                case 165:
+                case 178:
+                case 179:
+                case 49:
+                case 50:
+                case 168:
+                case 169:
+                case 175:
+                case 170:
+                case 171:
+                case 172:
+                case 97:
+                case 76:
+                case 32:
+                case 173:
+                case 35:
+                case 80:
+                case 81:
+                case 79:
+                    return -1;
+                case 176:
+                case 177:
+                case 7:
+                case 155:
+                case 8:
+                case 157:
+                case 125:
+                case 126:
+                case 92:
+                case 93:
+                case 129:
+                case 130:
+                case 131:
+                case 94:
+                case 91:
+                    return 1;
+                case 74:
+                case 60:
+                case 69:
+                case 70:
+                case 4:
+                    return 1024;
+                case 31:
+                case 42:
+                case 72:
+                    return 32;
+                case 87:
+                case 26:
+                case 33:
+                    return 2147483647;
+                case 34:
+                case 1:
+                    return 47839;
+                case 38:
+                case 36:
+                    return 99;
+                case 43:
+                case 37:
+                    return 2048;
+                case 0:
+                    return 2097152;
+                case 3:
+                    return 65536;
+                case 28:
+                    return 32768;
+                case 44:
+                    return 32767;
+                case 75:
+                    return 16384;
+                case 39:
+                    return 1e3;
+                case 89:
+                    return 700;
+                case 71:
+                    return 256;
+                case 40:
+                    return 255;
+                case 2:
+                    return 100;
+                case 180:
+                    return 64;
+                case 25:
+                    return 20;
+                case 5:
+                    return 16;
+                case 6:
+                    return 6;
+                case 73:
+                    return 4;
+                case 84: {
+                    if (typeof navigator === "object")
+                        return navigator["hardwareConcurrency"] || 1;
+                    return 1;
+                }
+            }
+            setErrNo(28);
+            return -1;
+        }
+        var asmLibraryArg = {
+            a: _abort,
+            n: _clock_gettime,
+            i: _dlopen,
+            e: _dlsym,
+            l: _emscripten_memcpy_big,
+            m: _emscripten_resize_heap,
+            o: _emscripten_thread_sleep,
+            p: _environ_get,
+            g: _environ_sizes_get,
+            j: _exit,
+            h: _fd_close,
+            k: _fd_seek,
+            c: _fd_write,
+            d: _pthread_create,
+            f: _pthread_join,
+            b: _sysconf,
+        };
+        createWasm();
+        var ___wasm_call_ctors = (Module["___wasm_call_ctors"] = function () {
+            return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["r"]).apply(null, arguments);
+        });
+        (Module["_getModelBufferMemoryOffset"] = function () {
+            return (Module["_getModelBufferMemoryOffset"] = Module["asm"]["s"]).apply(null, arguments);
+        });
+        (Module["_getInputMemoryOffset"] = function () {
+            return (Module["_getInputMemoryOffset"] = Module["asm"]["t"]).apply(null, arguments);
+        });
+        (Module["_getInputHeight"] = function () {
+            return (Module["_getInputHeight"] = Module["asm"]["u"]).apply(null, arguments);
+        });
+        (Module["_getInputWidth"] = function () {
+            return (Module["_getInputWidth"] = Module["asm"]["v"]).apply(null, arguments);
+        });
+        (Module["_getInputChannelCount"] = function () {
+            return (Module["_getInputChannelCount"] = Module["asm"]["w"]).apply(null, arguments);
+        });
+        (Module["_getOutputMemoryOffset"] = function () {
+            return (Module["_getOutputMemoryOffset"] = Module["asm"]["x"]).apply(null, arguments);
+        });
+        (Module["_getOutputHeight"] = function () {
+            return (Module["_getOutputHeight"] = Module["asm"]["y"]).apply(null, arguments);
+        });
+        (Module["_getOutputWidth"] = function () {
+            return (Module["_getOutputWidth"] = Module["asm"]["z"]).apply(null, arguments);
+        });
+        (Module["_getOutputChannelCount"] = function () {
+            return (Module["_getOutputChannelCount"] = Module["asm"]["A"]).apply(null, arguments);
+        });
+        (Module["_loadModel"] = function () {
+            return (Module["_loadModel"] = Module["asm"]["B"]).apply(null, arguments);
+        });
+        (Module["_runInference"] = function () {
+            return (Module["_runInference"] = Module["asm"]["C"]).apply(null, arguments);
+        });
+        var ___errno_location = (Module["___errno_location"] = function () {
+            return (___errno_location = Module["___errno_location"] = Module["asm"]["E"]).apply(null, arguments);
+        });
+        var calledRun;
+        function ExitStatus(status) {
+            this.name = "ExitStatus";
+            this.message = "Program terminated with exit(" + status + ")";
+            this.status = status;
+        }
+        dependenciesFulfilled = function runCaller() {
+            if (!calledRun)
+                run();
+            if (!calledRun)
+                dependenciesFulfilled = runCaller;
+        };
+        function run(args) {
+            if (runDependencies > 0) {
+                return;
+            }
+            preRun();
+            if (runDependencies > 0) {
+                return;
+            }
+            function doRun() {
+                if (calledRun)
+                    return;
+                calledRun = true;
+                Module["calledRun"] = true;
+                if (ABORT)
+                    return;
+                initRuntime();
+                preMain();
+                readyPromiseResolve(Module);
+                if (Module["onRuntimeInitialized"])
+                    Module["onRuntimeInitialized"]();
+                postRun();
+            }
+            if (Module["setStatus"]) {
+                Module["setStatus"]("Running...");
+                setTimeout(function () {
+                    setTimeout(function () {
+                        Module["setStatus"]("");
+                    }, 1);
+                    doRun();
+                }, 1);
+            }
+            else {
+                doRun();
+            }
+        }
+        Module["run"] = run;
+        function exit(status, implicit) {
+            quit_(status, new ExitStatus(status));
+        }
+        if (Module["preInit"]) {
+            if (typeof Module["preInit"] == "function")
+                Module["preInit"] = [Module["preInit"]];
+            while (Module["preInit"].length > 0) {
+                Module["preInit"].pop()();
+            }
+        }
+        run();
+        return createTFLiteSIMDModule.ready;
+    };
+})();
+
+var tfliteWasmUrl = "./assets/tflite/tflite.wasm";
+
+var tfliteSimdWasmUrl = "./assets/tflite/tflite-simd.wasm";
+
+var modelMeetLiteUrl = "./assets/models/segm_lite_v681.tflite";
+
+var modelMeetFullUrl = "./assets/models/segm_full_v679.tflite";
+
+var modelMLKitUrl = "./assets/models/selfiesegmentation_mlkit-256x256-2021_01_19-v1215.f16.tflite";
+
+const SEGMENTATIONMODEL_TYPE_BACKGROUND_PERSON = 1;
+const SEGMENTATIONMODEL_TYPE_PERSON = 2;
+const fixWebPackGeneratedFileUrl = (url) => {
+    return new URL(url, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+};
+const models = {
+    meetlite: {
+        url: fixWebPackGeneratedFileUrl(modelMeetLiteUrl),
+        type: SEGMENTATIONMODEL_TYPE_BACKGROUND_PERSON,
+    },
+    meetfull: {
+        url: fixWebPackGeneratedFileUrl(modelMeetFullUrl),
+        type: SEGMENTATIONMODEL_TYPE_BACKGROUND_PERSON,
+    },
+    mlkit: {
+        url: fixWebPackGeneratedFileUrl(modelMLKitUrl),
+        type: SEGMENTATIONMODEL_TYPE_PERSON,
+    },
+};
+let _tflite = null;
+const loadTFLite = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (_tflite)
+        return _tflite;
+    const simdIsSupported = yield wasmFeatureDetect.simd();
+    _tflite = yield (simdIsSupported ? createTFLiteSIMDModule : createTFLiteModule)({
+        locateFile(path) {
+            if (path.endsWith(".wasm")) {
+                return fixWebPackGeneratedFileUrl(simdIsSupported ? tfliteSimdWasmUrl : tfliteWasmUrl);
+            }
+            return path;
+        },
+    });
+    return _tflite;
+});
+let _currentModelAndInfo;
+const loadSegmentationModel = (segmentationModelId) => __awaiter(void 0, void 0, void 0, function* () {
+    const model = models[segmentationModelId];
+    const tflite = yield loadTFLite();
+    if ((_currentModelAndInfo === null || _currentModelAndInfo === void 0 ? void 0 : _currentModelAndInfo.url) === model.url)
+        return _currentModelAndInfo;
+    const modelResponse = yield fetch(model.url);
+    const modelBuffer = yield modelResponse.arrayBuffer();
+    const modelBufferOffset = tflite._getModelBufferMemoryOffset();
+    tflite.HEAPU8.set(new Uint8Array(modelBuffer), modelBufferOffset);
+    tflite._loadModel(modelBuffer.byteLength);
+    const inputHeight = tflite._getInputHeight();
+    const inputWidth = tflite._getInputWidth();
+    const inputMemoryOffset = tflite._getInputMemoryOffset() / 4;
+    const outputMemoryOffset = tflite._getOutputMemoryOffset() / 4;
+    const segmentationPixelCount = inputWidth * inputHeight;
+    tflite._runInference();
+    _currentModelAndInfo = {
+        tflite,
+        model,
+        url: model.url,
+        inputHeight,
+        inputWidth,
+        inputMemoryOffset,
+        outputMemoryOffset,
+        segmentationPixelCount,
+    };
+    return _currentModelAndInfo;
+});
+
+const baseCanvasParams = {
+    maskOperation: "copy",
+    maskFilter: "blur(4px)",
+    personOperation: "source-in",
+    personFilter: "none",
+    backgroundOperation: "destination-over",
+    backgroundFilter: "none",
+};
+function getBlurCanvasParams(amount) {
+    switch (amount) {
+        case "slight": {
+            return Object.assign(Object.assign({}, baseCanvasParams), { backgroundFilter: "blur(4px)", crop: 4 });
+        }
+        case "heavy": {
+            return Object.assign(Object.assign({}, baseCanvasParams), { maskFilter: "blur(8px)", backgroundFilter: "blur(16px)", crop: 16 });
+        }
+    }
+    return Object.assign(Object.assign({}, baseCanvasParams), { maskFilter: "blur(8px)", backgroundFilter: "blur(8px)", crop: 8 });
+}
+function getCanvasParams(params) {
+    if (params.backgroundBlur)
+        return getBlurCanvasParams(params.backgroundBlur.amount);
+    return baseCanvasParams;
+}
+function createCanvasEngine(videoWidth, videoHeight, setup, effectCanvas, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { tflite, model: segmentationModel, inputHeight, inputWidth, inputMemoryOffset, outputMemoryOffset, segmentationPixelCount, } = yield loadSegmentationModel(setup.segmentationModelId);
+        let canvasParams = getCanvasParams(params);
+        const segmentationCanvas = createCanvas(inputWidth, inputHeight);
+        const segmentationCtx = segmentationCanvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        const segmentationMask = new ImageData(inputWidth, inputHeight);
+        let currentBackgroundFrame = null;
+        let backgroundDimensions = { x: 0, y: 0, width: 0, height: 0 };
+        const videoAspectRatio = videoWidth / videoHeight;
+        let cropX = 0;
+        let cropY = 0;
+        const updateCrop = () => {
+            const crop = canvasParams.crop || 0;
+            if (crop) {
+                cropX = videoAspectRatio > 1 ? Math.round(crop * videoAspectRatio) : crop;
+                cropY = videoAspectRatio < 1 ? Math.round(crop / videoAspectRatio) : crop;
+            }
+            else {
+                cropX = 0;
+                cropY = 0;
+            }
+        };
+        updateCrop();
+        const effectCtx = effectCanvas.getContext("2d");
+        return {
+            effectCtx,
+            updateBackgroundFrame(frame, dimensions) {
+                currentBackgroundFrame = frame;
+                if (dimensions)
+                    backgroundDimensions = dimensions;
+            },
+            updateParams(updatedParams) {
+                canvasParams = getCanvasParams(updatedParams);
+                updateCrop();
+            },
+            processFrame(frame) {
+                segmentationCtx.drawImage(frame, 0, 0, videoWidth, videoHeight, 0, 0, inputWidth, inputHeight);
+                const imageData = segmentationCtx.getImageData(0, 0, inputWidth, inputHeight);
+                for (let i = 0; i < segmentationPixelCount; i++) {
+                    tflite.HEAPF32[inputMemoryOffset + i * 3] = imageData.data[i * 4] / 255;
+                    tflite.HEAPF32[inputMemoryOffset + i * 3 + 1] = imageData.data[i * 4 + 1] / 255;
+                    tflite.HEAPF32[inputMemoryOffset + i * 3 + 2] = imageData.data[i * 4 + 2] / 255;
+                }
+                tflite._runInference();
+                for (let i = 0; i < segmentationPixelCount; i++) {
+                    if (segmentationModel.type === SEGMENTATIONMODEL_TYPE_BACKGROUND_PERSON) {
+                        const background = tflite.HEAPF32[outputMemoryOffset + i * 2];
+                        const person = tflite.HEAPF32[outputMemoryOffset + i * 2 + 1];
+                        const shift = Math.max(background, person);
+                        const backgroundExp = Math.exp(background - shift);
+                        const personExp = Math.exp(person - shift);
+                        segmentationMask.data[i * 4 + 3] = (255 * personExp) / (backgroundExp + personExp);
+                    }
+                    else if (segmentationModel.type === SEGMENTATIONMODEL_TYPE_PERSON) {
+                        const person = tflite.HEAPF32[outputMemoryOffset + i];
+                        segmentationMask.data[i * 4 + 3] = 255 * person;
+                    }
+                }
+                segmentationCtx.putImageData(segmentationMask, 0, 0);
+                effectCtx.globalCompositeOperation = canvasParams.maskOperation;
+                effectCtx.filter = canvasParams.maskFilter;
+                effectCtx.drawImage(segmentationCanvas, 0, 0, inputWidth, inputHeight, 0, 0, videoWidth, videoHeight);
+                effectCtx.globalCompositeOperation = canvasParams.personOperation;
+                effectCtx.filter = canvasParams.personFilter;
+                effectCtx.drawImage(frame, 0, 0);
+                effectCtx.globalCompositeOperation = canvasParams.backgroundOperation;
+                effectCtx.filter = canvasParams.backgroundFilter;
+                if (currentBackgroundFrame) {
+                    effectCtx.drawImage(currentBackgroundFrame, backgroundDimensions.x, backgroundDimensions.y, backgroundDimensions.width, backgroundDimensions.height, 0, 0, videoWidth, videoHeight, 0);
+                }
+                else {
+                    effectCtx.drawImage(frame, 0, 0);
+                }
+                if (cropX || cropY) {
+                    effectCtx.globalCompositeOperation = "source-over";
+                    effectCtx.filter = "none";
+                    effectCtx.drawImage(effectCanvas, cropX, cropY, videoWidth - cropX * 2, videoHeight - cropY * 2, 0, 0, videoWidth, videoHeight);
+                }
+            },
+            dispose() { },
+        };
+    });
+}
+
+const glsl = String.raw;
+function createProgram(gl, vertexShader, fragmentShader) {
+    const program = gl.createProgram();
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        throw new Error(`Could not link WebGL program: ${gl.getProgramInfoLog(program)}`);
+    }
+    return program;
+}
+function createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer) {
+    const program = createProgram(gl, vertexShader, fragmentShader);
+    const positionAttributeLocation = gl.getAttribLocation(program, "a_position");
+    gl.enableVertexAttribArray(positionAttributeLocation);
+    gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+    gl.vertexAttribPointer(positionAttributeLocation, 2, gl.FLOAT, false, 0, 0);
+    const texCoordAttributeLocation = gl.getAttribLocation(program, "a_texCoord");
+    gl.enableVertexAttribArray(texCoordAttributeLocation);
+    gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
+    gl.vertexAttribPointer(texCoordAttributeLocation, 2, gl.FLOAT, false, 0, 0);
+    return program;
+}
+function compileShader(gl, shaderType, shaderSource) {
+    const shader = gl.createShader(shaderType);
+    gl.shaderSource(shader, shaderSource);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        throw new Error(`Could not compile shader: ${gl.getShaderInfoLog(shader)}`);
+    }
+    return shader;
+}
+function createTexture(gl, internalformat, width, height, minFilter = gl.NEAREST, magFilter = gl.NEAREST) {
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    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, minFilter);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, internalformat, width, height);
+    return texture;
+}
+
+function generateOptimizedGaussianKernel(sigma) {
+    const g = (x) => Math.exp(-(x * x) / (2 * sigma * sigma));
+    const numbers = [];
+    let x = 0;
+    let currentSum = 0;
+    while (true) {
+        const n = g(x);
+        const nextSum = currentSum + (currentSum ? n * 2 : n);
+        if (currentSum && n / nextSum < 0.01 && numbers.length % 2)
+            break;
+        currentSum = nextSum;
+        numbers.push(n);
+        x++;
+    }
+    const weights = numbers.map((n) => n / currentSum);
+    const optimizedWeights = [weights[0]];
+    const optimizedPositions = [0];
+    if (weights.length >= 3 && weights.length % 2 === 1) {
+        for (let i = 1; i < weights.length; i += 2) {
+            const w1 = weights[i];
+            const w2 = weights[i + 1];
+            const w = w1 + w2;
+            const p = w2 / (w1 + w2);
+            optimizedWeights.push(w);
+            optimizedPositions.push(i + p);
+        }
+    }
+    return {
+        weights: optimizedWeights,
+        positions: optimizedPositions,
+    };
+}
+function buildBlurPass(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, outputWidth, outputHeight, params) {
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_inputFrame;
+        uniform sampler2D u_personMask;
+        uniform float u_weight[20];
+        uniform float u_offset[20];
+        uniform int u_ksize;
+        uniform vec2 u_texelSize;
+        in vec2 v_texCoord;
+        out vec4 outColor;
+        void main() {
+            vec4 centerColor = texture(u_inputFrame, v_texCoord);
+            float personMask = texture(u_personMask, v_texCoord).a;
+            vec4 frameColor = centerColor * u_weight[0] * (1.0 - personMask);
+            for (int i = 1; i < u_ksize; i++) {
+                vec2 offset = vec2(u_offset[i]) * u_texelSize;
+                vec2 texCoord = v_texCoord + offset;
+                frameColor += texture(u_inputFrame, texCoord) * u_weight[i] *
+                    (1.0 - texture(u_personMask, texCoord).a);
+                texCoord = v_texCoord - offset;
+                frameColor += texture(u_inputFrame, texCoord) * u_weight[i] *
+                    (1.0 - texture(u_personMask, texCoord).a);
+            }
+            outColor = vec4(frameColor.rgb + (1.0 - frameColor.a) * centerColor.rgb, 1.0);
+        }`;
+    const scale = params.backgroundResampleScale || 0.2;
+    const blurredBackgroundWidth = Math.round(outputWidth * scale);
+    const blurredBackgroundHeight = Math.round(outputHeight * scale);
+    const texelWidth = 1 / blurredBackgroundWidth;
+    const texelHeight = 1 / blurredBackgroundHeight;
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+    const personMaskLocation = gl.getUniformLocation(program, "u_personMask");
+    const texelSizeLocation = gl.getUniformLocation(program, "u_texelSize");
+    const weightLocation = gl.getUniformLocation(program, "u_weight");
+    const offsetLocation = gl.getUniformLocation(program, "u_offset");
+    const kernelsizeLocation = gl.getUniformLocation(program, "u_ksize");
+    const texture1 = createTexture(gl, gl.RGBA8, blurredBackgroundWidth, blurredBackgroundHeight, gl.NEAREST, gl.LINEAR);
+    const texture2 = createTexture(gl, gl.RGBA8, blurredBackgroundWidth, blurredBackgroundHeight, gl.NEAREST, gl.LINEAR);
+    const frameBuffer1 = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer1);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture1, 0);
+    const frameBuffer2 = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer2);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture2, 0);
+    gl.useProgram(program);
+    gl.uniform1i(personMaskLocation, 1);
+    function updateKernel(kernel = "5x5") {
+        gl.useProgram(program);
+        if (kernel === "9x9") {
+            gl.uniform1i(kernelsizeLocation, 5);
+            gl.uniform1fv(weightLocation, [0.227027027, 0.1945945946, 0.1216216216, 0.0540540541, 0.0162162162]);
+            gl.uniform1fv(offsetLocation, [0.0, 1.0, 2.0, 3.0, 4.0]);
+        }
+        else if (kernel === "9x9o") {
+            gl.uniform1i(kernelsizeLocation, 3);
+            gl.uniform1fv(weightLocation, [0.2734375, 0.328125, 0.03515625]);
+            gl.uniform1fv(offsetLocation, [0.0, 1.3333333333333333, 3.111111111111111]);
+        }
+        else if (kernel === "7x7") {
+            gl.uniform1i(kernelsizeLocation, 4);
+            gl.uniform1fv(weightLocation, [0.3125, 0.234375, 0.09375, 0.015625]);
+            gl.uniform1fv(offsetLocation, [0.0, 1.0, 2.0, 3.0]);
+        }
+        else if (kernel === "5x5") {
+            gl.uniform1i(kernelsizeLocation, 3);
+            gl.uniform1fv(weightLocation, [0.3715, 0.25, 0.0625]);
+            gl.uniform1fv(offsetLocation, [0.0, 1.0, 2.0]);
+        }
+        else if (kernel === "3x3") {
+            gl.uniform1i(kernelsizeLocation, 2);
+            gl.uniform1fv(weightLocation, [0.5, 0.25]);
+            gl.uniform1fv(offsetLocation, [0.0, 1.0]);
+        }
+        else if (kernel === "101o") {
+            gl.uniform1i(kernelsizeLocation, 6);
+            gl.uniform1fv(weightLocation, [
+                0.0824930077775077, 0.1570851015371093, 0.12909299748961606, 0.09061657810797075,
+                0.05427127182510044, 0.027687547151449544,
+            ]);
+            gl.uniform1fv(offsetLocation, [0, 1.4851485148514851, 3.4653465346534653, 5.445544554455446, 7.425742574257426, 9.405940594059405]);
+        }
+        else if (kernel === "171o") {
+            gl.uniform1i(kernelsizeLocation, 7);
+            gl.uniform1fv(weightLocation, [
+                0.06465218005811185, 0.1255973586132927, 0.11180602454697099, 0.09067345726996107,
+                0.06697712131207971, 0.04504642671896425, 0.027573521509675278,
+            ]);
+            gl.uniform1fv(offsetLocation, [
+                0, 1.4912280701754388, 3.4795321637426904, 5.4678362573099415, 7.456140350877193, 9.444444444444445,
+                11.432748538011696,
+            ]);
+        }
+        else if (kernel.startsWith("og")) {
+            const s = parseFloat(kernel.substring(2));
+            const { weights, positions } = generateOptimizedGaussianKernel(s);
+            gl.uniform1i(kernelsizeLocation, weights.length);
+            gl.uniform1fv(weightLocation, weights);
+            gl.uniform1fv(offsetLocation, positions);
+        }
+    }
+    let numPasses = 1;
+    function updateParams(params) {
+        updateKernel(params.kernel);
+        numPasses = params.numPasses || 1;
+    }
+    updateParams(params);
+    function render() {
+        gl.viewport(0, 0, blurredBackgroundWidth, blurredBackgroundHeight);
+        gl.useProgram(program);
+        gl.uniform1i(inputFrameLocation, 0);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, personMaskTexture);
+        for (let i = 0; i < numPasses; i++) {
+            gl.uniform2f(texelSizeLocation, 0, texelHeight);
+            gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer1);
+            gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+            gl.activeTexture(gl.TEXTURE2);
+            gl.bindTexture(gl.TEXTURE_2D, texture1);
+            gl.uniform1i(inputFrameLocation, 2);
+            gl.uniform2f(texelSizeLocation, texelWidth, 0);
+            gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer2);
+            gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+            gl.bindTexture(gl.TEXTURE_2D, texture2);
+        }
+    }
+    function cleanUp() {
+        gl.deleteFramebuffer(frameBuffer2);
+        gl.deleteFramebuffer(frameBuffer1);
+        gl.deleteTexture(texture2);
+        gl.deleteTexture(texture1);
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+    }
+    return {
+        render,
+        updateParams,
+        cleanUp,
+    };
+}
+function buildBlendPass(gl, positionBuffer, texCoordBuffer, outputWidth, outputHeight, params) {
+    const vertexShaderSource = glsl `#version 300 es
+        in vec2 a_position;
+        in vec2 a_texCoord;
+        out vec2 v_texCoord;
+        void main() {
+            // Flipping Y is required when rendering to canvas
+            gl_Position = vec4(a_position * vec2(1.0, -1.0), 0.0, 1.0);
+            v_texCoord = a_texCoord;
+        }`;
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_inputFrame;
+        uniform sampler2D u_personMask;
+        uniform sampler2D u_blurredInputFrame;
+        uniform vec2 u_coverage;
+        in vec2 v_texCoord;
+        out vec4 outColor;
+        void main() {
+            vec3 color = texture(u_inputFrame, v_texCoord).rgb;
+            vec3 blurredColor = texture(u_blurredInputFrame, v_texCoord).rgb;
+            float personMask = texture(u_personMask, v_texCoord).a;
+            personMask = smoothstep(u_coverage.x, u_coverage.y, personMask);
+            outColor = vec4(mix(blurredColor, color, personMask), 1.0);
+        }`;
+    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+    const personMaskLocation = gl.getUniformLocation(program, "u_personMask");
+    const blurredInputFrame = gl.getUniformLocation(program, "u_blurredInputFrame");
+    const coverageLocation = gl.getUniformLocation(program, "u_coverage");
+    gl.useProgram(program);
+    gl.uniform1i(inputFrameLocation, 0);
+    gl.uniform1i(personMaskLocation, 1);
+    gl.uniform1i(blurredInputFrame, 2);
+    function updateParams(params) {
+        gl.useProgram(program);
+        const coverage = params.coverage || [0, 1];
+        gl.uniform2f(coverageLocation, coverage[0], coverage[1]);
+    }
+    updateParams(params);
+    function render() {
+        gl.viewport(0, 0, outputWidth, outputHeight);
+        gl.useProgram(program);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+    function cleanUp() {
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+        gl.deleteShader(vertexShader);
+    }
+    return {
+        render,
+        updateParams,
+        cleanUp,
+    };
+}
+function buildBackgroundBlurStage(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, outputWidth, outputHeight, params) {
+    let blurPass = buildBlurPass(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, outputWidth, outputHeight, params);
+    const blendPass = buildBlendPass(gl, positionBuffer, texCoordBuffer, outputWidth, outputHeight, params);
+    function render() {
+        blurPass.render();
+        blendPass.render();
+    }
+    let currentResampleScale = params.backgroundResampleScale;
+    function updateParams(params) {
+        if (currentResampleScale !== params.backgroundResampleScale) {
+            blurPass.cleanUp();
+            blurPass = buildBlurPass(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, outputWidth, outputHeight, params);
+            currentResampleScale = params.backgroundResampleScale;
+        }
+        blurPass.updateParams(params);
+        blendPass.updateParams(params);
+    }
+    function cleanUp() {
+        blendPass.cleanUp();
+        blurPass.cleanUp();
+    }
+    return {
+        render,
+        updateParams,
+        cleanUp,
+    };
+}
+
+function buildBackgroundImageStage(gl, positionBuffer, texCoordBuffer, personMaskTexture, backgroundImage, outputWidth, outputHeight, params) {
+    const vertexShaderSource = glsl `#version 300 es
+        uniform vec2 u_backgroundScale;
+        uniform vec2 u_backgroundOffset;
+        in vec2 a_position;
+        in vec2 a_texCoord;
+        out vec2 v_texCoord;
+        out vec2 v_backgroundCoord;
+        void main() {
+            // Flipping Y for canvas
+            gl_Position = vec4(a_position * vec2(1.0, -1.0), 0.0, 1.0);
+            v_texCoord = a_texCoord;
+            v_backgroundCoord = a_texCoord * u_backgroundScale + u_backgroundOffset;
+        }`;
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_inputFrame;
+        uniform sampler2D u_personMask;
+        uniform sampler2D u_background;
+        uniform vec2 u_coverage;
+        in vec2 v_texCoord;
+        in vec2 v_backgroundCoord;
+        out vec4 outColor;
+
+        void main() {
+            vec3 frameColor = texture(u_inputFrame, v_texCoord).rgb;
+            vec3 backgroundColor = texture(u_background, v_backgroundCoord).rgb;
+            float personMask = texture(u_personMask, v_texCoord).a;
+            personMask = smoothstep(u_coverage.x, u_coverage.y, personMask);
+            outColor = vec4(frameColor * personMask + backgroundColor * (1.0 - personMask), 1.0);
+        }`;
+    const outputRatio = outputWidth / outputHeight;
+    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const backgroundScaleLocation = gl.getUniformLocation(program, "u_backgroundScale");
+    const backgroundOffsetLocation = gl.getUniformLocation(program, "u_backgroundOffset");
+    const inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+    const personMaskLocation = gl.getUniformLocation(program, "u_personMask");
+    const backgroundLocation = gl.getUniformLocation(program, "u_background");
+    const coverageLocation = gl.getUniformLocation(program, "u_coverage");
+    gl.useProgram(program);
+    gl.uniform2f(backgroundScaleLocation, 1, 1);
+    gl.uniform2f(backgroundOffsetLocation, 0, 0);
+    gl.uniform1i(inputFrameLocation, 0);
+    gl.uniform1i(personMaskLocation, 1);
+    let backgroundTexture = null;
+    function render() {
+        gl.viewport(0, 0, outputWidth, outputHeight);
+        gl.useProgram(program);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, personMaskTexture);
+        if (backgroundTexture !== null) {
+            gl.activeTexture(gl.TEXTURE2);
+            gl.bindTexture(gl.TEXTURE_2D, backgroundTexture);
+            gl.uniform1i(backgroundLocation, 2);
+        }
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+    function initBackgroundImage(backgroundImage) {
+        const sourceWidth = backgroundImage.naturalWidth || backgroundImage.videoWidth || backgroundImage.width;
+        const sourceHeight = backgroundImage.naturalHeight || backgroundImage.videoHeight || backgroundImage.height;
+        backgroundTexture = createTexture(gl, gl.RGBA8, sourceWidth, sourceHeight, gl.LINEAR, gl.LINEAR);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, sourceWidth, sourceHeight, gl.RGBA, gl.UNSIGNED_BYTE, backgroundImage);
+        let xOffset = 0;
+        let yOffset = 0;
+        let backgroundWidth = sourceWidth;
+        let backgroundHeight = sourceHeight;
+        const backgroundRatio = backgroundWidth / backgroundHeight;
+        if (backgroundRatio < outputRatio) {
+            backgroundHeight = backgroundWidth / outputRatio;
+            yOffset = (sourceHeight - backgroundHeight) / 2;
+        }
+        else {
+            backgroundWidth = backgroundHeight * outputRatio;
+            xOffset = (sourceWidth - backgroundWidth) / 2;
+        }
+        const xScale = backgroundWidth / sourceWidth;
+        const yScale = backgroundHeight / sourceHeight;
+        xOffset /= sourceWidth;
+        yOffset /= sourceHeight;
+        gl.uniform2f(backgroundScaleLocation, xScale, yScale);
+        gl.uniform2f(backgroundOffsetLocation, xOffset, yOffset);
+    }
+    function updateBackgroundImage(backgroundImage, reInit) {
+        if (reInit) {
+            backgroundTexture = null;
+        }
+        if (!backgroundImage) {
+            if (backgroundTexture)
+                backgroundTexture = null;
+            return;
+        }
+        if (backgroundTexture) {
+            gl.bindTexture(gl.TEXTURE_2D, backgroundTexture);
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, backgroundImage.naturalWidth || backgroundImage.videoWidth || backgroundImage.width, backgroundImage.naturalHeight || backgroundImage.videoHeight || backgroundImage.height, gl.RGBA, gl.UNSIGNED_BYTE, backgroundImage);
+        }
+        else {
+            initBackgroundImage(backgroundImage);
+        }
+    }
+    function updateParams(params) {
+        gl.useProgram(program);
+        const coverage = params.coverage || [0, 1];
+        gl.uniform2f(coverageLocation, coverage[0], coverage[1]);
+    }
+    updateParams(params);
+    if (backgroundImage)
+        initBackgroundImage(backgroundImage);
+    function cleanUp() {
+        gl.deleteTexture(backgroundTexture);
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+        gl.deleteShader(vertexShader);
+    }
+    return {
+        render,
+        updateParams,
+        cleanUp,
+        updateBackgroundImage,
+    };
+}
+
+function buildImproveMaskStage(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, improvedMaskTexture, outputWidth, outputHeight) {
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_personMask;
+        uniform vec2 u_texelSize;
+        in vec2 v_texCoord;
+        out vec4 outColor;
+        const float offset[3] = float[](0.0, 1.0, 2.0);
+        const float weight[3] = float[](0.38774, 0.24477, 0.06136);
+            void main() {
+            float blurredAlpha = texture(u_personMask, v_texCoord).a * weight[0];
+            for (int i = 1; i < 3; i++) {
+                vec2 offset = vec2(offset[i]) * u_texelSize;
+                vec2 texCoord = v_texCoord + offset;
+                blurredAlpha += texture(u_personMask, texCoord).a * weight[i];
+                texCoord = v_texCoord - offset;
+                blurredAlpha += texture(u_personMask, texCoord).a * weight[i];
+            }
+            outColor = vec4(0,0,0,blurredAlpha);
+        }`;
+    const texelWidth = 1 / outputWidth;
+    const texelHeight = 1 / outputHeight;
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const personMaskLocation = gl.getUniformLocation(program, "u_personMask");
+    const texelSizeLocation = gl.getUniformLocation(program, "u_texelSize");
+    const texture1 = createTexture(gl, gl.RGBA8, outputWidth, outputHeight, gl.NEAREST, gl.NEAREST);
+    const frameBuffer1 = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer1);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture1, 0);
+    const frameBuffer2 = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer2);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, improvedMaskTexture, 0);
+    gl.useProgram(program);
+    gl.uniform1i(personMaskLocation, 1);
+    function render() {
+        gl.viewport(0, 0, outputWidth, outputHeight);
+        gl.useProgram(program);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, personMaskTexture);
+        gl.uniform2f(texelSizeLocation, 0, texelHeight);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer1);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.bindTexture(gl.TEXTURE_2D, texture1);
+        gl.uniform2f(texelSizeLocation, texelWidth, 0);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer2);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+    function cleanUp() {
+        gl.deleteFramebuffer(frameBuffer2);
+        gl.deleteFramebuffer(frameBuffer1);
+        gl.deleteTexture(texture1);
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+    }
+    return { render, cleanUp };
+}
+
+function buildTFLiteOutputToMaskStage(gl, vertexShader, positionBuffer, texCoordBuffer, outputTexture, tflite, outputWidth, outputHeight, outputMemoryOffset) {
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_inputSegmentation;
+
+        in vec2 v_texCoord;
+        out vec4 outColor;
+
+        float getMask(vec2 segmentation) {
+            float shift = max(segmentation.r, segmentation.g);
+            float backgroundExp = exp(segmentation.r - shift);
+            float personExp = exp(segmentation.g - shift);
+            return personExp / (backgroundExp + personExp);
+        }
+
+        void main() {
+            float mask = getMask(texture(u_inputSegmentation, v_texCoord).rg);
+            outColor = vec4(vec3(0.0), mask);
+        }`;
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const inputLocation = gl.getUniformLocation(program, "u_inputSegmentation");
+    const inputTexture = createTexture(gl, gl.RG32F, outputWidth, outputHeight, gl.NEAREST, gl.NEAREST);
+    const frameBuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
+    gl.useProgram(program);
+    gl.uniform1i(inputLocation, 1);
+    function render() {
+        gl.viewport(0, 0, outputWidth, outputHeight);
+        gl.useProgram(program);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, inputTexture);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, outputWidth, outputHeight, gl.RG, gl.FLOAT, tflite.HEAPF32, outputMemoryOffset);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    }
+    function cleanUp() {
+        gl.deleteFramebuffer(frameBuffer);
+        gl.deleteTexture(inputTexture);
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+    }
+    return { render, cleanUp };
+}
+
+function buildTFLiteInputStage(gl, vertexShader, positionBuffer, texCoordBuffer, tflite, inputWidth, inputHeight, segmentationPixelCount, inputMemoryOffset) {
+    const fragmentShaderSource = glsl `#version 300 es
+        precision highp float;
+        uniform sampler2D u_inputFrame;
+        uniform sampler2D u_floatlut;
+        in vec2 v_texCoord;
+        uniform float u_pixelSize;
+        out vec4 outColor;
+
+        void main() {
+            float x = v_texCoord.x;
+            vec4 color = texture(u_inputFrame, v_texCoord);
+            float r = mod(x * u_pixelSize, 3.0);
+            float c = 0.0;
+            if (r >= 2.0 ) c = color.b;
+            else if (r >= 1.0) c = color.g;
+            else c = color.r;
+            outColor = texture(u_floatlut, vec2(c, 0.5));
+        }`;
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+    const program = createPiplelineStageProgram(gl, vertexShader, fragmentShader, positionBuffer, texCoordBuffer);
+    const inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+    const pixelSizeLocation = gl.getUniformLocation(program, "u_pixelSize");
+    const floatlutLocation = gl.getUniformLocation(program, "u_floatlut");
+    const outputTexture = createTexture(gl, gl.RGBA8, inputWidth * 3, inputHeight);
+    const frameBuffer = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outputTexture, 0);
+    const outputPixels = new Uint8Array(tflite.HEAPF32.buffer, inputMemoryOffset * 4, segmentationPixelCount * 4 * 3);
+    gl.useProgram(program);
+    gl.uniform1i(inputFrameLocation, 0);
+    gl.uniform1f(pixelSizeLocation, inputWidth * 3);
+    gl.uniform1i(floatlutLocation, 3);
+    const floatLutTexture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, floatLutTexture);
+    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);
+    const lut = new Float32Array(256);
+    for (let i = 0; i < 256; i++)
+        lut[i] = i / 256;
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 256, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(lut.buffer, 0, 256 * 4));
+    function render() {
+        gl.viewport(0, 0, inputWidth * 3, inputHeight);
+        gl.useProgram(program);
+        gl.activeTexture(gl.TEXTURE3);
+        gl.bindTexture(gl.TEXTURE_2D, floatLutTexture);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+        gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+        gl.readPixels(0, 0, inputWidth * 3, inputHeight, gl.RGBA, gl.UNSIGNED_BYTE, outputPixels);
+    }
+    function cleanUp() {
+        gl.deleteFramebuffer(frameBuffer);
+        gl.deleteTexture(outputTexture);
+        gl.deleteTexture(floatLutTexture);
+        gl.deleteProgram(program);
+        gl.deleteShader(fragmentShader);
+    }
+    return { render, cleanUp };
+}
+
+function getBlurEngineParams(params) {
+    switch (params.amount) {
+        case "slight": {
+            return Object.assign({ kernel: "og5", numPasses: 1, backgroundResampleScale: 1 }, params);
+        }
+        case "heavy": {
+            return Object.assign({ kernel: "og10", numPasses: 1, backgroundResampleScale: 0.5 }, params);
+        }
+        default: {
+            return Object.assign({ kernel: "og5", numPasses: 1, backgroundResampleScale: 0.5 }, params);
+        }
+    }
+}
+function getEngineParams(params) {
+    const baseEngineParams = {
+        coverage: params.coverage,
+    };
+    if (params.backgroundBlur) {
+        return Object.assign({ baseEngineParams }, getBlurEngineParams(params.backgroundBlur));
+    }
+    return baseEngineParams;
+}
+function createWebGLEngine(videoWidth, videoHeight, setup, effectCanvas, params, initialBackgroundFrame) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { tflite, inputHeight, inputWidth, inputMemoryOffset, outputMemoryOffset, segmentationPixelCount } = yield loadSegmentationModel(setup.segmentationModelId);
+        let engineParams = getEngineParams(params);
+        const vertexShaderSource = glsl `#version 300 es
+        in vec2 a_position;
+        in vec2 a_texCoord;
+        out vec2 v_texCoord;
+        void main() {
+            gl_Position = vec4(a_position, 0.0, 1.0);
+            v_texCoord = a_texCoord;
+        }`;
+        const gl = effectCanvas.getContext("webgl2", setup.webglContextSettings);
+        const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+        const vertexArray = gl.createVertexArray();
+        gl.bindVertexArray(vertexArray);
+        const positionBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1.0, -1, -1, 1.0, 1.0, 1.0]), gl.STATIC_DRAW);
+        const texCoordBuffer = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]), gl.STATIC_DRAW);
+        const inputFrameTexture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, inputFrameTexture);
+        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);
+        const maskTexture = createTexture(gl, gl.RGBA8, inputWidth, inputHeight);
+        const improvedMaskWidth = inputWidth;
+        const improvedMaskHeight = inputHeight;
+        const improvedMaskTexture = createTexture(gl, gl.RGBA8, improvedMaskWidth, improvedMaskHeight, gl.LINEAR, gl.LINEAR);
+        const tfliteInputStage = buildTFLiteInputStage(gl, vertexShader, positionBuffer, texCoordBuffer, tflite, inputWidth, inputHeight, segmentationPixelCount, inputMemoryOffset);
+        const tfliteOutputToMaskStage = buildTFLiteOutputToMaskStage(gl, vertexShader, positionBuffer, texCoordBuffer, maskTexture, tflite, inputWidth, inputHeight, outputMemoryOffset);
+        const improveMaskStage = buildImproveMaskStage(gl, vertexShader, positionBuffer, texCoordBuffer, maskTexture, improvedMaskTexture, improvedMaskWidth, improvedMaskHeight);
+        const backgroundBlurStage = buildBackgroundBlurStage(gl, vertexShader, positionBuffer, texCoordBuffer, improvedMaskTexture, videoWidth, videoHeight, engineParams);
+        const backgroundImageStage = buildBackgroundImageStage(gl, positionBuffer, texCoordBuffer, improvedMaskTexture, initialBackgroundFrame, videoWidth, videoHeight, engineParams);
+        return {
+            effectCtx: gl,
+            updateBackgroundFrame(frame, _, reInit) {
+                backgroundImageStage.updateBackgroundImage(frame, reInit);
+            },
+            updateParams(updatedParams) {
+                params = updatedParams;
+                engineParams = getEngineParams(params);
+                backgroundBlurStage.updateParams(engineParams);
+                backgroundImageStage.updateParams(engineParams);
+            },
+            processFrame(frame) {
+                gl.clearColor(0, 0, 0, 0);
+                gl.clear(gl.COLOR_BUFFER_BIT);
+                gl.activeTexture(gl.TEXTURE0);
+                gl.bindTexture(gl.TEXTURE_2D, inputFrameTexture);
+                gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, frame);
+                gl.bindVertexArray(vertexArray);
+                tfliteInputStage.render();
+                tflite._runInference();
+                tfliteOutputToMaskStage.render();
+                improveMaskStage.render();
+                params.backgroundUrl ? backgroundImageStage.render() : backgroundBlurStage.render();
+            },
+            dispose() {
+                backgroundImageStage.cleanUp();
+                backgroundBlurStage.cleanUp();
+                improveMaskStage.cleanUp();
+                tfliteOutputToMaskStage.cleanUp();
+                tfliteInputStage.cleanUp();
+                gl.deleteTexture(improvedMaskTexture);
+                gl.deleteTexture(maskTexture);
+                gl.deleteTexture(inputFrameTexture);
+                gl.deleteBuffer(texCoordBuffer);
+                gl.deleteBuffer(positionBuffer);
+                gl.deleteVertexArray(vertexArray);
+                gl.deleteShader(vertexShader);
+            },
+        };
+    });
+}
+
+class Processor extends events.EventEmitter {
+    constructor({ setup, params, videoWidth, videoHeight, emit }) {
+        super();
+        this.setup = setup;
+        this.params = params;
+        this.videoWidth = videoWidth;
+        this.videoHeight = videoHeight;
+        if (emit)
+            this.emit = emit;
+    }
+    setupEngine(videoWidth, videoHeight, effectCanvas, initialBackgroundFrame) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.videoWidth = videoWidth;
+            this.videoHeight = videoHeight;
+            this.videoAspectRatio = this.videoWidth / this.videoHeight;
+            this.effectCanvas = effectCanvas || createCanvas(this.videoWidth, this.videoHeight);
+            const createEngine = this.setup.useWebGL ? createWebGLEngine : createCanvasEngine;
+            this.engine = yield createEngine(this.videoWidth, this.videoHeight, this.setup, this.effectCanvas, this.params, initialBackgroundFrame);
+            this.effectCtx = this.engine.effectCtx;
+            if (initialBackgroundFrame) {
+                this.updateBackgroundFrame({ frame: initialBackgroundFrame });
+            }
+        });
+    }
+    updateVideoSize(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ videoWidth, videoHeight }) {
+            const oldBackgroundFrame = this.currentBackgroundFrame;
+            this.currentBackgroundFrame = null;
+            const oldEngine = this.engine;
+            yield this.setupEngine(videoWidth, videoHeight, this.effectCanvas, oldBackgroundFrame);
+            oldEngine.dispose();
+        });
+    }
+    init(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ initialBackgroundFrame, useInsertableStreams, effectCanvas }) {
+            yield this.setupEngine(this.videoWidth, this.videoHeight, effectCanvas, initialBackgroundFrame);
+            if (useInsertableStreams) {
+                let dropFirst = 5;
+                let localStartTime = 0;
+                let frameStartTime = 0;
+                let firstFrameRendered = false;
+                this.transformer = new TransformStream({
+                    transform: (frame, controller) => __awaiter(this, void 0, void 0, function* () {
+                        this.transformController = controller;
+                        const frameTimestamp = frame.timestamp;
+                        const now = performance.now();
+                        if (!localStartTime) {
+                            localStartTime = now;
+                            frameStartTime = frameTimestamp / 1000;
+                        }
+                        const elapsedFrameTime = frameTimestamp / 1000 - frameStartTime;
+                        const elapsedLocalTime = now - localStartTime;
+                        if (dropFirst > 0 || elapsedLocalTime < elapsedFrameTime + 200) {
+                            this.processAndRenderFrame(frame);
+                            frame.close();
+                            if (this.hasVideoBackground && this.setup.transferType !== "canvas") {
+                                this.emit("getbackgroundframe");
+                            }
+                        }
+                        else {
+                            frame.close();
+                            return;
+                        }
+                        if (dropFirst > 0) {
+                            dropFirst--;
+                            localStartTime = now;
+                            frameStartTime = frameTimestamp / 1000;
+                        }
+                        controller.enqueue(new VideoFrame(this.effectCanvas, { timestamp: frameTimestamp }));
+                        if (!firstFrameRendered) {
+                            firstFrameRendered = true;
+                            this.emit("firstframerendered");
+                        }
+                    }),
+                });
+            }
+            else if (!this.setup.useBackgroundWorker) {
+                const timerWorkerUrl = new URL("./workers/timer.worker.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+                this.timerWorker = new Worker(timerWorkerUrl);
+                this.timerWorker.addEventListener("message", () => {
+                    this.emit("output", { frame: this.currentOutputFrame }, [this.currentOutputFrame]);
+                });
+            }
+            this.emit("ready");
+        });
+    }
+    updateParams({ params, initialBackgroundFrame }) {
+        this.params = params;
+        this.currentBackgroundFrame = null;
+        this.currentBackgroundFrameCtx = null;
+        if (initialBackgroundFrame) {
+            this.updateBackgroundFrame({ frame: initialBackgroundFrame, reInit: true });
+        }
+        else {
+            this.engine.updateBackgroundFrame(null);
+        }
+        this.engine.updateParams(params);
+    }
+    updateBackgroundFrame({ frame, reInit }) {
+        let updatedDimensions;
+        if (!this.currentBackgroundFrame) {
+            this.hasVideoBackground = this.params.backgroundUrl && this.params.backgroundType === "video";
+            updatedDimensions = { x: 0, y: 0, width: this.videoWidth, height: this.videoHeight };
+        }
+        switch (this.setup.transferType) {
+            case "imagebitmap": {
+                this.currentBackgroundFrame = frame;
+                break;
+            }
+            case "imagedata": {
+                if (!this.currentBackgroundFrame) {
+                    this.currentBackgroundFrame = createCanvas(this.videoWidth, this.videoHeight);
+                    this.currentBackgroundFrameCtx = this.currentBackgroundFrame.getContext("2d");
+                }
+                frame = new ImageData(new Uint8ClampedArray(frame), this.videoWidth, this.videoHeight);
+                this.currentBackgroundFrameCtx.putImageData(frame, 0, 0);
+                break;
+            }
+            case "canvas": {
+                if (!this.currentBackgroundFrame) {
+                    updatedDimensions.width = frame.videoWidth || frame.naturalWidth || frame.width;
+                    updatedDimensions.height = frame.videoHeight || frame.naturalHeight || frame.height;
+                    const backgroundAspectRatio = updatedDimensions.width / updatedDimensions.height;
+                    if (backgroundAspectRatio > this.videoAspectRatio) {
+                        const outsideX = updatedDimensions.width - updatedDimensions.height * this.videoAspectRatio;
+                        updatedDimensions.width -= outsideX;
+                        updatedDimensions.x = Math.floor(outsideX / 2);
+                    }
+                    else if (backgroundAspectRatio < this.videoAspectRatio) {
+                        const outsideY = updatedDimensions.height - updatedDimensions.width / this.videoAspectRatio;
+                        updatedDimensions.height -= outsideY;
+                        updatedDimensions.y = Math.floor(outsideY / 2);
+                    }
+                }
+                this.currentBackgroundFrame = frame;
+                break;
+            }
+        }
+        this.engine.updateBackgroundFrame(this.currentBackgroundFrame, updatedDimensions, reInit);
+    }
+    terminate() {
+        if (this.transformController)
+            this.transformController.terminate();
+        if (this.timerWorker)
+            this.timerWorker.terminate();
+        if (this.engine) {
+            this.engine.dispose();
+            this.engine = null;
+        }
+        this._terminated = true;
+        this.emit("terminated");
+    }
+    start({ inputStream, outputStream }) {
+        if (inputStream)
+            inputStream.pipeThrough(this.transformer).pipeTo(outputStream);
+        this.frameCounter = 0;
+        this.frameCounterTime = performance.now();
+    }
+    input(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ videoFrame, backgroundFrame, requestTime, lastRenderTime, delay }) {
+            var _b;
+            if (this._terminated)
+                return;
+            const rtt = (Date.now() - requestTime) * 2;
+            const returnTime = lastRenderTime + delay - rtt;
+            if (backgroundFrame)
+                this.updateBackgroundFrame({ frame: backgroundFrame });
+            let frame;
+            switch (this.setup.transferType) {
+                case "imagebitmap": {
+                    (_b = this.prevVideoFrame) === null || _b === void 0 ? void 0 : _b.close();
+                    this.prevVideoFrame = videoFrame;
+                    this.processAndRenderFrame(videoFrame);
+                    frame = yield createImageBitmap(this.effectCanvas);
+                    break;
+                }
+                case "imagedata": {
+                    videoFrame = new ImageData(new Uint8ClampedArray(videoFrame), this.videoWidth, this.videoHeight);
+                    if (!this.inputCanvas) {
+                        this.inputCanvas = createCanvas(this.videoWidth, this.videoHeight);
+                        this.inputCanvasCtx = this.inputCanvas.getContext("2d");
+                    }
+                    this.inputCanvasCtx.putImageData(videoFrame, 0, 0);
+                    this.processAndRenderFrame(this.inputCanvas);
+                    frame = this.effectCtx.getImageData(0, 0, this.videoWidth, this.videoHeight).data.buffer;
+                    break;
+                }
+                case "canvas": {
+                    this.processAndRenderFrame(videoFrame);
+                    frame = this.effectCanvas;
+                }
+            }
+            const returnDelay = Math.max(0, returnTime - Date.now());
+            if (this.timerWorker) {
+                this.currentOutputFrame = frame;
+                this.timerWorker.postMessage(returnDelay);
+            }
+            else {
+                setTimeout(() => {
+                    this.emit("output", { frame }, [frame]);
+                }, returnDelay);
+            }
+        });
+    }
+    processAndRenderFrame(frame) {
+        this.engine.processFrame(frame);
+        if (this.setup.logToConsole) {
+            this.frameCounter++;
+            const now = performance.now();
+            if (now - this.frameCounterTime > 1000) {
+                console.log(`Running camera effects, ${Math.round((this.frameCounter * 1000) / (now - this.frameCounterTime))} fps`);
+                this.frameCounter = 0;
+                this.frameCounterTime = now;
+            }
+        }
+    }
+}
+
+let nextProcessorId = 0;
+class ProcessorProxy extends events.EventEmitter {
+    constructor(worker, config) {
+        super();
+        const processorId = nextProcessorId++;
+        const proxyMethod = (name, getTransferable) => {
+            this[name] = (args) => {
+                worker.postMessage(Object.assign({ type: name, processorId }, args), getTransferable && getTransferable(args).filter((e) => e));
+            };
+        };
+        proxyMethod("init", (args) => [args.initialBackgroundFrame]);
+        proxyMethod("start", (args) => [args.inputStream, args.outputStream]);
+        proxyMethod("input", (args) => [args.videoFrame, args.backgroundFrame]);
+        proxyMethod("updateBackgroundFrame", (args) => [args.frame]);
+        proxyMethod("updateParams", (args) => [args.initialBackgroundFrame]);
+        proxyMethod("updateVideoSize");
+        proxyMethod("terminate");
+        const onMessage = (request) => __awaiter(this, void 0, void 0, function* () {
+            if (request.data.processorId !== processorId)
+                return;
+            const _a = request.data, { type } = _a, data = __rest(_a, ["type"]);
+            this.emit(type, data);
+            if (type === "terminated") {
+                worker.removeEventListener("message", onMessage);
+            }
+        });
+        worker.postMessage(Object.assign({ type: "create", processorId }, config));
+        worker.addEventListener("message", onMessage);
+    }
+}
+
+let sharedWorker;
+function createProcessor(useBackgroundWorker, config) {
+    if (!useBackgroundWorker)
+        return new Processor(config);
+    if (!sharedWorker) {
+        const workerUrl = new URL("./workers/ProcessorProxy.worker.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+        sharedWorker = new Worker(workerUrl);
+    }
+    return new ProcessorProxy(sharedWorker, config);
+}
+
+const grayImage = new Image(1, 1);
+grayImage.src = "data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==";
+function _createImageBitmap(source, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield createImageBitmap(source, options);
+        }
+        catch (_a) {
+            return yield createImageBitmap(grayImage, options);
+        }
+    });
+}
+const createEffectStream$1 = (inputStream, setup, params) => __awaiter(void 0, void 0, void 0, function* () {
+    yield fixBackgroundUrlPromise(params);
+    const cleanup = [];
+    const inputVideoTrack = inputStream.getVideoTracks()[0];
+    const inputAudioTrack = inputStream.getAudioTracks()[0];
+    let { width: videoWidth, height: videoHeight } = inputVideoTrack.getSettings();
+    const processor = createProcessor(setup.useBackgroundWorker, {
+        setup,
+        params,
+        videoWidth,
+        videoHeight,
+    });
+    let keepAliveVideoBackground;
+    const updateBackgroundProvider = (params) => __awaiter(void 0, void 0, void 0, function* () {
+        const backgroundElement = yield createBackgroundElement(params.backgroundUrl, params.backgroundType);
+        keepAliveVideoBackground =
+            backgroundElement &&
+                backgroundElement.play &&
+                (() => {
+                    if (backgroundElement.paused)
+                        backgroundElement.play();
+                });
+        return createBackgroundProvider(backgroundElement, videoWidth, videoHeight, setup.transferType);
+    });
+    let getBackgroundFrame = yield updateBackgroundProvider(params);
+    let firstFrameRenderedResolve = null;
+    const firstFrameRendered = new Promise((resolve) => (firstFrameRenderedResolve = resolve));
+    let resultCanvas;
+    let outputTrack;
+    if (setup.useInsertableStreams) {
+        const trackProcessor = new window.MediaStreamTrackProcessor({ track: inputVideoTrack, maxBufferSize: 2 });
+        const trackGenerator = new window.MediaStreamTrackGenerator({ kind: "video", signalTarget: inputVideoTrack });
+        outputTrack = trackGenerator;
+        processor.on("ready", () => {
+            processor.start({
+                inputStream: trackProcessor === null || trackProcessor === void 0 ? void 0 : trackProcessor.readable,
+                outputStream: trackGenerator === null || trackGenerator === void 0 ? void 0 : trackGenerator.writable,
+            });
+        });
+        processor.on("firstframerendered", () => firstFrameRenderedResolve());
+        processor.on("getbackgroundframe", () => __awaiter(void 0, void 0, void 0, function* () {
+            if (!keepAliveVideoBackground)
+                return;
+            keepAliveVideoBackground();
+            processor.updateBackgroundFrame({ frame: yield getBackgroundFrame() });
+        }));
+    }
+    else {
+        const videoElement = document.createElement("video");
+        const onResizeInputStream = () => __awaiter(void 0, void 0, void 0, function* () {
+            const { width, height } = inputVideoTrack.getSettings();
+            if (videoWidth === width && videoHeight === height)
+                return;
+            videoWidth = width;
+            videoHeight = height;
+            if (typeof resultCanvas === "object") {
+                resultCanvas.width = videoWidth;
+                resultCanvas.height = videoHeight;
+            }
+            yield processor.updateVideoSize({ videoWidth, videoHeight });
+            yield updateBackgroundProvider(params);
+        });
+        videoElement.addEventListener("resize", onResizeInputStream);
+        cleanup.push(() => {
+            videoElement.removeEventListener("resize", onResizeInputStream);
+        });
+        if (setup.keepVideoElementInDom) {
+            videoElement.playsInline = true;
+            videoElement.style.position = "absolute";
+            videoElement.style.top = "0px";
+            videoElement.style.left = "0px";
+            videoElement.style.width = "1px";
+            videoElement.style.opacity = 0;
+            document.body.appendChild(videoElement);
+            cleanup.push(() => {
+                try {
+                    document.body.removeChild(videoElement);
+                }
+                catch (_a) {
+                    console.warn("video element already removed from DOM");
+                }
+                videoElement.srcObject = null;
+            });
+        }
+        yield new Promise((resolve) => {
+            videoElement.addEventListener("loadedmetadata", resolve);
+            videoElement.srcObject = new MediaStream([inputVideoTrack]);
+            videoElement.play();
+        });
+        const onVisibilityChange = () => {
+            if (document.visibilityState !== "visible") {
+                videoElement.play();
+            }
+        };
+        document.addEventListener("visibilitychange", onVisibilityChange);
+        cleanup.push(() => {
+            document.removeEventListener("visibilitychange", onVisibilityChange);
+        });
+        resultCanvas = createCanvas(videoWidth, videoHeight);
+        let resultCanvasCtx;
+        let getInputFrame;
+        let renderOutputFrame;
+        if (setup.transferType === "imagebitmap") {
+            resultCanvasCtx = resultCanvas.getContext("bitmaprenderer");
+            getInputFrame = () => _createImageBitmap(videoElement);
+            renderOutputFrame = (frame) => {
+                resultCanvasCtx.transferFromImageBitmap(frame);
+                frame.close();
+            };
+        }
+        else if (setup.transferType === "imagedata") {
+            resultCanvasCtx = resultCanvas.getContext("2d");
+            const videoCanvas = createCanvas(videoWidth, videoHeight);
+            const videoCanvasCtx = videoCanvas.getContext("2d");
+            getInputFrame = () => {
+                videoCanvasCtx.drawImage(videoElement, 0, 0);
+                return videoCanvasCtx.getImageData(0, 0, videoWidth, videoHeight).data.buffer;
+            };
+            renderOutputFrame = (frame) => {
+                frame = new ImageData(new Uint8ClampedArray(frame), videoWidth, videoHeight);
+                resultCanvasCtx.putImageData(frame, 0, 0);
+            };
+        }
+        else if (setup.transferType === "canvas") {
+            resultCanvasCtx = resultCanvas.getContext(setup.useWebGL ? "webgl2" : "2d", setup.useWebGL ? setup.webglContextSettings : undefined);
+            getInputFrame = () => videoElement;
+            if (setup.useWebGL && setup.canvasMemoryLeakWorkaround)
+                getInputFrame = () => _createImageBitmap(videoElement);
+            renderOutputFrame = () => {
+            };
+        }
+        outputTrack = resultCanvas.captureStream().getVideoTracks()[0];
+        let lastRenderTime = Date.now();
+        const onInputFrame = () => __awaiter(void 0, void 0, void 0, function* () {
+            keepAliveVideoBackground === null || keepAliveVideoBackground === void 0 ? void 0 : keepAliveVideoBackground();
+            const [videoFrame, backgroundFrame] = yield Promise.all([
+                getInputFrame(),
+                keepAliveVideoBackground && getBackgroundFrame(),
+            ]);
+            processor.input({
+                videoFrame,
+                backgroundFrame,
+                lastRenderTime,
+                requestTime: Date.now(),
+                delay: setup.framerate ? 1000 / setup.framerate : 0,
+            });
+        });
+        const requestInputFrame = () => {
+            onInputFrame();
+        };
+        processor.on("ready", () => {
+            requestInputFrame();
+            processor.start({});
+        });
+        processor.on("output", ({ frame }) => {
+            lastRenderTime = Date.now();
+            renderOutputFrame(frame);
+            requestInputFrame();
+            if (firstFrameRenderedResolve) {
+                firstFrameRenderedResolve();
+                firstFrameRenderedResolve = null;
+            }
+        });
+    }
+    processor.on("terminated", () => {
+        cleanup.forEach((t) => t());
+    });
+    processor.init({
+        useInsertableStreams: setup.useInsertableStreams,
+        initialBackgroundFrame: yield getBackgroundFrame(),
+        effectCanvas: setup.transferType === "canvas" ? resultCanvas : undefined,
+    });
+    const stop = () => {
+        processor.terminate();
+    };
+    const updateParams = (params) => __awaiter(void 0, void 0, void 0, function* () {
+        yield fixBackgroundUrlPromise(params);
+        getBackgroundFrame = yield updateBackgroundProvider(params);
+        processor.updateParams({
+            params,
+            initialBackgroundFrame: yield getBackgroundFrame(),
+        });
+        return true;
+    });
+    yield firstFrameRendered;
+    Object.defineProperty(outputTrack, "label", {
+        get: () => inputVideoTrack.label,
+    });
+    Object.defineProperty(outputTrack, "readyState", {
+        get: () => inputVideoTrack.readyState,
+    });
+    Object.defineProperty(outputTrack, "enabled", {
+        get: () => inputVideoTrack.enabled,
+        set: (value) => {
+            inputVideoTrack.enabled = value;
+        },
+    });
+    Object.defineProperty(outputTrack, "getSettings", {
+        get: () => () => inputVideoTrack.getSettings(),
+    });
+    const outputStream = new MediaStream([outputTrack, inputAudioTrack].filter((e) => e));
+    return { stream: outputStream, stop, updateParams };
+});
+
+var tfliteSegmentCanvasEffectsModule = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createEffectStream: createEffectStream$1
+});
+
+const canUseWebGL = (function () {
+    const canvas = document.createElement("canvas");
+    return !!canvas.getContext("webgl2");
+})();
+const pipelines = {
+    tfliteSegmentCanvasEffects: {
+        module: tfliteSegmentCanvasEffectsModule,
+        getDefaultSetup: () => {
+            const shared = {
+                useWebGL: canUseWebGL,
+                segmentationModelId: "meetlite",
+                logToConsole: false,
+                framerate: 30,
+                useInsertableStreams: false,
+                canvasMemoryLeakWorkaround: true,
+                transferType: "canvas",
+                useBackgroundWorker: false,
+            };
+            if (adapter.browserDetails.browser === "chrome") {
+                return Object.assign(Object.assign({}, shared), { useWebGL: false });
+            }
+            if (adapter.browserDetails.browser === "firefox") {
+                return Object.assign(Object.assign({}, shared), { transferType: canUseWebGL ? "imagebitmap" : "canvas" });
+            }
+            if (adapter.browserDetails.browser === "safari") {
+                return Object.assign(Object.assign({}, shared), { canvasMemoryLeakWorkaround: false, keepVideoElementInDom: true });
+            }
+            return Object.assign({}, shared);
+        },
+        canUse: (options = {}) => {
+            var _a, _b, _c;
+            return (adapter.browserDetails.browser === "safari" && canUseWebGL && options.allowSafari) ||
+                (adapter.browserDetails.browser === "chrome" && ((_a = adapter.browserDetails.version) !== null && _a !== void 0 ? _a : 0) >= 90) ||
+                (adapter.browserDetails.browser === "firefox" && ((_c = (_b = adapter.browserDetails) === null || _b === void 0 ? void 0 : _b.version) !== null && _c !== void 0 ? _c : 0) >= 89);
+        },
+    },
+};
+const presets = [
+    {
+        id: "slight-blur",
+        pipelineConfigs: {
+            tfliteSegmentCanvasEffects: {
+                params: { backgroundBlur: { amount: "slight" } },
+            },
+        },
+    },
+    {
+        id: "blur",
+        pipelineConfigs: {
+            tfliteSegmentCanvasEffects: {
+                params: { backgroundBlur: { amount: "normal" } },
+            },
+        },
+    },
+    {
+        id: "heavy-blur",
+        pipelineConfigs: {
+            tfliteSegmentCanvasEffects: {
+                params: { backgroundBlur: { amount: "heavy" } },
+            },
+        },
+    },
+];
+presets.push(...[
+    { id: "cabin", backgroundUrl: Promise.resolve().then(function () { return cabin720p$1; }) },
+    { id: "concrete", backgroundUrl: Promise.resolve().then(function () { return concrete720p$1; }) },
+    { id: "brick", backgroundUrl: Promise.resolve().then(function () { return brick720p$1; }) },
+    { id: "sunrise", backgroundUrl: Promise.resolve().then(function () { return sunrise720p$1; }) },
+    { id: "day", backgroundUrl: Promise.resolve().then(function () { return day720p$1; }) },
+    { id: "night", backgroundUrl: Promise.resolve().then(function () { return night720p$1; }) },
+    { id: "clay", backgroundUrl: Promise.resolve().then(function () { return clay$1; }) },
+    { id: "focus", backgroundUrl: Promise.resolve().then(function () { return focus$1; }) },
+    { id: "glow", backgroundUrl: Promise.resolve().then(function () { return glow$1; }) },
+    { id: "haven", backgroundUrl: Promise.resolve().then(function () { return haven$1; }) },
+    { id: "pulse", backgroundUrl: Promise.resolve().then(function () { return pulse$1; }) },
+    { id: "studio", backgroundUrl: Promise.resolve().then(function () { return studio$1; }) },
+    { id: "custom" },
+].map(({ id, backgroundUrl }) => ({
+    id: `image-${id}`,
+    pipelineConfigs: {
+        tfliteSegmentCanvasEffects: {
+            params: {
+                backgroundUrl,
+            },
+        },
+    },
+})));
+presets.push(...[Promise.resolve().then(function () { return neon$1; }), Promise.resolve().then(function () { return bubbles$1; })].map((urlModule, index) => ({
+    id: `video-${index + 1}`,
+    pipelineConfigs: {
+        tfliteSegmentCanvasEffects: {
+            params: {
+                backgroundType: "video",
+                backgroundUrl: urlModule,
+            },
+        },
+    },
+})));
+const getPresetAndMergedParams = (presetId, setup, params) => {
+    var _a, _b, _c;
+    const preset = presets.find((p) => p.id === presetId);
+    if (!preset)
+        return;
+    let pipelineId = Object.keys((_a = preset.pipelineConfigs) !== null && _a !== void 0 ? _a : []).find((pipelineId) => pipelines[pipelineId].canUse());
+    if (!pipelineId)
+        pipelineId = Object.keys((_b = preset.pipelineConfigs) !== null && _b !== void 0 ? _b : [])[0];
+    if (!pipelineId)
+        return;
+    const pipelineConfig = (_c = preset.pipelineConfigs) === null || _c === void 0 ? void 0 : _c[pipelineId];
+    const pipeline = pipelines[pipelineId];
+    const mergedSetup = Object.assign(Object.assign(Object.assign({}, pipeline.getDefaultSetup()), pipelineConfig === null || pipelineConfig === void 0 ? void 0 : pipelineConfig.setup), setup);
+    mergedSetup.useWebGL = mergedSetup.useWebGL && canUseWebGL;
+    const mergedParams = Object.assign(Object.assign({}, pipelineConfig === null || pipelineConfig === void 0 ? void 0 : pipelineConfig.params), params);
+    return { pipeline, mergedSetup, mergedParams };
+};
+const safariKeepAliveVideoSrcObjectHack = () => {
+    let stop = false;
+    const keepAlive = () => requestAnimationFrame(() => {
+        if (!stop)
+            keepAlive();
+    });
+    keepAlive();
+    return () => (stop = true);
+};
+const createEffectStream = (inputStream, presetId, setup, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { pipeline, mergedSetup, mergedParams } = getPresetAndMergedParams(presetId, setup, params);
+    if (mergedSetup.logToConsole) {
+        console.log(`Setting effect preset ${presetId}`, { setup: mergedSetup, params: mergedParams });
+    }
+    const { stream, stop: stopEffectStream, updateParams, } = yield pipeline.module.createEffectStream(inputStream, mergedSetup, mergedParams);
+    const tryUpdate = (updatedPresetId, updatedSetup, updatedParams) => __awaiter(void 0, void 0, void 0, function* () {
+        const { pipeline: updatedPipeline, mergedSetup: updatedMergedSetup, mergedParams: updatedMergedParams, } = getPresetAndMergedParams(updatedPresetId, updatedSetup, updatedParams);
+        if (!updateParams ||
+            updatedPipeline !== pipeline ||
+            JSON.stringify(updatedMergedSetup) !== JSON.stringify(mergedSetup)) {
+            if (mergedSetup.logToConsole) {
+                console.log("Cannot update effect, needs to create new pipeline");
+            }
+            return false;
+        }
+        if (mergedSetup.logToConsole) {
+            console.log(`Updating to effect preset ${updatedPresetId}`, { params: updatedMergedParams });
+        }
+        return yield updateParams(updatedMergedParams);
+    });
+    const stopSafariHack = adapter.browserDetails.browser === "safari" ? safariKeepAliveVideoSrcObjectHack() : () => undefined;
+    const stop = () => {
+        if (mergedSetup.logToConsole) {
+            console.log("Stopping effects");
+        }
+        stopSafariHack();
+        stopEffectStream();
+    };
+    return { stream, stop, tryUpdate };
+});
+const getUsablePresets = (filter = (pipeline, options) => pipeline.canUse(options), options) => presets
+    .filter((preset) => {
+    var _a;
+    return Object.keys((_a = preset.pipelineConfigs) !== null && _a !== void 0 ? _a : []).find((pipelineId) => filter(pipelines[pipelineId], options));
+})
+    .map((preset) => preset.id);
+const getPresets = (options) => {
+    const kindOf = (id) => (id.startsWith("image-") ? "image" : id.startsWith("video-") ? "video" : "blur");
+    return presets.map((preset) => {
+        var _a;
+        const supported = !!Object.keys((_a = preset.pipelineConfigs) !== null && _a !== void 0 ? _a : []).find((pipelineId) => pipelines[pipelineId].canUse((options !== null && options !== void 0 ? options : {})));
+        return { id: preset.id, kind: kindOf(preset.id), supported };
+    });
+};
+const warmup = (presetId_1, ...args_1) => __awaiter(void 0, [presetId_1, ...args_1], void 0, function* (presetId, setup = () => ({}), params = {}) {
+    var _a;
+    const chosenPresetId = presetId || getUsablePresets((p) => p.canUse({}), {}).at(0) || ((_a = presets.at(0)) === null || _a === void 0 ? void 0 : _a.id);
+    if (!chosenPresetId)
+        return;
+    const merged = getPresetAndMergedParams(chosenPresetId, setup, params);
+    if (!merged)
+        return;
+    const { mergedSetup, mergedParams } = merged;
+    yield loadSegmentationModel(mergedSetup.segmentationModelId);
+    if (mergedParams === null || mergedParams === void 0 ? void 0 : mergedParams.backgroundUrl) {
+        yield fixBackgroundUrlPromise(mergedParams);
+        try {
+            yield createBackgroundElement(mergedParams.backgroundUrl, mergedParams.backgroundType);
+        }
+        catch (_b) {
+        }
+    }
+});
+const setDefaultSetup = (pipelineId, setup) => {
+    const oldSetup = pipelines[pipelineId].getDefaultSetup();
+    const newSetup = Object.assign(Object.assign({}, oldSetup), setup);
+    pipelines[pipelineId].getDefaultSetup = () => newSetup;
+};
+
+var cabin720p = "./assets/backgrounds/cabin-720p.jpg";
+
+var cabin720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: cabin720p
+});
+
+var concrete720p = "./assets/backgrounds/concrete-720p.jpg";
+
+var concrete720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: concrete720p
+});
+
+var brick720p = "./assets/backgrounds/brick-720p.jpg";
+
+var brick720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: brick720p
+});
+
+var sunrise720p = "./assets/backgrounds/sunrise-720p.png";
+
+var sunrise720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: sunrise720p
+});
+
+var day720p = "./assets/backgrounds/day-720p.png";
+
+var day720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: day720p
+});
+
+var night720p = "./assets/backgrounds/night-720p.png";
+
+var night720p$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: night720p
+});
+
+var clay = "./assets/backgrounds/clay.png";
+
+var clay$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: clay
+});
+
+var focus = "./assets/backgrounds/focus.png";
+
+var focus$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: focus
+});
+
+var glow = "./assets/backgrounds/glow.png";
+
+var glow$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: glow
+});
+
+var haven = "./assets/backgrounds/haven.png";
+
+var haven$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: haven
+});
+
+var pulse = "./assets/backgrounds/pulse.png";
+
+var pulse$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: pulse
+});
+
+var studio = "./assets/backgrounds/studio.png";
+
+var studio$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: studio
+});
+
+var neon = "./assets/backgrounds/neon.mp4";
+
+var neon$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: neon
+});
+
+var bubbles = "./assets/backgrounds/bubbles.mp4";
+
+var bubbles$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: bubbles
+});
+
+exports.createEffectStream = createEffectStream;
+exports.getPresets = getPresets;
+exports.getUsablePresets = getUsablePresets;
+exports.setDefaultSetup = setDefaultSetup;
+exports.warmup = warmup;