@cloudflare/realtimekit-virtual-background 0.0.1 → 0.0.2-staging.2

package/dist/index.es.js

@@ -0,0 +1,4266 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _initParams, _activeRunId, _initParams2, _activeRunId2, _imageBackgroundTransformer, _simpleBackgroundTrasnformer;
+class BackgroundTransformer {
+  constructor() {
+    this.createCameraVideoElement = async (rawVideoTrack) => {
+      const cameraTrack = rawVideoTrack;
+      const { height, width } = cameraTrack.getSettings();
+      if (height === void 0 || width === void 0) {
+        throw Error("Background removal can't commence as Height and Width of the video feed is undefined");
+      }
+      const cameraVideoElement = document.createElement("video");
+      cameraVideoElement.width = width;
+      cameraVideoElement.height = height;
+      cameraVideoElement.srcObject = new MediaStream([cameraTrack]);
+      cameraVideoElement.autoplay = true;
+      cameraVideoElement.muted = true;
+      cameraVideoElement.playsInline = true;
+      cameraVideoElement.controls = true;
+      try {
+        await cameraVideoElement.play();
+      } catch (ex) {
+        console.warn("RealtimeKitVideoBackgroundTransformer:: Couldn't play raw video feed in detached mode");
+      }
+      return cameraVideoElement;
+    };
+  }
+}
+const loadImage = (src) => new Promise((resolve, reject) => {
+  const img = new Image();
+  img.onload = () => resolve(img);
+  img.onerror = reject;
+  img.src = src;
+  img.crossOrigin = "anonymous";
+});
+const createImageFromVideoElement = (video) => new Promise((resolve, reject) => {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = video.videoWidth;
+  canvas.height = video.videoHeight;
+  ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+  const img = new Image();
+  img.onload = () => resolve(img);
+  img.onerror = reject;
+  img.src = canvas.toDataURL("image/jpeg");
+  img.crossOrigin = "anonymous";
+});
+const inputResolutions = {
+  "640x360": [640, 360],
+  "256x256": [256, 256],
+  "256x144": [256, 144],
+  "160x96": [160, 96]
+};
+function getTFLiteModelFileName(model, inputResolution) {
+  switch (model) {
+    case "meet":
+      return inputResolution === "256x144" ? "segm_full_v679" : "segm_lite_v681";
+    case "mlkit":
+      return "selfiesegmentation_mlkit-256x256-2021_01_19-v1215.f16";
+    default:
+      throw new Error(`No TFLite file for this segmentation model: ${model}`);
+  }
+}
+const glsl = String.raw;
+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 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 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;
+}
+async function readPixelsAsync(timerWorker, gl, x, y, width, height, format, type, dest) {
+  const buf = gl.createBuffer();
+  gl.bindBuffer(gl.PIXEL_PACK_BUFFER, buf);
+  gl.bufferData(gl.PIXEL_PACK_BUFFER, dest.byteLength, gl.STREAM_READ);
+  gl.readPixels(x, y, width, height, format, type, 0);
+  gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null);
+  await getBufferSubDataAsync(
+    timerWorker,
+    gl,
+    gl.PIXEL_PACK_BUFFER,
+    buf,
+    0,
+    dest
+  );
+  gl.deleteBuffer(buf);
+  return dest;
+}
+async function getBufferSubDataAsync(timerWorker, gl, target, buffer, srcByteOffset, dstBuffer, dstOffset, length) {
+  const sync = gl.fenceSync(gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
+  gl.flush();
+  const res = await clientWaitAsync(timerWorker, gl, sync);
+  gl.deleteSync(sync);
+  if (res !== gl.WAIT_FAILED) {
+    gl.bindBuffer(target, buffer);
+    gl.getBufferSubData(target, srcByteOffset, dstBuffer, dstOffset, length);
+    gl.bindBuffer(target, null);
+  }
+}
+function clientWaitAsync(timerWorker, gl, sync) {
+  return new Promise((resolve) => {
+    function test() {
+      const res = gl.clientWaitSync(sync, 0, 0);
+      if (res === gl.WAIT_FAILED) {
+        resolve(res);
+        return;
+      }
+      if (res === gl.TIMEOUT_EXPIRED) {
+        timerWorker.setTimeout(test, 0);
+        return;
+      }
+      resolve(res);
+    }
+    timerWorker.setTimeout(test, 0);
+  });
+}
+function buildBackgroundBlurStage(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, canvas, backgroundConfig) {
+  const blurPass = buildBlurPass(
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    personMaskTexture,
+    canvas,
+    backgroundConfig
+  );
+  const blendPass = buildBlendPass(gl, positionBuffer, texCoordBuffer, canvas);
+  function render() {
+    blurPass.render();
+    blendPass.render();
+  }
+  function updateCoverage(coverage) {
+    blendPass.updateCoverage(coverage);
+  }
+  function cleanUp() {
+    blendPass.cleanUp();
+    blurPass.cleanUp();
+  }
+  return {
+    render,
+    updateCoverage,
+    cleanUp
+  };
+}
+function buildBlurPass(gl, vertexShader, positionBuffer, texCoordBuffer, personMaskTexture, canvas, backgroundConfig) {
+  const fragmentShaderSource = glsl`#version 300 es
+
+    precision highp float;
+
+    uniform sampler2D u_inputFrame;
+    uniform sampler2D u_personMask;
+    uniform vec2 u_texelSize;
+    uniform float u_blurAmount;
+
+    in vec2 v_texCoord;
+
+    out vec4 outColor;
+
+    const float offset[5] = float[](0.0, 1.0, 2.0, 3.0, 4.0);
+    const float weight[5] = float[](0.2270270270, 0.1945945946, 0.1216216216,
+      0.0540540541, 0.0162162162);
+
+    void main() {
+      vec4 centerColor = texture(u_inputFrame, v_texCoord);
+      float personMask = texture(u_personMask, v_texCoord).a;
+
+      vec4 frameColor = centerColor * weight[0] * (1.0 - personMask);
+
+      for (int i = 1; i < 5; i++) {
+        vec2 offset = vec2(offset[i]) * u_texelSize * u_blurAmount;
+
+        vec2 texCoord = v_texCoord + offset;
+        frameColor += texture(u_inputFrame, texCoord) * weight[i] *
+          (1.0 - texture(u_personMask, texCoord).a);
+
+        texCoord = v_texCoord - offset;
+        frameColor += texture(u_inputFrame, texCoord) * weight[i] *
+          (1.0 - texture(u_personMask, texCoord).a);
+      }
+      outColor = vec4(frameColor.rgb + (1.0 - frameColor.a) * centerColor.rgb, 1.0);
+    }
+  `;
+  const scale = 0.5;
+  const outputWidth = canvas.width * scale;
+  const outputHeight = canvas.height * scale;
+  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 inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+  const personMaskLocation = gl.getUniformLocation(program, "u_personMask");
+  const texelSizeLocation = gl.getUniformLocation(program, "u_texelSize");
+  const blurAmountLocation = gl.getUniformLocation(program, "u_blurAmount");
+  const texture1 = createTexture(
+    gl,
+    gl.RGBA8,
+    outputWidth,
+    outputHeight,
+    gl.NEAREST,
+    gl.LINEAR
+  );
+  const texture2 = createTexture(
+    gl,
+    gl.RGBA8,
+    outputWidth,
+    outputHeight,
+    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);
+  const desiredBlurAmount = Math.max(0, Math.min(backgroundConfig.blurLength / 10, 10));
+  gl.uniform1f(blurAmountLocation, desiredBlurAmount);
+  gl.uniform1i(personMaskLocation, 1);
+  function render() {
+    gl.viewport(0, 0, outputWidth, outputHeight);
+    gl.useProgram(program);
+    gl.uniform1i(inputFrameLocation, 0);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, personMaskTexture);
+    for (let i = 0; i < 3; 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,
+    cleanUp
+  };
+}
+function buildBlendPass(gl, positionBuffer, texCoordBuffer, canvas) {
+  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 { width: outputWidth, height: outputHeight } = canvas;
+  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);
+  gl.uniform2f(coverageLocation, 0, 1);
+  function render() {
+    gl.viewport(0, 0, outputWidth, outputHeight);
+    gl.useProgram(program);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  }
+  function updateCoverage(coverage) {
+    gl.useProgram(program);
+    gl.uniform2f(coverageLocation, coverage[0], coverage[1]);
+  }
+  function cleanUp() {
+    gl.deleteProgram(program);
+    gl.deleteShader(fragmentShader);
+    gl.deleteShader(vertexShader);
+  }
+  return {
+    render,
+    updateCoverage,
+    cleanUp
+  };
+}
+function buildBackgroundImageStage(gl, positionBuffer, texCoordBuffer, personMaskTexture, backgroundImage, canvas, backgroundConfig) {
+  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 is required when rendering to 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;
+    uniform float u_lightWrapping;
+    uniform float u_blendMode;
+
+    in vec2 v_texCoord;
+    in vec2 v_backgroundCoord;
+
+    out vec4 outColor;
+
+    vec3 screen(vec3 a, vec3 b) {
+      return 1.0 - (1.0 - a) * (1.0 - b);
+    }
+
+    vec3 linearDodge(vec3 a, vec3 b) {
+      return a + b;
+    }
+
+    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;
+      float lightWrapMask = 1.0 - max(0.0, personMask - u_coverage.y) / (1.0 - u_coverage.y);
+      vec3 lightWrap = u_lightWrapping * lightWrapMask * backgroundColor;
+      frameColor = u_blendMode * linearDodge(frameColor, lightWrap) +
+        (1.0 - u_blendMode) * screen(frameColor, lightWrap);
+      personMask = smoothstep(u_coverage.x, u_coverage.y, personMask);
+      outColor = vec4(frameColor * personMask + backgroundColor * (1.0 - personMask), 1.0);
+    }
+  `;
+  const { width: outputWidth, height: outputHeight } = canvas;
+  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");
+  const lightWrappingLocation = gl.getUniformLocation(
+    program,
+    "u_lightWrapping"
+  );
+  const blendModeLocation = gl.getUniformLocation(program, "u_blendMode");
+  gl.useProgram(program);
+  gl.uniform2f(backgroundScaleLocation, 1, 1);
+  gl.uniform2f(backgroundOffsetLocation, 0, 0);
+  gl.uniform1i(inputFrameLocation, 0);
+  gl.uniform1i(personMaskLocation, 1);
+  gl.uniform2f(coverageLocation, 0, 1);
+  gl.uniform1f(lightWrappingLocation, 0);
+  gl.uniform1f(blendModeLocation, 0);
+  let backgroundTexture = null;
+  if (backgroundImage == null ? void 0 : backgroundImage.complete) {
+    updateBackgroundImage(backgroundImage);
+  } else if (backgroundImage) {
+    backgroundImage.onload = () => {
+      updateBackgroundImage(backgroundImage);
+    };
+  }
+  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 updateBackgroundImage(backgroundImage2) {
+    backgroundTexture = createTexture(
+      gl,
+      gl.RGBA8,
+      backgroundImage2.naturalWidth,
+      backgroundImage2.naturalHeight,
+      gl.LINEAR,
+      gl.LINEAR
+    );
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      0,
+      backgroundImage2.naturalWidth,
+      backgroundImage2.naturalHeight,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      backgroundImage2
+    );
+    let xOffset = 0;
+    let yOffset = 0;
+    let backgroundWidth = backgroundImage2.naturalWidth;
+    let backgroundHeight = backgroundImage2.naturalHeight;
+    const backgroundRatio = backgroundWidth / backgroundHeight;
+    if (backgroundRatio < outputRatio) {
+      backgroundHeight = backgroundWidth / outputRatio;
+      yOffset = (backgroundImage2.naturalHeight - backgroundHeight) / 2;
+    } else {
+      backgroundWidth = backgroundHeight * outputRatio;
+      xOffset = (backgroundImage2.naturalWidth - backgroundWidth) / 2;
+    }
+    const xScale = backgroundWidth / backgroundImage2.naturalWidth;
+    const yScale = backgroundHeight / backgroundImage2.naturalHeight;
+    xOffset /= backgroundImage2.naturalWidth;
+    yOffset /= backgroundImage2.naturalHeight;
+    gl.uniform2f(backgroundScaleLocation, xScale, yScale);
+    gl.uniform2f(backgroundOffsetLocation, xOffset, yOffset);
+  }
+  function updateCoverage(coverage) {
+    gl.useProgram(program);
+    gl.uniform2f(coverageLocation, coverage[0], coverage[1]);
+  }
+  function updateLightWrapping(lightWrapping) {
+    gl.useProgram(program);
+    gl.uniform1f(lightWrappingLocation, lightWrapping);
+  }
+  function updateBlendMode(blendMode) {
+    gl.useProgram(program);
+    gl.uniform1f(blendModeLocation, blendMode === "screen" ? 0 : 1);
+  }
+  function cleanUp() {
+    gl.deleteTexture(backgroundTexture);
+    gl.deleteProgram(program);
+    gl.deleteShader(fragmentShader);
+    gl.deleteShader(vertexShader);
+  }
+  return {
+    render,
+    updateCoverage,
+    updateLightWrapping,
+    updateBlendMode,
+    cleanUp
+  };
+}
+function buildJointBilateralFilterStage(gl, vertexShader, positionBuffer, texCoordBuffer, inputTexture, segmentationConfig, outputTexture, canvas) {
+  const fragmentShaderSource = glsl`#version 300 es
+
+    precision highp float;
+
+    uniform sampler2D u_inputFrame;
+    uniform sampler2D u_segmentationMask;
+    uniform vec2 u_texelSize;
+    uniform float u_step;
+    uniform float u_radius;
+    uniform float u_offset;
+    uniform float u_sigmaTexel;
+    uniform float u_sigmaColor;
+
+    in vec2 v_texCoord;
+
+    out vec4 outColor;
+
+    float gaussian(float x, float sigma) {
+      float coeff = -0.5 / (sigma * sigma * 4.0 + 1.0e-6);
+      return exp((x * x) * coeff);
+    }
+
+    void main() {
+      vec2 centerCoord = v_texCoord;
+      vec3 centerColor = texture(u_inputFrame, centerCoord).rgb;
+      float newVal = 0.0;
+
+      float spaceWeight = 0.0;
+      float colorWeight = 0.0;
+      float totalWeight = 0.0;
+
+      // Subsample kernel space.
+      for (float i = -u_radius + u_offset; i <= u_radius; i += u_step) {
+        for (float j = -u_radius + u_offset; j <= u_radius; j += u_step) {
+          vec2 shift = vec2(j, i) * u_texelSize;
+          vec2 coord = vec2(centerCoord + shift);
+          vec3 frameColor = texture(u_inputFrame, coord).rgb;
+          float outVal = texture(u_segmentationMask, coord).a;
+
+          spaceWeight = gaussian(distance(centerCoord, coord), u_sigmaTexel);
+          colorWeight = gaussian(distance(centerColor, frameColor), u_sigmaColor);
+          totalWeight += spaceWeight * colorWeight;
+
+          newVal += spaceWeight * colorWeight * outVal;
+        }
+      }
+      newVal /= totalWeight;
+
+      outColor = vec4(vec3(0.0), newVal);
+    }
+  `;
+  const [segmentationWidth, segmentationHeight] = inputResolutions[segmentationConfig.inputResolution];
+  const { width: outputWidth, height: outputHeight } = canvas;
+  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 inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+  const segmentationMaskLocation = gl.getUniformLocation(
+    program,
+    "u_segmentationMask"
+  );
+  const texelSizeLocation = gl.getUniformLocation(program, "u_texelSize");
+  const stepLocation = gl.getUniformLocation(program, "u_step");
+  const radiusLocation = gl.getUniformLocation(program, "u_radius");
+  const offsetLocation = gl.getUniformLocation(program, "u_offset");
+  const sigmaTexelLocation = gl.getUniformLocation(program, "u_sigmaTexel");
+  const sigmaColorLocation = gl.getUniformLocation(program, "u_sigmaColor");
+  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(inputFrameLocation, 0);
+  gl.uniform1i(segmentationMaskLocation, 1);
+  gl.uniform2f(texelSizeLocation, texelWidth, texelHeight);
+  updateSigmaSpace(0);
+  updateSigmaColor(0);
+  function render() {
+    gl.viewport(0, 0, outputWidth, outputHeight);
+    gl.useProgram(program);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, inputTexture);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  }
+  function updateSigmaSpace(sigmaSpace) {
+    sigmaSpace *= Math.max(
+      outputWidth / segmentationWidth,
+      outputHeight / segmentationHeight
+    );
+    const kSparsityFactor = 0.66;
+    const sparsity = Math.max(1, Math.sqrt(sigmaSpace) * kSparsityFactor);
+    const step = sparsity;
+    const radius = sigmaSpace;
+    const offset = step > 1 ? step * 0.5 : 0;
+    const sigmaTexel = Math.max(texelWidth, texelHeight) * sigmaSpace;
+    gl.useProgram(program);
+    gl.uniform1f(stepLocation, step);
+    gl.uniform1f(radiusLocation, radius);
+    gl.uniform1f(offsetLocation, offset);
+    gl.uniform1f(sigmaTexelLocation, sigmaTexel);
+  }
+  function updateSigmaColor(sigmaColor) {
+    gl.useProgram(program);
+    gl.uniform1f(sigmaColorLocation, sigmaColor);
+  }
+  function cleanUp() {
+    gl.deleteFramebuffer(frameBuffer);
+    gl.deleteProgram(program);
+    gl.deleteShader(fragmentShader);
+  }
+  return {
+    render,
+    updateSigmaSpace,
+    updateSigmaColor,
+    cleanUp
+  };
+}
+function buildLoadSegmentationStage(gl, vertexShader, positionBuffer, texCoordBuffer, segmentationConfig, tflite, outputTexture) {
+  const fragmentShaderSource = glsl`#version 300 es
+
+    precision highp float;
+
+    uniform sampler2D u_inputSegmentation;
+
+    in vec2 v_texCoord;
+
+    out vec4 outColor;
+
+    void main() {
+      float segmentation = texture(u_inputSegmentation, v_texCoord).r;
+      outColor = vec4(vec3(0.0), segmentation);
+    }
+  `;
+  const tfliteOutputMemoryOffset = tflite._getOutputMemoryOffset() / 4;
+  const [segmentationWidth, segmentationHeight] = inputResolutions[segmentationConfig.inputResolution];
+  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.R32F,
+    segmentationWidth,
+    segmentationHeight
+  );
+  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, segmentationWidth, segmentationHeight);
+    gl.useProgram(program);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, inputTexture);
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      0,
+      segmentationWidth,
+      segmentationHeight,
+      gl.RED,
+      gl.FLOAT,
+      tflite.HEAPF32,
+      tfliteOutputMemoryOffset
+    );
+    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 buildResizingStage(timerWorker, gl, vertexShader, positionBuffer, texCoordBuffer, segmentationConfig, tflite) {
+  const fragmentShaderSource = glsl`#version 300 es
+
+    precision highp float;
+
+    uniform sampler2D u_inputFrame;
+
+    in vec2 v_texCoord;
+
+    out vec4 outColor;
+
+    void main() {
+      outColor = texture(u_inputFrame, v_texCoord);
+    }
+  `;
+  const tfliteInputMemoryOffset = tflite._getInputMemoryOffset() / 4;
+  const [outputWidth, outputHeight] = inputResolutions[segmentationConfig.inputResolution];
+  const outputPixelCount = outputWidth * outputHeight;
+  const fragmentShader = compileShader(
+    gl,
+    gl.FRAGMENT_SHADER,
+    fragmentShaderSource
+  );
+  const program = createPiplelineStageProgram(
+    gl,
+    vertexShader,
+    fragmentShader,
+    positionBuffer,
+    texCoordBuffer
+  );
+  const inputFrameLocation = gl.getUniformLocation(program, "u_inputFrame");
+  const outputTexture = createTexture(gl, gl.RGBA8, outputWidth, outputHeight);
+  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(outputPixelCount * 4);
+  gl.useProgram(program);
+  gl.uniform1i(inputFrameLocation, 0);
+  async function render() {
+    gl.viewport(0, 0, outputWidth, outputHeight);
+    gl.useProgram(program);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, frameBuffer);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    const readPixelsPromise = readPixelsAsync(
+      timerWorker,
+      gl,
+      0,
+      0,
+      outputWidth,
+      outputHeight,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      outputPixels
+    );
+    if (segmentationConfig.deferInputResizing)
+      ;
+    else {
+      await readPixelsPromise;
+    }
+    for (let i = 0; i < outputPixelCount; i++) {
+      const tfliteIndex = tfliteInputMemoryOffset + i * 3;
+      const outputIndex = i * 4;
+      tflite.HEAPF32[tfliteIndex] = outputPixels[outputIndex] / 255;
+      tflite.HEAPF32[tfliteIndex + 1] = outputPixels[outputIndex + 1] / 255;
+      tflite.HEAPF32[tfliteIndex + 2] = outputPixels[outputIndex + 2] / 255;
+    }
+  }
+  function cleanUp() {
+    gl.deleteFramebuffer(frameBuffer);
+    gl.deleteTexture(outputTexture);
+    gl.deleteProgram(program);
+    gl.deleteShader(fragmentShader);
+  }
+  return { render, cleanUp };
+}
+function buildSoftmaxStage(gl, vertexShader, positionBuffer, texCoordBuffer, segmentationConfig, tflite, outputTexture) {
+  const fragmentShaderSource = glsl`#version 300 es
+
+    precision highp float;
+
+    uniform sampler2D u_inputSegmentation;
+
+    in vec2 v_texCoord;
+
+    out vec4 outColor;
+
+    void main() {
+      vec2 segmentation = texture(u_inputSegmentation, v_texCoord).rg;
+      float shift = max(segmentation.r, segmentation.g);
+      float backgroundExp = exp(segmentation.r - shift);
+      float personExp = exp(segmentation.g - shift);
+      outColor = vec4(vec3(0.0), personExp / (backgroundExp + personExp));
+    }
+  `;
+  const tfliteOutputMemoryOffset = tflite._getOutputMemoryOffset() / 4;
+  const [segmentationWidth, segmentationHeight] = inputResolutions[segmentationConfig.inputResolution];
+  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,
+    segmentationWidth,
+    segmentationHeight
+  );
+  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, segmentationWidth, segmentationHeight);
+    gl.useProgram(program);
+    gl.activeTexture(gl.TEXTURE1);
+    gl.bindTexture(gl.TEXTURE_2D, inputTexture);
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      0,
+      segmentationWidth,
+      segmentationHeight,
+      gl.RG,
+      gl.FLOAT,
+      tflite.HEAPF32,
+      tfliteOutputMemoryOffset
+    );
+    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 buildWebGL2Pipeline(sourcePlayback, backgroundConfig, segmentationConfig, canvas, tflite, timerWorker) {
+  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 { width: frameWidth, height: frameHeight } = sourcePlayback;
+  const [segmentationWidth, segmentationHeight] = inputResolutions[segmentationConfig.inputResolution];
+  const gl = canvas.getContext("webgl2");
+  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, -1, -1, 1, 1, 1]),
+    gl.STATIC_DRAW
+  );
+  const texCoordBuffer = gl.createBuffer();
+  gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
+  gl.bufferData(
+    gl.ARRAY_BUFFER,
+    new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]),
+    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 segmentationTexture = createTexture(
+    gl,
+    gl.RGBA8,
+    segmentationWidth,
+    segmentationHeight
+  );
+  const personMaskTexture = createTexture(
+    gl,
+    gl.RGBA8,
+    frameWidth,
+    frameHeight
+  );
+  const resizingStage = buildResizingStage(
+    timerWorker,
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    segmentationConfig,
+    tflite
+  );
+  const loadSegmentationStage = segmentationConfig.model === "meet" ? buildSoftmaxStage(
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    segmentationConfig,
+    tflite,
+    segmentationTexture
+  ) : buildLoadSegmentationStage(
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    segmentationConfig,
+    tflite,
+    segmentationTexture
+  );
+  const jointBilateralFilterStage = buildJointBilateralFilterStage(
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    segmentationTexture,
+    segmentationConfig,
+    personMaskTexture,
+    canvas
+  );
+  const backgroundStage = backgroundConfig.type === "blur" ? buildBackgroundBlurStage(
+    gl,
+    vertexShader,
+    positionBuffer,
+    texCoordBuffer,
+    personMaskTexture,
+    canvas,
+    backgroundConfig
+  ) : buildBackgroundImageStage(
+    gl,
+    positionBuffer,
+    texCoordBuffer,
+    personMaskTexture,
+    backgroundConfig.backgroundImage,
+    canvas
+  );
+  async function render() {
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, inputFrameTexture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      sourcePlayback.htmlElement
+    );
+    gl.bindVertexArray(vertexArray);
+    await resizingStage.render();
+    tflite._runInference();
+    loadSegmentationStage.render();
+    jointBilateralFilterStage.render();
+    backgroundStage.render();
+  }
+  function updatePostProcessingConfig(postProcessingConfig) {
+    jointBilateralFilterStage.updateSigmaSpace(
+      postProcessingConfig.jointBilateralFilter.sigmaSpace
+    );
+    jointBilateralFilterStage.updateSigmaColor(
+      postProcessingConfig.jointBilateralFilter.sigmaColor
+    );
+    if (backgroundConfig.type === "image") {
+      const backgroundImageStage = backgroundStage;
+      backgroundImageStage.updateCoverage(postProcessingConfig.coverage);
+      backgroundImageStage.updateLightWrapping(
+        postProcessingConfig.lightWrapping
+      );
+      backgroundImageStage.updateBlendMode(postProcessingConfig.blendMode);
+    } else if (backgroundConfig.type === "blur") {
+      const backgroundBlurStage = backgroundStage;
+      backgroundBlurStage.updateCoverage(postProcessingConfig.coverage);
+    } else {
+      const backgroundImageStage = backgroundStage;
+      backgroundImageStage.updateCoverage([0, 0.9999]);
+      backgroundImageStage.updateLightWrapping(0);
+    }
+  }
+  function cleanUp() {
+    backgroundStage.cleanUp();
+    jointBilateralFilterStage.cleanUp();
+    loadSegmentationStage.cleanUp();
+    resizingStage.cleanUp();
+    gl.deleteTexture(personMaskTexture);
+    gl.deleteTexture(segmentationTexture);
+    gl.deleteTexture(inputFrameTexture);
+    gl.deleteBuffer(texCoordBuffer);
+    gl.deleteBuffer(positionBuffer);
+    gl.deleteVertexArray(vertexArray);
+    gl.deleteShader(vertexShader);
+  }
+  return { render, updatePostProcessingConfig, cleanUp };
+}
+const BROWSER_ALIASES_MAP = {
+  "Amazon Silk": "amazon_silk",
+  "Android Browser": "android",
+  Bada: "bada",
+  BlackBerry: "blackberry",
+  Chrome: "chrome",
+  Chromium: "chromium",
+  Electron: "electron",
+  Epiphany: "epiphany",
+  Firefox: "firefox",
+  Focus: "focus",
+  Generic: "generic",
+  "Google Search": "google_search",
+  Googlebot: "googlebot",
+  "Internet Explorer": "ie",
+  "K-Meleon": "k_meleon",
+  Maxthon: "maxthon",
+  "Microsoft Edge": "edge",
+  "MZ Browser": "mz",
+  "NAVER Whale Browser": "naver",
+  Opera: "opera",
+  "Opera Coast": "opera_coast",
+  PhantomJS: "phantomjs",
+  Puffin: "puffin",
+  QupZilla: "qupzilla",
+  QQ: "qq",
+  QQLite: "qqlite",
+  Safari: "safari",
+  Sailfish: "sailfish",
+  "Samsung Internet for Android": "samsung_internet",
+  SeaMonkey: "seamonkey",
+  Sleipnir: "sleipnir",
+  Swing: "swing",
+  Tizen: "tizen",
+  "UC Browser": "uc",
+  Vivaldi: "vivaldi",
+  "WebOS Browser": "webos",
+  WeChat: "wechat",
+  "Yandex Browser": "yandex",
+  Roku: "roku"
+};
+const BROWSER_MAP = {
+  amazon_silk: "Amazon Silk",
+  android: "Android Browser",
+  bada: "Bada",
+  blackberry: "BlackBerry",
+  chrome: "Chrome",
+  chromium: "Chromium",
+  electron: "Electron",
+  epiphany: "Epiphany",
+  firefox: "Firefox",
+  focus: "Focus",
+  generic: "Generic",
+  googlebot: "Googlebot",
+  google_search: "Google Search",
+  ie: "Internet Explorer",
+  k_meleon: "K-Meleon",
+  maxthon: "Maxthon",
+  edge: "Microsoft Edge",
+  mz: "MZ Browser",
+  naver: "NAVER Whale Browser",
+  opera: "Opera",
+  opera_coast: "Opera Coast",
+  phantomjs: "PhantomJS",
+  puffin: "Puffin",
+  qupzilla: "QupZilla",
+  qq: "QQ Browser",
+  qqlite: "QQ Browser Lite",
+  safari: "Safari",
+  sailfish: "Sailfish",
+  samsung_internet: "Samsung Internet for Android",
+  seamonkey: "SeaMonkey",
+  sleipnir: "Sleipnir",
+  swing: "Swing",
+  tizen: "Tizen",
+  uc: "UC Browser",
+  vivaldi: "Vivaldi",
+  webos: "WebOS Browser",
+  wechat: "WeChat",
+  yandex: "Yandex Browser"
+};
+const PLATFORMS_MAP = {
+  tablet: "tablet",
+  mobile: "mobile",
+  desktop: "desktop",
+  tv: "tv"
+};
+const OS_MAP = {
+  WindowsPhone: "Windows Phone",
+  Windows: "Windows",
+  MacOS: "macOS",
+  iOS: "iOS",
+  Android: "Android",
+  WebOS: "WebOS",
+  BlackBerry: "BlackBerry",
+  Bada: "Bada",
+  Tizen: "Tizen",
+  Linux: "Linux",
+  ChromeOS: "Chrome OS",
+  PlayStation4: "PlayStation 4",
+  Roku: "Roku"
+};
+const ENGINE_MAP = {
+  EdgeHTML: "EdgeHTML",
+  Blink: "Blink",
+  Trident: "Trident",
+  Presto: "Presto",
+  Gecko: "Gecko",
+  WebKit: "WebKit"
+};
+class Utils {
+  static getFirstMatch(regexp, ua) {
+    const match = ua.match(regexp);
+    return match && match.length > 0 && match[1] || "";
+  }
+  static getSecondMatch(regexp, ua) {
+    const match = ua.match(regexp);
+    return match && match.length > 1 && match[2] || "";
+  }
+  static matchAndReturnConst(regexp, ua, _const) {
+    if (regexp.test(ua)) {
+      return _const;
+    }
+    return void 0;
+  }
+  static getWindowsVersionName(version) {
+    switch (version) {
+      case "NT":
+        return "NT";
+      case "XP":
+        return "XP";
+      case "NT 5.0":
+        return "2000";
+      case "NT 5.1":
+        return "XP";
+      case "NT 5.2":
+        return "2003";
+      case "NT 6.0":
+        return "Vista";
+      case "NT 6.1":
+        return "7";
+      case "NT 6.2":
+        return "8";
+      case "NT 6.3":
+        return "8.1";
+      case "NT 10.0":
+        return "10";
+      default:
+        return void 0;
+    }
+  }
+  static getMacOSVersionName(version) {
+    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
+    v.push(0);
+    if (v[0] !== 10)
+      return void 0;
+    switch (v[1]) {
+      case 5:
+        return "Leopard";
+      case 6:
+        return "Snow Leopard";
+      case 7:
+        return "Lion";
+      case 8:
+        return "Mountain Lion";
+      case 9:
+        return "Mavericks";
+      case 10:
+        return "Yosemite";
+      case 11:
+        return "El Capitan";
+      case 12:
+        return "Sierra";
+      case 13:
+        return "High Sierra";
+      case 14:
+        return "Mojave";
+      case 15:
+        return "Catalina";
+      default:
+        return void 0;
+    }
+  }
+  static getAndroidVersionName(version) {
+    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
+    v.push(0);
+    if (v[0] === 1 && v[1] < 5)
+      return void 0;
+    if (v[0] === 1 && v[1] < 6)
+      return "Cupcake";
+    if (v[0] === 1 && v[1] >= 6)
+      return "Donut";
+    if (v[0] === 2 && v[1] < 2)
+      return "Eclair";
+    if (v[0] === 2 && v[1] === 2)
+      return "Froyo";
+    if (v[0] === 2 && v[1] > 2)
+      return "Gingerbread";
+    if (v[0] === 3)
+      return "Honeycomb";
+    if (v[0] === 4 && v[1] < 1)
+      return "Ice Cream Sandwich";
+    if (v[0] === 4 && v[1] < 4)
+      return "Jelly Bean";
+    if (v[0] === 4 && v[1] >= 4)
+      return "KitKat";
+    if (v[0] === 5)
+      return "Lollipop";
+    if (v[0] === 6)
+      return "Marshmallow";
+    if (v[0] === 7)
+      return "Nougat";
+    if (v[0] === 8)
+      return "Oreo";
+    if (v[0] === 9)
+      return "Pie";
+    return void 0;
+  }
+  static getVersionPrecision(version) {
+    return version.split(".").length;
+  }
+  static compareVersions(versionA, versionB, isLoose = false) {
+    const versionAPrecision = Utils.getVersionPrecision(versionA);
+    const versionBPrecision = Utils.getVersionPrecision(versionB);
+    let precision = Math.max(versionAPrecision, versionBPrecision);
+    let lastPrecision = 0;
+    const chunks = Utils.map([versionA, versionB], (version) => {
+      const delta = precision - Utils.getVersionPrecision(version);
+      const _version = version + new Array(delta + 1).join(".0");
+      return Utils.map(_version.split("."), (chunk) => new Array(20 - chunk.length).join("0") + chunk).reverse();
+    });
+    if (isLoose) {
+      lastPrecision = precision - Math.min(versionAPrecision, versionBPrecision);
+    }
+    precision -= 1;
+    while (precision >= lastPrecision) {
+      if (chunks[0][precision] > chunks[1][precision]) {
+        return 1;
+      }
+      if (chunks[0][precision] === chunks[1][precision]) {
+        if (precision === lastPrecision) {
+          return 0;
+        }
+        precision -= 1;
+      } else if (chunks[0][precision] < chunks[1][precision]) {
+        return -1;
+      }
+    }
+    return void 0;
+  }
+  static map(arr, iterator) {
+    const result = [];
+    let i;
+    if (Array.prototype.map) {
+      return Array.prototype.map.call(arr, iterator);
+    }
+    for (i = 0; i < arr.length; i += 1) {
+      result.push(iterator(arr[i]));
+    }
+    return result;
+  }
+  static find(arr, predicate) {
+    let i;
+    let l;
+    if (Array.prototype.find) {
+      return Array.prototype.find.call(arr, predicate);
+    }
+    for (i = 0, l = arr.length; i < l; i += 1) {
+      const value = arr[i];
+      if (predicate(value, i)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  static assign(obj, ...assigners) {
+    const result = obj;
+    let i;
+    let l;
+    if (Object.assign) {
+      return Object.assign(obj, ...assigners);
+    }
+    for (i = 0, l = assigners.length; i < l; i += 1) {
+      const assigner = assigners[i];
+      if (typeof assigner === "object" && assigner !== null) {
+        const keys = Object.keys(assigner);
+        keys.forEach((key) => {
+          result[key] = assigner[key];
+        });
+      }
+    }
+    return obj;
+  }
+  static getBrowserAlias(browserName) {
+    return BROWSER_ALIASES_MAP[browserName];
+  }
+  static getBrowserTypeByAlias(browserAlias) {
+    return BROWSER_MAP[browserAlias] || "";
+  }
+}
+const commonVersionIdentifier = /version\/(\d+(\.?_?\d+)+)/i;
+const browsersList = [
+  {
+    test: [/googlebot/i],
+    describe(ua) {
+      const browser = {
+        name: "Googlebot"
+      };
+      const version = Utils.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/opera/i],
+    describe(ua) {
+      const browser = {
+        name: "Opera"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/opr\/|opios/i],
+    describe(ua) {
+      const browser = {
+        name: "Opera"
+      };
+      const version = Utils.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/SamsungBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: "Samsung Internet for Android"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/Whale/i],
+    describe(ua) {
+      const browser = {
+        name: "NAVER Whale Browser"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/MZBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: "MZ Browser"
+      };
+      const version = Utils.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/focus/i],
+    describe(ua) {
+      const browser = {
+        name: "Focus"
+      };
+      const version = Utils.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/swing/i],
+    describe(ua) {
+      const browser = {
+        name: "Swing"
+      };
+      const version = Utils.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/coast/i],
+    describe(ua) {
+      const browser = {
+        name: "Opera Coast"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/opt\/\d+(?:.?_?\d+)+/i],
+    describe(ua) {
+      const browser = {
+        name: "Opera Touch"
+      };
+      const version = Utils.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/yabrowser/i],
+    describe(ua) {
+      const browser = {
+        name: "Yandex Browser"
+      };
+      const version = Utils.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/ucbrowser/i],
+    describe(ua) {
+      const browser = {
+        name: "UC Browser"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/Maxthon|mxios/i],
+    describe(ua) {
+      const browser = {
+        name: "Maxthon"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/epiphany/i],
+    describe(ua) {
+      const browser = {
+        name: "Epiphany"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/puffin/i],
+    describe(ua) {
+      const browser = {
+        name: "Puffin"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/sleipnir/i],
+    describe(ua) {
+      const browser = {
+        name: "Sleipnir"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/k-meleon/i],
+    describe(ua) {
+      const browser = {
+        name: "K-Meleon"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/micromessenger/i],
+    describe(ua) {
+      const browser = {
+        name: "WeChat"
+      };
+      const version = Utils.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/qqbrowser/i],
+    describe(ua) {
+      const browser = {
+        name: /qqbrowserlite/i.test(ua) ? "QQ Browser Lite" : "QQ Browser"
+      };
+      const version = Utils.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/msie|trident/i],
+    describe(ua) {
+      const browser = {
+        name: "Internet Explorer"
+      };
+      const version = Utils.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/\sedg\//i],
+    describe(ua) {
+      const browser = {
+        name: "Microsoft Edge"
+      };
+      const version = Utils.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/edg([ea]|ios)/i],
+    describe(ua) {
+      const browser = {
+        name: "Microsoft Edge"
+      };
+      const version = Utils.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/vivaldi/i],
+    describe(ua) {
+      const browser = {
+        name: "Vivaldi"
+      };
+      const version = Utils.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/seamonkey/i],
+    describe(ua) {
+      const browser = {
+        name: "SeaMonkey"
+      };
+      const version = Utils.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/sailfish/i],
+    describe(ua) {
+      const browser = {
+        name: "Sailfish"
+      };
+      const version = Utils.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/silk/i],
+    describe(ua) {
+      const browser = {
+        name: "Amazon Silk"
+      };
+      const version = Utils.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/phantom/i],
+    describe(ua) {
+      const browser = {
+        name: "PhantomJS"
+      };
+      const version = Utils.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/slimerjs/i],
+    describe(ua) {
+      const browser = {
+        name: "SlimerJS"
+      };
+      const version = Utils.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(ua) {
+      const browser = {
+        name: "BlackBerry"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(ua) {
+      const browser = {
+        name: "WebOS Browser"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/bada/i],
+    describe(ua) {
+      const browser = {
+        name: "Bada"
+      };
+      const version = Utils.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/tizen/i],
+    describe(ua) {
+      const browser = {
+        name: "Tizen"
+      };
+      const version = Utils.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/qupzilla/i],
+    describe(ua) {
+      const browser = {
+        name: "QupZilla"
+      };
+      const version = Utils.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/firefox|iceweasel|fxios/i],
+    describe(ua) {
+      const browser = {
+        name: "Firefox"
+      };
+      const version = Utils.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/electron/i],
+    describe(ua) {
+      const browser = {
+        name: "Electron"
+      };
+      const version = Utils.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/MiuiBrowser/i],
+    describe(ua) {
+      const browser = {
+        name: "Miui"
+      };
+      const version = Utils.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/chromium/i],
+    describe(ua) {
+      const browser = {
+        name: "Chromium"
+      };
+      const version = Utils.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/chrome|crios|crmo/i],
+    describe(ua) {
+      const browser = {
+        name: "Chrome"
+      };
+      const version = Utils.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/GSA/i],
+    describe(ua) {
+      const browser = {
+        name: "Google Search"
+      };
+      const version = Utils.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test(parser) {
+      const notLikeAndroid = !parser.test(/like android/i);
+      const butAndroid = parser.test(/android/i);
+      return notLikeAndroid && butAndroid;
+    },
+    describe(ua) {
+      const browser = {
+        name: "Android Browser"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/playstation 4/i],
+    describe(ua) {
+      const browser = {
+        name: "PlayStation 4"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/safari|applewebkit/i],
+    describe(ua) {
+      const browser = {
+        name: "Safari"
+      };
+      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
+      if (version) {
+        browser.version = version;
+      }
+      return browser;
+    }
+  },
+  {
+    test: [/.*/i],
+    describe(ua) {
+      const regexpWithoutDeviceSpec = /^(.*)\/(.*) /;
+      const regexpWithDeviceSpec = /^(.*)\/(.*)[ \t]\((.*)/;
+      const hasDeviceSpec = ua.search("\\(") !== -1;
+      const regexp = hasDeviceSpec ? regexpWithDeviceSpec : regexpWithoutDeviceSpec;
+      return {
+        name: Utils.getFirstMatch(regexp, ua),
+        version: Utils.getSecondMatch(regexp, ua)
+      };
+    }
+  }
+];
+var osParsersList = [
+  {
+    test: [/Roku\/DVP/],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, ua);
+      return {
+        name: OS_MAP.Roku,
+        version
+      };
+    }
+  },
+  {
+    test: [/windows phone/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.WindowsPhone,
+        version
+      };
+    }
+  },
+  {
+    test: [/windows /i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, ua);
+      const versionName = Utils.getWindowsVersionName(version);
+      return {
+        name: OS_MAP.Windows,
+        version,
+        versionName
+      };
+    }
+  },
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe(ua) {
+      const result = {
+        name: OS_MAP.iOS
+      };
+      const version = Utils.getSecondMatch(/(Version\/)(\d[\d.]+)/, ua);
+      if (version) {
+        result.version = version;
+      }
+      return result;
+    }
+  },
+  {
+    test: [/macintosh/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, ua).replace(/[_\s]/g, ".");
+      const versionName = Utils.getMacOSVersionName(version);
+      const os = {
+        name: OS_MAP.MacOS,
+        version
+      };
+      if (versionName) {
+        os.versionName = versionName;
+      }
+      return os;
+    }
+  },
+  {
+    test: [/(ipod|iphone|ipad)/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, ua).replace(/[_\s]/g, ".");
+      return {
+        name: OS_MAP.iOS,
+        version
+      };
+    }
+  },
+  {
+    test(parser) {
+      const notLikeAndroid = !parser.test(/like android/i);
+      const butAndroid = parser.test(/android/i);
+      return notLikeAndroid && butAndroid;
+    },
+    describe(ua) {
+      const version = Utils.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, ua);
+      const versionName = Utils.getAndroidVersionName(version);
+      const os = {
+        name: OS_MAP.Android,
+        version
+      };
+      if (versionName) {
+        os.versionName = versionName;
+      }
+      return os;
+    }
+  },
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, ua);
+      const os = {
+        name: OS_MAP.WebOS
+      };
+      if (version && version.length) {
+        os.version = version;
+      }
+      return os;
+    }
+  },
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, ua) || Utils.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, ua) || Utils.getFirstMatch(/\bbb(\d+)/i, ua);
+      return {
+        name: OS_MAP.BlackBerry,
+        version
+      };
+    }
+  },
+  {
+    test: [/bada/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.Bada,
+        version
+      };
+    }
+  },
+  {
+    test: [/tizen/i],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.Tizen,
+        version
+      };
+    }
+  },
+  {
+    test: [/linux/i],
+    describe() {
+      return {
+        name: OS_MAP.Linux
+      };
+    }
+  },
+  {
+    test: [/CrOS/],
+    describe() {
+      return {
+        name: OS_MAP.ChromeOS
+      };
+    }
+  },
+  {
+    test: [/PlayStation 4/],
+    describe(ua) {
+      const version = Utils.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, ua);
+      return {
+        name: OS_MAP.PlayStation4,
+        version
+      };
+    }
+  }
+];
+var platformParsersList = [
+  {
+    test: [/googlebot/i],
+    describe() {
+      return {
+        type: "bot",
+        vendor: "Google"
+      };
+    }
+  },
+  {
+    test: [/huawei/i],
+    describe(ua) {
+      const model = Utils.getFirstMatch(/(can-l01)/i, ua) && "Nova";
+      const platform = {
+        type: PLATFORMS_MAP.mobile,
+        vendor: "Huawei"
+      };
+      if (model) {
+        platform.model = model;
+      }
+      return platform;
+    }
+  },
+  {
+    test: [/nexus\s*(?:7|8|9|10).*/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: "Nexus"
+      };
+    }
+  },
+  {
+    test: [/ipad/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  {
+    test: [/kftt build/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: "Amazon",
+        model: "Kindle Fire HD 7"
+      };
+    }
+  },
+  {
+    test: [/silk/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet,
+        vendor: "Amazon"
+      };
+    }
+  },
+  {
+    test: [/tablet(?! pc)/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet
+      };
+    }
+  },
+  {
+    test(parser) {
+      const iDevice = parser.test(/ipod|iphone/i);
+      const likeIDevice = parser.test(/like (ipod|iphone)/i);
+      return iDevice && !likeIDevice;
+    },
+    describe(ua) {
+      const model = Utils.getFirstMatch(/(ipod|iphone)/i, ua);
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: "Apple",
+        model
+      };
+    }
+  },
+  {
+    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: "Nexus"
+      };
+    }
+  },
+  {
+    test: [/[^-]mobi/i],
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === "blackberry";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: "BlackBerry"
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === "bada";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getBrowserName() === "windows phone";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile,
+        vendor: "Microsoft"
+      };
+    }
+  },
+  {
+    test(parser) {
+      const osMajorVersion = Number(String(parser.getOSVersion()).split(".")[0]);
+      return parser.getOSName(true) === "android" && osMajorVersion >= 3;
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tablet
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "android";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.mobile
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "macos";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop,
+        vendor: "Apple"
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "windows";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "linux";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.desktop
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "playstation 4";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tv
+      };
+    }
+  },
+  {
+    test(parser) {
+      return parser.getOSName(true) === "roku";
+    },
+    describe() {
+      return {
+        type: PLATFORMS_MAP.tv
+      };
+    }
+  }
+];
+var enginesParsersList = [
+  {
+    test(parser) {
+      return parser.getBrowserName(true) === "microsoft edge";
+    },
+    describe(ua) {
+      const isBlinkBased = /\sedg\//i.test(ua);
+      if (isBlinkBased) {
+        return {
+          name: ENGINE_MAP.Blink
+        };
+      }
+      const version = Utils.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, ua);
+      return {
+        name: ENGINE_MAP.EdgeHTML,
+        version
+      };
+    }
+  },
+  {
+    test: [/trident/i],
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Trident
+      };
+      const version = Utils.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        engine.version = version;
+      }
+      return engine;
+    }
+  },
+  {
+    test(parser) {
+      return parser.test(/presto/i);
+    },
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Presto
+      };
+      const version = Utils.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        engine.version = version;
+      }
+      return engine;
+    }
+  },
+  {
+    test(parser) {
+      const isGecko = parser.test(/gecko/i);
+      const likeGecko = parser.test(/like gecko/i);
+      return isGecko && !likeGecko;
+    },
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.Gecko
+      };
+      const version = Utils.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        engine.version = version;
+      }
+      return engine;
+    }
+  },
+  {
+    test: [/(apple)?webkit\/537\.36/i],
+    describe() {
+      return {
+        name: ENGINE_MAP.Blink
+      };
+    }
+  },
+  {
+    test: [/(apple)?webkit/i],
+    describe(ua) {
+      const engine = {
+        name: ENGINE_MAP.WebKit
+      };
+      const version = Utils.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, ua);
+      if (version) {
+        engine.version = version;
+      }
+      return engine;
+    }
+  }
+];
+class Parser {
+  constructor(UA, skipParsing = false) {
+    if (UA === void 0 || UA === null || UA === "") {
+      throw new Error("UserAgent parameter can't be empty");
+    }
+    this._ua = UA;
+    this.parsedResult = {};
+    if (skipParsing !== true) {
+      this.parse();
+    }
+  }
+  getUA() {
+    return this._ua;
+  }
+  test(regex) {
+    return regex.test(this._ua);
+  }
+  parseBrowser() {
+    this.parsedResult.browser = {};
+    const browserDescriptor = Utils.find(browsersList, (_browser) => {
+      if (typeof _browser.test === "function") {
+        return _browser.test(this);
+      }
+      if (_browser.test instanceof Array) {
+        return _browser.test.some((condition) => this.test(condition));
+      }
+      throw new Error("Browser's test function is not valid");
+    });
+    if (browserDescriptor) {
+      this.parsedResult.browser = browserDescriptor.describe(this.getUA());
+    }
+    return this.parsedResult.browser;
+  }
+  getBrowser() {
+    if (this.parsedResult.browser) {
+      return this.parsedResult.browser;
+    }
+    return this.parseBrowser();
+  }
+  getBrowserName(toLowerCase) {
+    if (toLowerCase) {
+      return String(this.getBrowser().name).toLowerCase() || "";
+    }
+    return this.getBrowser().name || "";
+  }
+  getBrowserVersion() {
+    return this.getBrowser().version;
+  }
+  getOS() {
+    if (this.parsedResult.os) {
+      return this.parsedResult.os;
+    }
+    return this.parseOS();
+  }
+  parseOS() {
+    this.parsedResult.os = {};
+    const os = Utils.find(osParsersList, (_os) => {
+      if (typeof _os.test === "function") {
+        return _os.test(this);
+      }
+      if (_os.test instanceof Array) {
+        return _os.test.some((condition) => this.test(condition));
+      }
+      throw new Error("Browser's test function is not valid");
+    });
+    if (os) {
+      this.parsedResult.os = os.describe(this.getUA());
+    }
+    return this.parsedResult.os;
+  }
+  getOSName(toLowerCase) {
+    const { name } = this.getOS();
+    if (toLowerCase) {
+      return String(name).toLowerCase() || "";
+    }
+    return name || "";
+  }
+  getOSVersion() {
+    return this.getOS().version;
+  }
+  getPlatform() {
+    if (this.parsedResult.platform) {
+      return this.parsedResult.platform;
+    }
+    return this.parsePlatform();
+  }
+  getPlatformType(toLowerCase = false) {
+    const { type } = this.getPlatform();
+    if (toLowerCase) {
+      return String(type).toLowerCase() || "";
+    }
+    return type || "";
+  }
+  parsePlatform() {
+    this.parsedResult.platform = {};
+    const platform = Utils.find(platformParsersList, (_platform) => {
+      if (typeof _platform.test === "function") {
+        return _platform.test(this);
+      }
+      if (_platform.test instanceof Array) {
+        return _platform.test.some((condition) => this.test(condition));
+      }
+      throw new Error("Browser's test function is not valid");
+    });
+    if (platform) {
+      this.parsedResult.platform = platform.describe(this.getUA());
+    }
+    return this.parsedResult.platform;
+  }
+  getEngine() {
+    if (this.parsedResult.engine) {
+      return this.parsedResult.engine;
+    }
+    return this.parseEngine();
+  }
+  getEngineName(toLowerCase) {
+    if (toLowerCase) {
+      return String(this.getEngine().name).toLowerCase() || "";
+    }
+    return this.getEngine().name || "";
+  }
+  parseEngine() {
+    this.parsedResult.engine = {};
+    const engine = Utils.find(enginesParsersList, (_engine) => {
+      if (typeof _engine.test === "function") {
+        return _engine.test(this);
+      }
+      if (_engine.test instanceof Array) {
+        return _engine.test.some((condition) => this.test(condition));
+      }
+      throw new Error("Browser's test function is not valid");
+    });
+    if (engine) {
+      this.parsedResult.engine = engine.describe(this.getUA());
+    }
+    return this.parsedResult.engine;
+  }
+  parse() {
+    this.parseBrowser();
+    this.parseOS();
+    this.parsePlatform();
+    this.parseEngine();
+    return this;
+  }
+  getResult() {
+    return Utils.assign({}, this.parsedResult);
+  }
+  satisfies(checkTree) {
+    const platformsAndOSes = {};
+    let platformsAndOSCounter = 0;
+    const browsers = {};
+    let browsersCounter = 0;
+    const allDefinitions = Object.keys(checkTree);
+    allDefinitions.forEach((key) => {
+      const currentDefinition = checkTree[key];
+      if (typeof currentDefinition === "string") {
+        browsers[key] = currentDefinition;
+        browsersCounter += 1;
+      } else if (typeof currentDefinition === "object") {
+        platformsAndOSes[key] = currentDefinition;
+        platformsAndOSCounter += 1;
+      }
+    });
+    if (platformsAndOSCounter > 0) {
+      const platformsAndOSNames = Object.keys(platformsAndOSes);
+      const OSMatchingDefinition = Utils.find(platformsAndOSNames, (name) => this.isOS(name));
+      if (OSMatchingDefinition) {
+        const osResult = this.satisfies(platformsAndOSes[OSMatchingDefinition]);
+        if (osResult !== void 0) {
+          return osResult;
+        }
+      }
+      const platformMatchingDefinition = Utils.find(
+        platformsAndOSNames,
+        (name) => this.isPlatform(name)
+      );
+      if (platformMatchingDefinition) {
+        const platformResult = this.satisfies(platformsAndOSes[platformMatchingDefinition]);
+        if (platformResult !== void 0) {
+          return platformResult;
+        }
+      }
+    }
+    if (browsersCounter > 0) {
+      const browserNames = Object.keys(browsers);
+      const matchingDefinition = Utils.find(browserNames, (name) => this.isBrowser(name, true));
+      if (matchingDefinition !== void 0) {
+        return this.compareVersion(browsers[matchingDefinition]);
+      }
+    }
+    return void 0;
+  }
+  isBrowser(browserName, includingAlias = false) {
+    const defaultBrowserName = this.getBrowserName().toLowerCase();
+    let browserNameLower = browserName.toLowerCase();
+    const alias = Utils.getBrowserTypeByAlias(browserNameLower);
+    if (includingAlias && alias) {
+      browserNameLower = alias.toLowerCase();
+    }
+    return browserNameLower === defaultBrowserName;
+  }
+  compareVersion(version) {
+    let expectedResults = [0];
+    let comparableVersion = version;
+    let isLoose = false;
+    const currentBrowserVersion = this.getBrowserVersion();
+    if (typeof currentBrowserVersion !== "string") {
+      return void 0;
+    }
+    if (version[0] === ">" || version[0] === "<") {
+      comparableVersion = version.substr(1);
+      if (version[1] === "=") {
+        isLoose = true;
+        comparableVersion = version.substr(2);
+      } else {
+        expectedResults = [];
+      }
+      if (version[0] === ">") {
+        expectedResults.push(1);
+      } else {
+        expectedResults.push(-1);
+      }
+    } else if (version[0] === "=") {
+      comparableVersion = version.substr(1);
+    } else if (version[0] === "~") {
+      isLoose = true;
+      comparableVersion = version.substr(1);
+    }
+    return expectedResults.indexOf(
+      Utils.compareVersions(currentBrowserVersion, comparableVersion, isLoose)
+    ) > -1;
+  }
+  isOS(osName) {
+    return this.getOSName(true) === String(osName).toLowerCase();
+  }
+  isPlatform(platformType) {
+    return this.getPlatformType(true) === String(platformType).toLowerCase();
+  }
+  isEngine(engineName) {
+    return this.getEngineName(true) === String(engineName).toLowerCase();
+  }
+  is(anything, includingAlias = false) {
+    return this.isBrowser(anything, includingAlias) || this.isOS(anything) || this.isPlatform(anything);
+  }
+  some(anythings = []) {
+    return anythings.some((anything) => this.is(anything));
+  }
+}
+/*!
+ * Bowser - a browser detector
+ * https://github.com/lancedikson/bowser
+ * MIT License | (c) Dustin Diaz 2012-2015
+ * MIT License | (c) Denis Demchenko 2015-2019
+ */
+class Bowser {
+  static getParser(UA, skipParsing = false) {
+    if (typeof UA !== "string") {
+      throw new Error("UserAgent should be a string");
+    }
+    return new Parser(UA, skipParsing);
+  }
+  static parse(UA) {
+    return new Parser(UA).getResult();
+  }
+  static get BROWSER_MAP() {
+    return BROWSER_MAP;
+  }
+  static get ENGINE_MAP() {
+    return ENGINE_MAP;
+  }
+  static get OS_MAP() {
+    return OS_MAP;
+  }
+  static get PLATFORMS_MAP() {
+    return PLATFORMS_MAP;
+  }
+}
+function getBrowser() {
+  return Bowser.getParser(window.navigator.userAgent);
+}
+function buildCanvas2dPipeline(sourcePlayback, backgroundConfig, segmentationConfig, canvas, tflite, WorkerTimers) {
+  const ctx = canvas.getContext("2d");
+  const [segmentationWidth, segmentationHeight] = inputResolutions[segmentationConfig.inputResolution];
+  const segmentationPixelCount = segmentationWidth * segmentationHeight;
+  const segmentationMask = new ImageData(segmentationWidth, segmentationHeight);
+  const segmentationMaskCanvas = document.createElement("canvas");
+  segmentationMaskCanvas.width = segmentationWidth;
+  segmentationMaskCanvas.height = segmentationHeight;
+  const segmentationMaskCtx = segmentationMaskCanvas.getContext("2d", { willReadFrequently: true });
+  const inputMemoryOffset = tflite._getInputMemoryOffset() / 4;
+  const outputMemoryOffset = tflite._getOutputMemoryOffset() / 4;
+  let postProcessingConfig;
+  let currentFrame = null;
+  const blurredBackgroundImagePromise = loadImage("https://assets.dyte.io/backgrounds/blur.jpg");
+  async function render() {
+    currentFrame = await createImageFromVideoElement(sourcePlayback.htmlElement);
+    if (backgroundConfig.type !== "none") {
+      resizeSource();
+    }
+    if (backgroundConfig.type !== "none") {
+      runTFLiteInference();
+    }
+    await runPostProcessing();
+  }
+  function updatePostProcessingConfig(newPostProcessingConfig) {
+    postProcessingConfig = newPostProcessingConfig;
+  }
+  function cleanUp() {
+  }
+  function resizeSource() {
+    segmentationMaskCtx.drawImage(
+      currentFrame,
+      0,
+      0,
+      sourcePlayback.width,
+      sourcePlayback.height,
+      0,
+      0,
+      segmentationWidth,
+      segmentationHeight
+    );
+    if (segmentationConfig.model === "meet" || segmentationConfig.model === "mlkit") {
+      const imageData = segmentationMaskCtx.getImageData(
+        0,
+        0,
+        segmentationWidth,
+        segmentationHeight
+      );
+      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;
+      }
+    }
+  }
+  function runTFLiteInference() {
+    tflite._runInference();
+    for (let i = 0; i < segmentationPixelCount; i++) {
+      if (segmentationConfig.model === "meet") {
+        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 (segmentationConfig.model === "mlkit") {
+        const person = tflite.HEAPF32[outputMemoryOffset + i];
+        segmentationMask.data[i * 4 + 3] = 255 * person;
+      }
+    }
+    segmentationMaskCtx.putImageData(segmentationMask, 0, 0);
+  }
+  async function runPostProcessing() {
+    ctx.globalCompositeOperation = "copy";
+    ctx.filter = "none";
+    ctx.drawImage(currentFrame, 0, 0);
+    if (postProcessingConfig == null ? void 0 : postProcessingConfig.smoothSegmentationMask) {
+      if (backgroundConfig.type === "blur") {
+        ctx.filter = "blur(8px)";
+      } else if (backgroundConfig.type === "image") {
+        ctx.filter = "blur(4px)";
+      }
+    }
+    if (backgroundConfig.type !== "none") {
+      ctx.globalCompositeOperation = "destination-in";
+      ctx.filter = "none";
+      drawSegmentationMask();
+    }
+    if (backgroundConfig.type === "blur") {
+      await blurBackground();
+    } else {
+      drawBackgroundImage();
+    }
+  }
+  function drawBackgroundImage() {
+    ctx.globalCompositeOperation = "destination-over";
+    ctx.drawImage(backgroundConfig.backgroundImage, 0, 0);
+  }
+  function drawSegmentationMask() {
+    ctx.drawImage(
+      segmentationMaskCanvas,
+      0,
+      0,
+      segmentationWidth,
+      segmentationHeight,
+      0,
+      0,
+      sourcePlayback.width,
+      sourcePlayback.height
+    );
+  }
+  async function blurBackground() {
+    ctx.globalCompositeOperation = "destination-over";
+    if (getBrowser().getBrowserName() === "Safari") {
+      const blurrredImageBackground = await blurredBackgroundImagePromise;
+      ctx.drawImage(blurrredImageBackground, 0, 0);
+    } else {
+      ctx.filter = `blur(${backgroundConfig.blurLength}px)`;
+      ctx.drawImage(currentFrame, 0, 0);
+    }
+  }
+  return { render, updatePostProcessingConfig, cleanUp };
+}
+const _ImageBackgroundTransformer = class extends BackgroundTransformer {
+  constructor(initParams) {
+    super();
+    __privateAdd(this, _initParams, void 0);
+    __privateAdd(this, _activeRunId, void 0);
+    __privateSet(this, _initParams, initParams);
+  }
+  static async init(initParams) {
+    return new _ImageBackgroundTransformer(initParams);
+  }
+  async createStaticBackgroundImageVideoMiddleware(backgroundImageUrl) {
+    const backgroundImage = await loadImage(backgroundImageUrl);
+    return async ({ canvas, WorkerTimers }) => {
+      const currentRunId = `RUN_${Date.now()}_${Math.round(Math.random() * 100)}`;
+      __privateSet(this, _activeRunId, currentRunId);
+      const rawVideoElement = await this.createCameraVideoElement(
+        __privateGet(this, _initParams).meeting.self.rawVideoTrack
+      );
+      canvas.width = rawVideoElement.width;
+      canvas.height = rawVideoElement.height;
+      const pipelineFn = __privateGet(this, _initParams).segmentationConfig.pipeline === "canvas2dCpu" ? buildCanvas2dPipeline : buildWebGL2Pipeline;
+      const pipeline = pipelineFn(
+        {
+          htmlElement: rawVideoElement,
+          width: __privateGet(this, _initParams).meeting.self.rawVideoTrack.getSettings().width,
+          height: __privateGet(this, _initParams).meeting.self.rawVideoTrack.getSettings().height
+        },
+        {
+          type: "image",
+          backgroundImage
+        },
+        __privateGet(this, _initParams).segmentationConfig,
+        canvas,
+        __privateGet(this, _initParams).tflite,
+        WorkerTimers
+      );
+      pipeline.updatePostProcessingConfig(__privateGet(this, _initParams).postProcessingConfig);
+      const targetTimerTimeoutMs = 1e3 / __privateGet(this, _initParams).segmentationConfig.targetFps;
+      const render = async () => {
+        if (currentRunId !== __privateGet(this, _activeRunId) || !__privateGet(this, _initParams).meeting.self.videoEnabled) {
+          await pipeline.cleanUp();
+          return;
+        }
+        const startTime = performance.now();
+        await pipeline.render();
+        WorkerTimers.setTimeout(
+          render,
+          Math.max(0, targetTimerTimeoutMs - (performance.now() - startTime))
+        );
+      };
+      WorkerTimers.setTimeout(() => {
+        render();
+      }, 0);
+    };
+  }
+  destruct() {
+    __privateSet(this, _activeRunId, null);
+  }
+};
+let ImageBackgroundTransformer = _ImageBackgroundTransformer;
+_initParams = new WeakMap();
+_activeRunId = new WeakMap();
+const _SimpleBackgroundTransformer = class extends BackgroundTransformer {
+  constructor(initParams) {
+    super();
+    __privateAdd(this, _initParams2, void 0);
+    __privateAdd(this, _activeRunId2, void 0);
+    __privateSet(this, _initParams2, initParams);
+  }
+  static async init(initParams) {
+    return new _SimpleBackgroundTransformer(initParams);
+  }
+  async createBackgroundBlurVideoMiddleware(blurLength) {
+    return async ({ canvas, WorkerTimers }) => {
+      const currentRunId = `RUN_${Date.now()}_${Math.round(Math.random() * 100)}`;
+      __privateSet(this, _activeRunId2, currentRunId);
+      const rawVideoElement = await this.createCameraVideoElement(
+        __privateGet(this, _initParams2).meeting.self.rawVideoTrack
+      );
+      canvas.width = rawVideoElement.width;
+      canvas.height = rawVideoElement.height;
+      const pipelineFn = __privateGet(this, _initParams2).segmentationConfig.pipeline === "canvas2dCpu" ? buildCanvas2dPipeline : buildWebGL2Pipeline;
+      const pipeline = pipelineFn(
+        {
+          htmlElement: rawVideoElement,
+          width: __privateGet(this, _initParams2).meeting.self.rawVideoTrack.getSettings().width,
+          height: __privateGet(this, _initParams2).meeting.self.rawVideoTrack.getSettings().height
+        },
+        {
+          type: "blur",
+          blurLength
+        },
+        __privateGet(this, _initParams2).segmentationConfig,
+        canvas,
+        __privateGet(this, _initParams2).tflite,
+        WorkerTimers
+      );
+      pipeline.updatePostProcessingConfig(__privateGet(this, _initParams2).postProcessingConfig);
+      const targetTimerTimeoutMs = 1e3 / __privateGet(this, _initParams2).segmentationConfig.targetFps;
+      const render = async () => {
+        if (currentRunId !== __privateGet(this, _activeRunId2) || !__privateGet(this, _initParams2).meeting.self.videoEnabled) {
+          await pipeline.cleanUp();
+          return;
+        }
+        const startTime = performance.now();
+        await pipeline.render();
+        WorkerTimers.setTimeout(
+          render,
+          Math.max(0, targetTimerTimeoutMs - (performance.now() - startTime))
+        );
+      };
+      WorkerTimers.setTimeout(() => {
+        render();
+      }, 0);
+    };
+  }
+  async destruct() {
+    __privateSet(this, _activeRunId2, null);
+  }
+};
+let SimpleBackgroundTransformer = _SimpleBackgroundTransformer;
+_initParams2 = new WeakMap();
+_activeRunId2 = new WeakMap();
+var createTFLiteModule = (() => {
+  var _scriptDir = "https://assets.dyte.io/virtual-bg/";
+  return function(createTFLiteModule2) {
+    createTFLiteModule2 = createTFLiteModule2 || {};
+    var Module = typeof createTFLiteModule2 != "undefined" ? createTFLiteModule2 : {};
+    var readyPromiseResolve, readyPromiseReject;
+    Module["ready"] = new Promise(function(resolve, reject) {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    var moduleOverrides = Object.assign({}, Module);
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var ENVIRONMENT_IS_WEB = true;
+    var scriptDirectory = "";
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory);
+      }
+      return scriptDirectory + path;
+    }
+    var readBinary;
+    {
+      if (typeof document != "undefined" && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      {
+        scriptDirectory = _scriptDir;
+      }
+      if (scriptDirectory.indexOf("blob:") !== 0) {
+        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+      } else {
+        scriptDirectory = "";
+      }
+    }
+    var out = Module["print"] || console.log.bind(console);
+    var err = Module["printErr"] || console.warn.bind(console);
+    Object.assign(Module, moduleOverrides);
+    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"];
+    var noExitRuntime = Module["noExitRuntime"] || true;
+    if (typeof WebAssembly != "object") {
+      abort("no native wasm support detected");
+    }
+    var wasmMemory;
+    var ABORT = false;
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
+    function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+        ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode((u0 & 31) << 6 | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+        } else {
+          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[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;
+    }
+    var buffer, HEAP8, HEAPU8, HEAPU32;
+    function updateGlobalBufferAndViews(buf) {
+      buffer = buf;
+      Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+      Module["HEAP16"] = new Int16Array(buf);
+      Module["HEAP32"] = new Int32Array(buf);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+      Module["HEAPU16"] = new Uint16Array(buf);
+      Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
+      Module["HEAPF32"] = new Float32Array(buf);
+      Module["HEAPF64"] = new Float64Array(buf);
+    }
+    Module["INITIAL_MEMORY"] || 16777216;
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATPOSTRUN__ = [];
+    function keepRuntimeAlive() {
+      return noExitRuntime;
+    }
+    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 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 addOnInit(cb) {
+      __ATINIT__.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();
+        }
+      }
+    }
+    function abort(what) {
+      {
+        if (Module["onAbort"]) {
+          Module["onAbort"](what);
+        }
+      }
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    function isDataURI(filename) {
+      return filename.startsWith(dataURIPrefix);
+    }
+    var wasmBinaryFile;
+    wasmBinaryFile = "tflite.wasm";
+    if (!isDataURI(wasmBinaryFile)) {
+      wasmBinaryFile = locateFile(wasmBinaryFile);
+    }
+    function getBinary(file) {
+      try {
+        if (file == wasmBinaryFile && wasmBinary) {
+          return new Uint8Array(wasmBinary);
+        }
+        if (readBinary)
+          ;
+        throw "both async and sync fetching of the wasm failed";
+      } catch (err2) {
+        abort(err2);
+      }
+    }
+    function getBinaryPromise() {
+      if (!wasmBinary && ENVIRONMENT_IS_WEB) {
+        if (typeof fetch == "function") {
+          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);
+          });
+        }
+      }
+      return Promise.resolve().then(function() {
+        return getBinary(wasmBinaryFile);
+      });
+    }
+    function createWasm() {
+      var info = { "env": asmLibraryArg, "wasi_snapshot_preview1": asmLibraryArg };
+      function receiveInstance(instance, module) {
+        var exports2 = instance.exports;
+        Module["asm"] = exports2;
+        wasmMemory = Module["asm"]["memory"];
+        updateGlobalBufferAndViews(wasmMemory.buffer);
+        Module["asm"]["__indirect_function_table"];
+        addOnInit(Module["asm"]["__wasm_call_ctors"]);
+        removeRunDependency();
+      }
+      addRunDependency();
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"]);
+      }
+      function instantiateArrayBuffer(receiver) {
+        return getBinaryPromise().then(function(binary) {
+          return WebAssembly.instantiate(binary, info);
+        }).then(function(instance) {
+          return instance;
+        }).then(receiver, function(reason) {
+          err("failed to asynchronously prepare wasm: " + reason);
+          abort(reason);
+        });
+      }
+      function instantiateAsync() {
+        if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {
+          return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
+            var result = WebAssembly.instantiateStreaming(response, info);
+            return result.then(receiveInstantiationResult, function(reason) {
+              err("wasm streaming compile failed: " + reason);
+              err("falling back to ArrayBuffer instantiation");
+              return instantiateArrayBuffer(receiveInstantiationResult);
+            });
+          });
+        } else {
+          return instantiateArrayBuffer(receiveInstantiationResult);
+        }
+      }
+      if (Module["instantiateWasm"]) {
+        try {
+          var exports = Module["instantiateWasm"](info, receiveInstance);
+          return exports;
+        } catch (e) {
+          err("Module.instantiateWasm callback failed with error: " + e);
+          readyPromiseReject(e);
+        }
+      }
+      instantiateAsync().catch(readyPromiseReject);
+      return {};
+    }
+    function ExitStatus(status) {
+      this.name = "ExitStatus";
+      this.message = "Program terminated with exit(" + status + ")";
+      this.status = status;
+    }
+    function callRuntimeCallbacks(callbacks) {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    }
+    function __dlinit(main_dso_handle) {
+    }
+    var dlopenMissingError = "To use dlopen, you need enable dynamic linking, see https://github.com/emscripten-core/emscripten/wiki/Linking";
+    function __dlopen_js(filename, flag) {
+      abort(dlopenMissingError);
+    }
+    function __dlsym_js(handle, symbol) {
+      abort(dlopenMissingError);
+    }
+    var nowIsMonotonic = true;
+    function __emscripten_get_now_is_monotonic() {
+      return nowIsMonotonic;
+    }
+    function __mmap_js(len, prot, flags, fd, off, allocated) {
+      return -52;
+    }
+    function __munmap_js(addr, len, prot, flags, fd, offset) {
+    }
+    function _abort() {
+      abort("");
+    }
+    function _emscripten_date_now() {
+      return Date.now();
+    }
+    function getHeapMax() {
+      return 2147483648;
+    }
+    function _emscripten_get_heap_max() {
+      return getHeapMax();
+    }
+    var _emscripten_get_now;
+    _emscripten_get_now = () => performance.now();
+    function _emscripten_memcpy_big(dest, src, num) {
+      HEAPU8.copyWithin(dest, src, src + num);
+    }
+    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 = HEAPU8.length;
+      requestedSize = requestedSize >>> 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+      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;
+    }
+    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) {
+          if (ENV[x] === void 0)
+            delete env[x];
+          else
+            env[x] = ENV[x];
+        }
+        var strings = [];
+        for (var x in env) {
+          strings.push(x + "=" + env[x]);
+        }
+        getEnvStrings.strings = strings;
+      }
+      return getEnvStrings.strings;
+    }
+    function writeAsciiToMemory(str, buffer2, dontAddNull) {
+      for (var i = 0; i < str.length; ++i) {
+        HEAP8[buffer2++ >> 0] = str.charCodeAt(i);
+      }
+      if (!dontAddNull)
+        HEAP8[buffer2 >> 0] = 0;
+    }
+    function _environ_get(__environ, environ_buf) {
+      var bufSize = 0;
+      getEnvStrings().forEach(function(string, i) {
+        var ptr = environ_buf + bufSize;
+        HEAPU32[__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();
+      HEAPU32[penviron_count >> 2] = strings.length;
+      var bufSize = 0;
+      strings.forEach(function(string) {
+        bufSize += string.length + 1;
+      });
+      HEAPU32[penviron_buf_size >> 2] = bufSize;
+      return 0;
+    }
+    function _proc_exit(code) {
+      if (!keepRuntimeAlive()) {
+        if (Module["onExit"])
+          Module["onExit"](code);
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    }
+    function exitJS(status, implicit) {
+      _proc_exit(status);
+    }
+    var _exit = exitJS;
+    function _fd_close(fd) {
+      return 52;
+    }
+    function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+      return 70;
+    }
+    var printCharBuffers = [null, [], []];
+    function printChar(stream, curr) {
+      var buffer2 = printCharBuffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer2, 0));
+        buffer2.length = 0;
+      } else {
+        buffer2.push(curr);
+      }
+    }
+    function _fd_write(fd, iov, iovcnt, pnum) {
+      var num = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        for (var j = 0; j < len; j++) {
+          printChar(fd, HEAPU8[ptr + j]);
+        }
+        num += len;
+      }
+      HEAPU32[pnum >> 2] = num;
+      return 0;
+    }
+    function getRandomDevice() {
+      if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
+        var randomBuffer = new Uint8Array(1);
+        return () => {
+          crypto.getRandomValues(randomBuffer);
+          return randomBuffer[0];
+        };
+      } else
+        return () => abort("randomDevice");
+    }
+    function _getentropy(buffer2, size) {
+      if (!_getentropy.randomDevice) {
+        _getentropy.randomDevice = getRandomDevice();
+      }
+      for (var i = 0; i < size; i++) {
+        HEAP8[buffer2 + i >> 0] = _getentropy.randomDevice();
+      }
+      return 0;
+    }
+    var asmLibraryArg = { "_dlinit": __dlinit, "_dlopen_js": __dlopen_js, "_dlsym_js": __dlsym_js, "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, "_mmap_js": __mmap_js, "_munmap_js": __munmap_js, "abort": _abort, "emscripten_date_now": _emscripten_date_now, "emscripten_get_heap_max": _emscripten_get_heap_max, "emscripten_get_now": _emscripten_get_now, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "exit": _exit, "fd_close": _fd_close, "fd_seek": _fd_seek, "fd_write": _fd_write, "getentropy": _getentropy };
+    createWasm();
+    Module["___wasm_call_ctors"] = function() {
+      return (Module["___wasm_call_ctors"] = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
+    };
+    Module["_getModelBufferMemoryOffset"] = function() {
+      return (Module["_getModelBufferMemoryOffset"] = Module["asm"]["getModelBufferMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getInputMemoryOffset"] = function() {
+      return (Module["_getInputMemoryOffset"] = Module["asm"]["getInputMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getInputHeight"] = function() {
+      return (Module["_getInputHeight"] = Module["asm"]["getInputHeight"]).apply(null, arguments);
+    };
+    Module["_getInputWidth"] = function() {
+      return (Module["_getInputWidth"] = Module["asm"]["getInputWidth"]).apply(null, arguments);
+    };
+    Module["_getInputChannelCount"] = function() {
+      return (Module["_getInputChannelCount"] = Module["asm"]["getInputChannelCount"]).apply(null, arguments);
+    };
+    Module["_getOutputMemoryOffset"] = function() {
+      return (Module["_getOutputMemoryOffset"] = Module["asm"]["getOutputMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getOutputHeight"] = function() {
+      return (Module["_getOutputHeight"] = Module["asm"]["getOutputHeight"]).apply(null, arguments);
+    };
+    Module["_getOutputWidth"] = function() {
+      return (Module["_getOutputWidth"] = Module["asm"]["getOutputWidth"]).apply(null, arguments);
+    };
+    Module["_getOutputChannelCount"] = function() {
+      return (Module["_getOutputChannelCount"] = Module["asm"]["getOutputChannelCount"]).apply(null, arguments);
+    };
+    Module["_loadModel"] = function() {
+      return (Module["_loadModel"] = Module["asm"]["loadModel"]).apply(null, arguments);
+    };
+    Module["_runInference"] = function() {
+      return (Module["_runInference"] = Module["asm"]["runInference"]).apply(null, arguments);
+    };
+    Module["_malloc"] = function() {
+      return (Module["_malloc"] = Module["asm"]["malloc"]).apply(null, arguments);
+    };
+    Module["___errno_location"] = function() {
+      return (Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments);
+    };
+    Module["___dl_seterr"] = function() {
+      return (Module["___dl_seterr"] = Module["asm"]["__dl_seterr"]).apply(null, arguments);
+    };
+    Module["stackSave"] = function() {
+      return (Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments);
+    };
+    Module["stackRestore"] = function() {
+      return (Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments);
+    };
+    Module["stackAlloc"] = function() {
+      return (Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments);
+    };
+    Module["dynCall_jjj"] = function() {
+      return (Module["dynCall_jjj"] = Module["asm"]["dynCall_jjj"]).apply(null, arguments);
+    };
+    Module["dynCall_jiii"] = function() {
+      return (Module["dynCall_jiii"] = Module["asm"]["dynCall_jiii"]).apply(null, arguments);
+    };
+    Module["dynCall_iiiijj"] = function() {
+      return (Module["dynCall_iiiijj"] = Module["asm"]["dynCall_iiiijj"]).apply(null, arguments);
+    };
+    Module["dynCall_viijj"] = function() {
+      return (Module["dynCall_viijj"] = Module["asm"]["dynCall_viijj"]).apply(null, arguments);
+    };
+    Module["dynCall_viiijjj"] = function() {
+      return (Module["dynCall_viiijjj"] = Module["asm"]["dynCall_viiijjj"]).apply(null, arguments);
+    };
+    Module["dynCall_iijjiiii"] = function() {
+      return (Module["dynCall_iijjiiii"] = Module["asm"]["dynCall_iijjiiii"]).apply(null, arguments);
+    };
+    Module["dynCall_jiji"] = function() {
+      return (Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments);
+    };
+    var calledRun;
+    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();
+        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();
+      }
+    }
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function")
+        Module["preInit"] = [Module["preInit"]];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].pop()();
+      }
+    }
+    run();
+    return createTFLiteModule2.ready;
+  };
+})();
+var createTFLiteSIMDModule = (() => {
+  var _scriptDir = "https://assets.dyte.io/virtual-bg/";
+  return function(createTFLiteSIMDModule2) {
+    createTFLiteSIMDModule2 = createTFLiteSIMDModule2 || {};
+    var Module = typeof createTFLiteSIMDModule2 != "undefined" ? createTFLiteSIMDModule2 : {};
+    var readyPromiseResolve, readyPromiseReject;
+    Module["ready"] = new Promise(function(resolve, reject) {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    var moduleOverrides = Object.assign({}, Module);
+    var thisProgram = "./this.program";
+    var quit_ = (status, toThrow) => {
+      throw toThrow;
+    };
+    var ENVIRONMENT_IS_WEB = true;
+    var scriptDirectory = "";
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory);
+      }
+      return scriptDirectory + path;
+    }
+    var readBinary;
+    {
+      if (typeof document != "undefined" && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      {
+        scriptDirectory = _scriptDir;
+      }
+      if (scriptDirectory.indexOf("blob:") !== 0) {
+        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+      } else {
+        scriptDirectory = "";
+      }
+    }
+    var out = Module["print"] || console.log.bind(console);
+    var err = Module["printErr"] || console.warn.bind(console);
+    Object.assign(Module, moduleOverrides);
+    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"];
+    var noExitRuntime = Module["noExitRuntime"] || true;
+    if (typeof WebAssembly != "object") {
+      abort("no native wasm support detected");
+    }
+    var wasmMemory;
+    var ABORT = false;
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
+    function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+      var endIdx = idx + maxBytesToRead;
+      var endPtr = idx;
+      while (heapOrArray[endPtr] && !(endPtr >= endIdx))
+        ++endPtr;
+      if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+        return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+      }
+      var str = "";
+      while (idx < endPtr) {
+        var u0 = heapOrArray[idx++];
+        if (!(u0 & 128)) {
+          str += String.fromCharCode(u0);
+          continue;
+        }
+        var u1 = heapOrArray[idx++] & 63;
+        if ((u0 & 224) == 192) {
+          str += String.fromCharCode((u0 & 31) << 6 | u1);
+          continue;
+        }
+        var u2 = heapOrArray[idx++] & 63;
+        if ((u0 & 240) == 224) {
+          u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+        } else {
+          u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[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;
+    }
+    var buffer, HEAP8, HEAPU8, HEAPU32;
+    function updateGlobalBufferAndViews(buf) {
+      buffer = buf;
+      Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+      Module["HEAP16"] = new Int16Array(buf);
+      Module["HEAP32"] = new Int32Array(buf);
+      Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+      Module["HEAPU16"] = new Uint16Array(buf);
+      Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
+      Module["HEAPF32"] = new Float32Array(buf);
+      Module["HEAPF64"] = new Float64Array(buf);
+    }
+    Module["INITIAL_MEMORY"] || 16777216;
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATPOSTRUN__ = [];
+    function keepRuntimeAlive() {
+      return noExitRuntime;
+    }
+    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 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 addOnInit(cb) {
+      __ATINIT__.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();
+        }
+      }
+    }
+    function abort(what) {
+      {
+        if (Module["onAbort"]) {
+          Module["onAbort"](what);
+        }
+      }
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    function isDataURI(filename) {
+      return filename.startsWith(dataURIPrefix);
+    }
+    var wasmBinaryFile;
+    wasmBinaryFile = "tflite-simd.wasm";
+    if (!isDataURI(wasmBinaryFile)) {
+      wasmBinaryFile = locateFile(wasmBinaryFile);
+    }
+    function getBinary(file) {
+      try {
+        if (file == wasmBinaryFile && wasmBinary) {
+          return new Uint8Array(wasmBinary);
+        }
+        if (readBinary)
+          ;
+        throw "both async and sync fetching of the wasm failed";
+      } catch (err2) {
+        abort(err2);
+      }
+    }
+    function getBinaryPromise() {
+      if (!wasmBinary && ENVIRONMENT_IS_WEB) {
+        if (typeof fetch == "function") {
+          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);
+          });
+        }
+      }
+      return Promise.resolve().then(function() {
+        return getBinary(wasmBinaryFile);
+      });
+    }
+    function createWasm() {
+      var info = { "env": asmLibraryArg, "wasi_snapshot_preview1": asmLibraryArg };
+      function receiveInstance(instance, module) {
+        var exports2 = instance.exports;
+        Module["asm"] = exports2;
+        wasmMemory = Module["asm"]["memory"];
+        updateGlobalBufferAndViews(wasmMemory.buffer);
+        Module["asm"]["__indirect_function_table"];
+        addOnInit(Module["asm"]["__wasm_call_ctors"]);
+        removeRunDependency();
+      }
+      addRunDependency();
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"]);
+      }
+      function instantiateArrayBuffer(receiver) {
+        return getBinaryPromise().then(function(binary) {
+          return WebAssembly.instantiate(binary, info);
+        }).then(function(instance) {
+          return instance;
+        }).then(receiver, function(reason) {
+          err("failed to asynchronously prepare wasm: " + reason);
+          abort(reason);
+        });
+      }
+      function instantiateAsync() {
+        if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && typeof fetch == "function") {
+          return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
+            var result = WebAssembly.instantiateStreaming(response, info);
+            return result.then(receiveInstantiationResult, function(reason) {
+              err("wasm streaming compile failed: " + reason);
+              err("falling back to ArrayBuffer instantiation");
+              return instantiateArrayBuffer(receiveInstantiationResult);
+            });
+          });
+        } else {
+          return instantiateArrayBuffer(receiveInstantiationResult);
+        }
+      }
+      if (Module["instantiateWasm"]) {
+        try {
+          var exports = Module["instantiateWasm"](info, receiveInstance);
+          return exports;
+        } catch (e) {
+          err("Module.instantiateWasm callback failed with error: " + e);
+          readyPromiseReject(e);
+        }
+      }
+      instantiateAsync().catch(readyPromiseReject);
+      return {};
+    }
+    function ExitStatus(status) {
+      this.name = "ExitStatus";
+      this.message = "Program terminated with exit(" + status + ")";
+      this.status = status;
+    }
+    function callRuntimeCallbacks(callbacks) {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    }
+    function __dlinit(main_dso_handle) {
+    }
+    var dlopenMissingError = "To use dlopen, you need enable dynamic linking, see https://github.com/emscripten-core/emscripten/wiki/Linking";
+    function __dlopen_js(filename, flag) {
+      abort(dlopenMissingError);
+    }
+    function __dlsym_js(handle, symbol) {
+      abort(dlopenMissingError);
+    }
+    var nowIsMonotonic = true;
+    function __emscripten_get_now_is_monotonic() {
+      return nowIsMonotonic;
+    }
+    function __mmap_js(len, prot, flags, fd, off, allocated) {
+      return -52;
+    }
+    function __munmap_js(addr, len, prot, flags, fd, offset) {
+    }
+    function _abort() {
+      abort("");
+    }
+    function _emscripten_date_now() {
+      return Date.now();
+    }
+    function getHeapMax() {
+      return 2147483648;
+    }
+    function _emscripten_get_heap_max() {
+      return getHeapMax();
+    }
+    var _emscripten_get_now;
+    _emscripten_get_now = () => performance.now();
+    function _emscripten_memcpy_big(dest, src, num) {
+      HEAPU8.copyWithin(dest, src, src + num);
+    }
+    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 = HEAPU8.length;
+      requestedSize = requestedSize >>> 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+      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;
+    }
+    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) {
+          if (ENV[x] === void 0)
+            delete env[x];
+          else
+            env[x] = ENV[x];
+        }
+        var strings = [];
+        for (var x in env) {
+          strings.push(x + "=" + env[x]);
+        }
+        getEnvStrings.strings = strings;
+      }
+      return getEnvStrings.strings;
+    }
+    function writeAsciiToMemory(str, buffer2, dontAddNull) {
+      for (var i = 0; i < str.length; ++i) {
+        HEAP8[buffer2++ >> 0] = str.charCodeAt(i);
+      }
+      if (!dontAddNull)
+        HEAP8[buffer2 >> 0] = 0;
+    }
+    function _environ_get(__environ, environ_buf) {
+      var bufSize = 0;
+      getEnvStrings().forEach(function(string, i) {
+        var ptr = environ_buf + bufSize;
+        HEAPU32[__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();
+      HEAPU32[penviron_count >> 2] = strings.length;
+      var bufSize = 0;
+      strings.forEach(function(string) {
+        bufSize += string.length + 1;
+      });
+      HEAPU32[penviron_buf_size >> 2] = bufSize;
+      return 0;
+    }
+    function _proc_exit(code) {
+      if (!keepRuntimeAlive()) {
+        if (Module["onExit"])
+          Module["onExit"](code);
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    }
+    function exitJS(status, implicit) {
+      _proc_exit(status);
+    }
+    var _exit = exitJS;
+    function _fd_close(fd) {
+      return 52;
+    }
+    function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+      return 70;
+    }
+    var printCharBuffers = [null, [], []];
+    function printChar(stream, curr) {
+      var buffer2 = printCharBuffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer2, 0));
+        buffer2.length = 0;
+      } else {
+        buffer2.push(curr);
+      }
+    }
+    function _fd_write(fd, iov, iovcnt, pnum) {
+      var num = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        for (var j = 0; j < len; j++) {
+          printChar(fd, HEAPU8[ptr + j]);
+        }
+        num += len;
+      }
+      HEAPU32[pnum >> 2] = num;
+      return 0;
+    }
+    function getRandomDevice() {
+      if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
+        var randomBuffer = new Uint8Array(1);
+        return () => {
+          crypto.getRandomValues(randomBuffer);
+          return randomBuffer[0];
+        };
+      } else
+        return () => abort("randomDevice");
+    }
+    function _getentropy(buffer2, size) {
+      if (!_getentropy.randomDevice) {
+        _getentropy.randomDevice = getRandomDevice();
+      }
+      for (var i = 0; i < size; i++) {
+        HEAP8[buffer2 + i >> 0] = _getentropy.randomDevice();
+      }
+      return 0;
+    }
+    var asmLibraryArg = { "_dlinit": __dlinit, "_dlopen_js": __dlopen_js, "_dlsym_js": __dlsym_js, "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic, "_mmap_js": __mmap_js, "_munmap_js": __munmap_js, "abort": _abort, "emscripten_date_now": _emscripten_date_now, "emscripten_get_heap_max": _emscripten_get_heap_max, "emscripten_get_now": _emscripten_get_now, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "environ_get": _environ_get, "environ_sizes_get": _environ_sizes_get, "exit": _exit, "fd_close": _fd_close, "fd_seek": _fd_seek, "fd_write": _fd_write, "getentropy": _getentropy };
+    createWasm();
+    Module["___wasm_call_ctors"] = function() {
+      return (Module["___wasm_call_ctors"] = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments);
+    };
+    Module["_getModelBufferMemoryOffset"] = function() {
+      return (Module["_getModelBufferMemoryOffset"] = Module["asm"]["getModelBufferMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getInputMemoryOffset"] = function() {
+      return (Module["_getInputMemoryOffset"] = Module["asm"]["getInputMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getInputHeight"] = function() {
+      return (Module["_getInputHeight"] = Module["asm"]["getInputHeight"]).apply(null, arguments);
+    };
+    Module["_getInputWidth"] = function() {
+      return (Module["_getInputWidth"] = Module["asm"]["getInputWidth"]).apply(null, arguments);
+    };
+    Module["_getInputChannelCount"] = function() {
+      return (Module["_getInputChannelCount"] = Module["asm"]["getInputChannelCount"]).apply(null, arguments);
+    };
+    Module["_getOutputMemoryOffset"] = function() {
+      return (Module["_getOutputMemoryOffset"] = Module["asm"]["getOutputMemoryOffset"]).apply(null, arguments);
+    };
+    Module["_getOutputHeight"] = function() {
+      return (Module["_getOutputHeight"] = Module["asm"]["getOutputHeight"]).apply(null, arguments);
+    };
+    Module["_getOutputWidth"] = function() {
+      return (Module["_getOutputWidth"] = Module["asm"]["getOutputWidth"]).apply(null, arguments);
+    };
+    Module["_getOutputChannelCount"] = function() {
+      return (Module["_getOutputChannelCount"] = Module["asm"]["getOutputChannelCount"]).apply(null, arguments);
+    };
+    Module["_loadModel"] = function() {
+      return (Module["_loadModel"] = Module["asm"]["loadModel"]).apply(null, arguments);
+    };
+    Module["_runInference"] = function() {
+      return (Module["_runInference"] = Module["asm"]["runInference"]).apply(null, arguments);
+    };
+    Module["_malloc"] = function() {
+      return (Module["_malloc"] = Module["asm"]["malloc"]).apply(null, arguments);
+    };
+    Module["___errno_location"] = function() {
+      return (Module["___errno_location"] = Module["asm"]["__errno_location"]).apply(null, arguments);
+    };
+    Module["___dl_seterr"] = function() {
+      return (Module["___dl_seterr"] = Module["asm"]["__dl_seterr"]).apply(null, arguments);
+    };
+    Module["stackSave"] = function() {
+      return (Module["stackSave"] = Module["asm"]["stackSave"]).apply(null, arguments);
+    };
+    Module["stackRestore"] = function() {
+      return (Module["stackRestore"] = Module["asm"]["stackRestore"]).apply(null, arguments);
+    };
+    Module["stackAlloc"] = function() {
+      return (Module["stackAlloc"] = Module["asm"]["stackAlloc"]).apply(null, arguments);
+    };
+    Module["dynCall_jjj"] = function() {
+      return (Module["dynCall_jjj"] = Module["asm"]["dynCall_jjj"]).apply(null, arguments);
+    };
+    Module["dynCall_jiii"] = function() {
+      return (Module["dynCall_jiii"] = Module["asm"]["dynCall_jiii"]).apply(null, arguments);
+    };
+    Module["dynCall_iiiijj"] = function() {
+      return (Module["dynCall_iiiijj"] = Module["asm"]["dynCall_iiiijj"]).apply(null, arguments);
+    };
+    Module["dynCall_viijj"] = function() {
+      return (Module["dynCall_viijj"] = Module["asm"]["dynCall_viijj"]).apply(null, arguments);
+    };
+    Module["dynCall_viiijjj"] = function() {
+      return (Module["dynCall_viiijjj"] = Module["asm"]["dynCall_viiijjj"]).apply(null, arguments);
+    };
+    Module["dynCall_iijjiiii"] = function() {
+      return (Module["dynCall_iijjiiii"] = Module["asm"]["dynCall_iijjiiii"]).apply(null, arguments);
+    };
+    Module["dynCall_jiji"] = function() {
+      return (Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments);
+    };
+    var calledRun;
+    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();
+        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();
+      }
+    }
+    if (Module["preInit"]) {
+      if (typeof Module["preInit"] == "function")
+        Module["preInit"] = [Module["preInit"]];
+      while (Module["preInit"].length > 0) {
+        Module["preInit"].pop()();
+      }
+    }
+    run();
+    return createTFLiteSIMDModule2.ready;
+  };
+})();
+async function useTFLite(segmentationConfig) {
+  let tflite = null;
+  let tfliteSIMD = null;
+  let selectedTFLite = null;
+  let isSIMDSupported = false;
+  async function loadTFLite() {
+    tflite = await createTFLiteModule();
+    try {
+      const createdTFLiteSIMD = await createTFLiteSIMDModule();
+      tfliteSIMD = createdTFLiteSIMD;
+      isSIMDSupported = true;
+      segmentationConfig.backend = "wasmSimd";
+    } catch (error) {
+      console.warn("Failed to create TFLite SIMD WebAssembly module.", error);
+    }
+  }
+  await loadTFLite();
+  async function loadTFLiteModel() {
+    if (!tflite || isSIMDSupported && !tfliteSIMD || !isSIMDSupported && segmentationConfig.backend === "wasmSimd" || segmentationConfig.model !== "meet" && segmentationConfig.model !== "mlkit") {
+      return;
+    }
+    selectedTFLite = null;
+    const newSelectedTFLite = segmentationConfig.backend === "wasmSimd" ? tfliteSIMD : tflite;
+    if (!newSelectedTFLite) {
+      throw new Error(
+        `TFLite backend unavailable: ${segmentationConfig.backend}`
+      );
+    }
+    const modelFileName = getTFLiteModelFileName(
+      segmentationConfig.model,
+      segmentationConfig.inputResolution
+    );
+    const modelResponse = await fetch(
+      `https://dyte-plugins.s3.ap-south-1.amazonaws.com/tf-assets/models/${modelFileName}.tflite`
+    );
+    const model = await modelResponse.arrayBuffer();
+    const modelBufferOffset = newSelectedTFLite._getModelBufferMemoryOffset();
+    newSelectedTFLite.HEAPU8.set(new Uint8Array(model), modelBufferOffset);
+    newSelectedTFLite._loadModel(model.byteLength);
+    selectedTFLite = newSelectedTFLite;
+  }
+  await loadTFLiteModel();
+  return { tflite: selectedTFLite, isSIMDSupported };
+}
+const _RealtimeKitVideoBackgroundTransformer = class {
+  constructor(imageBackgroundTransformer, simpleBackgroundTransformer) {
+    __privateAdd(this, _imageBackgroundTransformer, void 0);
+    __privateAdd(this, _simpleBackgroundTrasnformer, void 0);
+    __privateSet(this, _imageBackgroundTransformer, imageBackgroundTransformer);
+    __privateSet(this, _simpleBackgroundTrasnformer, simpleBackgroundTransformer);
+  }
+  static async init({
+    meeting,
+    segmentationConfig: passedSegmentationConfig,
+    postProcessingConfig: passedPostProcessingConfig
+  }) {
+    if (!this.isSupported()) {
+      console.error("Initialising it in an unsupported environment, the middleware might not work");
+    }
+    window.addEventListener("error", (event) => {
+      var _a;
+      if (!((_a = event.filename) == null ? void 0 : _a.includes("localhost")) && event.lineno !== 0) {
+        console.error("RealtimeKitVideoBackgroundTransformer::UnhandledError", event.error);
+      }
+    });
+    window.addEventListener("unhandledrejection", (error) => {
+      console.error("RealtimeKitVideoBackgroundTransformer::UnhandledRejection", error.reason);
+    });
+    const segmentationConfig = {
+      model: "mlkit",
+      backend: "wasmSimd",
+      inputResolution: "256x256",
+      pipeline: "webgl2",
+      targetFps: 35,
+      deferInputResizing: true,
+      ...passedSegmentationConfig || {}
+    };
+    const browser = getBrowser();
+    if (browser.getEngineName() === "WebKit") {
+      segmentationConfig.pipeline = "canvas2dCpu";
+    }
+    const postProcessingConfig = {
+      smoothSegmentationMask: true,
+      jointBilateralFilter: { sigmaSpace: 1, sigmaColor: 0.1 },
+      coverage: [0.5, 0.75],
+      lightWrapping: 0.3,
+      blendMode: "screen",
+      ...passedPostProcessingConfig || {}
+    };
+    await meeting.self.setVideoMiddlewareGlobalConfig({ disablePerFrameCanvasRendering: true });
+    const { tflite } = await useTFLite(segmentationConfig);
+    return new _RealtimeKitVideoBackgroundTransformer(
+      await ImageBackgroundTransformer.init({
+        meeting,
+        segmentationConfig,
+        postProcessingConfig,
+        tflite
+      }),
+      await SimpleBackgroundTransformer.init({
+        meeting,
+        segmentationConfig,
+        postProcessingConfig,
+        tflite
+      })
+    );
+  }
+  static isSupported() {
+    var _a;
+    let isMiddlewareSupported = false;
+    try {
+      const browser = getBrowser();
+      const dummyCanvas = document.createElement("canvas");
+      const context = dummyCanvas.getContext("webgl2", {}) || dummyCanvas.getContext("webgl", {});
+      const browserMajorVersion = +((_a = browser.getBrowserVersion()) == null ? void 0 : _a.split(".")[0]);
+      if (!context || browser.getOSName() === "iOS" || browser.getBrowserName() === "Safari" && browserMajorVersion < 17) {
+        return false;
+      }
+      isMiddlewareSupported = true;
+    } catch {
+      isMiddlewareSupported = false;
+    }
+    return isMiddlewareSupported;
+  }
+  async createStaticBackgroundVideoMiddleware(staticBackgroundImageURL) {
+    const staticBackgroundVideoMiddleware = await __privateGet(this, _imageBackgroundTransformer).createStaticBackgroundImageVideoMiddleware(staticBackgroundImageURL);
+    return staticBackgroundVideoMiddleware;
+  }
+  async createBackgroundBlurVideoMiddleware(blurLength = 50) {
+    return __privateGet(this, _simpleBackgroundTrasnformer).createBackgroundBlurVideoMiddleware(blurLength);
+  }
+  destruct() {
+    __privateGet(this, _imageBackgroundTransformer).destruct();
+    __privateGet(this, _simpleBackgroundTrasnformer).destruct();
+  }
+};
+let RealtimeKitVideoBackgroundTransformer = _RealtimeKitVideoBackgroundTransformer;
+_imageBackgroundTransformer = new WeakMap();
+_simpleBackgroundTrasnformer = new WeakMap();
+export { RealtimeKitVideoBackgroundTransformer as default };