@jaak.ai/stamps 1.0.0-beta.1

package/dist/collection/utils/sdk.service.js

@@ -0,0 +1,943 @@
+import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";
+import { AvailableRecognizers, CameraExperience, EventReady, ImageRecognitionType, RecognitionStatus, SDKError, } from "./data-structures";
+import * as ErrorTypes from "./error-structures";
+import { globalState } from "./state-lifter";
+/**
+ * Get the additional processing information from the BlinkIdResult.
+ * @param result
+ * @returns
+ */
+export function getAdditionalProcessingInfo(result) {
+  if ("scanningFirstSideDone" in result) {
+    return !result.scanningFirstSideDone
+      ? result.frontAdditionalProcessingInfo
+      : result.backAdditionalProcessingInfo;
+  }
+  else {
+    return result.additionalProcessingInfo;
+  }
+}
+export function getImageAnalysisResult(result) {
+  if ("scanningFirstSideDone" in result) {
+    return !result.scanningFirstSideDone
+      ? result.frontImageAnalysisResult
+      : result.backImageAnalysisResult;
+  }
+  else {
+    return result.imageAnalysisResult;
+  }
+}
+export const isFirstSideDone = (result) => {
+  return "scanningFirstSideDone" in result && result.scanningFirstSideDone;
+};
+export async function getCameraDevices() {
+  const devices = await BlinkIDSDK.getCameraDevices();
+  const allDevices = devices.frontCameras.concat(devices.backCameras);
+  const finalEntries = allDevices.map((el) => {
+    return {
+      prettyName: el.label,
+      details: el,
+    };
+  });
+  return finalEntries;
+}
+export class SdkService {
+  constructor() {
+    this.cancelInitiatedFromOutside = false;
+    this.showOverlay = false;
+    this.lastKnownCardRotation = BlinkIDSDK.CardRotation.None;
+    this.lastDetectionStatus = BlinkIDSDK.DetectionStatus.Failed;
+    this.eventEmitter$ = document.createElement("a");
+  }
+  delete() {
+    this.sdk?.delete();
+  }
+  async initialize(licenseKey, sdkSettings) {
+    const loadSettings = new BlinkIDSDK.WasmSDKLoadSettings(licenseKey);
+    loadSettings.allowHelloMessage = sdkSettings.allowHelloMessage;
+    loadSettings.engineLocation = sdkSettings.engineLocation;
+    loadSettings.workerLocation = await fetch(sdkSettings.workerLocation)
+      .then((response) => response.blob())
+      .then((blob) => window.URL.createObjectURL(blob));
+    loadSettings.blinkIdVariant = sdkSettings.blinkIdVariant;
+    if (sdkSettings.wasmType) {
+      loadSettings.wasmType = sdkSettings.wasmType;
+    }
+    return new Promise((resolve) => {
+      BlinkIDSDK.loadWasmModule(loadSettings)
+        .then((sdk) => {
+        this.sdk = sdk;
+        this.showOverlay = sdk.showOverlay;
+        resolve(new EventReady(this.sdk));
+      })
+        .catch((error) => {
+        resolve(new SDKError(ErrorTypes.componentErrors.sdkLoadFailed, error));
+      });
+    });
+  }
+  checkRecognizers(recognizers) {
+    if (!recognizers || !recognizers.length) {
+      return {
+        status: false,
+        message: "There are no provided recognizers!",
+      };
+    }
+    for (const recognizer of recognizers) {
+      if (!this.isRecognizerAvailable(recognizer)) {
+        return {
+          status: false,
+          message: `Recognizer "${recognizer}" doesn't exist!`,
+        };
+      }
+      if (recognizer === "BlinkIdMultiSideRecognizer" &&
+        recognizers.length > 1) {
+        return {
+          status: false,
+          message: 'Recognizer "BlinkIdMultiSideRecognizer" cannot be used in combination with other recognizers!',
+        };
+      }
+    }
+    return {
+      status: true,
+    };
+  }
+  getDesiredCameraExperience(_recognizers = [], _recognizerOptions = {}) {
+    if (_recognizers.indexOf("BlinkIdMultiSideRecognizer") > -1) {
+      return CameraExperience.CardMultiSide;
+    }
+    if (_recognizers.indexOf("BlinkIdSingleSideRecognizer") > -1) {
+      return CameraExperience.CardSingleSide;
+    }
+    return CameraExperience.Barcode;
+  }
+  async scanFromCamera(configuration, eventCallback) {
+    eventCallback({ status: RecognitionStatus.Preparing });
+    this.cancelInitiatedFromOutside = false;
+    // Prepare terminate mechanism before recognizer and runner instances are created
+    this.eventEmitter$.addEventListener("terminate", async () => {
+      this.videoRecognizer?.cancelRecognition?.();
+      window.setTimeout(() => this.videoRecognizer?.releaseVideoFeed?.(), 1);
+      if (recognizerRunner) {
+        try {
+          await recognizerRunner.delete();
+        }
+        catch (error) {
+          // Psst, this error should not happen.
+        }
+      }
+      for (const recognizer of recognizers) {
+        if (!recognizer) {
+          continue;
+        }
+        if (recognizer.recognizer?.objectHandle > -1) {
+          recognizer.recognizer.delete?.();
+        }
+      }
+    });
+    // Prepare recognizers and runner
+    const recognizers = await this.createRecognizers(configuration.recognizers, configuration.recognizerOptions, eventCallback);
+    const recognizerRunner = await this.createRecognizerRunner(recognizers);
+    if (configuration.pingProxyUrl) {
+      await recognizerRunner.setPingProxyUrl(configuration.pingProxyUrl);
+    }
+    try {
+      this.videoRecognizer =
+        await BlinkIDSDK.VideoRecognizer.createVideoRecognizerFromCameraStream(configuration.cameraFeed, recognizerRunner, configuration.cameraId);
+      eventCallback({ status: RecognitionStatus.Ready });
+      await this.videoRecognizer.setVideoRecognitionMode(BlinkIDSDK.VideoRecognitionMode.Recognition);
+      const activeRecognizer = recognizers[0]
+        .recognizer;
+      const recognizerSettings = await activeRecognizer.currentSettings();
+      // We do per-frame operations here
+      this.videoRecognizer.setOnFrameProcessed((result) => {
+        window.setTimeout(() => {
+          // detection status callback is triggered before the video frame callback
+          // reset it after each frame is done processing
+          this.lastDetectionStatus = BlinkIDSDK.DetectionStatus.Failed;
+        }, 0);
+        const isMultiside = "scanningFirstSideDone" in result;
+        const isFrontSuccessFrame = result.processingStatus ===
+          BlinkIDSDK.ProcessingStatus.AwaitingOtherSide;
+        //We start scanning the second side only after not the success frame
+        const isOnSecondSide = isMultiside && result.scanningFirstSideDone && !isFrontSuccessFrame;
+        const additionalProcessingInfo = getAdditionalProcessingInfo(result);
+        const imageAnalysisResult = getImageAnalysisResult(result);
+        const isPassport = result.classInfo.documentType === BlinkIDSDK.DocumentType.PASSPORT;
+        // horrible hack to get the passport status to the global state
+        globalState.isPassport = isPassport;
+        const notDetected = this.lastDetectionStatus === BlinkIDSDK.DetectionStatus.Failed;
+        if (imageAnalysisResult.cardRotation) {
+          // save last known rotation in case we lose the document
+          this.lastKnownCardRotation = imageAnalysisResult.cardRotation;
+        }
+        // framing
+        switch (this.lastDetectionStatus) {
+          case BlinkIDSDK.DetectionStatus.CameraTooFar:
+            eventCallback({
+              status: RecognitionStatus.DetectionStatusCameraTooHigh,
+            });
+            break;
+          case BlinkIDSDK.DetectionStatus.FallbackSuccess:
+            eventCallback({
+              status: RecognitionStatus.DetectionStatusFallbackSuccess,
+            });
+            break;
+          case BlinkIDSDK.DetectionStatus.DocumentPartiallyVisible:
+            eventCallback({ status: RecognitionStatus.DetectionStatusPartial });
+            break;
+          case BlinkIDSDK.DetectionStatus.CameraAngleTooSteep:
+            eventCallback({
+              status: RecognitionStatus.DetectionStatusCameraAtAngle,
+            });
+            break;
+          case BlinkIDSDK.DetectionStatus.CameraTooClose:
+            eventCallback({
+              status: RecognitionStatus.DetectionStatusCameraTooNear,
+            });
+            break;
+          case BlinkIDSDK.DetectionStatus.DocumentTooCloseToCameraEdge:
+            eventCallback({
+              status: RecognitionStatus.DetectionStatusDocumentTooCloseToEdge,
+            });
+            break;
+        }
+        // handle no detection
+        if (notDetected) {
+          if (!isPassport) {
+            eventCallback({
+              // this status doesn't seem to do anything
+              // the logic is probably handled as a "default" state somewhere else
+              status: RecognitionStatus.DetectionStatusFail,
+            });
+          }
+          else {
+            // Get the user to scan the passport
+            // again, refer to the page relative to the last one scanned
+            if (isOnSecondSide) {
+              switch (this.lastKnownCardRotation) {
+                case BlinkIDSDK.CardRotation.None: {
+                  eventCallback({
+                    status: RecognitionStatus.MovePassportUpError,
+                  });
+                  break;
+                }
+                case BlinkIDSDK.CardRotation.Clockwise90: {
+                  eventCallback({
+                    status: RecognitionStatus.MovePassportRightError,
+                  });
+                  break;
+                }
+                case BlinkIDSDK.CardRotation.CounterClockwise90: {
+                  eventCallback({
+                    status: RecognitionStatus.MovePassportLeftError,
+                  });
+                  break;
+                }
+                case BlinkIDSDK.CardRotation.UpsideDown: {
+                  eventCallback({
+                    status: RecognitionStatus.MovePassportDownError,
+                  });
+                  break;
+                }
+              }
+            }
+          }
+          return;
+        }
+        // handle glare
+        if (imageAnalysisResult.glareDetected &&
+          recognizerSettings.enableGlareFilter) {
+          eventCallback({
+            status: RecognitionStatus.GlareDetected,
+          });
+          return;
+        }
+        // handle blur
+        if (imageAnalysisResult.blurDetected &&
+          recognizerSettings.enableBlurFilter) {
+          eventCallback({
+            status: RecognitionStatus.BlurDetected,
+          });
+          return;
+        }
+        // handle face occlusion
+        if (additionalProcessingInfo.imageExtractionFailures?.includes(BlinkIDSDK.ImageExtractionType.Face)) {
+          eventCallback({
+            status: RecognitionStatus.FacePhotoCovered,
+          });
+          return;
+        }
+        // first side done - show flip/move. This status triggers only once
+        if (isFrontSuccessFrame) {
+          if (!isPassport) {
+            eventCallback({ status: RecognitionStatus.OnFirstSideResult });
+          }
+          else {
+            // Passport only branch
+            switch (this.lastKnownCardRotation) {
+              case BlinkIDSDK.CardRotation.None: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportUp,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.Clockwise90: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportRight,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.CounterClockwise90: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportLeft,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.UpsideDown: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportDown,
+                });
+                break;
+              }
+            }
+          }
+          return;
+        }
+        // scanning wrong side
+        if (result.processingStatus ===
+          BlinkIDSDK.ProcessingStatus.ScanningWrongSide) {
+          if (isPassport) {
+            // Passport only branch
+            switch (this.lastKnownCardRotation) {
+              case BlinkIDSDK.CardRotation.None: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportUpError,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.Clockwise90: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportRightError,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.CounterClockwise90: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportLeftError,
+                });
+                break;
+              }
+              case BlinkIDSDK.CardRotation.UpsideDown: {
+                eventCallback({
+                  status: RecognitionStatus.MovePassportDownError,
+                });
+                break;
+              }
+            }
+          }
+          else {
+            // some other document, maybe unclassified?
+            eventCallback({
+              status: RecognitionStatus.WrongSide,
+            });
+          }
+          return;
+        }
+        // fallback - success?
+        eventCallback({ status: RecognitionStatus.DetectionStatusSuccess });
+      });
+      //////////////////////////////////////////////////
+      // Start recognition
+      await this.videoRecognizer
+        .startRecognition(async (recognitionState) => {
+        this.videoRecognizer.pauseRecognition();
+        eventCallback({ status: RecognitionStatus.Processing });
+        if (recognitionState !== BlinkIDSDK.RecognizerResultState.Empty) {
+          for (const recognizer of recognizers) {
+            const results = await recognizer.recognizer.getResult();
+            this.recognizerName = recognizer.recognizer.recognizerName;
+            if (!results ||
+              results.state === BlinkIDSDK.RecognizerResultState.Empty) {
+              eventCallback({
+                status: RecognitionStatus.EmptyResultState,
+                data: {
+                  initiatedByUser: this.cancelInitiatedFromOutside,
+                  recognizerName: this.recognizerName,
+                },
+              });
+            }
+            else {
+              const recognitionResults = {
+                recognizer: results,
+                recognizerName: this.recognizerName,
+              };
+              if (configuration.recognizerOptions?.returnSignedJSON) {
+                recognitionResults.resultSignedJSON =
+                  await recognizer.recognizer.toSignedJSON();
+              }
+              if (results.fullDocumentFrontImage.encodedImage) {
+                results.fullDocumentFrontImage.encodedImage = this.base64ArrayBuffer(results.fullDocumentFrontImage.encodedImage);
+              }
+              if (results.fullDocumentBackImage.encodedImage) {
+                results.fullDocumentBackImage.encodedImage = this.base64ArrayBuffer(results.fullDocumentBackImage.encodedImage);
+              }
+              if (results.signatureImage.encodedImage) {
+                results.signatureImage.encodedImage = this.base64ArrayBuffer(results.signatureImage.encodedImage);
+              }
+              if (results.faceImage.encodedImage) {
+                results.faceImage.encodedImage = this.base64ArrayBuffer(results.faceImage.encodedImage);
+              }
+              let borderlessFront = undefined;
+              let borderlessBack = undefined;
+              if (results.fullDocumentFrontImage?.encodedImage) {
+                let base64Image;
+                if (typeof results.fullDocumentFrontImage.encodedImage === 'string') {
+                  base64Image = results.fullDocumentFrontImage.encodedImage;
+                }
+                else {
+                  base64Image = this.base64ArrayBuffer(results.fullDocumentFrontImage.encodedImage);
+                }
+                if (!base64Image.startsWith('data:image/')) {
+                  base64Image = 'data:image/jpeg;base64,' + base64Image;
+                }
+                borderlessFront = await this.cropDocumentFromImage(base64Image, {
+                  upFactor: 0.1,
+                  downFactor: 0.1,
+                  leftFactor: 0.1,
+                  rightFactor: 0.1
+                });
+              }
+              if (results.fullDocumentBackImage?.encodedImage) {
+                let base64Image;
+                if (typeof results.fullDocumentBackImage.encodedImage === 'string') {
+                  base64Image = results.fullDocumentBackImage.encodedImage;
+                }
+                else {
+                  base64Image = this.base64ArrayBuffer(results.fullDocumentBackImage.encodedImage);
+                }
+                if (!base64Image.startsWith('data:image/')) {
+                  base64Image = 'data:image/jpeg;base64,' + base64Image;
+                }
+                borderlessBack = await this.cropDocumentFromImage(base64Image, {
+                  upFactor: 0.1,
+                  downFactor: 0.1,
+                  leftFactor: 0.1,
+                  rightFactor: 0.1
+                });
+              }
+              const scanData = {
+                result: {
+                  status: RecognitionStatus.ScanSuccessful,
+                  data: {
+                    type: "RESULTS",
+                    message: "results-success",
+                    data: {
+                      documentData: {
+                        generalData: {
+                          type: results.mrz.documentCode,
+                          nationality: results.nationality.latin,
+                          name: results.fullName.latin || results.firstName.latin,
+                          surname: results.fathersName.latin || results.lastName.latin,
+                          motherSurname: results.mothersName.latin,
+                          address: results.address.latin,
+                          expiryPermanent: false,
+                          birthDate: results.frontViz.dateOfBirth.originalString.latin,
+                          gender: results.sex.latin,
+                          documentImage: {
+                            frontFull: results.fullDocumentFrontImage.encodedImage,
+                            backFull: results.fullDocumentBackImage.encodedImage,
+                            front: borderlessFront,
+                            back: borderlessBack,
+                            signature: results.signatureImage.encodedImage,
+                            face: results.faceImage.encodedImage
+                          }
+                        },
+                        mechanicalReadingZone: results.mrz.rawMRZString,
+                        specificData: [
+                          {
+                            label: "curp",
+                            value: results.personalIdNumber.latin
+                          },
+                          {
+                            label: "electorKey",
+                            value: results.frontViz.documentAdditionalNumber.latin
+                          },
+                          {
+                            label: "registerYear",
+                            value: results.frontViz.dateOfIssue.year
+                          },
+                          {
+                            label: "registerMonth",
+                            value: results.frontViz.dateOfIssue.month
+                          },
+                          {
+                            label: "emissionYear",
+                            value: results.frontViz.dateOfIssue.year
+                          },
+                          {
+                            label: "identificationOCR",
+                            value: results.mrz.sanitizedOpt1
+                          },
+                          {
+                            label: "numIdentificationCredential",
+                            value: results.mrz.documentNumber
+                          }
+                        ]
+                      },
+                    },
+                  },
+                },
+                initiatedByUser: this.cancelInitiatedFromOutside,
+              };
+              eventCallback({
+                status: RecognitionStatus.ScanSuccessful,
+                data: scanData,
+              });
+              break;
+            }
+          }
+        }
+        else {
+          eventCallback({
+            status: RecognitionStatus.EmptyResultState,
+            data: {
+              initiatedByUser: this.cancelInitiatedFromOutside,
+              recognizerName: "",
+            },
+          });
+        }
+        window.setTimeout(() => void this.cancelRecognition(), 400);
+      }, configuration.recognitionTimeout)
+        .then(() => {
+        /* Scanning... */
+      })
+        .catch((error) => {
+        throw error;
+      });
+    }
+    catch (error) {
+      if (!error.code) {
+        eventCallback({ status: RecognitionStatus.UnknownError });
+      }
+      else {
+        switch (error.code) {
+          case BlinkIDSDK.ErrorCodes.VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED:
+            eventCallback({
+              status: RecognitionStatus.NoSupportForMediaDevices,
+            });
+            break;
+          case BlinkIDSDK.ErrorCodes.VIDEO_RECOGNIZER_CAMERA_MISSING:
+            eventCallback({ status: RecognitionStatus.CameraNotFound });
+            break;
+          case BlinkIDSDK.ErrorCodes.VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED:
+            eventCallback({ status: RecognitionStatus.CameraNotAllowed });
+            break;
+          case BlinkIDSDK.ErrorCodes.VIDEO_RECOGNIZER_CAMERA_IN_USE:
+            eventCallback({ status: RecognitionStatus.CameraInUse });
+            break;
+          default:
+            eventCallback({ status: RecognitionStatus.UnableToAccessCamera });
+            break;
+        }
+      }
+      console.warn("Error in VideoRecognizer", error.code, error.message);
+      void this.cancelRecognition();
+    }
+  }
+  async cropDocumentFromImage(imageBase64, factors) {
+    return new Promise((resolve, reject) => {
+      const image = new window.Image();
+      image.onload = () => {
+        const width = image.width;
+        const height = image.height;
+        const docWidth = width / (1 + factors.leftFactor + factors.rightFactor);
+        const docHeight = height / (1 + factors.upFactor + factors.downFactor);
+        const offsetX = factors.leftFactor * docWidth;
+        const offsetY = factors.upFactor * docHeight;
+        const canvas = document.createElement('canvas');
+        canvas.width = docWidth;
+        canvas.height = docHeight;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(image, offsetX, offsetY, docWidth, docHeight, 0, 0, docWidth, docHeight);
+        resolve(canvas.toDataURL().replace(/^data:image\/(png|jpg);base64,/, ""));
+      };
+      image.onerror = reject;
+      image.src = imageBase64;
+    });
+  }
+  base64ArrayBuffer(arrayBuffer) {
+    let base64 = "";
+    const encodings = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const bytes = new Uint8Array(arrayBuffer);
+    const byteLength = bytes.byteLength;
+    const byteRemainder = byteLength % 3;
+    const mainLength = byteLength - byteRemainder;
+    let a;
+    let b;
+    let c;
+    let d;
+    let chunk;
+    // Main loop deals with bytes in chunks of 3
+    for (let i = 0; i < mainLength; i = i + 3) {
+      // Combine the three bytes into a single integer
+      // tslint:disable-next-line:no-bitwise
+      chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+      // Use bitmasks to extract 6-bit segments from the triplet
+      // tslint:disable-next-line:no-bitwise
+      a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
+      // tslint:disable-next-line:no-bitwise
+      b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
+      // tslint:disable-next-line:no-bitwise
+      c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
+      // tslint:disable-next-line:no-bitwise
+      d = chunk & 63; // 63       = 2^6 - 1
+      // Convert the raw binary segments to the appropriate ASCII encoding
+      base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
+    }
+    // Deal with the remaining bytes and padding
+    if (byteRemainder === 1) {
+      chunk = bytes[mainLength];
+      // tslint:disable-next-line:no-bitwise
+      a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
+      // Set the 4 least significant bits to zero
+      // tslint:disable-next-line:no-bitwise
+      b = (chunk & 3) << 4; // 3   = 2^2 - 1
+      base64 += encodings[a] + encodings[b] + "==";
+    }
+    else if (byteRemainder === 2) {
+      // tslint:disable-next-line:no-bitwise
+      chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
+      // tslint:disable-next-line:no-bitwise
+      a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
+      // tslint:disable-next-line:no-bitwise
+      b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
+      // Set the 2 least significant bits to zero
+      // tslint:disable-next-line:no-bitwise
+      c = (chunk & 15) << 2; // 15    = 2^4 - 1
+      base64 += encodings[a] + encodings[b] + encodings[c] + "=";
+    }
+    return base64;
+  }
+  async flipCamera() {
+    await this.videoRecognizer.flipCamera();
+  }
+  isCameraFlipped() {
+    if (!this.videoRecognizer) {
+      return false;
+    }
+    return this.videoRecognizer.isCameraFlipped();
+  }
+  isScanFromImageAvailable(_recognizers = [], _recognizerOptions = {}) {
+    return true;
+  }
+  getScanFromImageType(_recognizers = [], _recognizerOptions = {}) {
+    if (_recognizers.indexOf("BlinkIdMultiSideRecognizer") > -1) {
+      return ImageRecognitionType.MultiSide;
+    }
+    return ImageRecognitionType.SingleSide;
+  }
+  async scanFromImage(configuration, eventCallback) {
+    eventCallback({ status: RecognitionStatus.Preparing });
+    const recognizers = await this.createRecognizers(configuration.recognizers, configuration.recognizerOptions, eventCallback);
+    const recognizerRunner = await this.createRecognizerRunner(recognizers);
+    if (configuration.pingProxyUrl) {
+      await recognizerRunner.setPingProxyUrl(configuration.pingProxyUrl);
+    }
+    const handleTerminate = async () => {
+      this.eventEmitter$.removeEventListener("terminate", handleTerminate);
+      if (recognizerRunner) {
+        try {
+          await recognizerRunner.delete();
+        }
+        catch (error) {
+          // Psst, this error should not happen.
+        }
+      }
+      for (const recognizer of recognizers) {
+        if (!recognizer) {
+          continue;
+        }
+        if (recognizer.recognizer?.objectHandle > -1) {
+          recognizer.recognizer.delete?.();
+        }
+      }
+      this.eventEmitter$.dispatchEvent(new Event("terminate:done"));
+    };
+    this.eventEmitter$.addEventListener("terminate", handleTerminate);
+    // Get image file
+    if (!configuration.file ||
+      !RegExp(/^image\//).exec(configuration.file.type)) {
+      eventCallback({ status: RecognitionStatus.NoImageFileFound });
+      window.setTimeout(() => void this.cancelRecognition(), 500);
+      return;
+    }
+    const file = configuration.file;
+    const imageElement = new Image();
+    imageElement.src = URL.createObjectURL(file);
+    await imageElement.decode();
+    const imageFrame = BlinkIDSDK.captureFrame(imageElement);
+    // Get results
+    eventCallback({ status: RecognitionStatus.Processing });
+    const processResult = await recognizerRunner.processImage(imageFrame);
+    if (processResult !== BlinkIDSDK.RecognizerResultState.Empty) {
+      for (const recognizer of recognizers) {
+        const results = await recognizer.recognizer.getResult();
+        if (!results ||
+          results.state === BlinkIDSDK.RecognizerResultState.Empty) {
+          eventCallback({
+            status: RecognitionStatus.EmptyResultState,
+            data: {
+              initiatedByUser: this.cancelInitiatedFromOutside,
+              recognizerName: recognizer.name,
+            },
+          });
+        }
+        else {
+          const recognitionResults = {
+            recognizer: results,
+            recognizerName: recognizer.name,
+          };
+          if (configuration.recognizerOptions?.returnSignedJSON) {
+            recognitionResults.resultSignedJSON =
+              await recognizer.recognizer.toSignedJSON();
+          }
+          eventCallback({
+            status: RecognitionStatus.ScanSuccessful,
+            data: recognitionResults,
+          });
+          break;
+        }
+      }
+    }
+    else {
+      // If necessary, scan the image once again with different settings
+      if (configuration.thoroughScan &&
+        configuration.recognizers.indexOf("BlinkIdSingleSideRecognizer") > -1) {
+        const c = configuration;
+        c.thoroughScan = false;
+        c.recognizerOptions = c.recognizerOptions || {};
+        for (const r of c.recognizers) {
+          c.recognizerOptions[r] = c.recognizerOptions[r] || {};
+          c.recognizerOptions[r].scanCroppedDocumentImage =
+            !!c.recognizerOptions[r].scanCroppedDocumentImage;
+          c.recognizerOptions[r].scanCroppedDocumentImage =
+            !c.recognizerOptions[r].scanCroppedDocumentImage;
+        }
+        const eventHandler = (recognitionEvent) => eventCallback(recognitionEvent);
+        const handleTerminateDone = () => {
+          this.eventEmitter$.removeEventListener("terminate:done", handleTerminateDone);
+          this.scanFromImage(configuration, eventHandler);
+        };
+        this.eventEmitter$.addEventListener("terminate:done", handleTerminateDone);
+        window.setTimeout(() => void this.cancelRecognition(), 500);
+        return;
+      }
+      eventCallback({
+        status: RecognitionStatus.EmptyResultState,
+        data: {
+          initiatedByUser: this.cancelInitiatedFromOutside,
+          recognizerName: "",
+        },
+      });
+    }
+    window.setTimeout(() => void this.cancelRecognition(), 500);
+  }
+  async scanFromImageMultiSide(configuration, eventCallback) {
+    eventCallback({ status: RecognitionStatus.Preparing });
+    const recognizers = await this.createRecognizers(configuration.recognizers, configuration.recognizerOptions, eventCallback);
+    const recognizerRunner = await this.createRecognizerRunner(recognizers);
+    if (configuration.pingProxyUrl) {
+      await recognizerRunner.setPingProxyUrl(configuration.pingProxyUrl);
+    }
+    const handleTerminate = async () => {
+      this.eventEmitter$.removeEventListener("terminate", handleTerminate);
+      if (recognizerRunner) {
+        try {
+          await recognizerRunner.delete();
+        }
+        catch (error) {
+          // Psst, this error should not happen.
+        }
+      }
+      for (const recognizer of recognizers) {
+        if (!recognizer) {
+          continue;
+        }
+        if (recognizer.recognizer?.objectHandle > -1) {
+          recognizer.recognizer.delete?.();
+        }
+      }
+      this.eventEmitter$.dispatchEvent(new Event("terminate:done"));
+    };
+    this.eventEmitter$.addEventListener("terminate", handleTerminate);
+    if (!configuration.firstFile) {
+      eventCallback({ status: RecognitionStatus.NoFirstImageFileFound });
+      window.setTimeout(() => void this.cancelRecognition(), 500);
+      return;
+    }
+    if (!configuration.secondFile) {
+      eventCallback({ status: RecognitionStatus.NoSecondImageFileFound });
+      window.setTimeout(() => void this.cancelRecognition(), 500);
+      return;
+    }
+    // Get results
+    eventCallback({ status: RecognitionStatus.Processing });
+    const imageElement = new Image();
+    imageElement.src = URL.createObjectURL(configuration.firstFile);
+    await imageElement.decode();
+    const firstFrame = BlinkIDSDK.captureFrame(imageElement);
+    const firstProcessResult = await recognizerRunner.processImage(firstFrame);
+    if (firstProcessResult !== BlinkIDSDK.RecognizerResultState.Empty) {
+      const imageElement = new Image();
+      imageElement.src = URL.createObjectURL(configuration.secondFile);
+      await imageElement.decode();
+      const secondFrame = BlinkIDSDK.captureFrame(imageElement);
+      const secondProcessResult = await recognizerRunner.processImage(secondFrame);
+      if (secondProcessResult !== BlinkIDSDK.RecognizerResultState.Empty) {
+        for (const recognizer of recognizers) {
+          const results = await recognizer.recognizer.getResult();
+          if (!results ||
+            results.state === BlinkIDSDK.RecognizerResultState.Empty) {
+            eventCallback({
+              status: RecognitionStatus.EmptyResultState,
+              data: {
+                initiatedByUser: this.cancelInitiatedFromOutside,
+                recognizerName: recognizer.name,
+              },
+            });
+          }
+          else {
+            const recognitionResults = {
+              recognizer: results,
+              recognizerName: recognizer.name,
+            };
+            if (configuration.recognizerOptions?.returnSignedJSON) {
+              recognitionResults.resultSignedJSON =
+                await recognizer.recognizer.toSignedJSON();
+            }
+            eventCallback({
+              status: RecognitionStatus.ScanSuccessful,
+              data: recognitionResults,
+            });
+            break;
+          }
+        }
+      }
+      else {
+        eventCallback({
+          status: RecognitionStatus.EmptyResultState,
+          data: {
+            initiatedByUser: this.cancelInitiatedFromOutside,
+            recognizerName: "",
+          },
+        });
+      }
+    }
+    else {
+      // If necessary, scan the image once again with different settings
+      if (configuration.thoroughScan &&
+        configuration.recognizers.indexOf("BlinkIdMultiSideRecognizer") > -1) {
+        const c = configuration;
+        c.thoroughScan = false;
+        c.recognizerOptions = c.recognizerOptions || {};
+        for (const r of c.recognizers) {
+          c.recognizerOptions[r] = c.recognizerOptions[r] || {};
+          c.recognizerOptions[r].scanCroppedDocumentImage =
+            !!c.recognizerOptions[r].scanCroppedDocumentImage;
+          c.recognizerOptions[r].scanCroppedDocumentImage =
+            !c.recognizerOptions[r].scanCroppedDocumentImage;
+        }
+        const eventHandler = (recognitionEvent) => eventCallback(recognitionEvent);
+        const handleTerminateDone = () => {
+          this.eventEmitter$.removeEventListener("terminate:done", handleTerminateDone);
+          this.scanFromImageMultiSide(configuration, eventHandler);
+        };
+        this.eventEmitter$.addEventListener("terminate:done", handleTerminateDone);
+        window.setTimeout(() => void this.cancelRecognition(), 500);
+        return;
+      }
+      eventCallback({
+        status: RecognitionStatus.EmptyResultState,
+        data: {
+          initiatedByUser: this.cancelInitiatedFromOutside,
+          recognizerName: "",
+        },
+      });
+    }
+    window.setTimeout(() => void this.cancelRecognition(), 500);
+  }
+  async stopRecognition() {
+    void (await this.cancelRecognition(true));
+  }
+  async resumeRecognition() {
+    this.videoRecognizer.resumeRecognition(true);
+  }
+  changeCameraDevice(camera) {
+    return new Promise((resolve) => {
+      this.videoRecognizer
+        .changeCameraDevice(camera)
+        .then(() => resolve(true))
+        .catch(() => resolve(false));
+    });
+  }
+  getProductIntegrationInfo() {
+    return this.sdk.getProductIntegrationInfo();
+  }
+  //////////////////////////////////////////////////////////////////////////////
+  //
+  // PRIVATE METHODS
+  isRecognizerAvailable(recognizer) {
+    return !!AvailableRecognizers[recognizer];
+  }
+  async createRecognizers(recognizers, recognizerOptions, eventCallback) {
+    const pureRecognizers = [];
+    for (const recognizer of recognizers) {
+      const instance = await BlinkIDSDK[AvailableRecognizers[recognizer]](this.sdk);
+      pureRecognizers.push(instance);
+    }
+    if (recognizerOptions && Object.keys(recognizerOptions).length > 0) {
+      for (const recognizer of pureRecognizers) {
+        const settings = await recognizer.currentSettings();
+        if (!recognizerOptions[recognizer.recognizerName] ||
+          Object.keys(recognizerOptions[recognizer.recognizerName]).length < 1) {
+          continue;
+        }
+        for (const [key, value] of Object.entries(recognizerOptions[recognizer.recognizerName])) {
+          if (key in settings) {
+            settings[key] = value;
+          }
+        }
+        settings.barcodeScanningStartedCallback = () => {
+          eventCallback({ status: RecognitionStatus.BarcodeScanningStarted });
+        };
+        settings.classifierCallback = (supported) => {
+          eventCallback({
+            status: RecognitionStatus.DocumentClassified,
+            data: supported,
+          });
+        };
+        await recognizer.updateSettings(settings);
+      }
+    }
+    const recognizerInstances = [];
+    for (let i = 0; i < pureRecognizers.length; ++i) {
+      const recognizer = pureRecognizers[i];
+      const instance = { name: recognizers[i], recognizer };
+      recognizerInstances.push(instance);
+    }
+    return recognizerInstances;
+  }
+  async createRecognizerRunner(recognizers) {
+    const metadataCallbacks = {
+      onQuadDetection: (quad) => {
+        this.lastDetectionStatus = quad.detectionStatus;
+      },
+    };
+    const recognizerRunner = await BlinkIDSDK.createRecognizerRunner(this.sdk, recognizers.map((el) => el.recognizer), false, metadataCallbacks);
+    return recognizerRunner;
+  }
+  async cancelRecognition(initiatedFromOutside = false) {
+    this.cancelInitiatedFromOutside = initiatedFromOutside;
+    this.eventEmitter$.dispatchEvent(new Event("terminate"));
+  }
+}