@sqaitech/visualizer 0.5.0

package/dist/lib/hooks/usePlaygroundExecution.js

@@ -0,0 +1,214 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    usePlaygroundExecution: ()=>usePlaygroundExecution
+});
+const external_react_namespaceObject = require("react");
+const store_js_namespaceObject = require("../store/store.js");
+const playground_namespaceObject = require("@sqaitech/playground");
+const constants_js_namespaceObject = require("../utils/constants.js");
+const replay_scripts_js_namespaceObject = require("../utils/replay-scripts.js");
+function usePlaygroundExecution(playgroundSDK, storage, actionSpace, loading, setLoading, infoList, setInfoList, replayCounter, setReplayCounter, verticalMode, currentRunningIdRef, interruptedFlagRef) {
+    const { deepThink, screenshotIncluded, domIncluded } = (0, store_js_namespaceObject.useEnvConfig)();
+    const handleRun = (0, external_react_namespaceObject.useCallback)(async (value)=>{
+        if (!playgroundSDK) return void console.warn('PlaygroundSDK is not available');
+        const thisRunningId = Date.now();
+        const actionType = value.type;
+        const displayContent = `${value.type}: ${value.prompt || JSON.stringify(value.params)}`;
+        const userItem = {
+            id: `user-${Date.now()}`,
+            type: 'user',
+            content: displayContent,
+            timestamp: new Date()
+        };
+        setInfoList((prev)=>[
+                ...prev,
+                userItem
+            ]);
+        setLoading(true);
+        const result = {
+            ...constants_js_namespaceObject.BLANK_RESULT
+        };
+        const systemItem = {
+            id: `system-${thisRunningId}`,
+            type: 'system',
+            content: '',
+            timestamp: new Date(),
+            loading: true,
+            loadingProgressText: ''
+        };
+        setInfoList((prev)=>[
+                ...prev,
+                systemItem
+            ]);
+        try {
+            currentRunningIdRef.current = thisRunningId;
+            interruptedFlagRef.current[thisRunningId] = false;
+            if (playgroundSDK.onProgressUpdate) playgroundSDK.onProgressUpdate(()=>{});
+            if (playgroundSDK.onProgressUpdate) playgroundSDK.onProgressUpdate((tip)=>{
+                if (interruptedFlagRef.current[thisRunningId]) return;
+                setInfoList((prev)=>{
+                    const lastItem = prev[prev.length - 1];
+                    if (lastItem && 'progress' === lastItem.type && lastItem.content === tip) return prev;
+                    const progressItem = {
+                        id: `progress-${thisRunningId}-${Date.now()}`,
+                        type: 'progress',
+                        content: tip,
+                        timestamp: new Date()
+                    };
+                    return [
+                        ...prev,
+                        progressItem
+                    ];
+                });
+            });
+            result.result = await playgroundSDK.executeAction(actionType, value, {
+                requestId: thisRunningId.toString(),
+                deepThink,
+                screenshotIncluded,
+                domIncluded
+            });
+            if ('object' == typeof result.result && null !== result.result) {
+                const resultObj = result.result;
+                if (resultObj.dump) result.dump = resultObj.dump;
+                if (resultObj.reportHTML) result.reportHTML = resultObj.reportHTML;
+                if (resultObj.error) result.error = resultObj.error;
+                if (void 0 !== resultObj.result) result.result = resultObj.result;
+            }
+        } catch (e) {
+            result.error = (null == e ? void 0 : e.message) || String(e);
+            console.error('Playground execution error:', e);
+        }
+        if (interruptedFlagRef.current[thisRunningId]) return;
+        setLoading(false);
+        currentRunningIdRef.current = null;
+        let replayInfo = null;
+        let counter = replayCounter;
+        if ((null == result ? void 0 : result.dump) && !playground_namespaceObject.noReplayAPIs.includes(actionType)) {
+            const info = (0, replay_scripts_js_namespaceObject.allScriptsFromDump)(result.dump);
+            setReplayCounter((c)=>c + 1);
+            replayInfo = info;
+            counter = replayCounter + 1;
+        }
+        setInfoList((prev)=>prev.map((item)=>item.id === `system-${thisRunningId}` ? {
+                    ...item,
+                    content: '',
+                    loading: false,
+                    loadingProgressText: ''
+                } : item));
+        const resultItem = {
+            id: `result-${thisRunningId}`,
+            type: 'result',
+            content: 'Execution result',
+            timestamp: new Date(),
+            result: result,
+            loading: false,
+            replayScriptsInfo: replayInfo,
+            replayCounter: counter,
+            loadingProgressText: '',
+            verticalMode: verticalMode
+        };
+        setInfoList((prev)=>[
+                ...prev,
+                resultItem
+            ]);
+        if (null == storage ? void 0 : storage.saveResult) try {
+            await storage.saveResult(resultItem.id, resultItem);
+        } catch (error) {
+            console.error('Failed to save result:', error);
+        }
+        const separatorItem = {
+            id: `separator-${thisRunningId}`,
+            type: 'separator',
+            content: 'New Session',
+            timestamp: new Date()
+        };
+        setInfoList((prev)=>[
+                ...prev,
+                separatorItem
+            ]);
+    }, [
+        playgroundSDK,
+        storage,
+        actionSpace,
+        setLoading,
+        setInfoList,
+        replayCounter,
+        setReplayCounter,
+        verticalMode,
+        currentRunningIdRef,
+        interruptedFlagRef,
+        deepThink,
+        screenshotIncluded,
+        domIncluded
+    ]);
+    const handleStop = (0, external_react_namespaceObject.useCallback)(async ()=>{
+        const thisRunningId = currentRunningIdRef.current;
+        if (thisRunningId && playgroundSDK && playgroundSDK.cancelExecution) try {
+            await playgroundSDK.cancelExecution(thisRunningId.toString());
+            interruptedFlagRef.current[thisRunningId] = true;
+            setLoading(false);
+            if (playgroundSDK.onProgressUpdate) playgroundSDK.onProgressUpdate(()=>{});
+            setInfoList((prev)=>prev.map((item)=>item.id === `system-${thisRunningId}` && item.loading ? {
+                        ...item,
+                        content: 'Operation stopped',
+                        loading: false,
+                        loadingProgressText: ''
+                    } : item));
+            const separatorItem = {
+                id: `separator-${thisRunningId}`,
+                type: 'separator',
+                content: 'New Session',
+                timestamp: new Date()
+            };
+            setInfoList((prev)=>[
+                    ...prev,
+                    separatorItem
+                ]);
+        } catch (error) {
+            console.error('Failed to stop execution:', error);
+        }
+    }, [
+        playgroundSDK,
+        currentRunningIdRef,
+        interruptedFlagRef,
+        setLoading,
+        setInfoList
+    ]);
+    const canStop = loading && !!currentRunningIdRef.current && !!playgroundSDK && !!playgroundSDK.cancelExecution;
+    return {
+        handleRun,
+        handleStop,
+        canStop
+    };
+}
+exports.usePlaygroundExecution = __webpack_exports__.usePlaygroundExecution;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "usePlaygroundExecution"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/hooks/usePlaygroundState.js

