@aws-amplify/ui-react-liveness 2.0.10 → 3.0.0

package/dist/esm/components/FaceLivenessDetector/service/machine/index.mjs

@@ -1 +1,1130 @@
-import{__awaiter as e,__asyncValues as t}from"tslib";import{createMachine as a,assign as o,spawn as r,actions as i}from"xstate";import{getBoundingBox as s,getColorsSequencesFromSessionInformation as n,isCameraDeviceVirtual as c,getFaceMatchState as d,isFaceDistanceBelowThreshold as l,estimateIllumination as v,getOvalDetailsFromSessionInformation as m,generateBboxFromLandmarks as h,drawLivenessOvalInCanvas as g,getOvalBoundingBox as f,getIntersectionOverUnion as u,getFaceMatchStateInLivenessOval as S,getStaticLivenessOvalDetails as p}from"../utils/liveness.mjs";import{FaceMatchState as E}from"../types/liveness.mjs";import{LivenessErrorState as F}from"../types/error.mjs";import{BlazeFaceFaceDetection as R}from"../utils/blazefaceFaceDetection.mjs";import{LivenessStreamProvider as D}from"../utils/streamProvider.mjs";import{FreshnessColorDisplay as A}from"../utils/freshnessColorDisplay.mjs";import{nanoid as M}from"nanoid";import{isServerSesssionInformationEvent as C,isDisconnectionEvent as T,isValidationExceptionEvent as P,isInternalServerExceptionEvent as O,isThrottlingExceptionEvent as I,isServiceQuotaExceededExceptionEvent as w,isInvalidSignatureRegionException as y}from"../utils/eventUtils.mjs";import{STATIC_VIDEO_CONSTRAINTS as b}from"../../StartLiveness/helpers.mjs";import{WS_CLOSURE_CODE as _}from"../utils/constants.mjs";const k=500;let B;const N=a({id:"livenessMachine",initial:"start",predictableActionArguments:!0,context:{challengeId:M(),maxFailedAttempts:0,failedAttempts:0,componentProps:void 0,serverSessionInformation:void 0,videoAssociatedParams:{videoConstraints:b},ovalAssociatedParams:void 0,faceMatchAssociatedParams:{illuminationState:void 0,faceMatchState:void 0,faceMatchPercentage:25,currentDetectedFace:void 0,startFace:void 0,endFace:void 0,initialFaceMatchTime:void 0},freshnessColorAssociatedParams:{freshnessColorEl:void 0,freshnessColors:[],freshnessColorsComplete:!1,freshnessColorDisplay:void 0},errorState:void 0,livenessStreamProvider:void 0,responseStreamActorRef:void 0,shouldDisconnect:!1,faceMatchStateBeforeStart:void 0,isFaceFarEnoughBeforeRecording:void 0,isRecordingStopped:!1},on:{CANCEL:"userCancel",TIMEOUT:{target:"retryableTimeout",actions:"updateErrorStateForTimeout"},SET_SESSION_INFO:{internal:!0,actions:"updateSessionInfo"},DISCONNECT_EVENT:{internal:!0,actions:"updateShouldDisconnect"},SET_DOM_AND_CAMERA_DETAILS:{actions:"setDOMAndCameraDetails"},SERVER_ERROR:{target:"error",actions:"updateErrorStateForServer"},RUNTIME_ERROR:{target:"error"},MOBILE_LANDSCAPE_WARNING:{target:"mobileLandscapeWarning",actions:"updateErrorStateForServer"}},states:{start:{on:{BEGIN:"cameraCheck"}},cameraCheck:{entry:["resetErrorState","initializeFaceDetector"],invoke:{src:"checkVirtualCameraAndGetStream",onDone:{target:"waitForDOMAndCameraDetails",actions:["updateVideoMediaStream"]},onError:{target:"permissionDenied"}}},waitForDOMAndCameraDetails:{after:{0:{target:"detectFaceBeforeStart",cond:"hasDOMAndCameraDetails"},500:{target:"waitForDOMAndCameraDetails"}}},detectFaceBeforeStart:{invoke:{src:"detectFace",onDone:{target:"checkFaceDetectedBeforeStart",actions:["updateFaceMatchBeforeStartDetails"]}}},checkFaceDetectedBeforeStart:{after:{0:{target:"detectFaceDistanceBeforeRecording",cond:"hasSingleFaceBeforeStart"},100:{target:"detectFaceBeforeStart"}}},detectFaceDistanceBeforeRecording:{invoke:{src:"detectFaceDistance",onDone:{target:"checkFaceDistanceBeforeRecording",actions:["updateFaceDistanceBeforeRecording"]}}},checkFaceDistanceBeforeRecording:{after:{0:{target:"initializeLivenessStream",cond:"hasEnoughFaceDistanceBeforeRecording"},100:{target:"detectFaceDistanceBeforeRecording"}}},initializeLivenessStream:{invoke:{src:"openLivenessStreamConnection",onDone:{target:"notRecording",actions:["updateLivenessStreamProvider","spawnResponseStreamActor"]}}},notRecording:{on:{START_RECORDING:"recording"},initial:"waitForSessionInfo",states:{waitForSessionInfo:{after:{0:{target:"#livenessMachine.recording",cond:"hasServerSessionInfo"},100:{target:"waitForSessionInfo"}}}}},recording:{entry:["clearErrorState","startRecording"],initial:"ovalDrawing",states:{ovalDrawing:{entry:["sendTimeoutAfterOvalDrawingDelay"],invoke:{src:"detectInitialFaceAndDrawOval",onDone:{target:"checkFaceDetected",actions:["updateOvalAndFaceDetailsPostDraw","sendTimeoutAfterOvalMatchDelay"]},onError:{target:"#livenessMachine.error",actions:"updateErrorStateForRuntime"}}},checkFaceDetected:{after:{0:{target:"checkRecordingStarted",cond:"hasSingleFace"},100:{target:"ovalDrawing"}}},checkRecordingStarted:{after:{0:{target:"ovalMatching",cond:"hasRecordingStarted",actions:["updateRecordingStartTimestampMs"]},100:{target:"checkRecordingStarted"}}},ovalMatching:{entry:["cancelOvalDrawingTimeout"],invoke:{src:"detectFaceAndMatchOval",onDone:{target:"checkMatch",actions:"updateFaceDetailsPostMatch"}}},checkMatch:{after:{0:{target:"flashFreshnessColors",cond:"hasFaceMatchedInOvalWithMinTime",actions:["updateEndFaceMatch","setupFlashFreshnessColors","cancelOvalMatchTimeout","cancelOvalDrawingTimeout"]},.1:{target:"ovalMatching",cond:"hasFaceMatchedInOval",actions:"setFaceMatchTimeAndStartFace"},1:{target:"ovalMatching",cond:"hasNotFaceMatchedInOval"}}},flashFreshnessColors:{invoke:{src:"flashColors",onDone:[{target:"success",cond:"hasFreshnessColorShown"},{target:"flashFreshnessColors",actions:"updateFreshnessDetails"}]}},success:{entry:["stopRecording"],type:"final"}},onDone:"uploading"},uploading:{initial:"pending",states:{pending:{entry:["sendTimeoutAfterWaitingForDisconnect","pauseVideoStream"],invoke:{src:"stopVideo",onDone:"waitForDisconnectEvent",onError:{target:"#livenessMachine.error",actions:"updateErrorStateForRuntime"}}},waitForDisconnectEvent:{after:{0:{target:"getLivenessResult",cond:"getShouldDisconnect"},100:{target:"waitForDisconnectEvent"}}},getLivenessResult:{entry:["cancelWaitForDisconnectTimeout","freezeStream"],invoke:{src:"getLiveness",onError:{target:"#livenessMachine.error",actions:"updateErrorStateForServer"}}}}},retryableTimeout:{entry:"updateFailedAttempts",always:[{target:"timeout",cond:"shouldTimeoutOnFailedAttempts"},{target:"notRecording"}]},permissionDenied:{entry:"callUserPermissionDeniedCallback",on:{RETRY_CAMERA_CHECK:"cameraCheck"}},mobileLandscapeWarning:{entry:"callMobileLandscapeWarningCallback",always:[{target:"error"}]},timeout:{entry:["cleanUpResources","callUserTimeoutCallback","freezeStream"]},error:{entry:["cleanUpResources","callErrorCallback","cancelOvalDrawingTimeout","cancelWaitForDisconnectTimeout","cancelOvalMatchTimeout","freezeStream"]},userCancel:{entry:["cleanUpResources","callUserCancelCallback","resetContext"],always:[{target:"start"}]}}},{actions:{spawnResponseStreamActor:o({responseStreamActorRef:()=>r(j)}),updateFailedAttempts:o({failedAttempts:e=>e.failedAttempts+1}),updateVideoMediaStream:o({videoAssociatedParams:(e,t)=>{var a;return Object.assign(Object.assign({},e.videoAssociatedParams),{videoMediaStream:null===(a=t.data)||void 0===a?void 0:a.stream})}}),initializeFaceDetector:o({ovalAssociatedParams:e=>{const{componentProps:t}=e,{faceModelUrl:a,binaryPath:o}=t.config,r=new R(o,a);return r.triggerModelLoading(),Object.assign(Object.assign({},e.ovalAssociatedParams),{faceDetector:r})}}),updateLivenessStreamProvider:o({livenessStreamProvider:(e,t)=>{var a;return null===(a=t.data)||void 0===a?void 0:a.livenessStreamProvider}}),setDOMAndCameraDetails:o({videoAssociatedParams:(e,t)=>{var a,o,r;return Object.assign(Object.assign({},e.videoAssociatedParams),{videoEl:null===(a=t.data)||void 0===a?void 0:a.videoEl,canvasEl:null===(o=t.data)||void 0===o?void 0:o.canvasEl,isMobile:null===(r=t.data)||void 0===r?void 0:r.isMobile})},freshnessColorAssociatedParams:(e,t)=>{var a;return Object.assign(Object.assign({},e.freshnessColorAssociatedParams),{freshnessColorEl:null===(a=t.data)||void 0===a?void 0:a.freshnessColorEl})}}),updateRecordingStartTimestampMs:o({videoAssociatedParams:e=>{const{challengeId:t,videoAssociatedParams:a,ovalAssociatedParams:o,livenessStreamProvider:r}=e,{recordingStartApiTimestamp:i,recorderStartTimestamp:n}=r.videoRecorder,{videoMediaStream:c}=a,{initialFace:d}=o,l=Math.round(.73*(n-i)+i),{width:v,height:m}=c.getTracks()[0].getSettings(),h=v-d.left-d.width;return e.livenessStreamProvider.sendClientInfo({Challenge:{FaceMovementAndLightChallenge:{ChallengeId:t,VideoStartTimestamp:l,InitialFace:{InitialFaceDetectedTimestamp:d.timestampMs,BoundingBox:s({deviceHeight:m,deviceWidth:v,height:d.height,width:d.width,top:d.top,left:h})}}}}),Object.assign(Object.assign({},e.videoAssociatedParams),{recordingStartTimestampMs:l})}}),startRecording:o({videoAssociatedParams:e=>{if(!e.serverSessionInformation)throw new Error("Session information was not received from response stream");return e.livenessStreamProvider.videoRecorder&&"recording"!==e.livenessStreamProvider.videoRecorder.getState()&&e.livenessStreamProvider.startRecordingLivenessVideo(),Object.assign({},e.videoAssociatedParams)}}),stopRecording:e=>{},updateFaceMatchBeforeStartDetails:o({faceMatchStateBeforeStart:(e,t)=>t.data.faceMatchState}),updateFaceDistanceBeforeRecording:o({isFaceFarEnoughBeforeRecording:(e,t)=>t.data.isFaceFarEnoughBeforeRecording}),updateFaceDistanceWhileLoading:o({isFaceFarEnoughBeforeRecording:(e,t)=>t.data.isFaceFarEnoughBeforeRecording,errorState:(e,t)=>{var a;return null===(a=t.data)||void 0===a?void 0:a.error}}),updateOvalAndFaceDetailsPostDraw:o({ovalAssociatedParams:(e,t)=>Object.assign(Object.assign({},e.ovalAssociatedParams),{initialFace:t.data.initialFace,ovalDetails:t.data.ovalDetails,scaleFactor:t.data.scaleFactor}),faceMatchAssociatedParams:(e,t)=>Object.assign(Object.assign({},e.faceMatchAssociatedParams),{faceMatchState:t.data.faceMatchState,illuminationState:t.data.illuminationState})}),updateFaceDetailsPostMatch:o({faceMatchAssociatedParams:(e,t)=>Object.assign(Object.assign({},e.faceMatchAssociatedParams),{faceMatchState:t.data.faceMatchState,faceMatchPercentage:t.data.faceMatchPercentage,illuminationState:t.data.illuminationState,currentDetectedFace:t.data.detectedFace})}),updateEndFaceMatch:o({faceMatchAssociatedParams:e=>Object.assign(Object.assign({},e.faceMatchAssociatedParams),{endFace:e.faceMatchAssociatedParams.currentDetectedFace})}),setFaceMatchTimeAndStartFace:o({faceMatchAssociatedParams:e=>Object.assign(Object.assign({},e.faceMatchAssociatedParams),{startFace:void 0===e.faceMatchAssociatedParams.startFace?e.faceMatchAssociatedParams.currentDetectedFace:e.faceMatchAssociatedParams.startFace,initialFaceMatchTime:void 0===e.faceMatchAssociatedParams.initialFaceMatchTime?Date.now():e.faceMatchAssociatedParams.initialFaceMatchTime})}),resetErrorState:o({errorState:e=>{}}),updateErrorStateForTimeout:o({errorState:(e,t)=>{var a;return(null===(a=t.data)||void 0===a?void 0:a.errorState)||F.TIMEOUT}}),updateErrorStateForRuntime:o({errorState:(e,t)=>{var a;return(null===(a=t.data)||void 0===a?void 0:a.errorState)||F.RUNTIME_ERROR}}),updateErrorStateForServer:o({errorState:e=>F.SERVER_ERROR}),clearErrorState:o({errorState:e=>{}}),updateSessionInfo:o({serverSessionInformation:(e,t)=>t.data.sessionInfo}),updateShouldDisconnect:o({shouldDisconnect:e=>!0}),updateFreshnessDetails:o({freshnessColorAssociatedParams:(e,t)=>Object.assign(Object.assign({},e.freshnessColorAssociatedParams),{freshnessColorsComplete:t.data.freshnessColorsComplete})}),setupFlashFreshnessColors:o({freshnessColorAssociatedParams:e=>{const{serverSessionInformation:t}=e,a=n(t),o=new A(e,a);return Object.assign(Object.assign({},e.freshnessColorAssociatedParams),{freshnessColorDisplay:o})}}),sendTimeoutAfterOvalDrawingDelay:i.send({type:"TIMEOUT"},{delay:5e3,id:"ovalDrawingTimeout"}),cancelOvalDrawingTimeout:i.cancel("ovalDrawingTimeout"),sendTimeoutAfterOvalMatchDelay:i.send({type:"TIMEOUT"},{delay:e=>{var t,a,o,r;return(null===(r=null===(o=null===(a=null===(t=e.serverSessionInformation)||void 0===t?void 0:t.Challenge)||void 0===a?void 0:a.FaceMovementAndLightChallenge)||void 0===o?void 0:o.ChallengeConfig)||void 0===r?void 0:r.OvalFitTimeout)||7e3},id:"ovalMatchTimeout"}),cancelOvalMatchTimeout:i.cancel("ovalMatchTimeout"),sendTimeoutAfterWaitingForDisconnect:i.send({type:"TIMEOUT",data:{errorState:F.SERVER_ERROR}},{delay:2e4,id:"waitForDisconnectTimeout"}),cancelWaitForDisconnectTimeout:i.cancel("waitForDisconnectTimeout"),sendTimeoutAfterFaceDistanceDelay:i.send({type:"RUNTIME_ERROR",data:new Error("Avoid moving closer during countdown and ensure only one face is in front of camera.")},{delay:0,id:"faceDistanceTimeout"}),cancelFaceDistanceTimeout:i.cancel("faceDistanceTimeout"),callUserPermissionDeniedCallback:o({errorState:(e,t)=>{var a,o;let r;r=t.data.message.includes("15 fps")?F.CAMERA_FRAMERATE_ERROR:F.CAMERA_ACCESS_ERROR;const i=t.data.message||t.data.Message,s={state:r,error:new Error(i)};return null===(o=(a=e.componentProps).onError)||void 0===o||o.call(a,s),r}}),callMobileLandscapeWarningCallback:o({errorState:e=>F.MOBILE_LANDSCAPE_ERROR}),callUserCancelCallback:t=>e(void 0,void 0,void 0,(function*(){var e,a;null===(a=(e=t.componentProps).onUserCancel)||void 0===a||a.call(e)})),callUserTimeoutCallback:t=>e(void 0,void 0,void 0,(function*(){var e,a;const o=new Error("Client Timeout");o.name=t.errorState;const r={state:t.errorState,error:o};null===(a=(e=t.componentProps).onError)||void 0===a||a.call(e,r)})),callErrorCallback:(t,a)=>e(void 0,void 0,void 0,(function*(){var e,o,r;const i={state:t.errorState,error:(null===(e=a.data)||void 0===e?void 0:e.error)||a.data};null===(r=(o=t.componentProps).onError)||void 0===r||r.call(o,i)})),cleanUpResources:t=>e(void 0,void 0,void 0,(function*(){var e;const{freshnessColorEl:a}=t.freshnessColorAssociatedParams;a&&(a.style.display="none");let o=_.DEFAULT_ERROR_CODE;t.errorState===F.TIMEOUT?o=_.FACE_FIT_TIMEOUT:t.errorState===F.RUNTIME_ERROR?o=_.RUNTIME_ERROR:t.errorState===F.FACE_DISTANCE_ERROR||t.errorState===F.MULTIPLE_FACES_ERROR?o=_.USER_ERROR_DURING_CONNECTION:void 0===t.errorState&&(o=_.USER_CANCEL),yield null===(e=t.livenessStreamProvider)||void 0===e?void 0:e.endStreamWithCode(o)})),freezeStream:t=>e(void 0,void 0,void 0,(function*(){const{videoMediaStream:e,videoEl:a}=t.videoAssociatedParams;t.isRecordingStopped=!0,null==a||a.pause(),null==e||e.getTracks().forEach((function(e){e.stop()}))})),pauseVideoStream:t=>e(void 0,void 0,void 0,(function*(){const{videoEl:e}=t.videoAssociatedParams;t.isRecordingStopped=!0,e.pause()})),resetContext:o({challengeId:M(),maxFailedAttempts:0,failedAttempts:0,componentProps:e=>e.componentProps,serverSessionInformation:e=>{},videoAssociatedParams:e=>({videoConstraints:b}),ovalAssociatedParams:e=>{},errorState:e=>{},livenessStreamProvider:e=>{},responseStreamActorRef:e=>{},shouldDisconnect:!1,faceMatchStateBeforeStart:e=>{},isFaceFarEnoughBeforeRecording:e=>{},isRecordingStopped:!1})},guards:{shouldTimeoutOnFailedAttempts:e=>e.failedAttempts>=e.maxFailedAttempts,hasFaceMatchedInOvalWithMinTime:e=>{const{faceMatchState:t,initialFaceMatchTime:a}=e.faceMatchAssociatedParams,o=Date.now()-a;return t===E.MATCHED&&o>=500},hasFaceMatchedInOval:e=>e.faceMatchAssociatedParams.faceMatchState===E.MATCHED,hasNotFaceMatchedInOval:e=>e.faceMatchAssociatedParams.faceMatchState!==E.MATCHED,hasSingleFace:e=>e.faceMatchAssociatedParams.faceMatchState===E.FACE_IDENTIFIED,hasSingleFaceBeforeStart:e=>e.faceMatchStateBeforeStart===E.FACE_IDENTIFIED,hasEnoughFaceDistanceBeforeRecording:e=>e.isFaceFarEnoughBeforeRecording,hasNotEnoughFaceDistanceBeforeRecording:e=>!e.isFaceFarEnoughBeforeRecording,hasLivenessCheckSucceeded:(e,t,a)=>a.state.event.data.isLive,hasFreshnessColorShown:e=>e.freshnessColorAssociatedParams.freshnessColorsComplete,hasServerSessionInfo:e=>void 0!==e.serverSessionInformation,hasDOMAndCameraDetails:e=>void 0!==e.videoAssociatedParams.videoEl&&void 0!==e.videoAssociatedParams.canvasEl&&void 0!==e.freshnessColorAssociatedParams.freshnessColorEl,getShouldDisconnect:e=>!!e.shouldDisconnect,hasRecordingStarted:e=>void 0!==e.livenessStreamProvider.videoRecorder.firstChunkTimestamp},services:{checkVirtualCameraAndGetStream(t){return e(this,void 0,void 0,(function*(){const{videoConstraints:e}=t.videoAssociatedParams,a=yield navigator.mediaDevices.getUserMedia({video:e,audio:!1}),o=(yield navigator.mediaDevices.enumerateDevices()).filter((e=>"videoinput"===e.kind)).filter((e=>!c(e)));if(!o.length)throw new Error("No real video devices found");const r=a.getTracks().filter((e=>e.getSettings().frameRate>=15));if(r.length<1)throw new Error("No camera found with more than 15 fps");const i=r[0].getSettings().deviceId;let s=a;return o.some((e=>e.deviceId===i))||(s=yield navigator.mediaDevices.getUserMedia({video:Object.assign(Object.assign({},e),{deviceId:{exact:o[0].deviceId}}),audio:!1})),{stream:s}}))},openLivenessStreamConnection(t){return e(this,void 0,void 0,(function*(){const{config:e}=t.componentProps,{credentialProvider:a,endpointOverride:o}=e,r=new D({sessionId:t.componentProps.sessionId,region:t.componentProps.region,stream:t.videoAssociatedParams.videoMediaStream,videoEl:t.videoAssociatedParams.videoEl,credentialProvider:a,endpointOverride:o});return B=r.getResponseStream(),{livenessStreamProvider:r}}))},detectFace(t){return e(this,void 0,void 0,(function*(){const{videoEl:e}=t.videoAssociatedParams,{faceDetector:a}=t.ovalAssociatedParams;try{yield a.modelLoadingPromise}catch(e){console.log({err:e})}return{faceMatchState:yield d(a,e)}}))},detectFaceDistance(t){return e(this,void 0,void 0,(function*(){const{isFaceFarEnoughBeforeRecording:e}=t,{videoEl:a,videoMediaStream:o,isMobile:r}=t.videoAssociatedParams,{faceDetector:i}=t.ovalAssociatedParams,{width:s,height:n}=o.getTracks()[0].getSettings(),c=p({width:s,height:n}),{isDistanceBelowThreshold:d}=yield l({faceDetector:i,videoEl:a,ovalDetails:c,reduceThreshold:e,isMobile:r});return{isFaceFarEnoughBeforeRecording:d}}))},detectFaceDistanceWhileLoading(t){return e(this,void 0,void 0,(function*(){const{isFaceFarEnoughBeforeRecording:e}=t,{videoEl:a,videoMediaStream:o,isMobile:r}=t.videoAssociatedParams,{faceDetector:i}=t.ovalAssociatedParams,{width:s,height:n}=o.getTracks()[0].getSettings(),c=p({width:s,height:n}),{isDistanceBelowThreshold:d,error:v}=yield l({faceDetector:i,videoEl:a,ovalDetails:c,reduceThreshold:e,isMobile:r});return{isFaceFarEnoughBeforeRecording:d,error:v}}))},detectInitialFaceAndDrawOval(t){return e(this,void 0,void 0,(function*(){const{serverSessionInformation:e,livenessStreamProvider:a}=t,{videoEl:o,canvasEl:r,isMobile:i}=t.videoAssociatedParams,{faceDetector:s}=t.ovalAssociatedParams;try{yield s.modelLoadingPromise,yield a.videoRecorder.recorderStarted}catch(e){console.log({err:e})}const n=yield s.detectFaces(o);let c,d,l;switch(n.length){case 0:d=E.CANT_IDENTIFY,l=v(o);break;case 1:d=E.FACE_IDENTIFIED,c=n[0];break;default:d=E.TOO_MANY}if(!c)return{faceMatchState:d,illuminationState:l};const{width:f,height:u}=o.getBoundingClientRect();i?(r.width=window.innerWidth,r.height=window.innerHeight):(r.width=f,r.height=u);const S=f/o.videoWidth,p=m({sessionInformation:e,videoWidth:o.width}),F=h(c,p);return c.top=F.top,c.left=F.left,c.height=F.bottom-F.top,c.width=F.right-F.left,g({canvas:r,oval:p,scaleFactor:S,videoEl:o}),{faceMatchState:d,ovalDetails:p,scaleFactor:S,initialFace:c}}))},detectFaceAndMatchOval(t){return e(this,void 0,void 0,(function*(){const{serverSessionInformation:e}=t,{videoEl:a}=t.videoAssociatedParams,{faceDetector:o,ovalDetails:r,initialFace:i}=t.ovalAssociatedParams,s=yield o.detectFaces(a);let n,c,d,l=0;const m=h(i,r),{ovalBoundingBox:g}=f(r),p=u(m,g);switch(s.length){case 0:n=E.CANT_IDENTIFY,d=v(a);break;case 1:{c=s[0];const{faceMatchState:t,faceMatchPercentage:a}=S(c,r,p,e);n=t,l=a;break}default:n=E.TOO_MANY}return{faceMatchState:n,faceMatchPercentage:l,illuminationState:d,detectedFace:c}}))},flashColors(t){return e(this,void 0,void 0,(function*(){const{freshnessColorsComplete:e,freshnessColorDisplay:a}=t.freshnessColorAssociatedParams;if(e)return;return{freshnessColorsComplete:yield a.displayColorTick()}}))},stopVideo(t){return e(this,void 0,void 0,(function*(){const{challengeId:e,livenessStreamProvider:a}=t,{videoMediaStream:o}=t.videoAssociatedParams,{initialFace:r,ovalDetails:i}=t.ovalAssociatedParams,{startFace:n,endFace:c}=t.faceMatchAssociatedParams,{width:d,height:l}=o.getTracks()[0].getSettings(),v=d-r.left-r.width;yield a.stopVideo();const m={Challenge:{FaceMovementAndLightChallenge:{ChallengeId:e,InitialFace:{InitialFaceDetectedTimestamp:r.timestampMs,BoundingBox:s({deviceHeight:l,deviceWidth:d,height:r.height,width:r.width,top:r.top,left:v})},TargetFace:{FaceDetectedInTargetPositionStartTimestamp:n.timestampMs,FaceDetectedInTargetPositionEndTimestamp:c.timestampMs,BoundingBox:s({deviceHeight:l,deviceWidth:d,height:i.height,width:i.width,top:i.centerY-i.height/2,left:i.centerX-i.width/2})},VideoEndTimestamp:a.videoRecorder.recorderEndTimestamp}}};if(0===a.videoRecorder.getVideoChunkSize())throw new Error("Video chunks not recorded successfully.");a.sendClientInfo(m),yield a.dispatchStopVideoEvent()}))},getLiveness(t){return e(this,void 0,void 0,(function*(){const{onAnalysisComplete:e}=t.componentProps;yield e()}))}}}),j=a=>e(void 0,void 0,void 0,(function*(){var e,o,r,i;try{const d=yield B;try{for(var s,n=!0,c=t(d);!(e=(s=yield c.next()).done);){i=s.value,n=!1;try{const e=i;C(e)?a({type:"SET_SESSION_INFO",data:{sessionInfo:e.ServerSessionInformationEvent.SessionInformation}}):T(e)?a({type:"DISCONNECT_EVENT"}):P(e)?a({type:"SERVER_ERROR",data:{error:Object.assign({},e.ValidationException)}}):O(e)?a({type:"SERVER_ERROR",data:{error:Object.assign({},e.InternalServerException)}}):I(e)?a({type:"SERVER_ERROR",data:{error:Object.assign({},e.ThrottlingException)}}):w(e)&&a({type:"SERVER_ERROR",data:{error:Object.assign({},e.ServiceQuotaExceededException)}})}finally{n=!0}}}catch(e){o={error:e}}finally{try{n||e||!(r=c.return)||(yield r.call(c))}finally{if(o)throw o.error}}}catch(e){let t=e;y(e)&&(t=new Error("Invalid region in FaceLivenessDetector or credentials are scoped to the wrong region.")),t instanceof Error&&a({type:"SERVER_ERROR",data:{error:t}})}}));export{k as MIN_FACE_MATCH_TIME,N as livenessMachine};
+import { createMachine, assign, spawn, actions } from 'xstate';
+import { drawStaticOval, getBoundingBox, getColorsSequencesFromSessionInformation, isCameraDeviceVirtual, getFaceMatchState, isFaceDistanceBelowThreshold, estimateIllumination, getOvalDetailsFromSessionInformation, generateBboxFromLandmarks, drawLivenessOvalInCanvas, getOvalBoundingBox, getIntersectionOverUnion, getFaceMatchStateInLivenessOval, getStaticLivenessOvalDetails } from '../utils/liveness.mjs';
+import { FaceMatchState } from '../types/liveness.mjs';
+import { LivenessErrorState } from '../types/error.mjs';
+import { BlazeFaceFaceDetection } from '../utils/blazefaceFaceDetection.mjs';
+import { LivenessStreamProvider } from '../utils/streamProvider.mjs';
+import { FreshnessColorDisplay } from '../utils/freshnessColorDisplay.mjs';
+import { nanoid } from 'nanoid';
+import { isServerSesssionInformationEvent, isDisconnectionEvent, isValidationExceptionEvent, isInternalServerExceptionEvent, isThrottlingExceptionEvent, isServiceQuotaExceededExceptionEvent, isInvalidSignatureRegionException } from '../utils/eventUtils.mjs';
+import { STATIC_VIDEO_CONSTRAINTS } from '../../utils/helpers.mjs';
+import { WS_CLOSURE_CODE } from '../utils/constants.mjs';
+
+/* eslint-disable */
+const MIN_FACE_MATCH_TIME = 1000;
+const DEFAULT_FACE_FIT_TIMEOUT = 7000;
+let responseStream;
+const CAMERA_ID_KEY = 'AmplifyLivenessCameraId';
+function getLastSelectedCameraId() {
+    return localStorage.getItem(CAMERA_ID_KEY);
+}
+function setLastSelectedCameraId(deviceId) {
+    localStorage.setItem(CAMERA_ID_KEY, deviceId);
+}
+const livenessMachine = createMachine({
+    id: 'livenessMachine',
+    initial: 'cameraCheck',
+    predictableActionArguments: true,
+    context: {
+        challengeId: nanoid(),
+        maxFailedAttempts: 0,
+        failedAttempts: 0,
+        componentProps: undefined,
+        serverSessionInformation: undefined,
+        videoAssociatedParams: {
+            videoConstraints: STATIC_VIDEO_CONSTRAINTS,
+            selectableDevices: [],
+        },
+        ovalAssociatedParams: undefined,
+        faceMatchAssociatedParams: {
+            illuminationState: undefined,
+            faceMatchState: undefined,
+            /**
+             * faceMatchPercentage is a starting point we set as a baseline
+             * for what we want our progress bar to visually start at. This correlates
+             * to the formula we use to calculate the faceMatchPercentage
+             * in getFaceMatchStateInLivenessOval
+             */
+            faceMatchPercentage: 25,
+            currentDetectedFace: undefined,
+            startFace: undefined,
+            endFace: undefined,
+            initialFaceMatchTime: undefined,
+        },
+        freshnessColorAssociatedParams: {
+            freshnessColorEl: undefined,
+            freshnessColors: [],
+            freshnessColorsComplete: false,
+            freshnessColorDisplay: undefined,
+        },
+        errorState: undefined,
+        livenessStreamProvider: undefined,
+        responseStreamActorRef: undefined,
+        shouldDisconnect: false,
+        faceMatchStateBeforeStart: undefined,
+        isFaceFarEnoughBeforeRecording: undefined,
+        isRecordingStopped: false,
+    },
+    on: {
+        CANCEL: 'userCancel',
+        TIMEOUT: {
+            target: 'retryableTimeout',
+            actions: 'updateErrorStateForTimeout',
+        },
+        SET_SESSION_INFO: {
+            internal: true,
+            actions: 'updateSessionInfo',
+        },
+        DISCONNECT_EVENT: {
+            internal: true,
+            actions: 'updateShouldDisconnect',
+        },
+        SET_DOM_AND_CAMERA_DETAILS: {
+            actions: 'setDOMAndCameraDetails',
+        },
+        UPDATE_DEVICE_AND_STREAM: {
+            actions: 'updateDeviceAndStream',
+        },
+        SERVER_ERROR: {
+            target: 'error',
+            actions: 'updateErrorStateForServer',
+        },
+        RUNTIME_ERROR: {
+            target: 'error',
+        },
+        MOBILE_LANDSCAPE_WARNING: {
+            target: 'mobileLandscapeWarning',
+            actions: 'updateErrorStateForServer',
+        },
+    },
+    states: {
+        cameraCheck: {
+            entry: ['resetErrorState'],
+            invoke: {
+                src: 'checkVirtualCameraAndGetStream',
+                onDone: {
+                    target: 'waitForDOMAndCameraDetails',
+                    actions: ['updateVideoMediaStream'],
+                },
+                onError: {
+                    target: 'permissionDenied',
+                },
+            },
+        },
+        waitForDOMAndCameraDetails: {
+            after: {
+                0: {
+                    target: 'start',
+                    cond: 'hasDOMAndCameraDetails',
+                },
+                10: { target: 'waitForDOMAndCameraDetails' },
+            },
+        },
+        start: {
+            entry: ['drawStaticOval', 'initializeFaceDetector'],
+            always: [
+                {
+                    target: 'detectFaceBeforeStart',
+                    cond: 'shouldSkipStartScreen',
+                },
+            ],
+            on: {
+                BEGIN: 'detectFaceBeforeStart',
+            },
+        },
+        detectFaceBeforeStart: {
+            invoke: {
+                src: 'detectFace',
+                onDone: {
+                    target: 'checkFaceDetectedBeforeStart',
+                    actions: ['updateFaceMatchBeforeStartDetails'],
+                },
+            },
+        },
+        checkFaceDetectedBeforeStart: {
+            after: {
+                0: {
+                    target: 'detectFaceDistanceBeforeRecording',
+                    cond: 'hasSingleFaceBeforeStart',
+                },
+                100: { target: 'detectFaceBeforeStart' },
+            },
+        },
+        detectFaceDistanceBeforeRecording: {
+            invoke: {
+                src: 'detectFaceDistance',
+                onDone: {
+                    target: 'checkFaceDistanceBeforeRecording',
+                    actions: ['updateFaceDistanceBeforeRecording'],
+                },
+            },
+        },
+        checkFaceDistanceBeforeRecording: {
+            after: {
+                0: {
+                    target: 'initializeLivenessStream',
+                    cond: 'hasEnoughFaceDistanceBeforeRecording',
+                },
+                100: { target: 'detectFaceDistanceBeforeRecording' },
+            },
+        },
+        initializeLivenessStream: {
+            invoke: {
+                src: 'openLivenessStreamConnection',
+                onDone: {
+                    target: 'notRecording',
+                    actions: [
+                        'updateLivenessStreamProvider',
+                        'spawnResponseStreamActor',
+                    ],
+                },
+            },
+        },
+        notRecording: {
+            initial: 'waitForSessionInfo',
+            states: {
+                waitForSessionInfo: {
+                    after: {
+                        0: {
+                            target: '#livenessMachine.recording',
+                            cond: 'hasServerSessionInfo',
+                        },
+                        100: { target: 'waitForSessionInfo' },
+                    },
+                },
+            },
+        },
+        recording: {
+            entry: ['clearErrorState', 'startRecording'],
+            initial: 'ovalDrawing',
+            states: {
+                ovalDrawing: {
+                    entry: ['sendTimeoutAfterOvalDrawingDelay'],
+                    invoke: {
+                        src: 'detectInitialFaceAndDrawOval',
+                        onDone: {
+                            target: 'checkFaceDetected',
+                            actions: [
+                                'updateOvalAndFaceDetailsPostDraw',
+                                'sendTimeoutAfterOvalMatchDelay',
+                            ],
+                        },
+                        onError: {
+                            target: '#livenessMachine.error',
+                            actions: 'updateErrorStateForRuntime',
+                        },
+                    },
+                },
+                checkFaceDetected: {
+                    after: {
+                        0: {
+                            target: 'checkRecordingStarted',
+                            cond: 'hasSingleFace',
+                        },
+                        100: { target: 'ovalDrawing' },
+                    },
+                },
+                checkRecordingStarted: {
+                    after: {
+                        0: {
+                            target: 'ovalMatching',
+                            cond: 'hasRecordingStarted',
+                            actions: ['updateRecordingStartTimestampMs'],
+                        },
+                        100: { target: 'checkRecordingStarted' },
+                    },
+                },
+                ovalMatching: {
+                    entry: ['cancelOvalDrawingTimeout'],
+                    invoke: {
+                        src: 'detectFaceAndMatchOval',
+                        onDone: {
+                            target: 'checkMatch',
+                            actions: 'updateFaceDetailsPostMatch',
+                        },
+                    },
+                },
+                checkMatch: {
+                    after: {
+                        0: {
+                            target: 'flashFreshnessColors',
+                            cond: 'hasFaceMatchedInOvalWithMinTime',
+                            actions: [
+                                'updateEndFaceMatch',
+                                'setupFlashFreshnessColors',
+                                'cancelOvalMatchTimeout',
+                                'cancelOvalDrawingTimeout',
+                            ],
+                        },
+                        0.1: {
+                            target: 'ovalMatching',
+                            cond: 'hasFaceMatchedInOval',
+                            actions: 'setFaceMatchTimeAndStartFace',
+                        },
+                        1: {
+                            target: 'ovalMatching',
+                            cond: 'hasNotFaceMatchedInOval',
+                        },
+                    },
+                },
+                flashFreshnessColors: {
+                    invoke: {
+                        src: 'flashColors',
+                        onDone: [
+                            {
+                                target: 'success',
+                                cond: 'hasFreshnessColorShown',
+                            },
+                            {
+                                target: 'flashFreshnessColors',
+                                actions: 'updateFreshnessDetails',
+                            },
+                        ],
+                    },
+                },
+                success: {
+                    entry: ['stopRecording'],
+                    type: 'final',
+                },
+            },
+            onDone: 'uploading',
+        },
+        uploading: {
+            initial: 'pending',
+            states: {
+                pending: {
+                    entry: ['sendTimeoutAfterWaitingForDisconnect', 'pauseVideoStream'],
+                    invoke: {
+                        src: 'stopVideo',
+                        onDone: 'waitForDisconnectEvent',
+                        onError: {
+                            target: '#livenessMachine.error',
+                            actions: 'updateErrorStateForRuntime',
+                        },
+                    },
+                },
+                waitForDisconnectEvent: {
+                    after: {
+                        0: {
+                            target: 'getLivenessResult',
+                            cond: 'getShouldDisconnect',
+                        },
+                        100: { target: 'waitForDisconnectEvent' },
+                    },
+                },
+                getLivenessResult: {
+                    entry: ['cancelWaitForDisconnectTimeout', 'freezeStream'],
+                    invoke: {
+                        src: 'getLiveness',
+                        onError: {
+                            target: '#livenessMachine.error',
+                            actions: 'updateErrorStateForServer',
+                        },
+                    },
+                },
+            },
+        },
+        retryableTimeout: {
+            entry: 'updateFailedAttempts',
+            always: [
+                {
+                    target: 'timeout',
+                    cond: 'shouldTimeoutOnFailedAttempts',
+                },
+                { target: 'notRecording' },
+            ],
+        },
+        permissionDenied: {
+            entry: 'callUserPermissionDeniedCallback',
+            on: {
+                RETRY_CAMERA_CHECK: 'cameraCheck',
+            },
+        },
+        mobileLandscapeWarning: {
+            entry: 'callMobileLandscapeWarningCallback',
+            always: [{ target: 'error' }],
+        },
+        timeout: {
+            entry: ['cleanUpResources', 'callUserTimeoutCallback', 'freezeStream'],
+        },
+        error: {
+            entry: [
+                'cleanUpResources',
+                'callErrorCallback',
+                'cancelOvalDrawingTimeout',
+                'cancelWaitForDisconnectTimeout',
+                'cancelOvalMatchTimeout',
+                'freezeStream',
+            ],
+        },
+        userCancel: {
+            entry: ['cleanUpResources', 'callUserCancelCallback', 'resetContext'],
+            always: [{ target: 'cameraCheck' }],
+        },
+    },
+}, {
+    actions: {
+        spawnResponseStreamActor: assign({
+            responseStreamActorRef: () => spawn(responseStreamActor),
+        }),
+        updateFailedAttempts: assign({
+            failedAttempts: (context) => {
+                return context.failedAttempts + 1;
+            },
+        }),
+        updateVideoMediaStream: assign({
+            videoAssociatedParams: (context, event) => ({
+                ...context.videoAssociatedParams,
+                videoMediaStream: event.data?.stream,
+                selectedDeviceId: event.data?.selectedDeviceId,
+                selectableDevices: event.data?.selectableDevices,
+            }),
+        }),
+        initializeFaceDetector: assign({
+            ovalAssociatedParams: (context) => {
+                const { componentProps } = context;
+                const { faceModelUrl, binaryPath } = componentProps.config;
+                const faceDetector = new BlazeFaceFaceDetection(binaryPath, faceModelUrl);
+                faceDetector.triggerModelLoading();
+                return {
+                    ...context.ovalAssociatedParams,
+                    faceDetector,
+                };
+            },
+        }),
+        updateLivenessStreamProvider: assign({
+            livenessStreamProvider: (context, event) => {
+                return event.data?.livenessStreamProvider;
+            },
+        }),
+        setDOMAndCameraDetails: assign({
+            videoAssociatedParams: (context, event) => {
+                return {
+                    ...context.videoAssociatedParams,
+                    videoEl: event.data?.videoEl,
+                    canvasEl: event.data?.canvasEl,
+                    isMobile: event.data?.isMobile,
+                };
+            },
+            freshnessColorAssociatedParams: (context, event) => ({
+                ...context.freshnessColorAssociatedParams,
+                freshnessColorEl: event.data?.freshnessColorEl,
+            }),
+        }),
+        updateDeviceAndStream: assign({
+            videoAssociatedParams: (context, event) => {
+                setLastSelectedCameraId(event.data?.newDeviceId);
+                return {
+                    ...context.videoAssociatedParams,
+                    selectedDeviceId: event.data?.newDeviceId,
+                    videoMediaStream: event.data?.newStream,
+                };
+            },
+        }),
+        drawStaticOval: (context) => {
+            const { canvasEl, videoEl, videoMediaStream } = context.videoAssociatedParams;
+            drawStaticOval(canvasEl, videoEl, videoMediaStream);
+        },
+        updateRecordingStartTimestampMs: assign({
+            videoAssociatedParams: (context) => {
+                const { challengeId, videoAssociatedParams, ovalAssociatedParams, livenessStreamProvider, } = context;
+                const { recordingStartApiTimestamp, recorderStartTimestamp } = livenessStreamProvider.videoRecorder;
+                const { videoMediaStream } = videoAssociatedParams;
+                const { initialFace } = ovalAssociatedParams;
+                /**
+                 * This calculation is provided by Science team after doing analysis
+                 * of unreliable .onstart() (recorderStartTimestamp) timestamp that is
+                 * returned from mediaRecorder.
+                 */
+                const timestamp = Math.round(0.73 * (recorderStartTimestamp - recordingStartApiTimestamp) +
+                    recordingStartApiTimestamp);
+                // Send client info for initial face position
+                const { width, height } = videoMediaStream
+                    .getTracks()[0]
+                    .getSettings();
+                const flippedInitialFaceLeft = width - initialFace.left - initialFace.width;
+                context.livenessStreamProvider.sendClientInfo({
+                    Challenge: {
+                        FaceMovementAndLightChallenge: {
+                            ChallengeId: challengeId,
+                            VideoStartTimestamp: timestamp,
+                            InitialFace: {
+                                InitialFaceDetectedTimestamp: initialFace.timestampMs,
+                                BoundingBox: getBoundingBox({
+                                    deviceHeight: height,
+                                    deviceWidth: width,
+                                    height: initialFace.height,
+                                    width: initialFace.width,
+                                    top: initialFace.top,
+                                    left: flippedInitialFaceLeft,
+                                }),
+                            },
+                        },
+                    },
+                });
+                return {
+                    ...context.videoAssociatedParams,
+                    recordingStartTimestampMs: timestamp,
+                };
+            },
+        }),
+        startRecording: assign({
+            videoAssociatedParams: (context) => {
+                if (!context.serverSessionInformation) {
+                    throw new Error('Session information was not received from response stream');
+                }
+                if (context.livenessStreamProvider.videoRecorder &&
+                    context.livenessStreamProvider.videoRecorder.getState() !==
+                        'recording') {
+                    context.livenessStreamProvider.startRecordingLivenessVideo();
+                }
+                return {
+                    ...context.videoAssociatedParams,
+                };
+            },
+        }),
+        stopRecording: (context) => { },
+        updateFaceMatchBeforeStartDetails: assign({
+            faceMatchStateBeforeStart: (_, event) => {
+                return event.data.faceMatchState;
+            },
+        }),
+        updateFaceDistanceBeforeRecording: assign({
+            isFaceFarEnoughBeforeRecording: (_, event) => {
+                return event.data.isFaceFarEnoughBeforeRecording;
+            },
+        }),
+        updateFaceDistanceWhileLoading: assign({
+            isFaceFarEnoughBeforeRecording: (_, event) => {
+                return event.data.isFaceFarEnoughBeforeRecording;
+            },
+            errorState: (_, event) => {
+                return event.data?.error;
+            },
+        }),
+        updateOvalAndFaceDetailsPostDraw: assign({
+            ovalAssociatedParams: (context, event) => ({
+                ...context.ovalAssociatedParams,
+                initialFace: event.data.initialFace,
+                ovalDetails: event.data.ovalDetails,
+                scaleFactor: event.data.scaleFactor,
+            }),
+            faceMatchAssociatedParams: (context, event) => ({
+                ...context.faceMatchAssociatedParams,
+                faceMatchState: event.data.faceMatchState,
+                illuminationState: event.data.illuminationState,
+            }),
+        }),
+        updateFaceDetailsPostMatch: assign({
+            faceMatchAssociatedParams: (context, event) => ({
+                ...context.faceMatchAssociatedParams,
+                faceMatchState: event.data.faceMatchState,
+                faceMatchPercentage: event.data.faceMatchPercentage,
+                illuminationState: event.data.illuminationState,
+                currentDetectedFace: event.data.detectedFace,
+            }),
+        }),
+        updateEndFaceMatch: assign({
+            faceMatchAssociatedParams: (context) => ({
+                ...context.faceMatchAssociatedParams,
+                endFace: context.faceMatchAssociatedParams.currentDetectedFace,
+            }),
+        }),
+        setFaceMatchTimeAndStartFace: assign({
+            faceMatchAssociatedParams: (context) => {
+                return {
+                    ...context.faceMatchAssociatedParams,
+                    startFace: context.faceMatchAssociatedParams.startFace === undefined
+                        ? context.faceMatchAssociatedParams.currentDetectedFace
+                        : context.faceMatchAssociatedParams.startFace,
+                    initialFaceMatchTime: context.faceMatchAssociatedParams.initialFaceMatchTime ===
+                        undefined
+                        ? Date.now()
+                        : context.faceMatchAssociatedParams.initialFaceMatchTime,
+                };
+            },
+        }),
+        resetErrorState: assign({
+            errorState: (_) => undefined,
+        }),
+        updateErrorStateForTimeout: assign({
+            errorState: (_, event) => {
+                return event.data?.errorState || LivenessErrorState.TIMEOUT;
+            },
+        }),
+        updateErrorStateForRuntime: assign({
+            errorState: (_, event) => {
+                return event.data?.errorState || LivenessErrorState.RUNTIME_ERROR;
+            },
+        }),
+        updateErrorStateForServer: assign({
+            errorState: (_) => LivenessErrorState.SERVER_ERROR,
+        }),
+        clearErrorState: assign({
+            errorState: (_) => undefined,
+        }),
+        updateSessionInfo: assign({
+            serverSessionInformation: (context, event) => {
+                return event.data.sessionInfo;
+            },
+        }),
+        updateShouldDisconnect: assign({
+            shouldDisconnect: (context) => {
+                return true;
+            },
+        }),
+        updateFreshnessDetails: assign({
+            freshnessColorAssociatedParams: (context, event) => {
+                return {
+                    ...context.freshnessColorAssociatedParams,
+                    freshnessColorsComplete: event.data.freshnessColorsComplete,
+                };
+            },
+        }),
+        setupFlashFreshnessColors: assign({
+            freshnessColorAssociatedParams: (context) => {
+                const { serverSessionInformation } = context;
+                const freshnessColors = getColorsSequencesFromSessionInformation(serverSessionInformation);
+                const freshnessColorDisplay = new FreshnessColorDisplay(context, freshnessColors);
+                return {
+                    ...context.freshnessColorAssociatedParams,
+                    freshnessColorDisplay,
+                };
+            },
+        }),
+        // timeouts
+        sendTimeoutAfterOvalDrawingDelay: actions.send({ type: 'TIMEOUT' }, {
+            delay: 5000,
+            id: 'ovalDrawingTimeout',
+        }),
+        cancelOvalDrawingTimeout: actions.cancel('ovalDrawingTimeout'),
+        sendTimeoutAfterOvalMatchDelay: actions.send({ type: 'TIMEOUT' }, {
+            delay: (context) => {
+                return (context.serverSessionInformation?.Challenge
+                    ?.FaceMovementAndLightChallenge?.ChallengeConfig
+                    ?.OvalFitTimeout || DEFAULT_FACE_FIT_TIMEOUT);
+            },
+            id: 'ovalMatchTimeout',
+        }),
+        cancelOvalMatchTimeout: actions.cancel('ovalMatchTimeout'),
+        sendTimeoutAfterWaitingForDisconnect: actions.send({
+            type: 'TIMEOUT',
+            data: { errorState: LivenessErrorState.SERVER_ERROR },
+        }, {
+            delay: 20000,
+            id: 'waitForDisconnectTimeout',
+        }),
+        cancelWaitForDisconnectTimeout: actions.cancel('waitForDisconnectTimeout'),
+        sendTimeoutAfterFaceDistanceDelay: actions.send({
+            type: 'RUNTIME_ERROR',
+            data: new Error('Avoid moving closer during countdown and ensure only one face is in front of camera.'),
+        }, {
+            delay: 0,
+            id: 'faceDistanceTimeout',
+        }),
+        cancelFaceDistanceTimeout: actions.cancel('faceDistanceTimeout'),
+        // callbacks
+        callUserPermissionDeniedCallback: assign({
+            errorState: (context, event) => {
+                let errorState;
+                if (event.data.message.includes('15 fps')) {
+                    errorState = LivenessErrorState.CAMERA_FRAMERATE_ERROR;
+                }
+                else {
+                    errorState = LivenessErrorState.CAMERA_ACCESS_ERROR;
+                }
+                const errorMessage = event.data.message || event.data.Message;
+                const error = new Error(errorMessage);
+                const livenessError = {
+                    state: errorState,
+                    error: error,
+                };
+                context.componentProps.onError?.(livenessError);
+                return errorState;
+            },
+        }),
+        callMobileLandscapeWarningCallback: assign({
+            errorState: (context) => {
+                return LivenessErrorState.MOBILE_LANDSCAPE_ERROR;
+            },
+        }),
+        callUserCancelCallback: async (context) => {
+            context.componentProps.onUserCancel?.();
+        },
+        callUserTimeoutCallback: async (context) => {
+            const error = new Error('Client Timeout');
+            error.name = context.errorState;
+            const livenessError = {
+                state: context.errorState,
+                error: error,
+            };
+            context.componentProps.onError?.(livenessError);
+        },
+        callErrorCallback: async (context, event) => {
+            const livenessError = {
+                state: context.errorState,
+                error: event.data?.error || event.data,
+            };
+            context.componentProps.onError?.(livenessError);
+        },
+        cleanUpResources: async (context) => {
+            const { freshnessColorEl } = context.freshnessColorAssociatedParams;
+            if (freshnessColorEl) {
+                freshnessColorEl.style.display = 'none';
+            }
+            let closureCode = WS_CLOSURE_CODE.DEFAULT_ERROR_CODE;
+            if (context.errorState === LivenessErrorState.TIMEOUT) {
+                closureCode = WS_CLOSURE_CODE.FACE_FIT_TIMEOUT;
+            }
+            else if (context.errorState === LivenessErrorState.RUNTIME_ERROR) {
+                closureCode = WS_CLOSURE_CODE.RUNTIME_ERROR;
+            }
+            else if (context.errorState === LivenessErrorState.FACE_DISTANCE_ERROR ||
+                context.errorState === LivenessErrorState.MULTIPLE_FACES_ERROR) {
+                closureCode = WS_CLOSURE_CODE.USER_ERROR_DURING_CONNECTION;
+            }
+            else if (context.errorState === undefined) {
+                closureCode = WS_CLOSURE_CODE.USER_CANCEL;
+            }
+            await context.livenessStreamProvider?.endStreamWithCode(closureCode);
+        },
+        freezeStream: async (context) => {
+            const { videoMediaStream, videoEl } = context.videoAssociatedParams;
+            context.isRecordingStopped = true;
+            videoEl?.pause();
+            videoMediaStream?.getTracks().forEach(function (track) {
+                track.stop();
+            });
+        },
+        pauseVideoStream: async (context) => {
+            const { videoEl } = context.videoAssociatedParams;
+            context.isRecordingStopped = true;
+            videoEl.pause();
+        },
+        resetContext: assign({
+            challengeId: nanoid(),
+            maxFailedAttempts: 0,
+            failedAttempts: 0,
+            componentProps: (context) => context.componentProps,
+            serverSessionInformation: (_) => undefined,
+            videoAssociatedParams: (_) => {
+                return {
+                    videoConstraints: STATIC_VIDEO_CONSTRAINTS,
+                };
+            },
+            ovalAssociatedParams: (_) => undefined,
+            errorState: (_) => undefined,
+            livenessStreamProvider: (_) => undefined,
+            responseStreamActorRef: (_) => undefined,
+            shouldDisconnect: false,
+            faceMatchStateBeforeStart: (_) => undefined,
+            isFaceFarEnoughBeforeRecording: (_) => undefined,
+            isRecordingStopped: false,
+        }),
+    },
+    guards: {
+        shouldTimeoutOnFailedAttempts: (context) => context.failedAttempts >= context.maxFailedAttempts,
+        hasFaceMatchedInOvalWithMinTime: (context) => {
+            const { faceMatchState, initialFaceMatchTime } = context.faceMatchAssociatedParams;
+            const timeSinceInitialFaceMatch = Date.now() - initialFaceMatchTime;
+            const hasMatched = faceMatchState === FaceMatchState.MATCHED &&
+                timeSinceInitialFaceMatch >= MIN_FACE_MATCH_TIME;
+            return hasMatched;
+        },
+        hasFaceMatchedInOval: (context) => {
+            return (context.faceMatchAssociatedParams.faceMatchState ===
+                FaceMatchState.MATCHED);
+        },
+        hasNotFaceMatchedInOval: (context) => {
+            return (context.faceMatchAssociatedParams.faceMatchState !==
+                FaceMatchState.MATCHED);
+        },
+        hasSingleFace: (context) => {
+            return (context.faceMatchAssociatedParams.faceMatchState ===
+                FaceMatchState.FACE_IDENTIFIED);
+        },
+        hasSingleFaceBeforeStart: (context) => {
+            return (context.faceMatchStateBeforeStart === FaceMatchState.FACE_IDENTIFIED);
+        },
+        hasEnoughFaceDistanceBeforeRecording: (context) => {
+            return context.isFaceFarEnoughBeforeRecording;
+        },
+        hasNotEnoughFaceDistanceBeforeRecording: (context) => {
+            return !context.isFaceFarEnoughBeforeRecording;
+        },
+        hasLivenessCheckSucceeded: (_, __, meta) => meta.state.event.data.isLive,
+        hasFreshnessColorShown: (context) => context.freshnessColorAssociatedParams.freshnessColorsComplete,
+        hasServerSessionInfo: (context) => {
+            return context.serverSessionInformation !== undefined;
+        },
+        hasDOMAndCameraDetails: (context) => {
+            return (context.videoAssociatedParams.videoEl !== undefined &&
+                context.videoAssociatedParams.canvasEl !== undefined &&
+                context.freshnessColorAssociatedParams.freshnessColorEl !== undefined);
+        },
+        getShouldDisconnect: (context) => {
+            return !!context.shouldDisconnect;
+        },
+        hasRecordingStarted: (context) => {
+            return (context.livenessStreamProvider.videoRecorder.firstChunkTimestamp !==
+                undefined);
+        },
+        shouldSkipStartScreen: (context) => {
+            return !!context.componentProps?.disableStartScreen;
+        },
+    },
+    services: {
+        async checkVirtualCameraAndGetStream(context) {
+            const { videoConstraints } = context.videoAssociatedParams;
+            // Get initial stream to enumerate devices with non-empty labels
+            const existingDeviceId = getLastSelectedCameraId();
+            const initialStream = await navigator.mediaDevices.getUserMedia({
+                video: {
+                    ...videoConstraints,
+                    ...(existingDeviceId ? { deviceId: existingDeviceId } : {}),
+                },
+                audio: false,
+            });
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            const realVideoDevices = devices
+                .filter((device) => device.kind === 'videoinput')
+                .filter((device) => !isCameraDeviceVirtual(device));
+            if (!realVideoDevices.length) {
+                throw new Error('No real video devices found');
+            }
+            // Ensure that at least one of the cameras is capable of at least 15 fps
+            const tracksWithMoreThan15Fps = initialStream
+                .getTracks()
+                .filter((track) => {
+                const settings = track.getSettings();
+                return settings.frameRate >= 15;
+            });
+            if (tracksWithMoreThan15Fps.length < 1) {
+                throw new Error('No camera found with more than 15 fps');
+            }
+            // If the initial stream is of real camera, use it otherwise use the first real camera
+            const initialStreamDeviceId = tracksWithMoreThan15Fps[0].getSettings().deviceId;
+            const isInitialStreamFromRealDevice = realVideoDevices.some((device) => device.deviceId === initialStreamDeviceId);
+            let deviceId = initialStreamDeviceId;
+            let realVideoDeviceStream = initialStream;
+            if (!isInitialStreamFromRealDevice) {
+                deviceId = realVideoDevices[0].deviceId;
+                realVideoDeviceStream = await navigator.mediaDevices.getUserMedia({
+                    video: {
+                        ...videoConstraints,
+                        deviceId: { exact: realVideoDevices[0].deviceId },
+                    },
+                    audio: false,
+                });
+            }
+            setLastSelectedCameraId(deviceId);
+            return {
+                stream: realVideoDeviceStream,
+                selectedDeviceId: initialStreamDeviceId,
+                selectableDevices: realVideoDevices,
+            };
+        },
+        async openLivenessStreamConnection(context) {
+            const { config } = context.componentProps;
+            const { credentialProvider, endpointOverride } = config;
+            const livenessStreamProvider = new LivenessStreamProvider({
+                sessionId: context.componentProps.sessionId,
+                region: context.componentProps.region,
+                stream: context.videoAssociatedParams.videoMediaStream,
+                videoEl: context.videoAssociatedParams.videoEl,
+                credentialProvider: credentialProvider,
+                endpointOverride: endpointOverride,
+            });
+            responseStream = livenessStreamProvider.getResponseStream();
+            return { livenessStreamProvider };
+        },
+        async detectFace(context) {
+            const { videoEl } = context.videoAssociatedParams;
+            const { faceDetector } = context.ovalAssociatedParams;
+            // initialize models
+            try {
+                await faceDetector.modelLoadingPromise;
+            }
+            catch (err) {
+                console.log({ err });
+            }
+            // detect face
+            const faceMatchState = await getFaceMatchState(faceDetector, videoEl);
+            return { faceMatchState };
+        },
+        async detectFaceDistance(context) {
+            const { isFaceFarEnoughBeforeRecording: faceDistanceCheckBeforeRecording, } = context;
+            const { videoEl, videoMediaStream, isMobile } = context.videoAssociatedParams;
+            const { faceDetector } = context.ovalAssociatedParams;
+            const { width, height } = videoMediaStream
+                .getTracks()[0]
+                .getSettings();
+            const ovalDetails = getStaticLivenessOvalDetails({
+                width: width,
+                height: height,
+            });
+            const { isDistanceBelowThreshold: isFaceFarEnoughBeforeRecording } = await isFaceDistanceBelowThreshold({
+                faceDetector: faceDetector,
+                videoEl: videoEl,
+                ovalDetails,
+                reduceThreshold: faceDistanceCheckBeforeRecording,
+                isMobile,
+            });
+            return { isFaceFarEnoughBeforeRecording };
+        },
+        async detectFaceDistanceWhileLoading(context) {
+            const { isFaceFarEnoughBeforeRecording: faceDistanceCheckBeforeRecording, } = context;
+            const { videoEl, videoMediaStream, isMobile } = context.videoAssociatedParams;
+            const { faceDetector } = context.ovalAssociatedParams;
+            const { width, height } = videoMediaStream
+                .getTracks()[0]
+                .getSettings();
+            const ovalDetails = getStaticLivenessOvalDetails({
+                width: width,
+                height: height,
+            });
+            const { isDistanceBelowThreshold: isFaceFarEnoughBeforeRecording, error, } = await isFaceDistanceBelowThreshold({
+                faceDetector: faceDetector,
+                videoEl: videoEl,
+                ovalDetails,
+                reduceThreshold: faceDistanceCheckBeforeRecording,
+                isMobile,
+            });
+            return { isFaceFarEnoughBeforeRecording, error };
+        },
+        async detectInitialFaceAndDrawOval(context) {
+            const { serverSessionInformation, livenessStreamProvider } = context;
+            const { videoEl, canvasEl, isMobile } = context.videoAssociatedParams;
+            const { faceDetector } = context.ovalAssociatedParams;
+            // initialize models
+            try {
+                await faceDetector.modelLoadingPromise;
+                await livenessStreamProvider.videoRecorder.recorderStarted;
+            }
+            catch (err) {
+                console.log({ err });
+            }
+            // detect face
+            const detectedFaces = await faceDetector.detectFaces(videoEl);
+            let initialFace;
+            let faceMatchState;
+            let illuminationState;
+            switch (detectedFaces.length) {
+                case 0: {
+                    // no face detected;
+                    faceMatchState = FaceMatchState.CANT_IDENTIFY;
+                    illuminationState = estimateIllumination(videoEl);
+                    break;
+                }
+                case 1: {
+                    faceMatchState = FaceMatchState.FACE_IDENTIFIED;
+                    initialFace = detectedFaces[0];
+                    break;
+                }
+                default: {
+                    //more than one face detected ;
+                    faceMatchState = FaceMatchState.TOO_MANY;
+                    break;
+                }
+            }
+            if (!initialFace) {
+                return { faceMatchState, illuminationState };
+            }
+            // Get width/height of video element so we can compute scaleFactor
+            // and set canvas width/height.
+            const { width: videoScaledWidth, height: videoScaledHeight } = videoEl.getBoundingClientRect();
+            if (isMobile) {
+                canvasEl.width = window.innerWidth;
+                canvasEl.height = window.innerHeight;
+            }
+            else {
+                canvasEl.width = videoScaledWidth;
+                canvasEl.height = videoScaledHeight;
+            }
+            // Compute scaleFactor which is how much our video element is scaled
+            // vs the intrinsic video resolution
+            const scaleFactor = videoScaledWidth / videoEl.videoWidth;
+            // generate oval details from initialFace and video dimensions
+            const ovalDetails = getOvalDetailsFromSessionInformation({
+                sessionInformation: serverSessionInformation,
+                videoWidth: videoEl.width,
+            });
+            // renormalize initial face
+            const renormalizedFace = generateBboxFromLandmarks(initialFace, ovalDetails);
+            initialFace.top = renormalizedFace.top;
+            initialFace.left = renormalizedFace.left;
+            initialFace.height = renormalizedFace.bottom - renormalizedFace.top;
+            initialFace.width = renormalizedFace.right - renormalizedFace.left;
+            // Draw oval in canvas using ovalDetails and scaleFactor
+            drawLivenessOvalInCanvas({
+                canvas: canvasEl,
+                oval: ovalDetails,
+                scaleFactor,
+                videoEl: videoEl,
+            });
+            return {
+                faceMatchState,
+                ovalDetails,
+                scaleFactor,
+                initialFace,
+            };
+        },
+        async detectFaceAndMatchOval(context) {
+            const { serverSessionInformation } = context;
+            const { videoEl } = context.videoAssociatedParams;
+            const { faceDetector, ovalDetails, initialFace } = context.ovalAssociatedParams;
+            // detect face
+            const detectedFaces = await faceDetector.detectFaces(videoEl);
+            let faceMatchState;
+            let faceMatchPercentage = 0;
+            let detectedFace;
+            let illuminationState;
+            const initialFaceBoundingBox = generateBboxFromLandmarks(initialFace, ovalDetails);
+            const { ovalBoundingBox } = getOvalBoundingBox(ovalDetails);
+            const initialFaceIntersection = getIntersectionOverUnion(initialFaceBoundingBox, ovalBoundingBox);
+            switch (detectedFaces.length) {
+                case 0: {
+                    //no face detected;
+                    faceMatchState = FaceMatchState.CANT_IDENTIFY;
+                    illuminationState = estimateIllumination(videoEl);
+                    break;
+                }
+                case 1: {
+                    //exactly one face detected, match face with oval;
+                    detectedFace = detectedFaces[0];
+                    const { faceMatchState: faceMatchStateInLivenessOval, faceMatchPercentage: faceMatchPercentageInLivenessOval, } = getFaceMatchStateInLivenessOval(detectedFace, ovalDetails, initialFaceIntersection, serverSessionInformation);
+                    faceMatchState = faceMatchStateInLivenessOval;
+                    faceMatchPercentage = faceMatchPercentageInLivenessOval;
+                    break;
+                }
+                default: {
+                    //more than one face detected ;
+                    faceMatchState = FaceMatchState.TOO_MANY;
+                    break;
+                }
+            }
+            return {
+                faceMatchState,
+                faceMatchPercentage,
+                illuminationState,
+                detectedFace,
+            };
+        },
+        async flashColors(context) {
+            const { freshnessColorsComplete, freshnessColorDisplay } = context.freshnessColorAssociatedParams;
+            if (freshnessColorsComplete) {
+                return;
+            }
+            const completed = await freshnessColorDisplay.displayColorTick();
+            return { freshnessColorsComplete: completed };
+        },
+        async stopVideo(context) {
+            const { challengeId, livenessStreamProvider } = context;
+            const { videoMediaStream } = context.videoAssociatedParams;
+            const { initialFace, ovalDetails } = context.ovalAssociatedParams;
+            const { startFace, endFace } = context.faceMatchAssociatedParams;
+            const { width, height } = videoMediaStream
+                .getTracks()[0]
+                .getSettings();
+            const flippedInitialFaceLeft = width - initialFace.left - initialFace.width;
+            await livenessStreamProvider.stopVideo();
+            const livenessActionDocument = {
+                Challenge: {
+                    FaceMovementAndLightChallenge: {
+                        ChallengeId: challengeId,
+                        InitialFace: {
+                            InitialFaceDetectedTimestamp: initialFace.timestampMs,
+                            BoundingBox: getBoundingBox({
+                                deviceHeight: height,
+                                deviceWidth: width,
+                                height: initialFace.height,
+                                width: initialFace.width,
+                                top: initialFace.top,
+                                left: flippedInitialFaceLeft,
+                            }),
+                        },
+                        TargetFace: {
+                            FaceDetectedInTargetPositionStartTimestamp: startFace.timestampMs,
+                            FaceDetectedInTargetPositionEndTimestamp: endFace.timestampMs,
+                            BoundingBox: getBoundingBox({
+                                deviceHeight: height,
+                                deviceWidth: width,
+                                height: ovalDetails.height,
+                                width: ovalDetails.width,
+                                top: ovalDetails.centerY - ovalDetails.height / 2,
+                                left: ovalDetails.centerX - ovalDetails.width / 2,
+                            }),
+                        },
+                        VideoEndTimestamp: livenessStreamProvider.videoRecorder.recorderEndTimestamp,
+                    },
+                },
+            };
+            if (livenessStreamProvider.videoRecorder.getVideoChunkSize() === 0) {
+                throw new Error('Video chunks not recorded successfully.');
+            }
+            livenessStreamProvider.sendClientInfo(livenessActionDocument);
+            await livenessStreamProvider.dispatchStopVideoEvent();
+        },
+        async getLiveness(context) {
+            const { onAnalysisComplete } = context.componentProps;
+            // Get liveness result
+            await onAnalysisComplete();
+        },
+    },
+});
+const responseStreamActor = async (callback) => {
+    try {
+        const stream = await responseStream;
+        for await (const event of stream) {
+            if (isServerSesssionInformationEvent(event)) {
+                callback({
+                    type: 'SET_SESSION_INFO',
+                    data: {
+                        sessionInfo: event.ServerSessionInformationEvent.SessionInformation,
+                    },
+                });
+            }
+            else if (isDisconnectionEvent(event)) {
+                callback({ type: 'DISCONNECT_EVENT' });
+            }
+            else if (isValidationExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ValidationException } },
+                });
+            }
+            else if (isInternalServerExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.InternalServerException } },
+                });
+            }
+            else if (isThrottlingExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ThrottlingException } },
+                });
+            }
+            else if (isServiceQuotaExceededExceptionEvent(event)) {
+                callback({
+                    type: 'SERVER_ERROR',
+                    data: { error: { ...event.ServiceQuotaExceededException } },
+                });
+            }
+        }
+    }
+    catch (error) {
+        let returnedError = error;
+        if (isInvalidSignatureRegionException(error)) {
+            returnedError = new Error('Invalid region in FaceLivenessDetector or credentials are scoped to the wrong region.');
+        }
+        if (returnedError instanceof Error) {
+            callback({
+                type: 'SERVER_ERROR',
+                data: { error: returnedError },
+            });
+        }
+    }
+};
+
+export { MIN_FACE_MATCH_TIME, livenessMachine };