@tsocial/tvweb-sdk 5.34.4 → 5.34.6

package/build/tvweb-sdk.standalone.js

@@ -33783,7 +33783,7 @@
 	    }, nS$1;
 	}();
 	function nB$1() {
-	    return "5.34.4";
+	    return "5.34.6";
 	}
 	function nI$1() {
 	    return {
@@ -41259,50 +41259,48 @@
 	        }, uz;
 	    }(), uG);
 	}();
-	let dm = db, dg = db, dy = dx();
+	let dm = dv, dg = dv, dy = dx();
 	for(;;)try {
-	    if (parseInt(dg(458)) / 1 * (parseInt(dg(480)) / 2) + -parseInt(dg(455)) / 3 * (-parseInt(dg(457)) / 4) + -parseInt(dg(471)) / 5 + -parseInt(dg(465)) / 6 + parseInt(dg(463)) / 7 * (-parseInt(dg(477)) / 8) + -parseInt(dg(460)) / 9 * (parseInt(dg(468)) / 10) + -parseInt(dg(476)) / 11 * (-parseInt(dg(473)) / 12) === 233663) break;
+	    if (-parseInt(dg(400)) / 1 + -parseInt(dg(412)) / 2 * (parseInt(dg(413)) / 3) + -parseInt(dg(398)) / 4 + parseInt(dg(393)) / 5 * (-parseInt(dg(403)) / 6) + -parseInt(dg(414)) / 7 + parseInt(dg(404)) / 8 * (-parseInt(dg(405)) / 9) + parseInt(dg(410)) / 10 === 675039) break;
 	    dy.push(dy.shift());
 	} catch (e) {
 	    dy.push(dy.shift());
 	}