@@ -0,0 +1,237 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    usePlaygroundState: ()=>usePlaygroundState
+});
+const external_react_namespaceObject = require("react");
+const storage_provider_js_namespaceObject = require("../component/universal-playground/providers/storage-provider.js");
+const constants_js_namespaceObject = require("../utils/constants.js");
+function usePlaygroundState(playgroundSDK, storage, contextProvider) {
+    const [loading, setLoading] = (0, external_react_namespaceObject.useState)(false);
+    const [infoList, setInfoList] = (0, external_react_namespaceObject.useState)([]);
+    const [actionSpace, setActionSpace] = (0, external_react_namespaceObject.useState)([]);
+    const [actionSpaceLoading, setActionSpaceLoading] = (0, external_react_namespaceObject.useState)(true);
+    const [uiContextPreview, setUiContextPreview] = (0, external_react_namespaceObject.useState)();
+    const [showScrollToBottomButton, setShowScrollToBottomButton] = (0, external_react_namespaceObject.useState)(false);
+    const [verticalMode, setVerticalMode] = (0, external_react_namespaceObject.useState)(false);
+    const [replayCounter, setReplayCounter] = (0, external_react_namespaceObject.useState)(0);
+    const infoListRef = (0, external_react_namespaceObject.useRef)(null);
+    const currentRunningIdRef = (0, external_react_namespaceObject.useRef)(null);
+    const interruptedFlagRef = (0, external_react_namespaceObject.useRef)({});
+    const initializedRef = (0, external_react_namespaceObject.useRef)(false);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const migrateFromOldNamespace = async ()=>{
+            const oldStorage = (0, storage_provider_js_namespaceObject.createStorageProvider)((0, storage_provider_js_namespaceObject.detectBestStorageType)(), 'playground-default');
+            try {
+                if (null == oldStorage ? void 0 : oldStorage.loadMessages) {
+                    const oldMessages = await oldStorage.loadMessages();
+                    if (oldMessages.length > 1) {
+                        console.log('Found data in old namespace, migrating...');
+                        if (null == storage ? void 0 : storage.saveMessages) await storage.saveMessages(oldMessages);
+                        if (oldStorage.clearMessages) await oldStorage.clearMessages();
+                        return oldMessages;
+                    }
+                }
+            } catch (error) {
+                console.debug('No data found in old namespace:', error);
+            }
+            return [];
+        };
+        const initializeMessages = async ()=>{
+            const welcomeMessage = {
+                ...constants_js_namespaceObject.WELCOME_MESSAGE_TEMPLATE,
+                id: 'welcome',
+                timestamp: new Date()
+            };
+            if (null == storage ? void 0 : storage.loadMessages) try {
+                let storedMessages = await storage.loadMessages();
+                if (0 === storedMessages.length) storedMessages = await migrateFromOldNamespace();
+                const hasWelcomeMessage = storedMessages.some((msg)=>'welcome' === msg.id);
+                hasWelcomeMessage ? setInfoList(storedMessages) : setInfoList([
+                    welcomeMessage,
+                    ...storedMessages
+                ]);
+            } catch (error) {
+                console.error('Failed to load messages:', error);
+                setInfoList([
+                    welcomeMessage
+                ]);
+            }
+            else setInfoList([
+                welcomeMessage
+            ]);
+        };
+        if (storage && !initializedRef.current) {
+            initializedRef.current = true;
+            initializeMessages();
+        } else if (!storage && 0 === infoList.length) initializeMessages();
+    }, [
+        storage
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if ((null == storage ? void 0 : storage.saveMessages) && infoList.length > 1) storage.saveMessages(infoList).catch((error)=>{
+            if (error instanceof DOMException && 'QuotaExceededError' === error.name) console.warn('Storage quota exceeded - some messages may not be saved persistently');
+            else console.error('Failed to save messages:', error);
+        });
+    }, [
+        infoList,
+        storage
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!(null == contextProvider ? void 0 : contextProvider.getUIContext) || uiContextPreview) return;
+        contextProvider.getUIContext().then((context)=>setUiContextPreview(context)).catch((error)=>{
+            console.error('Failed to get UI context:', error);
+        });
+    }, [
+        contextProvider,
+        uiContextPreview
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const loadActionSpace = async ()=>{
+            setActionSpaceLoading(true);
+            try {
+                var _contextProvider_getUIContext;
+                if (!playgroundSDK) return void setActionSpace([]);
+                const context = uiContextPreview || await (null == contextProvider ? void 0 : null == (_contextProvider_getUIContext = contextProvider.getUIContext) ? void 0 : _contextProvider_getUIContext.call(contextProvider));
+                const space = await playgroundSDK.getActionSpace(context);
+                setActionSpace(space || []);
+            } catch (error) {
+                console.error('Failed to load action space:', error);
+                setActionSpace([]);
+            } finally{
+                setActionSpaceLoading(false);
+            }
+        };
+        loadActionSpace();
+    }, [
+        playgroundSDK,
+        uiContextPreview,
+        contextProvider
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const sizeThreshold = 750;
+        setVerticalMode(window.innerWidth < sizeThreshold);
+        const handleResize = ()=>{
+            setVerticalMode(window.innerWidth < sizeThreshold);
+        };
+        window.addEventListener('resize', handleResize);
+        return ()=>window.removeEventListener('resize', handleResize);
+    }, []);
+    const scrollToBottom = (0, external_react_namespaceObject.useCallback)(()=>{
+        setTimeout(()=>{
+            if (infoListRef.current) infoListRef.current.scrollTop = infoListRef.current.scrollHeight;
+        }, 100);
+    }, []);
+    const checkIfScrolledToBottom = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (infoListRef.current) {
+            const { scrollTop, scrollHeight, clientHeight } = infoListRef.current;
+            const isAtBottom = scrollTop + clientHeight >= scrollHeight - 10;
+            setShowScrollToBottomButton(!isAtBottom);
+        }
+    }, []);
+    const handleScrollToBottom = (0, external_react_namespaceObject.useCallback)(()=>{
+        if (infoListRef.current) {
+            infoListRef.current.scrollTo({
+                top: infoListRef.current.scrollHeight,
+                behavior: 'smooth'
+            });
+            setShowScrollToBottomButton(false);
+        }
+    }, []);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (infoList.length > 0) scrollToBottom();
+    }, [
+        infoList,
+        scrollToBottom
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        const container = infoListRef.current;
+        if (container) {
+            container.addEventListener('scroll', checkIfScrolledToBottom);
+            checkIfScrolledToBottom();
+            return ()=>{
+                container.removeEventListener('scroll', checkIfScrolledToBottom);
+            };
+        }
+    }, [
+        checkIfScrolledToBottom
+    ]);
+    const clearInfoList = (0, external_react_namespaceObject.useCallback)(async ()=>{
+        const welcomeMessage = {
+            ...constants_js_namespaceObject.WELCOME_MESSAGE_TEMPLATE,
+            id: 'welcome',
+            timestamp: new Date()
+        };
+        setInfoList([
+            welcomeMessage
+        ]);
+        if (null == storage ? void 0 : storage.clearMessages) try {
+            await storage.clearMessages();
+        } catch (error) {
+            console.error('Failed to clear stored messages:', error);
+        }
+    }, [
+        storage
+    ]);
+    const refreshContext = (0, external_react_namespaceObject.useCallback)(async ()=>{
+        if (null == contextProvider ? void 0 : contextProvider.refreshContext) try {
+            const newContext = await contextProvider.refreshContext();
+            setUiContextPreview(newContext);
+        } catch (error) {
+            console.error('Failed to refresh context:', error);
+        }
+    }, [
+        contextProvider
+    ]);
+    return {
+        loading,
+        setLoading,
+        infoList,
+        setInfoList,
+        actionSpace,
+        actionSpaceLoading,
+        uiContextPreview,
+        setUiContextPreview,
+        showScrollToBottomButton,
+        verticalMode,
+        replayCounter,
+        setReplayCounter,
+        infoListRef,
+        currentRunningIdRef,
+        interruptedFlagRef,
+        clearInfoList,
+        refreshContext,
+        handleScrollToBottom,
+        scrollToBottom
+    };
+}
+exports.usePlaygroundState = __webpack_exports__.usePlaygroundState;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "usePlaygroundState"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/hooks/useSafeOverrideAIConfig.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    safeOverrideAIConfig: ()=>safeOverrideAIConfig,
+    useSafeOverrideAIConfig: ()=>useSafeOverrideAIConfig
+});
+const env_namespaceObject = require("@sqaitech/shared/env");
+const external_antd_namespaceObject = require("antd");
+function safeOverrideAIConfig(newConfig) {
+    let extendMode = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : false, showErrorMessage = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : true;
+    try {
+        (0, env_namespaceObject.overrideAIConfig)(newConfig, extendMode);
+        return true;
+    } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        console.error('Failed to override AI config:', err);
+        if (showErrorMessage) external_antd_namespaceObject.message.error(`Failed to apply AI configuration: ${err.message}`);
+        return false;
+    }
+}
+function useSafeOverrideAIConfig() {
+    const applyConfig = function(newConfig) {
+        let extendMode = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : false, showErrorMessage = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : true;
+        return safeOverrideAIConfig(newConfig, extendMode, showErrorMessage);
+    };
+    return {
+        applyConfig
+    };
+}
+exports.safeOverrideAIConfig = __webpack_exports__.safeOverrideAIConfig;
+exports.useSafeOverrideAIConfig = __webpack_exports__.useSafeOverrideAIConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "safeOverrideAIConfig",
+    "useSafeOverrideAIConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/hooks/useServerValid.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useServerValid: ()=>useServerValid
+});
+const playground_namespaceObject = require("@sqaitech/playground");
+const external_react_namespaceObject = require("react");
+const store_js_namespaceObject = require("../store/store.js");
+const useServerValid = function() {
+    let shouldRun = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : true;
+    const [serverValid, setServerValid] = (0, external_react_namespaceObject.useState)(true);
+    const { serviceMode } = (0, store_js_namespaceObject.useEnvConfig)();
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        let interruptFlag = false;
+        if (!shouldRun) return;
+        Promise.resolve((async ()=>{
+            while(!interruptFlag){
+                const playgroundSDK = new playground_namespaceObject.PlaygroundSDK({
+                    type: 'remote-execution'
+                });
+                const status = await playgroundSDK.checkStatus();
+                status ? setServerValid(true) : setServerValid(false);
+                await new Promise((resolve)=>setTimeout(resolve, 1000));
+            }
+        })());
+        return ()=>{
+            interruptFlag = true;
+        };
+    }, [
+        serviceMode,
+        shouldRun
+    ]);
+    return serverValid;
+};
+exports.useServerValid = __webpack_exports__.useServerValid;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useServerValid"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/icons/avatar.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>avatar
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+require("react");
+const SvgAvatar = (props)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 20,
+        height: 20,
+        fill: "none",
+        "aria-label": "Playground",
+        viewBox: "0 0 20 20",
+        ...props,
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("rect", {
+                width: 20,
+                height: 20,
+                fill: "#2B83FF",
+                rx: 10
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("path", {
+                fill: "#2B83FF",
+                stroke: "#fff",
+                strokeLinejoin: "round",
+                strokeWidth: 1.125,
+                d: "M6.866 5.882a.56.56 0 0 1 .667-.078l3.248 1.875 3.247 1.875a.563.563 0 0 1 0 .974l-3.247 1.875-3.248 1.875a.563.563 0 0 1-.784-.74l1.749-3.497-1.75-3.498a.56.56 0 0 1 .118-.661Z"
+            })
+        ]
+    });
+const avatar = SvgAvatar;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});