@tsocial/tvweb-sdk 5.34.5 → 5.34.7

package/build/tvweb-sdk.standalone.js

@@ -33783,7 +33783,7 @@
 	    }, nS$1;
 	}();
 	function nB$1() {
-	    return "5.34.5";
+	    return "5.34.7";
 	}
 	function nI$1() {
 	    return {
@@ -41259,51 +41259,49 @@
 	        }, uz;
 	    }(), uG);
 	}();
-	let dm = dg;
-	function dg(e, t) {
-	    let r = dv();
-	    return (dg = function(e, t) {
-	        return r[e -= 187];
-	    })(e, t);
-	}
-	let dy = dg, db = dv();
+	let dm = d_, dg = d_, dy = dv();
 	for(;;)try {
-	    if (-parseInt(dy(192)) / 1 + -parseInt(dy(203)) / 2 * (parseInt(dy(195)) / 3) + parseInt(dy(196)) / 4 + -parseInt(dy(207)) / 5 + -parseInt(dy(190)) / 6 + -parseInt(dy(189)) / 7 * (parseInt(dy(191)) / 8) + parseInt(dy(187)) / 9 === 698852) break;
-	    db.push(db.shift());
+	    if (parseInt(dg(290)) / 1 + parseInt(dg(291)) / 2 + parseInt(dg(289)) / 3 * (parseInt(dg(298)) / 4) + parseInt(dg(293)) / 5 + parseInt(dg(292)) / 6 * (-parseInt(dg(299)) / 7) + -parseInt(dg(285)) / 8 + -parseInt(dg(295)) / 9 === 848564) break;
+	    dy.push(dy.shift());
 	} catch (e) {
-	    db.push(db.shift());
+	    dy.push(dy.shift());
 	}
+	let db = dm(283) + dm(288) + dm(287) + "2a8648ce3d" + dm(286) + "000";
 	function dv() {
 	    let e = [
-	        "ssRdXLZEX8",
-	        "0301070342",
-	        "KoZIzj0DAQ",
-	        "ytJdcsPxrD",
 	        "ZIzj0CAQYI",
-	        "44P0rKKsZK",
-	        "78oZoJhH",
-	        "2a8648ce3d",
-	        "000",
+	        "ytJdcsPxrD",
+	        "cDQgAE9h6Z",
+	        "KA==",
 	        "3059301306",
-	        "5437410AYDgCq",
-	        "+faHkP3QC3",
-	        "Mjci1ul8mm",
-	        "37124379gQRvRs",
-	        "MFkwEwYHKo",
-	        "7ZYIbTa",
-	        "4421568SgMIDk",
-	        "1587704kuyojg",
-	        "850895lAaPpT",
 	        "DepBO8t60S",
-	        "cDQgAE9h6Z",
-	        "48579GCEgeE",
-	        "316864rFHuHL"
+	        "5781856ASdVnB",
+	        "0301070342",
+	        "3d02010608",
+	        "072a8648ce",
+	        "4666479rjrWyS",
+	        "110707ijpBPi",
+	        "762470mjWkJP",
+	        "42mNPKlj",
+	        "3656320tEDxFW",
+	        "KoZIzj0DAQ",
+	        "9579789ARHRJm",
+	        "Mjci1ul8mm",
+	        "D9EKOWS+U4",
+	        "4jyWTrx",
+	        "142982jYbZDz"
 	    ];
 	    return (dv = function() {
 	        return e;
 	    })();
 	}
-	let d_ = dm(206) + "072a8648ce3d02010608" + dm(204) + dm(198) + dm(205), dx = dm(188) + dm(201) + dm(199) + dm(194) + dm(193) + dm(200) + dm(208) + dm(202) + dm(209) + "D9EKOWS+U4MfPrcYTM70" + dm(197) + "KA==";
+	function d_(e, t) {
+	    let r = dv();
+	    return (d_ = function(e, t) {
+	        return r[e -= 282];
+	    })(e, t);
+	}
+	let dx = "MFkwEwYHKo" + dm(300) + dm(294) + dm(302) + dm(284) + dm(301) + "+faHkP3QC344P0rKKsZK" + dm(296) + dm(297) + "MfPrcYTM70ssRdXLZEX8" + dm(282);
 	async function dC(e) {
 	    let t = new TextEncoder().encode(e);
 	    return Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", t))).map((e)=>e.toString(16).padStart(2, "0")).join("");
@@ -41408,7 +41406,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 || dx, n = i4$1(r).replace(d_, ""), 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 || dx, 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);
@@ -45322,7 +45320,7 @@
 	        return this.getKey().getPublicKey();
 	    }, e.prototype.getPublicKeyB64 = function() {
 	        return this.getKey().getPublicBaseKeyB64();
-	    }, e.version = "5.34.4", e;
+	    }, e.version = "5.34.6", e;
 	}();
 	let hO = [
 	    "-",
@@ -88698,204 +88696,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(()=>{
@@ -91387,15 +91187,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);
@@ -91432,8 +91223,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,
@@ -91919,17 +91709,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
+	                    })
 	                })
 	            })
 	        })
@@ -113616,7 +113608,7 @@
 	    };
 	};
 
-	const defaultAssetRoot = "https://vision-cdn.trustingsocial.com/tvweb-sdk/5.34.5/assets";
+	const defaultAssetRoot = "https://vision-cdn.trustingsocial.com/tvweb-sdk/5.34.7/assets";
 	class TVWebSDK extends gU {
 	    constructor(props){
 	        super({