@microblink/blinkid-in-browser-sdk
Version:
A simple ID scanning library for WebAssembly-enabled browsers.
1,221 lines (1,212 loc) • 677 kB
JavaScript
import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-a26bf010.js';
/*! ****************************************************************************
Copyright (c) Microblink. All rights reserved.
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
***************************************************************************** */
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
let nextMessageID = 0;
function getNextMessageID() {
const msgId = nextMessageID;
nextMessageID = nextMessageID + 1;
return msgId;
}
class BaseRequestMessage {
constructor(action) {
this.action = action;
this.messageID = getNextMessageID();
}
}
class InitMessage extends BaseRequestMessage {
constructor(wasmLoadSettings, userId) {
super(InitMessage.action);
this.wasmModuleName = wasmLoadSettings.wasmModuleName;
this.licenseKey = wasmLoadSettings.licenseKey;
this.userId = userId;
this.registerLoadCallback = wasmLoadSettings.loadProgressCallback !== null;
this.allowHelloMessage = wasmLoadSettings.allowHelloMessage;
this.engineLocation = wasmLoadSettings.engineLocation;
this.wasmType = wasmLoadSettings.wasmType;
this.initialMemory = wasmLoadSettings.initialMemory;
this.blinkIDVariant = wasmLoadSettings.blinkIdVariant;
this.numberOfWorkers = wasmLoadSettings.numberOfWorkers;
}
}
InitMessage.action = "init";
var ParameterType;
(function (ParameterType) {
ParameterType[ParameterType["Any"] = 0] = "Any";
ParameterType[ParameterType["Recognizer"] = 1] = "Recognizer";
ParameterType[ParameterType["RecognizerSettings"] = 2] = "RecognizerSettings";
ParameterType[ParameterType["Callback"] = 3] = "Callback";
})(ParameterType || (ParameterType = {}));
class CreateNewRecognizer extends BaseRequestMessage {
constructor(className, params) {
super(CreateNewRecognizer.action);
this.className = className;
this.params = params;
}
}
CreateNewRecognizer.action = "createNewNativeObject";
class CreateRecognizerRunner extends BaseRequestMessage {
constructor(recognizerHandles, allowMultipleResults, registeredMetadataCallbacks) {
super(CreateRecognizerRunner.action);
this.recognizerHandles = recognizerHandles;
this.allowMultipleResults = allowMultipleResults;
this.registeredMetadataCallbacks = registeredMetadataCallbacks;
}
}
CreateRecognizerRunner.action = "createRecognizerRunner";
class ReconfigureRecognizerRunner extends BaseRequestMessage {
constructor(recognizerHandles, allowMultipleResults) {
super(ReconfigureRecognizerRunner.action);
this.recognizerHandles = recognizerHandles;
this.allowMultipleResults = allowMultipleResults;
}
}
ReconfigureRecognizerRunner.action = "reconfigureRecognizerRunner";
class DeleteRecognizerRunner extends BaseRequestMessage {
constructor() {
super(DeleteRecognizerRunner.action);
}
}
DeleteRecognizerRunner.action = "deleteRecognizerRunner";
class InvokeObjectMethod extends BaseRequestMessage {
constructor(objectHandle, methodName, params) {
super(InvokeObjectMethod.action);
this.objectHandle = objectHandle;
this.methodName = methodName;
this.params = params;
}
}
InvokeObjectMethod.action = "invokeObject";
class ProcessImage extends BaseRequestMessage {
constructor(image) {
super(ProcessImage.action);
this.frame = image;
}
getTransferrables() {
return [this.frame.imageData.data.buffer];
}
}
ProcessImage.action = "processImage";
class ResetRecognizers extends BaseRequestMessage {
constructor(hardReset) {
super(ResetRecognizers.action);
this.hardReset = hardReset;
}
}
ResetRecognizers.action = "resetRecognizers";
class RegisteredMetadataCallbacks {
constructor() {
this.onDebugText = false;
this.onDetectionFailed = false;
this.onQuadDetection = false;
this.onPointsDetection = false;
this.onFirstSideResult = false;
}
}
class RegisterMetadataCallbacks extends BaseRequestMessage {
constructor(registeredMetadataCallbacks) {
super(RegisterMetadataCallbacks.action);
this.registeredMetadataCallbacks = registeredMetadataCallbacks;
}
}
RegisterMetadataCallbacks.action = "registerMetadataCallbacks";
class SetDetectionOnly extends BaseRequestMessage {
constructor(detectionOnlyMode) {
super(SetDetectionOnly.action);
this.detectionOnlyMode = detectionOnlyMode;
}
}
SetDetectionOnly.action = "setDetectionOnly";
class SetCameraPreviewMirrored extends BaseRequestMessage {
constructor(cameraPreviewMirrored) {
super(SetCameraPreviewMirrored.action);
this.cameraPreviewMirrored = cameraPreviewMirrored;
}
}
SetCameraPreviewMirrored.action = "setCameraPreviewMirrored";
class GetProductIntegrationInfo extends BaseRequestMessage {
constructor(userId) {
super(GetProductIntegrationInfo.action);
this.userId = userId;
}
}
GetProductIntegrationInfo.action = "getProductIntegrationInfo";
class SetPingProxyUrl extends BaseRequestMessage {
constructor(pingProxyUrl) {
super(SetPingProxyUrl.action);
this.pingProxyUrl = pingProxyUrl;
}
}
SetPingProxyUrl.action = "setPingProxyUrl";
class SetPingData extends BaseRequestMessage {
constructor(data) {
super(SetPingData.action);
this.data = data;
}
}
SetPingData.action = "setPingData";
// ===================================== /
// Metadata callback messages
// ===================================== /
var MetadataCallback;
(function (MetadataCallback) {
MetadataCallback[MetadataCallback["onDebugText"] = 0] = "onDebugText";
MetadataCallback[MetadataCallback["onDetectionFailed"] = 1] = "onDetectionFailed";
MetadataCallback[MetadataCallback["onQuadDetection"] = 2] = "onQuadDetection";
MetadataCallback[MetadataCallback["onPointsDetection"] = 3] = "onPointsDetection";
MetadataCallback[MetadataCallback["onFirstSideResult"] = 4] = "onFirstSideResult";
MetadataCallback[MetadataCallback["recognizerCallback"] = 5] = "recognizerCallback";
})(MetadataCallback || (MetadataCallback = {}));
/* eslint-enable @typescript-eslint/no-explicit-any */
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
/**
* Defines the type of the WASM that will be loaded.
*/
var WasmType;
(function (WasmType) {
/**
* The WASM that will be loaded will be most compatible with all browsers that
* support the WASM, but will lack features that could be used to improve performance.
*/
WasmType["Basic"] = "BASIC";
/**
* The WASM that will be loaded will be built with advanced WASM features, such as
* bulk memory, SIMD, non-trapping floating point and sign extension. Such WASM can only
* be executed in browsers that support those features. Attempting to run this
* WASM in a non-compatible browser will crash your app.
*/
WasmType["Advanced"] = "ADVANCED";
/**
* The WASM that will be loaded will be build with advanced WASM features, just
* like above. Additionally, it will be also built with support for multi-threaded
* processing. This feature requires a browser with support for both advanced WASM
* features and `SharedArrayBuffer`
*/
WasmType["AdvancedWithThreads"] = "ADVANCED_WITH_THREADS";
})(WasmType || (WasmType = {}));
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
const defaultWasmModuleName = "BlinkIDWasmSDK";
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
/* eslint-disable @typescript-eslint/no-explicit-any,
@typescript-eslint/no-unsafe-assignment */
class SDKError extends Error {
constructor(error, details) {
super();
if (!error.code || !error.message) {
throw new Error("Instance of SDKError is required to have code and message.");
}
this.message = error.message;
this.code = error.code;
if (error instanceof SerializableSDKError && error.details && "message" in error.details) {
const errorObj = new Error(error.details.message);
if ("stack" in error.details) {
errorObj.stack = error.details.stack;
}
this.details = errorObj;
}
else {
this.details = details;
}
}
}
class SerializableSDKError {
constructor(error, details) {
if (!error.code || !error.message) {
throw new Error("Instance of SDKError is required to have code and message.");
}
this.message = error.message;
this.code = error.code;
if (details instanceof Error) {
this.details = new CustomError(details);
}
else {
this.details = details;
}
}
}
class CustomError {
constructor(error) {
this.message = error.message;
this.name = error.name;
this.stack = error.stack;
}
}
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
/**
* Checks if provided string is valid secure URL without subpaths.
* @param url URL to check.
* @returns Boolean indicating if provided URL is valid.
*/
function isValidURL(url) {
// eslint-disable-next-line no-useless-escape
const regex = /^https:\/\/[^\/]+(?::\d+)?\/?$/;
return regex.test(url);
}
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
/* eslint-disable max-len */
/**
* Structures of Error Codes, Error Messages, and CustomError compatible objects for the Error Generator utility.
* Error Code convention: SECTION_OBJECT_(ACTION)_PROBLEM
*/
var ErrorCodes$1;
(function (ErrorCodes) {
ErrorCodes["WORKER_WASM_LOAD_FAILURE"] = "WORKER_WASM_LOAD_FAILURE";
ErrorCodes["WORKER_WASM_INIT_MISSING"] = "WORKER_WASM_INIT_MISSING";
ErrorCodes["WORKER_FUNCTION_INVOKE_FAILURE"] = "WORKER_FUNCTION_INVOKE_FAILURE";
ErrorCodes["WORKER_RECOGNIZER_CREATION_FAILURE"] = "WORKER_RECOGNIZER_CREATION_FAILURE";
ErrorCodes["WORKER_RUNNER_EXISTS"] = "WORKER_RUNNER_EXISTS";
ErrorCodes["WORKER_RUNNER_CREATION_FAILURE"] = "WORKER_RUNNER_CREATION_FAILURE";
ErrorCodes["WORKER_RUNNER_MISSING"] = "WORKER_RUNNER_MISSING";
ErrorCodes["WORKER_RUNNER_RECONFIGURE_FAILURE"] = "WORKER_RUNNER_RECONFIGURE_FAILURE";
ErrorCodes["WORKER_RUNNER_DELETED"] = "WORKER_RUNNER_DELETED";
ErrorCodes["WORKER_RUNNER_DELETE_FAILURE"] = "WORKER_RUNNER_DELETE_FAILURE";
ErrorCodes["WORKER_OBJECT_INVOKE_FAILURE"] = "WORKER_OBJECT_INVOKE_FAILURE";
ErrorCodes["WORKER_IMAGE_PROCESS_FAILURE"] = "WORKER_IMAGE_PROCESS_FAILURE";
ErrorCodes["WORKER_HANDLE_UNDEFINED"] = "WORKER_HANDLE_UNDEFINED";
ErrorCodes["WORKER_MESSAGE_ACTION_UNKNOWN"] = "WORKER_MESSAGE_ACTION_UNKNOWN";
ErrorCodes["WORKER_LICENSE_UNLOCK_ERROR"] = "WORKER_LICENSE_UNLOCK_ERROR";
ErrorCodes["WORKER_INTEGRATION_INFO_FAILURE"] = "WORKER_INTEGRATION_INFO_FAILURE";
ErrorCodes["LOCAL_SDK_RUNNER_MISSING"] = "LOCAL_SDK_RUNNER_MISSING";
ErrorCodes["LOCAL_SDK_RUNNER_EMPTY"] = "LOCAL_SDK_RUNNER_EMPTY";
ErrorCodes["LICENSE_UNLOCK_ERROR"] = "LICENSE_UNLOCK_ERROR";
ErrorCodes["FRAME_CAPTURE_SVG_UNSUPPORTED"] = "FRAME_CAPTURE_SVG_UNSUPPORTED";
ErrorCodes["FRAME_CAPTURE_CANVAS_MISSING"] = "FRAME_CAPTURE_CANVAS_MISSING";
ErrorCodes["SDK_WASM_SETTINGS_MISSING"] = "SDK_WASM_SETTINGS_MISSING";
ErrorCodes["SDK_LICENSE_KEY_MISSING"] = "SDK_LICENSE_KEY_MISSING";
ErrorCodes["SDK_WASM_MODULE_NAME_MISSING"] = "SDK_WASM_MODULE_NAME_MISSING";
ErrorCodes["SDK_ENGINE_LOCATION_INVALID"] = "SDK_ENGINE_LOCATION_INVALID";
ErrorCodes["SDK_WORKER_LOCATION_INVALID"] = "SDK_WORKER_LOCATION_INVALID";
ErrorCodes["SDK_MISSING"] = "SDK_MISSING";
ErrorCodes["SDK_RECOGNIZERS_MISSING"] = "SDK_RECOGNIZERS_MISSING";
ErrorCodes["VIDEO_RECOGNIZER_ELEMENT_MISSING"] = "VIDEO_RECOGNIZER_ELEMENT_MISSING";
ErrorCodes["VIDEO_RECOGNIZER_CAMERA_MISSING"] = "VIDEO_RECOGNIZER_CAMERA_MISSING";
ErrorCodes["VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED"] = "VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED";
ErrorCodes["VIDEO_RECOGNIZER_CAMERA_UNAVAILABLE"] = "VIDEO_RECOGNIZER_CAMERA_UNAVAILABLE";
ErrorCodes["VIDEO_RECOGNIZER_CAMERA_IN_USE"] = "VIDEO_RECOGNIZER_CAMERA_IN_USE";
ErrorCodes["VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED"] = "VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED";
ErrorCodes["VIDEO_RECOGNIZER_FEED_RELEASED"] = "VIDEO_RECOGNIZER_FEED_RELEASED";
ErrorCodes["VIDEO_RECOGNIZER_FEED_NOT_PAUSED"] = "VIDEO_RECOGNIZER_FEED_NOT_PAUSED";
ErrorCodes["VIDEO_RECOGNIZER_PLAY_REQUEST_INTERRUPTED"] = "VIDEO_RECOGNIZER_PLAY_REQUEST_INTERRUPTED";
ErrorCodes["VIDEO_RECOGNIZER_FEED_PAUSED"] = "VIDEO_RECOGNIZER_FEED_PAUSED";
ErrorCodes["VIDEO_RECOGNIZER_RECOGNIZERS_RESET_FAILURE"] = "VIDEO_RECOGNIZER_RECOGNIZERS_RESET_FAILURE";
ErrorCodes["VIDEO_RECOGNIZER_FEED_MISSING"] = "VIDEO_RECOGNIZER_FEED_MISSING";
ErrorCodes["INVALID_PING_PROXY_URL"] = "INVALID_PROXY_URL";
ErrorCodes["PING_PROXY_PERMISSION_NOT_GRANTED"] = "PING_PROXY_PERMISSION_NOT_GRANTED";
ErrorCodes["PING_DATA_KEYS_AMOUNT_EXCEEDED"] = "PING_DATA_KEYS_AMOUNT_EXCEEDED";
ErrorCodes["PING_DATA_KEY_LENGTH_EXCEEDED"] = "PING_DATA_KEY_LENGTH_EXCEEDED";
ErrorCodes["PING_DATA_VALUE_LENGTH_EXCEEDED"] = "PING_DATA_VALUE_LENGTH_EXCEEDED";
})(ErrorCodes$1 || (ErrorCodes$1 = {}));
var ErrorMessages$1;
(function (ErrorMessages) {
ErrorMessages["WORKER_HANDLE_UNDEFINED"] = "Cannot find object with handle: undefined";
ErrorMessages["WORKER_WASM_LOAD_FAILURE"] = "Failed to load WASM in web worker!";
ErrorMessages["WORKER_WASM_INIT_MISSING"] = "WASM module is not initialized!";
ErrorMessages["WORKER_FUNCTION_INVOKE_FAILURE"] = "Failed to invoke function!";
ErrorMessages["WORKER_RECOGNIZER_CREATION_FAILURE"] = "Failed to create new recognizer!";
ErrorMessages["WORKER_RUNNER_EXISTS"] = "Recognizer runner is already created! Multiple instances are not allowed!";
ErrorMessages["WORKER_RUNNER_CREATION_FAILURE"] = "Failed to create new recognizer runner!";
ErrorMessages["WORKER_RUNNER_MISSING"] = "Recognizer runner is not created! There is nothing to reconfigure!";
ErrorMessages["WORKER_RUNNER_RECONFIGURE_FAILURE"] = "Failed to reconfigure recognizer runner!";
ErrorMessages["WORKER_RUNNER_DELETED"] = "Recognizer runner is already deleted!";
ErrorMessages["WORKER_RUNNER_DELETE_FAILURE"] = "Failed to delete recognizer runner!";
ErrorMessages["WORKER_OBJECT_INVOKE_FAILURE"] = "Failed to invoke object!";
ErrorMessages["WORKER_IMAGE_PROCESS_FAILURE"] = "Recognizer runner is not initialized! Cannot process image!";
ErrorMessages["WORKER_INTEGRATION_INFO_FAILURE"] = "Failed to get product integration info!";
ErrorMessages["LOCAL_SDK_RUNNER_MISSING"] = "Property nativeRecognizerRunner is not available!";
ErrorMessages["LOCAL_SDK_RUNNER_EMPTY"] = "Native RecognizerRunner cannot be empty!";
ErrorMessages["LICENSE_TOKEN_STATE_INCORRECT"] = "Internal error (Incorrect token state)";
ErrorMessages["LICENSE_PAYLOAD_VERIFICATION_FAILED"] = "Failed to verify server permission's digital signature!";
ErrorMessages["LICENSE_PAYLOAD_CORRUPTED"] = "Server permission payload is corrupted!";
ErrorMessages["LICENSE_PERMISSION_EXPIRED"] = "Internal error (server permission expired)";
ErrorMessages["LICENSE_REMOTE_LOCKED"] = "Provided license key has been remotely locked. Please contact support for more information!";
ErrorMessages["FRAME_CAPTURE_SVG_UNSUPPORTED"] = "Recognition of SVG elements not supported!";
ErrorMessages["FRAME_CAPTURE_CANVAS_MISSING"] = "Could not get canvas 2d context!";
ErrorMessages["SDK_WASM_SETTINGS_MISSING"] = "Missing WASM load settings!";
ErrorMessages["SDK_LICENSE_KEY_MISSING"] = "Missing license key!";
ErrorMessages["SDK_WASM_MODULE_NAME_MISSING"] = "Missing WASM module name!";
ErrorMessages["SDK_ENGINE_LOCATION_INVALID"] = "Setting property 'engineLocation' must be a string!";
ErrorMessages["SDK_WORKER_LOCATION_INVALID"] = "Setting property 'workerLocation' must be a string!";
ErrorMessages["SDK_MISSING"] = "SDK is not provided!";
ErrorMessages["SDK_RECOGNIZERS_MISSING"] = "To create RecognizerRunner at least 1 recognizer is required.";
ErrorMessages["VIDEO_RECOGNIZER_ELEMENT_MISSING"] = "Video element, i.e. camera feed is not provided!";
ErrorMessages["VIDEO_RECOGNIZER_CAMERA_MISSING"] = "Camera not found!";
ErrorMessages["VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED"] = "Camera not allowed!";
ErrorMessages["VIDEO_RECOGNIZER_CAMERA_UNAVAILABLE"] = "Camera not available!";
ErrorMessages["VIDEO_RECOGNIZER_CAMERA_IN_USE"] = "Camera in use!";
ErrorMessages["VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED"] = "Media devices not supported by browser.";
ErrorMessages["VIDEO_RECOGNIZER_FEED_RELEASED"] = "The associated video feed has been released!";
ErrorMessages["VIDEO_RECOGNIZER_FEED_NOT_PAUSED"] = "The associated video feed is not paused. Use resumeRecognition instead!";
ErrorMessages["VIDEO_RECOGNIZER_PLAY_REQUEST_INTERRUPTED"] = "The play() request was interrupted or prevented by browser security rules!";
ErrorMessages["VIDEO_RECOGNIZER_FEED_PAUSED"] = "Cannot resume recognition while video feed is paused! Use recognize or startRecognition";
ErrorMessages["VIDEO_RECOGNIZER_RECOGNIZERS_RESET_FAILURE"] = "Could not reset recognizers!";
ErrorMessages["VIDEO_RECOGNIZER_FEED_MISSING"] = "Missing video feed!";
ErrorMessages["INVALID_PING_PROXY_URL"] = "Provided ping proxy URL is not a valid secure URL in format 'https://{host}:{port?}'.";
ErrorMessages["PING_PROXY_PERMISSION_NOT_GRANTED"] = "Allow ping proxy permission not found in license.";
ErrorMessages["PING_DATA_KEYS_AMOUNT_EXCEEDED"] = "Maximum number of ping data keys exceeded.";
ErrorMessages["PING_DATA_KEY_LENGTH_EXCEEDED"] = "Ping data key is too long.";
ErrorMessages["PING_DATA_VALUE_LENGTH_EXCEEDED"] = "Ping data value is too long.";
})(ErrorMessages$1 || (ErrorMessages$1 = {}));
const videoRecognizerErrors = {
feedMissing: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_FEED_MISSING,
code: ErrorCodes$1.VIDEO_RECOGNIZER_FEED_MISSING,
},
recognizersResetFailure: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_RECOGNIZERS_RESET_FAILURE,
code: ErrorCodes$1.VIDEO_RECOGNIZER_RECOGNIZERS_RESET_FAILURE,
},
feedPaused: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_FEED_PAUSED,
code: ErrorCodes$1.VIDEO_RECOGNIZER_FEED_PAUSED,
},
playRequestInterrupted: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_PLAY_REQUEST_INTERRUPTED,
code: ErrorCodes$1.VIDEO_RECOGNIZER_PLAY_REQUEST_INTERRUPTED,
},
videoFeedNotPaused: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_FEED_NOT_PAUSED,
code: ErrorCodes$1.VIDEO_RECOGNIZER_FEED_NOT_PAUSED,
},
videoFeedReleased: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_FEED_RELEASED,
code: ErrorCodes$1.VIDEO_RECOGNIZER_FEED_RELEASED,
},
mediaDevicesUnsupported: {
code: ErrorCodes$1.VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED,
message: ErrorMessages$1.VIDEO_RECOGNIZER_MEDIA_DEVICES_UNSUPPORTED,
},
cameraMissing: {
code: ErrorCodes$1.VIDEO_RECOGNIZER_CAMERA_MISSING,
message: ErrorMessages$1.VIDEO_RECOGNIZER_CAMERA_MISSING,
},
cameraNotAllowed: {
code: ErrorCodes$1.VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED,
message: ErrorMessages$1.VIDEO_RECOGNIZER_CAMERA_NOT_ALLOWED,
},
elementMissing: {
message: ErrorMessages$1.VIDEO_RECOGNIZER_ELEMENT_MISSING,
code: ErrorCodes$1.VIDEO_RECOGNIZER_ELEMENT_MISSING,
},
};
const sdkErrors = {
wasmSettingsMissing: {
message: ErrorMessages$1.SDK_WASM_SETTINGS_MISSING,
code: ErrorCodes$1.SDK_WASM_SETTINGS_MISSING,
},
licenseKeyMissing: {
message: ErrorMessages$1.SDK_LICENSE_KEY_MISSING,
code: ErrorCodes$1.SDK_LICENSE_KEY_MISSING,
},
wasmModuleNameMissing: {
message: ErrorMessages$1.SDK_WASM_MODULE_NAME_MISSING,
code: ErrorCodes$1.SDK_WASM_MODULE_NAME_MISSING,
},
engineLocationInvalid: {
message: ErrorMessages$1.SDK_ENGINE_LOCATION_INVALID,
code: ErrorCodes$1.SDK_ENGINE_LOCATION_INVALID,
},
workerLocationInvalid: {
message: ErrorMessages$1.SDK_WORKER_LOCATION_INVALID,
code: ErrorCodes$1.SDK_WORKER_LOCATION_INVALID,
},
missing: {
message: ErrorMessages$1.SDK_MISSING,
code: ErrorCodes$1.SDK_MISSING,
},
recognizersMissing: {
message: ErrorMessages$1.SDK_RECOGNIZERS_MISSING,
code: ErrorCodes$1.SDK_RECOGNIZERS_MISSING,
},
};
const frameCaptureErrors = {
svgUnsupported: {
message: ErrorMessages$1.FRAME_CAPTURE_SVG_UNSUPPORTED,
code: ErrorCodes$1.FRAME_CAPTURE_SVG_UNSUPPORTED,
},
canvasMissing: {
message: ErrorMessages$1.FRAME_CAPTURE_CANVAS_MISSING,
code: ErrorCodes$1.FRAME_CAPTURE_CANVAS_MISSING,
},
};
const licenseErrors = {
licenseTokenStateIncorrect: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
message: ErrorMessages$1.LICENSE_TOKEN_STATE_INCORRECT,
},
licensePayloadVerificationFailed: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
message: ErrorMessages$1.LICENSE_PAYLOAD_VERIFICATION_FAILED,
},
licensePayloadCorrupted: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
message: ErrorMessages$1.LICENSE_PAYLOAD_CORRUPTED,
},
licensePermissionExpired: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
message: ErrorMessages$1.LICENSE_PERMISSION_EXPIRED,
},
licenseRemoteLocked: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
message: ErrorMessages$1.LICENSE_REMOTE_LOCKED,
},
licenseNetworkError: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
},
licenseInvalid: {
code: ErrorCodes$1.LICENSE_UNLOCK_ERROR,
},
};
const localSdkErrors = {
runnerMissing: {
message: ErrorMessages$1.LOCAL_SDK_RUNNER_MISSING,
code: ErrorCodes$1.LOCAL_SDK_RUNNER_MISSING,
},
runnerEmpty: {
message: ErrorMessages$1.LOCAL_SDK_RUNNER_EMPTY,
code: ErrorCodes$1.LOCAL_SDK_RUNNER_EMPTY,
},
};
const workerErrors = {
imageProcessFailure: {
message: ErrorMessages$1.WORKER_IMAGE_PROCESS_FAILURE,
code: ErrorCodes$1.WORKER_IMAGE_PROCESS_FAILURE,
},
objectInvokeFailure: {
message: ErrorMessages$1.WORKER_OBJECT_INVOKE_FAILURE,
code: ErrorCodes$1.WORKER_OBJECT_INVOKE_FAILURE,
},
runnerDeleteFailure: {
message: ErrorMessages$1.WORKER_RUNNER_DELETE_FAILURE,
code: ErrorCodes$1.WORKER_RUNNER_DELETE_FAILURE,
},
runnerDeleted: {
message: ErrorMessages$1.WORKER_RUNNER_DELETED,
code: ErrorCodes$1.WORKER_RUNNER_DELETED,
},
runnerReconfigureFailure: {
message: ErrorMessages$1.WORKER_RUNNER_RECONFIGURE_FAILURE,
code: ErrorCodes$1.WORKER_RUNNER_RECONFIGURE_FAILURE,
},
runnerMissing: {
message: ErrorMessages$1.WORKER_RUNNER_MISSING,
code: ErrorCodes$1.WORKER_RUNNER_MISSING,
},
runnerCreationFailure: {
message: ErrorMessages$1.WORKER_RUNNER_CREATION_FAILURE,
code: ErrorCodes$1.WORKER_RUNNER_CREATION_FAILURE,
},
runnerExists: {
message: ErrorMessages$1.WORKER_RUNNER_EXISTS,
code: ErrorCodes$1.WORKER_RUNNER_EXISTS,
},
recognizerCreationFailure: {
message: ErrorMessages$1.WORKER_RECOGNIZER_CREATION_FAILURE,
code: ErrorCodes$1.WORKER_RECOGNIZER_CREATION_FAILURE,
},
functionInvokeFailure: {
message: ErrorMessages$1.WORKER_FUNCTION_INVOKE_FAILURE,
code: ErrorCodes$1.WORKER_FUNCTION_INVOKE_FAILURE,
},
wasmInitMissing: {
message: ErrorMessages$1.WORKER_WASM_INIT_MISSING,
code: ErrorCodes$1.WORKER_WASM_INIT_MISSING,
},
wasmLoadFailure: {
message: ErrorMessages$1.WORKER_WASM_LOAD_FAILURE,
code: ErrorCodes$1.WORKER_WASM_LOAD_FAILURE,
},
handleUndefined: {
message: ErrorMessages$1.WORKER_HANDLE_UNDEFINED,
code: ErrorCodes$1.WORKER_HANDLE_UNDEFINED,
},
integrationInfoFailure: {
message: ErrorMessages$1.WORKER_INTEGRATION_INFO_FAILURE,
code: ErrorCodes$1.WORKER_INTEGRATION_INFO_FAILURE,
},
};
const pingErrors = {
invalidProxyUrl: {
message: ErrorMessages$1.INVALID_PING_PROXY_URL,
code: ErrorCodes$1.INVALID_PING_PROXY_URL,
},
permissionNotGranted: {
message: ErrorMessages$1.PING_PROXY_PERMISSION_NOT_GRANTED,
code: ErrorCodes$1.PING_PROXY_PERMISSION_NOT_GRANTED,
},
dataKeysAmountExceeded: {
message: ErrorMessages$1.PING_DATA_KEYS_AMOUNT_EXCEEDED,
code: ErrorCodes$1.PING_DATA_KEYS_AMOUNT_EXCEEDED,
},
dataKeyLengthExceeded: {
message: ErrorMessages$1.PING_DATA_KEY_LENGTH_EXCEEDED,
code: ErrorCodes$1.PING_DATA_KEY_LENGTH_EXCEEDED,
},
dataValueLengthExceeded: {
message: ErrorMessages$1.PING_DATA_VALUE_LENGTH_EXCEEDED,
code: ErrorCodes$1.PING_DATA_VALUE_LENGTH_EXCEEDED,
}
};
/* eslint-disable @typescript-eslint/no-unsafe-argument */
function defaultEventHandler(resolve, reject) {
return (msg) => {
const resultMsg = msg;
if (resultMsg.success) {
resolve();
}
else {
if (typeof resultMsg.error === "string" || resultMsg.error === null) {
reject(resultMsg.error);
}
else {
reject(new SDKError(resultMsg.error));
}
}
};
}
function defaultResultEventHandler(successResolver, reject) {
return (msg) => {
const resultMsg = msg;
if (resultMsg.success) {
successResolver(msg);
}
else {
if (typeof resultMsg.error === "string" || resultMsg.error === null) {
reject(resultMsg.error);
}
else {
reject(new SDKError(resultMsg.error));
}
}
};
}
/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
function wrapParameters(params) {
// convert params
const wrappedPrameters = [];
for (let param of params) {
let paramType = ParameterType.Any;
if (param instanceof RemoteRecognizer) {
paramType = ParameterType.Recognizer;
param = param.getRemoteObjectHandle();
}
wrappedPrameters.push({
parameter: param,
type: paramType
});
}
return wrappedPrameters;
}
/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment */
class RemoteRecognizer {
/* eslint-enable lines-between-class-members */
constructor(wasmWorker, recognizerName, remoteObjHandle) {
this.wasmSDKWorker = wasmWorker;
this.objectHandle = remoteObjHandle;
this.recognizerName = recognizerName;
this.callbacks = new Map();
}
/* eslint-enable @typescript-eslint/ban-types */
getRemoteObjectHandle() {
return this.objectHandle;
}
currentSettings() {
return new Promise((resolve, reject) => {
if (this.objectHandle < 0) {
reject("Invalid object handle: " + this.objectHandle.toString());
return;
}
const msg = new InvokeObjectMethod(this.objectHandle, "currentSettings", []);
const handler = defaultResultEventHandler((msg) => {
resolve(msg.result);
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
toSignedJSON() {
{
return new Promise((resolve, reject) => {
if (this.objectHandle < 0) {
reject("Invalid object handle: " + this.objectHandle.toString());
return;
}
const msg = new InvokeObjectMethod(this.objectHandle, "toSignedJSON", []);
const handler = defaultResultEventHandler((msg) => {
resolve(msg.result);
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
}
clearAllCallbacks() {
this.callbacks.clear();
this.wasmSDKWorker.unregisterRecognizerCallbacks(this.objectHandle);
}
/* eslint-disable @typescript-eslint/no-explicit-any,
@typescript-eslint/no-unsafe-assignment,
@typescript-eslint/no-unsafe-member-access,
@typescript-eslint/no-unsafe-return
*/
// convert each function member into wrapped parameter, containing address where callback needs to be delivered
removeFunctions(settings) {
// clear any existing callbacks
this.clearAllCallbacks();
const keys = Object.keys(settings);
let needsRegistering = false;
for (const key of keys) {
const data = settings[key];
if (typeof data === "function") {
this.callbacks.set(key, data);
const wrappedFunction = {
parameter: {
recognizerHandle: this.objectHandle,
callbackName: key
}, // in order to know to which instance callback needs to be delivered
type: ParameterType.Callback
};
settings[key] = wrappedFunction;
needsRegistering = true;
}
}
if (needsRegistering) {
this.wasmSDKWorker.registerRecognizerCallbacks(this.objectHandle, this);
}
return settings;
}
/* eslint-enable @typescript-eslint/no-explicit-any,
@typescript-eslint/no-unsafe-assignment,
@typescript-eslint/no-unsafe-member-access,
@typescript-eslint/no-unsafe-return
*/
updateSettings(newSettings) {
return new Promise((resolve, reject) => {
if (this.objectHandle < 0) {
reject("Invalid object handle: " + this.objectHandle.toString());
return;
}
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
const msg = new InvokeObjectMethod(this.objectHandle, "updateSettings", [
{
parameter: this.removeFunctions(newSettings),
type: ParameterType.RecognizerSettings
}
]);
/* eslint-enable @typescript-eslint/no-unsafe-assignment */
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
/* eslint-disable @typescript-eslint/no-explicit-any */
invokeCallback(callbackName, args) {
const callback = this.callbacks.get(callbackName);
if (callback !== undefined) {
callback(...args);
}
else {
console.warn("Cannot find callback", callbackName);
}
}
/* eslint-enable @typescript-eslint/no-explicit-any */
getResult() {
return new Promise((resolve, reject) => {
if (this.objectHandle < 0) {
reject("Invalid object handle: " + this.objectHandle.toString());
return;
}
const msg = new InvokeObjectMethod(this.objectHandle, "getResult", []);
const handler = defaultResultEventHandler((msg) => {
resolve(msg.result);
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
delete() {
return new Promise((resolve, reject) => {
if (this.objectHandle < 0) {
reject("Invalid object handle: " + this.objectHandle.toString());
return;
}
this.clearAllCallbacks();
const msg = new InvokeObjectMethod(this.objectHandle, "delete", []);
const handler = defaultEventHandler(() => {
this.objectHandle = -1;
resolve();
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
}
function createRegisteredCallbacks(metadataCallbacks) {
const msg = new RegisteredMetadataCallbacks();
// https://stackoverflow.com/a/20093686/213057
msg.onDebugText = !!metadataCallbacks.onDebugText;
msg.onDetectionFailed = !!metadataCallbacks.onDetectionFailed;
msg.onPointsDetection = !!metadataCallbacks.onPointsDetection;
msg.onQuadDetection = !!metadataCallbacks.onQuadDetection;
msg.onFirstSideResult = !!metadataCallbacks.onFirstSideResult;
return msg;
}
class RemoteRecognizerRunner {
constructor(wasmWorker, recognizers) {
this.deleted = false;
this.wasmSDKWorker = wasmWorker;
this.recognizers = recognizers;
}
processImage(image) {
return new Promise((resolve, reject) => {
if (this.deleted) {
reject("Recognizer runner is deleted. It cannot be used anymore!");
return;
}
const msg = new ProcessImage(image);
const handler = defaultResultEventHandler((response) => {
const state = response.recognitionState;
resolve(state);
}, reject);
this.wasmSDKWorker.postTransferrableMessage(msg, handler);
});
}
reconfigureRecognizers(recognizers, allowMultipleResults) {
return new Promise((resolve, reject) => {
if (this.deleted) {
reject("Recognizer runner is deleted. It cannot be used anymore!");
return;
}
const recognizerHandles = getRecognizerHandles(recognizers);
const msg = new ReconfigureRecognizerRunner(recognizerHandles, allowMultipleResults);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
this.recognizers = recognizers;
});
}
setMetadataCallbacks(metadataCallbacks) {
return new Promise((resolve, reject) => {
const msg = new RegisterMetadataCallbacks(createRegisteredCallbacks(metadataCallbacks));
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessageAndRegisterCallbacks(msg, metadataCallbacks, handler);
});
}
resetRecognizers(hardReset) {
return new Promise((resolve, reject) => {
const msg = new ResetRecognizers(hardReset);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
setDetectionOnlyMode(detectionOnly) {
return new Promise((resolve, reject) => {
const msg = new SetDetectionOnly(detectionOnly);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
setPingProxyUrl(url) {
if (!isValidURL(url)) {
throw new SDKError(pingErrors.invalidProxyUrl);
}
return new Promise((resolve, reject) => {
const msg = new SetPingProxyUrl(url);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
setPingData(data) {
return new Promise((resolve, reject) => {
const msg = new SetPingData(data);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
setCameraPreviewMirrored(mirrored) {
return new Promise((resolve, reject) => {
const msg = new SetCameraPreviewMirrored(mirrored);
const handler = defaultEventHandler(resolve, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
delete() {
if (this.deleted) {
return Promise.reject("Recognizer runner is already deleted.");
}
return new Promise((resolve, reject) => {
const msg = new DeleteRecognizerRunner();
const handler = defaultEventHandler(() => {
this.deleted = true;
resolve();
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
}
function getRecognizerHandles(remoteRecognizers) {
const recognizerHandles = [];
for (const remoteRecognizer of remoteRecognizers) {
recognizerHandles.push(remoteRecognizer.getRemoteObjectHandle());
}
return recognizerHandles;
}
class WasmModuleWorkerProxy {
constructor(wasmSDKWorker) {
this.wasmSDKWorker = wasmSDKWorker;
}
createRecognizerRunner(recognizers, allowMultipleResults = false, metadataCallbacks = {}) {
return new Promise((resolve, reject) => {
const recognizerHandles = getRecognizerHandles(recognizers);
const msg = new CreateRecognizerRunner(recognizerHandles, allowMultipleResults, createRegisteredCallbacks(metadataCallbacks));
const handler = defaultEventHandler(() => {
resolve(new RemoteRecognizerRunner(this.wasmSDKWorker, recognizers));
}, reject);
this.wasmSDKWorker.postMessageAndRegisterCallbacks(msg, metadataCallbacks, handler);
});
}
/* eslint-disable @typescript-eslint/no-explicit-any */
newRecognizer(className, ...constructorArgs) {
return new Promise((resolve, reject) => {
const msg = new CreateNewRecognizer(className, wrapParameters(constructorArgs));
const handler = defaultResultEventHandler((msg) => {
const remoteRecognizer = new RemoteRecognizer(this.wasmSDKWorker, className, msg.objectHandle);
resolve(remoteRecognizer);
}, reject);
this.wasmSDKWorker.postMessage(msg, handler);
});
}
}
class WasmSDKWorker {
/* eslint-enable lines-between-class-members */
constructor(worker, loadProgressCallback, userId, rejectHandler) {
this.eventHandlers = {};
this.metadataCallbacks = {};
this.loadedWasmType = WasmType.Basic; // will be updated after WASM gets loaded
this.mbWasmWorker = worker;
this.mbWasmWorker.onmessage = (event) => { this.handleWorkerEvent(event); };
this.mbWasmWorker.onerror = () => {
rejectHandler("Problem during initialization of worker file!");
return;
};
this.mbWasmModule = new WasmModuleWorkerProxy(this);
this.loadCallback = loadProgressCallback;
this.recognizersWithCallbacks = new Map();
this.userId = userId;
this.showOverlay = false;
}
postMessage(message, eventHandler) {
this.eventHandlers[message.messageID] = eventHandler;
this.mbWasmWorker.postMessage(message);
}
postTransferrableMessage(message, eventHandler) {
this.eventHandlers[message.messageID] = eventHandler;
this.mbWasmWorker.postMessage(message, message.getTransferrables());
}
postMessageAndRegisterCallbacks(message, metadataCallbacks, eventHandler) {
this.eventHandlers[message.messageID] = eventHandler;
this.metadataCallbacks = metadataCallbacks;
this.mbWasmWorker.postMessage(message);
}
registerRecognizerCallbacks(remoteRecognizerHandle, recognizer) {
this.recognizersWithCallbacks.set(remoteRecognizerHandle, recognizer);
}
unregisterRecognizerCallbacks(remoteRecognizerHandle) {
this.recognizersWithCallbacks.delete(remoteRecognizerHandle);
}
/**
* Clean up the active instance of the SDK.
*
* It's not possible to use the SDK after this method is called.
*/
delete() {
this.mbWasmWorker.terminate();
}
getProductIntegrationInfo() {
return new Promise((resolve, reject) => {
const msg = new GetProductIntegrationInfo(this.userId);
const handler = defaultResultEventHandler((msg) => {
resolve(msg.result);
}, reject);
this.postMessage(msg, handler);
});
}
handleWorkerEvent(event) {
if ("isCallbackMessage" in event.data) {
const msg = event.data;
switch (msg.callbackType) {
case MetadataCallback.onDebugText:
if (typeof this.metadataCallbacks.onDebugText === "function") {
this.metadataCallbacks.onDebugText(msg.callbackParameters[0]);
}
break;
case MetadataCallback.onDetectionFailed:
if (typeof this.metadataCallbacks.onDetectionFailed === "function") {
this.metadataCallbacks.onDetectionFailed();
}
break;
case MetadataCallback.onPointsDetection:
if (typeof this.metadataCallbacks.onPointsDetection === "function") {
this.metadataCallbacks.onPointsDetection(msg.callbackParameters[0]);
}
break;
case MetadataCallback.onQuadDetection:
if (typeof this.metadataCallbacks.onQuadDetection === "function") {
this.metadataCallbacks.onQuadDetection(msg.callbackParameters[0]);
}
break;
case MetadataCallback.onFirstSideResult:
if (typeof this.metadataCallbacks.onFirstSideResult === "function") {
this.metadataCallbacks.onFirstSideResult();
}
break;
case MetadataCallback.recognizerCallback:
{
// first parameter is address, other parameters are callback parameters
const address = msg.callbackParameters.shift();
const recognizer = this.recognizersWithCallbacks.get(address.recognizerHandle);
if (recognizer !== undefined) {
recognizer.invokeCallback(address.callbackName, msg.callbackParameters);
}
else {
console.warn("Cannot find recognizer to deliver callback message. Maybe it's destroyed?", address);
}
break;
}
default:
throw new Error(`Unknown callback type: ${MetadataCallback[msg.callbackType]}`);
}
}
else if ("isLoadProgressMessage" in event.data) {
const msg = event.data;
if (typeof this.loadCallback === "function") {
this.loadCallback(msg.progress);
}
}
else {
const msg = event.data;
const eventHandler = this.eventHandlers[msg.messageID];
delete this.eventHandlers[msg.messageID];
eventHandler(msg);
}
}
static async createWasmWorker(worker, wasmLoadSettings, userId) {
return new Promise((resolve, reject) => {
const wasmWorker = new WasmSDKWorker(worker, wasmLoadSettings.loadProgressCallback, userId, reject);
const initMessage = new InitMessage(wasmLoadSettings, userId);
const initEventHandler = defaultResultEventHandler((msg) => {
const successMsg = msg;
wasmWorker.showOverlay = successMsg.showOverlay;
wasmWorker.loadedWasmType = successMsg.wasmType;
resolve(wasmWorker);
},
/* eslint-disable @typescript-eslint/no-explicit-any */
(error) => {
if (wasmWorker && typeof wasmWorker.delete === "function") {
wasmWorker.delete();
}
reject(error);
}
/* eslint-enable @typescript-eslint/no-explicit-any */
);
wasmWorker.postMessage(initMessage, initEventHandler);
});
}
}
/**
* Copyright (c) Microblink Ltd. All rights reserved.
*/
/**
* Preferred type of camera to be used when opening the camera feed.
*/
var PreferredCameraType;
(function (PreferredCameraType) {
/** Prefer back facing camera */
PreferredCameraType[PreferredCameraType["BackFacingCamera"] = 0] = "BackFacingCamera";
/** Prefer front facing camera */
PreferredCameraType[PreferredCameraType["FrontFacingCamera"] = 1] = "FrontFacingCamera";
})(PreferredCameraType || (PreferredCameraType = {}));
// inspired by https://unpkg.com/browse/scandit-sdk@4.6.1/src/lib/cameraAccess.ts
const backCameraKeywords = [
"rear",
"back",
"rück",
"arrière",
"trasera",
"trás",
"traseira",
"posteriore",
"posterior",
"后面",
"後面",
"背面",
"后置", // alternative
"後置", // alternative
"背置", // alternative
"задней",
"الخلفية",
"후",
"arka",
"achterzijde",
"หลัง",
"baksidan",
"bagside",
"sau",
"bak",
"tylny",
"takakamera",
"belakang",
"אחורית",
"πίσω",
"spate",
"hátsó",
"zadní",
"darrere",
"zadná",
"задня",
"stražnja",
"belakang",
"बैक"
];
const backDualWideCameraLocalizations = [
"Cameră dublă cu obiectiv superangular spate",
"מצלמה כפולה רחבה אחורית",
"Артқы қос кең бұрышты камера",
"Câmara grande angular dupla traseira",
"Πίσω διπλή ευρεία κάμερα",
"後置雙廣角鏡頭相機",
"Задна двойна широкоъгълна камера",
"Càmera dual posterior amb gran angular",
"Zadná duálna širokouhlá kamera",
"كاميرا خلفية مزدوجة عريضة",
"Задняя двойная широкоугольная камера",
"Задня здвоєна ширококутна камера",
"Cámara amplia posterior doble",
"Dwikamera Lebar Belakang",
"Tylny dwuobiektywowy aparat szerokokątny",
"Dubbel vidvinkelkamera på baksidan",
"Back Dual Wide Camera",
"Hátsó, kettős, széles látószögű kamera",
"후면 듀얼 와이드 카메라",
"Double caméra grand angle arrière",
"Fotocamera doppia con grandangolo (posteriore)",
"Double appareil photo grand angle arrière",
"Zadní duální širokoúhlý fotoaparát",
"Çift Geniş Kamera Arka Yüzü",
"Laajakulmainen kaksoistakakamera",
"Rückseitige Dual-Weitwinkelkamera",
"बैक ड्युअल वाइड कैमरा",
"后置双广角镜头",
"Câmera Dupla Grande-Angular Traseira",
"後置雙廣角相機",
"กล้องคู่ด้านหลังมุมกว้าง",
"Kamera Lebar Belakang Ganda",
"Dobbelt vidvinkelkamera bak",
"Camera kép rộng mặt sau",
"Cámara trasera dual con gran angular",
"背面デュアル広角カメラ",
"Stražnja dvostruka široka kamera"
];
const backCameraLocalizations = [
"후면 카메라",
"後置相機",
"Задна камера",
"後置鏡頭",
"Camera mặt sau",
"Hátoldali kamera",
"Cámara trasera",
"Back Camera",
"Kamera på baksidan",
"Πίσω κάμερα",
"Bagsidekamera",
"Zadná kamera",
"Fotocamera (posteriore)",
"Câmara traseira",
"מצלמה אחורית",
"Takakamera",
"Rückkamera",
"Caméra arrière",
"Zadní fotoaparát",
"Артқы камера",
"Tylny aparat",
"बैक कैमरा",
"Hátsó kamera",
"Camera aan achterzijde",
"Kamera Belakang",
"Câmera Traseira",
"Stražnja kamera",
"الكاميرا الخلفية",
"Càmera posterior",
"Fotocamera posteriore",
"Càmera del darrere",
"กล้องด้านหลัง",
"Cameră spate",
"Kamera, bagside",
"背面カメラ",
"Задня камера",
"Arka Kamera",
"后置相机",
"Камера на задней панели",
"后置镜头",
"Kamera bak",
"Задняя камера",
"Aparat tylny",
"Kamera på baksiden",
"Câmera de Trás"
];
const isAndroidDevice = () => {
const u = navigator.userAgent;
return !!u.match(/Android/i);
};
const isIOSDevice = () => {
const u = navigator.userAgent;
return !!u.match(/iPhone/i);
};
const isMobileDevice = () => {
return isAndroidDevice() || isIOSDevice();
};
function isBackCameraLabel(label) {
const lowercaseLabel = label.toLowerCase();
return backCameraKeywords.some(keyword => lowercaseLabel.includes(keyword));
}
class SelectedCamera {
constructor(mdi, facing, label) {
this.deviceId = mdi.deviceId;
this.facing = facing;
this.groupId = mdi.groupId;
// apply custom label
if (label) {
this.label = label;
}
else {
this.label = mdi.label;
}
}
}
async function getCameraDevices$1() {
const frontCameras = [];
const backCameras = [];
let devices = await navigator.mediaDevices.enumerateDevices();
// if permission is not given, label of video devices will be empty string
if (devices.filter(device => device.kind === "videoinput").every(device => device.label === "")) {
const stream = await navigator.mediaDevices.getUserMedia({
video: {
facingMode: { ideal: "environment" }
},
audio: false
});
// enumerate devices again - now the label field should be non-empty, as we have a stream active
// (even if we didn't get persistent permission for camera)
devices = await navigator.mediaDevices.enumerateDevices();
// close the stream, as we don't need it anymore
stream.getTracks().forEach(track => track.sto