-	function db(e, t) {
+	let db = dm(399) + dm(397) + "3d02010608" + dm(402) + dm(409) + dm(417);
+	function dv(e, t) {
 	    let r = dx();
-	    return (db = function(e, t) {
-	        return r[e -= 454];
+	    return (dv = function(e, t) {
+	        return r[e -= 393];
 	    })(e, t);
 	}
-	let dv = dm(462) + dm(467) + dm(479) + dm(459) + "0301070342" + dm(472), d_ = dm(474) + dm(466) + dm(456) + dm(478) + dm(454) + "ytJdcsPxrD" + dm(461) + dm(464) + "Mjci1ul8mm" + dm(475) + dm(481) + dm(470) + dm(469);
+	let d_ = dm(396) + dm(415) + dm(406) + dm(407) + dm(416) + dm(394) + "+faHkP3QC3" + dm(408) + dm(411) + "D9EKOWS+U4" + dm(395) + dm(401) + "KA==";
 	function dx() {
 	    let e = [
-	        "D9EKOWS+U4",
-	        "4532icGLnQ",
-	        "18448xyLlKj",
-	        "cDQgAE9h6Z",
-	        "3d02010608",
-	        "204126ixklsL",
-	        "MfPrcYTM70",
-	        "DepBO8t60S",
-	        "87nmVtHP",
-	        "KoZIzj0DAQ",
-	        "55712UVQONf",
-	        "2EfgRUw",
-	        "2a8648ce3d",
-	        "136242zgynFf",
-	        "+faHkP3QC3",
-	        "3059301306",
-	        "553JRucLG",
-	        "44P0rKKsZK",
-	        "879336fcuqSw",
+	        "754034MVAlGX",
+	        "9qfvzvF",
+	        "9231341WBMLOs",
 	        "ZIzj0CAQYI",
+	        "DepBO8t60S",
+	        "000",
+	        "575PumApD",
+	        "ytJdcsPxrD",
+	        "MfPrcYTM70",
+	        "MFkwEwYHKo",
 	        "072a8648ce",
-	        "20JpJYZN",
-	        "KA==",
+	        "4960704BbpIae",
+	        "3059301306",
+	        "1049264TQjxFs",
 	        "ssRdXLZEX8",
-	        "241645RDykmR",
-	        "000",
-	        "960aXGJaK",
-	        "MFkwEwYHKo"
+	        "2a8648ce3d",
+	        "12156RnmUwF",
+	        "40rodesL",
+	        "1651338WhfRhr",
+	        "KoZIzj0DAQ",
+	        "cDQgAE9h6Z",
+	        "44P0rKKsZK",
+	        "0301070342",
+	        "65646930BDCMCU",
+	        "Mjci1ul8mm"
 	    ];
 	    return (dx = function() {
 	        return e;
@@ -41412,7 +41410,7 @@
 	            isValid: !1,
 	            error: i0$1.invalid_license
 	        };
-	        let { mode: a, license: o, signature: s } = dS(e), c = dw(i4$1(o)), l = (r = t || d_, n = i4$1(r).replace(dv, ""), i = new dp.ec("p256").keyFromPublic(n, "hex"), {
+	        let { mode: a, license: o, signature: s } = dS(e), c = dw(i4$1(o)), l = (r = t || d_, n = i4$1(r).replace(db, ""), i = new dp.ec("p256").keyFromPublic(n, "hex"), {
 	            verifySignature: async (e, t)=>{
 	                try {
 	                    let r = await dC(e), n = i4$1(t);
@@ -45326,7 +45324,7 @@
 	        return this.getKey().getPublicKey();
 	    }, e.prototype.getPublicKeyB64 = function() {
 	        return this.getKey().getPublicBaseKeyB64();
-	    }, e.version = "5.34.3", e;
+	    }, e.version = "5.34.5", e;
 	}();
 	let hO = [
 	    "-",
@@ -88702,204 +88700,6 @@
 	    return videoCanvas;
 	};
 
-	const MODE = {
-	    LANDSCAPE: 'landscape',
-	    PORTRAIT: 'portrait',
-	    DESKTOP: 'desktop'
-	};
-	const useDetectOrientation = (onOrientationChange)=>{
-	    const portraitQuery = reactExports.useRef(window.matchMedia('(orientation: portrait)'));
-	    const initOrientation = reactExports.useRef(portraitQuery.current.matches ? MODE.PORTRAIT : MODE.LANDSCAPE);
-	    const [curOrientation, setCurOrientation] = reactExports.useState(initOrientation.current);
-	    reactExports.useEffect(()=>{
-	        function handleResizeForScreen() {
-	            const orientationType = get(screen, 'orientation.type')?.split('-')?.[0];
-	            setCurOrientation(orientationType);
-	            if (typeof onOrientationChange === 'function') {
-	                onOrientationChange(orientationType);
-	            }
-	        }
-	        function handleResizeForQuery(e) {
-	            let orientation;
-	            if (e.matches) {
-	                orientation = MODE.PORTRAIT;
-	            } else {
-	                orientation = MODE.LANDSCAPE;
-	            }
-	            setCurOrientation(orientation);
-	            if (typeof onOrientationChange === 'function') {
-	                onOrientationChange(orientation);
-	            }
-	        }
-	        if (screen.orientation) {
-	            screen.orientation.addEventListener('change', handleResizeForScreen);
-	        } else {
-	            // screen.orientation only available on ios > 16.4
-	            // fallback to window.matchMedia
-	            portraitQuery.current.addEventListener('change', handleResizeForQuery);
-	        }
-	        return ()=>{
-	            if (screen.orientation) {
-	                screen.orientation.removeEventListener('change', handleResizeForScreen);
-	            } else {
-	                // eslint-disable-next-line react-hooks/exhaustive-deps
-	                portraitQuery.current.removeEventListener('change', handleResizeForQuery);
-	            }
-	        };
-	    }, [
-	        onOrientationChange
-	    ]);
-	    return libExports.isMobile ? {
-	        curOrientation,
-	        initOrientation: initOrientation.current
-	    } : {
-	        curOrientation: MODE.DESKTOP
-	    };
-	};
-
-	/**
-	 * Custom hook to delay rendering when transitioning from hidden to visible state.
-	 * Useful for waiting for browser dimension updates after orientation changes.
-	 *
-	 * @param params - Hook parameters
-	 * @param params.isVisible - Whether the component is currently visible
-	 * @param params.enableDelay - Whether to apply delay logic for show transitions
-	 * @param params.delayMs - Delay in milliseconds before showing (default: 500)
-	 * @returns Delayed visibility state
-	 */ function useDelayedRender({ isVisible, enableDelay, delayMs = 500 }) {
-	    const [isVisibleDelayed, setIsVisibleDelayed] = reactExports.useState(isVisible);
-	    const prevIsVisibleRef = reactExports.useRef(isVisible);
-	    const timeoutRef = reactExports.useRef(null);
-	    reactExports.useEffect(()=>{
-	        const prevIsVisible = prevIsVisibleRef.current;
-	        // When delay is disabled, always sync immediately
-	        if (!enableDelay) {
-	            setIsVisibleDelayed(isVisible);
-	            prevIsVisibleRef.current = isVisible;
-	            return undefined;
-	        }
-	        // Handle transitions when delay is enabled
-	        const isTransitionToShow = !prevIsVisible && isVisible;
-	        const isTransitionToHide = prevIsVisible && !isVisible;
-	        if (isTransitionToShow) {
-	            // Delay showing when transitioning from hidden to visible
-	            timeoutRef.current = setTimeout(()=>{
-	                setIsVisibleDelayed(true);
-	            }, delayMs);
-	        } else if (isTransitionToHide) {
-	            // Immediately hide and cancel pending show
-	            if (timeoutRef.current) {
-	                clearTimeout(timeoutRef.current);
-	                timeoutRef.current = null;
-	            }
-	            setIsVisibleDelayed(false);
-	        }
-	        prevIsVisibleRef.current = isVisible;
-	        return ()=>{
-	            if (timeoutRef.current) {
-	                clearTimeout(timeoutRef.current);
-	            }
-	        };
-	    }, [
-	        isVisible,
-	        enableDelay,
-	        delayMs
-	    ]);
-	    return isVisibleDelayed;
-	}
-
-	const PopupContent$1 = dt$1.div`
-  text-align: center;
-  font-size: 20px;
-  font-weight: 600;
-`;
-	const ChildrenWrapper$1 = dt$1.div`
-  width: 100%;
-  height: 100%;
-  opacity: ${({ $showChildren })=>$showChildren ? 1 : 0};
-`;
-	const defaultPreferredOrientations = [
-	    MODE.PORTRAIT,
-	    MODE.DESKTOP
-	];
-	function OrientationDetectionV2({ onOrientationChange = noop$1, unmountOnHidden = false, remountDelayMs = 500, preferredOrientations = defaultPreferredOrientations, children }) {
-	    const t = gB();
-	    const { curOrientation } = useDetectOrientation(onOrientationChange);
-	    const hasCorrectOrientation = preferredOrientations.includes(curOrientation);
-	    const isVisible = useDelayedRender({
-	        isVisible: hasCorrectOrientation,
-	        enableDelay: unmountOnHidden,
-	        delayMs: remountDelayMs
-	    });
-	    const shouldMountChildrenOnDom = unmountOnHidden ? isVisible : true;
-	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
-	        children: [
-	            !preferredOrientations.includes(curOrientation) && /*#__PURE__*/ jsxRuntimeExports.jsx(PopupComponent, {
-	                open: true,
-	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(PopupContent$1, {
-	                    children: t('wrong_orientation')
-	                })
-	            }),
-	            shouldMountChildrenOnDom && /*#__PURE__*/ jsxRuntimeExports.jsx(ChildrenWrapper$1, {
-	                $showChildren: hasCorrectOrientation,
-	                children: children
-	            })
-	        ]
-	    });
-	}
-
-	const PopupContent = dt$1.div`
-  text-align: center;
-  font-size: 20px;
-  font-weight: 600;
-`;
-	const ChildrenWrapper = dt$1.div`
-  width: 100%;
-  height: 100%;
-  opacity: ${({ showChildren })=>showChildren ? 1 : 0};
-`;
-	// eslint-disable-next-line react/require-default-props
-	function OrientationDetectionV1({ onOrientationChange, unmountOnHidden, children }) {
-	    const t = gB();
-	    const { curOrientation } = useDetectOrientation(onOrientationChange);
-	    const shouldShowChildren = curOrientation === MODE.PORTRAIT || curOrientation === MODE.DESKTOP;
-	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
-	        children: [
-	            curOrientation === MODE.LANDSCAPE && /*#__PURE__*/ jsxRuntimeExports.jsx(PopupComponent, {
-	                open: true,
-	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(PopupContent, {
-	                    children: t('wrong_orientation')
-	                })
-	            }),
-	            (unmountOnHidden ? shouldShowChildren : true) && /*#__PURE__*/ jsxRuntimeExports.jsx(ChildrenWrapper, {
-	                showChildren: shouldShowChildren,
-	                children: children
-	            })
-	        ]
-	    });
-	}
-	OrientationDetectionV1.defaultProps = {
-	    onOrientationChange: ()=>{},
-	    unmountOnHidden: false
-	};
-	OrientationDetectionV1.propTypes = {
-	    onOrientationChange: PropTypes.func,
-	    unmountOnHidden: PropTypes.bool
-	};
-
-	function OrientationDetection({ version = 'v1', children, ...rest }) {
-	    if (version === 'v2') {
-	        return /*#__PURE__*/ jsxRuntimeExports.jsx(OrientationDetectionV2, {
-	            ...rest,
-	            children: children
-	        });
-	    }
-	    return /*#__PURE__*/ jsxRuntimeExports.jsx(OrientationDetectionV1, {
-	        ...rest,
-	        children: children
-	    });
-	}
-
 	const useEkycSession = ()=>{
 	    const [sessionId, setSessionId] = reactExports.useState(Date.now());
 	    const updateSessionId = reactExports.useCallback(()=>{
@@ -91391,15 +91191,6 @@
 	    useRunEffectWhen(()=>logEvent('selfie_flash', 'user_activity.start_flash'), step === STEP.START_FLASHING);
 	    const progressPercentage = colorIndex === STOP_COLOR ? 0 : Math.min(Math.round((colorIndex + 1) / (colors.length * framesPerColor) * 100), 100);
 	    const { Loading } = styledComponent;
-	    const onOrientationChange = reactExports.useCallback((curOrientation)=>{
-	        if (curOrientation === MODE.LANDSCAPE) {
-	            videoRef.current?.pause();
-	        } else {
-	            videoRef.current?.play();
-	        }
-	    }, [
-	        videoRef
-	    ]);
 	    // ============================= Timer =============================
 	    const onTimeout = reactExports.useCallback(()=>{
 	        setIsAutoCapturing(false);
@@ -91436,8 +91227,7 @@
 	    const errorMessage = getErrorMessage(faceError);
 	    // error message should be centered in the oval
 	    const errorY = cropArea.y + cropArea.height / 2 + ovalVerticalOffset;
-	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(OrientationDetection, {
-	        onOrientationChange: onOrientationChange,
+	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
 	        children: [
 	            /*#__PURE__*/ jsxRuntimeExports.jsx(NormalCamera, {
 	                frontCamera: frontCamera,
@@ -91923,17 +91713,219 @@
 	    });
 	};
 
+	const MODE = {
+	    LANDSCAPE: 'landscape',
+	    PORTRAIT: 'portrait',
+	    DESKTOP: 'desktop'
+	};
+	const useDetectOrientation = (onOrientationChange)=>{
+	    const portraitQuery = reactExports.useRef(window.matchMedia('(orientation: portrait)'));
+	    const initOrientation = reactExports.useRef(portraitQuery.current.matches ? MODE.PORTRAIT : MODE.LANDSCAPE);
+	    const [curOrientation, setCurOrientation] = reactExports.useState(initOrientation.current);
+	    reactExports.useEffect(()=>{
+	        function handleResizeForScreen() {
+	            const orientationType = get(screen, 'orientation.type')?.split('-')?.[0];
+	            setCurOrientation(orientationType);
+	            if (typeof onOrientationChange === 'function') {
+	                onOrientationChange(orientationType);
+	            }
+	        }
+	        function handleResizeForQuery(e) {
+	            let orientation;
+	            if (e.matches) {
+	                orientation = MODE.PORTRAIT;
+	            } else {
+	                orientation = MODE.LANDSCAPE;
+	            }
+	            setCurOrientation(orientation);
+	            if (typeof onOrientationChange === 'function') {
+	                onOrientationChange(orientation);
+	            }
+	        }
+	        if (screen.orientation) {
+	            screen.orientation.addEventListener('change', handleResizeForScreen);
+	        } else {
+	            // screen.orientation only available on ios > 16.4
+	            // fallback to window.matchMedia
+	            portraitQuery.current.addEventListener('change', handleResizeForQuery);
+	        }
+	        return ()=>{
+	            if (screen.orientation) {
+	                screen.orientation.removeEventListener('change', handleResizeForScreen);
+	            } else {
+	                // eslint-disable-next-line react-hooks/exhaustive-deps
+	                portraitQuery.current.removeEventListener('change', handleResizeForQuery);
+	            }
+	        };
+	    }, [
+	        onOrientationChange
+	    ]);
+	    return libExports.isMobile ? {
+	        curOrientation,
+	        initOrientation: initOrientation.current
+	    } : {
+	        curOrientation: MODE.DESKTOP
+	    };
+	};
+
+	/**
+	 * Custom hook to delay rendering when transitioning from hidden to visible state.
+	 * Useful for waiting for browser dimension updates after orientation changes.
+	 *
+	 * @param params - Hook parameters
+	 * @param params.isVisible - Whether the component is currently visible
+	 * @param params.enableDelay - Whether to apply delay logic for show transitions
+	 * @param params.delayMs - Delay in milliseconds before showing (default: 500)
+	 * @returns Delayed visibility state
+	 */ function useDelayedRender({ isVisible, enableDelay, delayMs = 500 }) {
+	    const [isVisibleDelayed, setIsVisibleDelayed] = reactExports.useState(isVisible);
+	    const prevIsVisibleRef = reactExports.useRef(isVisible);
+	    const timeoutRef = reactExports.useRef(null);
+	    reactExports.useEffect(()=>{
+	        const prevIsVisible = prevIsVisibleRef.current;
+	        // When delay is disabled, always sync immediately
+	        if (!enableDelay) {
+	            setIsVisibleDelayed(isVisible);
+	            prevIsVisibleRef.current = isVisible;
+	            return undefined;
+	        }
+	        // Handle transitions when delay is enabled
+	        const isTransitionToShow = !prevIsVisible && isVisible;
+	        const isTransitionToHide = prevIsVisible && !isVisible;
+	        if (isTransitionToShow) {
+	            // Delay showing when transitioning from hidden to visible
+	            timeoutRef.current = setTimeout(()=>{
+	                setIsVisibleDelayed(true);
+	            }, delayMs);
+	        } else if (isTransitionToHide) {
+	            // Immediately hide and cancel pending show
+	            if (timeoutRef.current) {
+	                clearTimeout(timeoutRef.current);
+	                timeoutRef.current = null;
+	            }
+	            setIsVisibleDelayed(false);
+	        }
+	        prevIsVisibleRef.current = isVisible;
+	        return ()=>{
+	            if (timeoutRef.current) {
+	                clearTimeout(timeoutRef.current);
+	            }
+	        };
+	    }, [
+	        isVisible,
+	        enableDelay,
+	        delayMs
+	    ]);
+	    return isVisibleDelayed;
+	}
+
+	const PopupContent$1 = dt$1.div`
+  text-align: center;
+  font-size: 20px;
+  font-weight: 600;
+`;
+	const ChildrenWrapper$1 = dt$1.div`
+  width: 100%;
+  height: 100%;
+  opacity: ${({ $showChildren })=>$showChildren ? 1 : 0};
+`;
+	const defaultPreferredOrientations = [
+	    MODE.PORTRAIT,
+	    MODE.DESKTOP
+	];
+	function OrientationDetectionV2({ onOrientationChange = noop$1, unmountOnHidden = false, remountDelayMs = 500, preferredOrientations = defaultPreferredOrientations, children }) {
+	    const t = gB();
+	    const { curOrientation } = useDetectOrientation(onOrientationChange);
+	    const hasCorrectOrientation = preferredOrientations.includes(curOrientation);
+	    const isVisible = useDelayedRender({
+	        isVisible: hasCorrectOrientation,
+	        enableDelay: unmountOnHidden,
+	        delayMs: remountDelayMs
+	    });
+	    const shouldMountChildrenOnDom = unmountOnHidden ? isVisible : true;
+	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+	        children: [
+	            !preferredOrientations.includes(curOrientation) && /*#__PURE__*/ jsxRuntimeExports.jsx(PopupComponent, {
+	                open: true,
+	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(PopupContent$1, {
+	                    children: t('wrong_orientation')
+	                })
+	            }),
+	            shouldMountChildrenOnDom && /*#__PURE__*/ jsxRuntimeExports.jsx(ChildrenWrapper$1, {
+	                $showChildren: hasCorrectOrientation,
+	                children: children
+	            })
+	        ]
+	    });
+	}
+
+	const PopupContent = dt$1.div`
+  text-align: center;
+  font-size: 20px;
+  font-weight: 600;
+`;
+	const ChildrenWrapper = dt$1.div`
+  width: 100%;
+  height: 100%;
+  opacity: ${({ showChildren })=>showChildren ? 1 : 0};
+`;
+	// eslint-disable-next-line react/require-default-props
+	function OrientationDetectionV1({ onOrientationChange, unmountOnHidden, children }) {
+	    const t = gB();
+	    const { curOrientation } = useDetectOrientation(onOrientationChange);
+	    const shouldShowChildren = curOrientation === MODE.PORTRAIT || curOrientation === MODE.DESKTOP;
+	    return /*#__PURE__*/ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, {
+	        children: [
+	            curOrientation === MODE.LANDSCAPE && /*#__PURE__*/ jsxRuntimeExports.jsx(PopupComponent, {
+	                open: true,
+	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(PopupContent, {
+	                    children: t('wrong_orientation')
+	                })
+	            }),
+	            (unmountOnHidden ? shouldShowChildren : true) && /*#__PURE__*/ jsxRuntimeExports.jsx(ChildrenWrapper, {
+	                showChildren: shouldShowChildren,
+	                children: children
+	            })
+	        ]
+	    });
+	}
+	OrientationDetectionV1.defaultProps = {
+	    onOrientationChange: ()=>{},
+	    unmountOnHidden: false
+	};
+	OrientationDetectionV1.propTypes = {
+	    onOrientationChange: PropTypes.func,
+	    unmountOnHidden: PropTypes.bool
+	};
+
+	function OrientationDetection({ version = 'v1', children, ...rest }) {
+	    if (version === 'v2') {
+	        return /*#__PURE__*/ jsxRuntimeExports.jsx(OrientationDetectionV2, {
+	            ...rest,
+	            children: children
+	        });
+	    }
+	    return /*#__PURE__*/ jsxRuntimeExports.jsx(OrientationDetectionV1, {
+	        ...rest,
+	        children: children
+	    });
+	}
+
 	// eslint-disable-next-line react/require-default-props
 	const FlashLiveness = (props)=>{
 	    const { apiCredentials, outputEncryptionSettings, mode } = props;
-	    return /*#__PURE__*/ jsxRuntimeExports.jsx(ApiClientProvider, {
-	        apiCredentials: apiCredentials,
-	        children: /*#__PURE__*/ jsxRuntimeExports.jsx(FlashModeProvider, {
-	            flashMode: mode,
-	            children: /*#__PURE__*/ jsxRuntimeExports.jsx(OutputEncryptionProvider, {
-	                settings: outputEncryptionSettings,
-	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(FlashLivenessContainer, {
-	                    ...props
+	    return /*#__PURE__*/ jsxRuntimeExports.jsx(OrientationDetection, {
+	        version: "v2",
+	        unmountOnHidden: true,
+	        children: /*#__PURE__*/ jsxRuntimeExports.jsx(ApiClientProvider, {
+	            apiCredentials: apiCredentials,
+	            children: /*#__PURE__*/ jsxRuntimeExports.jsx(FlashModeProvider, {
+	                flashMode: mode,
+	                children: /*#__PURE__*/ jsxRuntimeExports.jsx(OutputEncryptionProvider, {
+	                    settings: outputEncryptionSettings,
+	                    children: /*#__PURE__*/ jsxRuntimeExports.jsx(FlashLivenessContainer, {
+	                        ...props
+	                    })
 	                })
 	            })
 	        })
@@ -110652,13 +110644,11 @@
 	    }
 	    return apiClient.detectIDTampering(payload);
 	}
-	async function readIdCard({ cardType, apiClient, frontCardId, backCardId, isCapturingFrontSide, qrImageId }) {
+	async function readIdCard({ cardType, apiClient, cardImageId, qrImageId }) {
 	    const payload = {
 	        card_type: cardType,
-	        image1: isCapturingFrontSide ? {
-	            id: frontCardId
-	        } : {
-	            id: backCardId
+	        image1: {
+	            id: cardImageId
 	        }
 	    };
 	    if (qrImageId) {
@@ -110671,10 +110661,6 @@
 	    return apiClient.readIDCard(payload);
 	}
 	async function handleApiCheck({ image, frontCardId: existingFrontCardId, qrImageId: existingQRImageId, onError, recordedVideos, apiClient, cardType, cardSide, qrScannedResult, outputEncryptionSettings, enabledServices, fullVideo, capturingVideo, previousCapturingVideoId, previousFullVideoId }) {
-	    if (cardSide === IDCardSide$2.BACK && !existingFrontCardId) {
-	        onError(Errors$3.missing_front_id_card);
-	        return;
-	    }
 	    const uploadPromises = [
 	        uploadIdCard({
 	            image,
@@ -110714,15 +110700,6 @@
 	    }
 	    const imageId = uploadIdCardResult.data.image_id;
 	    const qrImageId = uploadQrResult?.data?.image_id || existingQRImageId;
-	    let frontCardId;
-	    let backCardId;
-	    const isCapturingFrontSide = cardSide === IDCardSide$2.FRONT;
-	    if (isCapturingFrontSide) {
-	        frontCardId = imageId;
-	    } else {
-	        frontCardId = existingFrontCardId;
-	        backCardId = imageId;
-	    }
 	    const sanityResult = {
 	        data: null
 	    };
@@ -110748,9 +110725,7 @@
 	        const result = await readIdCard({
 	            cardType,
 	            apiClient,
-	            frontCardId,
-	            backCardId,
-	            isCapturingFrontSide,
+	            cardImageId: imageId,
 	            qrImageId
 	        });
 	        if (result.errors) {
@@ -110768,6 +110743,20 @@
 	        data: null
 	    };
 	    if (enabledServices?.enableDetectIDCardTampering) {
+	        // Detect ID Tampering requires front ID card image
+	        if (cardSide === IDCardSide$2.BACK && !existingFrontCardId) {
+	            onError(Errors$3.missing_front_id_card);
+	            return;
+	        }
+	        let frontCardId;
+	        let backCardId;
+	        const isCapturingFrontSide = cardSide === IDCardSide$2.FRONT;
+	        if (isCapturingFrontSide) {
+	            frontCardId = imageId;
+	        } else {
+	            frontCardId = existingFrontCardId;
+	            backCardId = imageId;
+	        }
 	        const result = await detectIDTampering({
 	            apiClient,
 	            cardType,
@@ -113623,7 +113612,7 @@
 	    };
 	};
 
-	const defaultAssetRoot = "https://vision-cdn.trustingsocial.com/tvweb-sdk/5.34.4/assets";
+	const defaultAssetRoot = "https://vision-cdn.trustingsocial.com/tvweb-sdk/5.34.6/assets";
 	class TVWebSDK extends gU {
 	    constructor(props){
 	        super({