@midscene/visualizer 0.26.2 → 0.26.3-beta-20250813021342.0

package/dist/es/component/replay-scripts.mjs

@@ -0,0 +1,271 @@
+'use client';
+import "./player.css";
+import { mousePointer } from "../utils.mjs";
+import { paramStr, typeStr } from "@midscene/web/ui-utils";
+import { treeToList } from "@midscene/shared/extractor";
+const stillDuration = 900;
+const actionSpinningPointerDuration = 300;
+const stillAfterInsightDuration = 300;
+const locateDuration = 800;
+const actionDuration = 1000;
+const clearInsightDuration = 200;
+const cameraStateForRect = (rect, imageWidth, imageHeight)=>{
+    const canvasRatio = imageWidth / imageHeight;
+    const rectRatio = rect.width / rect.height;
+    let rectWidthOnPage;
+    rectWidthOnPage = rectRatio >= canvasRatio ? rect.width : rect.height / imageHeight * imageWidth;
+    const cameraPaddingRatio = rectWidthOnPage > 400 ? 0.1 : rectWidthOnPage > 50 ? 0.2 : 0.3;
+    const cameraWidth = Math.min(imageWidth, rectWidthOnPage + imageWidth * cameraPaddingRatio * 2);
+    const cameraHeight = imageHeight / imageWidth * cameraWidth;
+    let left = Math.min(rect.left - imageWidth * cameraPaddingRatio, imageWidth - cameraWidth);
+    left = Math.max(left, 0);
+    let top = Math.min(rect.top - imageHeight * cameraPaddingRatio, imageHeight - cameraHeight);
+    top = Math.max(top, 0);
+    return {
+        left: Math.round(left),
+        top: Math.round(top),
+        width: Math.round(cameraWidth)
+    };
+};
+const mergeTwoCameraState = (cameraState1, cameraState2)=>{
+    const newLeft = Math.min(cameraState1.left, cameraState2.left);
+    const newTop = Math.min(cameraState1.top, cameraState2.top);
+    const newRight = Math.max(cameraState1.left + cameraState1.width, cameraState2.left + cameraState2.width);
+    const newWidth = newRight - newLeft;
+    return {
+        left: newLeft,
+        top: newTop,
+        width: newWidth
+    };
+};
+const allScriptsFromDump = (dump)=>{
+    let width;
+    let height;
+    let sdkVersion;
+    let modelName;
+    let modelDescription;
+    dump.executions.forEach((execution)=>{
+        if (execution.sdkVersion) sdkVersion = execution.sdkVersion;
+        if (execution.model_name) modelName = execution.model_name;
+        if (execution.model_description) modelDescription = execution.model_description;
+        execution.tasks.forEach((task)=>{
+            var _insightTask_pageContext_size, _insightTask_pageContext;
+            const insightTask = task;
+            if (null == (_insightTask_pageContext = insightTask.pageContext) ? void 0 : null == (_insightTask_pageContext_size = _insightTask_pageContext.size) ? void 0 : _insightTask_pageContext_size.width) {
+                width = insightTask.pageContext.size.width;
+                height = insightTask.pageContext.size.height;
+            }
+        });
+    });
+    if (!width || !height) {
+        console.warn('width or height is missing in dump file');
+        return {
+            scripts: [],
+            sdkVersion,
+            modelName,
+            modelDescription
+        };
+    }
+    const allScripts = [];
+    dump.executions.forEach((execution)=>{
+        const scripts = generateAnimationScripts(execution, -1, width, height);
+        if (scripts) allScripts.push(...scripts);
+    });
+    const allScriptsWithoutIntermediateDoneFrame = allScripts.filter((script, index)=>{
+        if (index !== allScripts.length - 1 && 'Done' === script.title) return false;
+        return true;
+    });
+    return {
+        scripts: allScriptsWithoutIntermediateDoneFrame,
+        width,
+        height,
+        sdkVersion,
+        modelName,
+        modelDescription
+    };
+};
+const generateAnimationScripts = (execution, task, imageWidth, imageHeight)=>{
+    if (!execution || !execution.tasks.length) return null;
+    if (0 === imageWidth || 0 === imageHeight) return null;
+    let tasksIncluded = [];
+    if (-1 === task) tasksIncluded = execution.tasks;
+    else {
+        const startIndex = execution.tasks.findIndex((t)=>t === task);
+        if (-1 === startIndex) {
+            console.error("task not found, cannot generate animation scripts");
+            return null;
+        }
+        if (startIndex === execution.tasks.length - 1) return null;
+        for(let i = startIndex; i < execution.tasks.length; i++){
+            if (i > startIndex && 'Planning' === execution.tasks[i].type) break;
+            tasksIncluded.push(execution.tasks[i]);
+        }
+    }
+    if (0 === tasksIncluded.length) return null;
+    const fullPageCameraState = cameraStateForRect({
+        left: 0,
+        top: 0,
+        width: imageWidth,
+        height: imageHeight
+    }, imageWidth, imageHeight);
+    const pointerScript = (img, title, subTitle)=>({
+            type: 'pointer',
+            img,
+            duration: 0,
+            title,
+            subTitle
+        });
+    const scripts = [];
+    let insightCameraState;
+    let currentCameraState = fullPageCameraState;
+    let insightOnTop = false;
+    const taskCount = tasksIncluded.length;
+    let initSubTitle = '';
+    let errorStateFlag = false;
+    tasksIncluded.forEach((task, index)=>{
+        if (errorStateFlag) return;
+        if (0 === index) initSubTitle = paramStr(task);
+        if ('Planning' === task.type) {
+            const planningTask = task;
+            if (planningTask.recorder && planningTask.recorder.length > 0) {
+                var _planningTask_recorder_, _planningTask_recorder;
+                scripts.push({
+                    type: 'img',
+                    img: null == (_planningTask_recorder = planningTask.recorder) ? void 0 : null == (_planningTask_recorder_ = _planningTask_recorder[0]) ? void 0 : _planningTask_recorder_.screenshot,
+                    camera: 0 === index ? fullPageCameraState : void 0,
+                    duration: stillDuration,
+                    title: typeStr(task),
+                    subTitle: paramStr(task)
+                });
+            }
+        } else if ('Insight' === task.type && 'Locate' === task.subType) {
+            var _insightTask_output;
+            const insightTask = task;
+            const resultElement = null == (_insightTask_output = insightTask.output) ? void 0 : _insightTask_output.element;
+            const title = typeStr(task);
+            const subTitle = paramStr(task);
+            if (null == resultElement ? void 0 : resultElement.rect) insightCameraState = {
+                ...cameraStateForRect(resultElement.rect, imageWidth, imageHeight),
+                pointerLeft: resultElement.center[0],
+                pointerTop: resultElement.center[1]
+            };
+            const context = insightTask.pageContext;
+            if (null == context ? void 0 : context.screenshotBase64) {
+                var _insightTask_log, _insightTask_output1, _insightDump_taskInfo;
+                const insightDump = null == (_insightTask_log = insightTask.log) ? void 0 : _insightTask_log.dump;
+                const insightContentLength = context.tree ? treeToList(context.tree).length : 0;
+                if (context.screenshotBase64) scripts.push({
+                    type: 'img',
+                    img: context.screenshotBase64,
+                    duration: stillAfterInsightDuration,
+                    title,
+                    subTitle
+                });
+                let cameraState;
+                cameraState = currentCameraState === fullPageCameraState ? void 0 : insightCameraState ? mergeTwoCameraState(currentCameraState, insightCameraState) : void 0;
+                scripts.push({
+                    type: 'insight',
+                    img: context.screenshotBase64,
+                    context: context,
+                    camera: cameraState,
+                    highlightElement: (null == (_insightTask_output1 = insightTask.output) ? void 0 : _insightTask_output1.element) || void 0,
+                    searchArea: null == insightDump ? void 0 : null == (_insightDump_taskInfo = insightDump.taskInfo) ? void 0 : _insightDump_taskInfo.searchArea,
+                    duration: insightContentLength > 20 ? locateDuration : 0.5 * locateDuration,
+                    insightCameraDuration: locateDuration,
+                    title,
+                    subTitle
+                });
+                scripts.push({
+                    type: 'sleep',
+                    duration: stillAfterInsightDuration,
+                    title,
+                    subTitle
+                });
+                insightOnTop = true;
+            }
+        } else if ('Action' === task.type && 'FalsyConditionStatement' !== task.subType) {
+            var _task_recorder_, _task_recorder, _task_recorder_1, _task_recorder1;
+            const title = typeStr(task);
+            const subTitle = paramStr(task);
+            scripts.push(pointerScript(mousePointer, title, subTitle));
+            currentCameraState = null != insightCameraState ? insightCameraState : fullPageCameraState;
+            scripts.push({
+                type: 'img',
+                img: null == (_task_recorder = task.recorder) ? void 0 : null == (_task_recorder_ = _task_recorder[0]) ? void 0 : _task_recorder_.screenshot,
+                duration: actionDuration,
+                camera: 'Sleep' === task.subType ? fullPageCameraState : insightCameraState,
+                title,
+                subTitle
+            });
+            if (insightOnTop) {
+                scripts.push({
+                    type: 'clear-insight',
+                    duration: clearInsightDuration,
+                    title,
+                    subTitle
+                });
+                insightOnTop = false;
+            }
+            const imgStillDuration = index < taskCount - 1 ? stillDuration : 0;
+            if (null == (_task_recorder1 = task.recorder) ? void 0 : null == (_task_recorder_1 = _task_recorder1[1]) ? void 0 : _task_recorder_1.screenshot) {
+                var _task_recorder_2, _task_recorder2;
+                scripts.push({
+                    type: 'spinning-pointer',
+                    duration: actionSpinningPointerDuration,
+                    title,
+                    subTitle
+                });
+                scripts.push(pointerScript(mousePointer, title, subTitle));
+                scripts.push({
+                    type: 'img',
+                    img: null == (_task_recorder2 = task.recorder) ? void 0 : null == (_task_recorder_2 = _task_recorder2[1]) ? void 0 : _task_recorder_2.screenshot,
+                    duration: imgStillDuration,
+                    title,
+                    subTitle
+                });
+            } else scripts.push({
+                type: 'sleep',
+                duration: imgStillDuration,
+                title,
+                subTitle
+            });
+        } else {
+            var _task_recorder_3, _task_recorder3;
+            const title = typeStr(task);
+            const subTitle = paramStr(task);
+            const screenshot = null == (_task_recorder3 = task.recorder) ? void 0 : null == (_task_recorder_3 = _task_recorder3[task.recorder.length - 1]) ? void 0 : _task_recorder_3.screenshot;
+            if (screenshot) scripts.push({
+                type: 'img',
+                img: screenshot,
+                duration: stillDuration,
+                camera: fullPageCameraState,
+                title,
+                subTitle
+            });
+        }
+        if ('finished' !== task.status) {
+            errorStateFlag = true;
+            const errorTitle = typeStr(task);
+            const errorMsg = task.errorMessage || 'unknown error';
+            const errorSubTitle = errorMsg.indexOf('NOT_IMPLEMENTED_AS_DESIGNED') > 0 ? 'Further actions cannot be performed in the current environment' : errorMsg;
+            scripts.push({
+                type: 'img',
+                img: task.recorder && task.recorder.length > 0 ? task.recorder[task.recorder.length - 1].screenshot : '',
+                camera: fullPageCameraState,
+                duration: stillDuration,
+                title: errorTitle,
+                subTitle: errorSubTitle
+            });
+            return;
+        }
+    });
+    if (!errorStateFlag) scripts.push({
+        title: 'Done',
+        subTitle: initSubTitle,
+        type: 'img',
+        duration: stillDuration,
+        camera: fullPageCameraState
+    });
+    return scripts;
+};
+export { allScriptsFromDump, cameraStateForRect, generateAnimationScripts, mergeTwoCameraState };

package/dist/es/component/shiny-text.css

@@ -1,64 +1,75 @@
 .shiny-text {
-  position: relative;
-  display: inline-block;
-  background-size: 300% auto;
+  color: rgba(0, 0, 0, 0);
+  letter-spacing: .5px;
+  text-shadow: 0 1px 2px rgba(0, 0, 0, .05);
+  background-image: linear-gradient(45deg, #2b83ff, #6a11cb, #2575fc, #4481eb);
+  background-size: 300%;
   -webkit-background-clip: text;
   background-clip: text;
-  color: transparent;
   font-weight: 600;
-  letter-spacing: 0.5px;
-  text-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+  animation: 8s infinite textGradient;
+  display: inline-block;
+  position: relative;
   overflow: hidden;
-  animation: textGradient 8s ease infinite;
-  background-image: linear-gradient(45deg, #2b83ff, #6a11cb, #2575fc, #4481eb);
 }
-.shiny-text::after {
+
+.shiny-text:after {
   content: "";
-  position: absolute;
-  top: -10%;
-  left: -150%;
   width: 120%;
   height: 120%;
-  background: linear-gradient(90deg, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, 0.1) 10%, rgba(255, 255, 255, 0.6) 50%, rgba(255, 255, 255, 0.1) 90%, rgba(255, 255, 255, 0) 100%);
-  transform: skewX(-20deg) translateY(0);
-  animation: shine var(--animation-duration, 5s) cubic-bezier(0.25, 0.1, 0.25, 1) infinite;
+  animation: shine var(--animation-duration, 5s) cubic-bezier(.25, .1, .25, 1) infinite;
   z-index: 1;
   pointer-events: none;
+  background: linear-gradient(90deg, rgba(255, 255, 255, 0) 0%, rgba(255, 255, 255, .1) 10%, rgba(255, 255, 255, .6) 50%, rgba(255, 255, 255, .1) 90%, rgba(255, 255, 255, 0) 100%);
+  position: absolute;
+  top: -10%;
+  left: -150%;
+  transform: skewX(-20deg)translateY(0);
 }
+
 .shiny-text.disabled {
-  animation: none;
   background: #2b83ff;
   -webkit-background-clip: text;
   background-clip: text;
+  animation: none;
 }
-.shiny-text.disabled::after {
+
+.shiny-text.disabled:after {
   animation: none;
   display: none;
 }
+
 @keyframes shine {
   0% {
+    opacity: .7;
     left: -150%;
-    opacity: 0.7;
   }
+
   20% {
     opacity: 1;
   }
+
   80% {
     opacity: 1;
   }
+
   100% {
+    opacity: .7;
     left: 250%;
-    opacity: 0.7;
   }
 }
+
 @keyframes textGradient {
   0% {
-    background-position: 0% 50%;
+    background-position: 0%;
   }
+
   50% {
-    background-position: 100% 50%;
+    background-position: 100%;
   }
+
   100% {
-    background-position: 0% 50%;
+    background-position: 0%;
   }
 }
+

package/dist/es/component/shiny-text.mjs

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import "./shiny-text.css";
+const ShinyText = (param)=>{
+    let { text, disabled = false, speed = 5, className = '' } = param;
+    const style = {
+        '--animation-duration': `${speed}s`
+    };
+    return /*#__PURE__*/ jsx("div", {
+        className: `shiny-text ${disabled ? 'disabled' : ''} ${className}`,
+        style: style,
+        children: text
+    });
+};
+const shiny_text = ShinyText;
+export { shiny_text as default };

package/dist/es/component/store/history.mjs

@@ -0,0 +1,55 @@
+import { create } from "zustand";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var external_zustand_namespaceObject = {};
+__webpack_require__.r(external_zustand_namespaceObject);
+__webpack_require__.d(external_zustand_namespaceObject, {
+    create: ()=>create
+});
+const { create: history_create } = external_zustand_namespaceObject;
+const HISTORY_KEY = 'midscene-prompt-history';
+const getHistoryFromLocalStorage = ()=>{
+    const historyString = localStorage.getItem(HISTORY_KEY);
+    return historyString ? JSON.parse(historyString) : [];
+};
+const useHistoryStore = history_create((set, get)=>({
+        history: getHistoryFromLocalStorage(),
+        clearHistory: ()=>{
+            set({
+                history: []
+            });
+            localStorage.removeItem(HISTORY_KEY);
+        },
+        addHistory: (historyItem)=>{
+            const newHistory = [
+                historyItem,
+                ...get().history.filter((h)=>h.prompt !== historyItem.prompt)
+            ];
+            while(newHistory.length > 10)newHistory.pop();
+            set({
+                history: newHistory
+            });
+            localStorage.setItem(HISTORY_KEY, JSON.stringify(newHistory));
+        }
+    }));
+export { useHistoryStore };

package/dist/es/component/store/store.mjs

@@ -0,0 +1,128 @@
+import { create } from "zustand";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var external_zustand_namespaceObject = {};
+__webpack_require__.r(external_zustand_namespaceObject);
+__webpack_require__.d(external_zustand_namespaceObject, {
+    create: ()=>create
+});
+const { create: store_create } = external_zustand_namespaceObject;
+const useBlackboardPreference = store_create((set)=>({
+        markerVisible: true,
+        elementsVisible: true,
+        setMarkerVisible: (visible)=>{
+            set({
+                markerVisible: visible
+            });
+        },
+        setTextsVisible: (visible)=>{
+            set({
+                elementsVisible: visible
+            });
+        }
+    }));
+const CONFIG_KEY = 'midscene-env-config';
+const SERVICE_MODE_KEY = 'midscene-service-mode';
+const TRACKING_ACTIVE_TAB_KEY = 'midscene-tracking-active-tab';
+const DEEP_THINK_KEY = 'midscene-deep-think';
+const getConfigStringFromLocalStorage = ()=>{
+    const configString = localStorage.getItem(CONFIG_KEY);
+    return configString || '';
+};
+const parseConfig = (configString)=>{
+    const lines = configString.split('\n');
+    const config = {};
+    lines.forEach((line)=>{
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#')) return;
+        const cleanLine = trimmed.replace(/^export\s+/i, '').replace(/;$/, '').trim();
+        const match = cleanLine.match(/^(\w+)=(.*)$/);
+        if (match) {
+            const [, key, value] = match;
+            let parsedValue = value.trim();
+            if (parsedValue.startsWith("'") && parsedValue.endsWith("'") || parsedValue.startsWith('"') && parsedValue.endsWith('"')) parsedValue = parsedValue.slice(1, -1);
+            config[key] = parsedValue;
+        }
+    });
+    return config;
+};
+const useEnvConfig = store_create((set, get)=>{
+    const configString = getConfigStringFromLocalStorage();
+    const config = parseConfig(configString);
+    const ifInExtension = window.location.href.startsWith('chrome-extension');
+    const savedServiceMode = localStorage.getItem(SERVICE_MODE_KEY);
+    const savedForceSameTabNavigation = 'false' !== localStorage.getItem(TRACKING_ACTIVE_TAB_KEY);
+    const savedDeepThink = 'true' === localStorage.getItem(DEEP_THINK_KEY);
+    return {
+        serviceMode: ifInExtension ? 'In-Browser-Extension' : savedServiceMode || 'Server',
+        setServiceMode: (serviceMode)=>{
+            if (ifInExtension) throw new Error('serviceMode cannot be set in extension');
+            set({
+                serviceMode
+            });
+            localStorage.setItem(SERVICE_MODE_KEY, serviceMode);
+        },
+        config,
+        configString,
+        setConfig: (config)=>set({
+                config
+            }),
+        loadConfig: (configString)=>{
+            const config = parseConfig(configString);
+            set({
+                config,
+                configString
+            });
+            localStorage.setItem(CONFIG_KEY, configString);
+        },
+        syncFromStorage: ()=>{
+            const latestConfigString = getConfigStringFromLocalStorage();
+            const latestConfig = parseConfig(latestConfigString);
+            set({
+                config: latestConfig,
+                configString: latestConfigString
+            });
+        },
+        forceSameTabNavigation: savedForceSameTabNavigation,
+        setForceSameTabNavigation: (forceSameTabNavigation)=>{
+            set({
+                forceSameTabNavigation
+            });
+            localStorage.setItem(TRACKING_ACTIVE_TAB_KEY, forceSameTabNavigation.toString());
+        },
+        deepThink: savedDeepThink,
+        setDeepThink: (deepThink)=>{
+            set({
+                deepThink
+            });
+            localStorage.setItem(DEEP_THINK_KEY, deepThink.toString());
+        },
+        popupTab: 'playground',
+        setPopupTab: (tab)=>{
+            set({
+                popupTab: tab
+            });
+        }
+    };
+});
+export { useBlackboardPreference, useEnvConfig };

package/dist/es/icons/close.mjs

@@ -0,0 +1,19 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+const SvgClose = (props)=>/*#__PURE__*/ jsx("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 18,
+        height: 16,
+        fill: "none",
+        viewBox: "0 0 18 16",
+        ...props,
+        children: /*#__PURE__*/ jsx("path", {
+            stroke: "#333",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 1.333,
+            d: "m3.124 2.667 11.162 10.666M3.124 13.333 14.286 2.667"
+        })
+    });
+const icons_close = SvgClose;
+export { icons_close as default };

package/dist/es/icons/history.mjs

@@ -0,0 +1,30 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+const SvgHistory = (props)=>/*#__PURE__*/ jsxs("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 25,
+        height: 25,
+        fill: "none",
+        viewBox: "0 0 25 25",
+        ...props,
+        children: [
+            /*#__PURE__*/ jsx("path", {
+                stroke: "#000",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeOpacity: 0.85,
+                strokeWidth: 1.33,
+                d: "M6.63 9.021c-2.862 6.126 2.197 10.501 6.063 10.501a7 7 0 1 0-6.063-10.5"
+            }),
+            /*#__PURE__*/ jsx("path", {
+                stroke: "#000",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeOpacity: 0.85,
+                strokeWidth: 1.33,
+                d: "M12.695 8.322v4.203l2.967 2.968"
+            })
+        ]
+    });
+const icons_history = SvgHistory;
+export { icons_history as default };

package/dist/es/icons/magnifying-glass.mjs

@@ -0,0 +1,39 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+const SvgMagnifyingGlass = (props)=>/*#__PURE__*/ jsxs("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 19,
+        height: 19,
+        fill: "none",
+        viewBox: "0 0 19 19",
+        ...props,
+        children: [
+            /*#__PURE__*/ jsxs("g", {
+                stroke: "#000",
+                strokeLinejoin: "round",
+                strokeOpacity: 0.65,
+                strokeWidth: 1.5,
+                clipPath: "url(#magnifying-glass_svg__a)",
+                children: [
+                    /*#__PURE__*/ jsx("path", {
+                        d: "M8.397 14.29a6.375 6.375 0 1 0 0-12.75 6.375 6.375 0 0 0 0 12.75Z"
+                    }),
+                    /*#__PURE__*/ jsx("path", {
+                        strokeLinecap: "round",
+                        d: "M10.519 5.42a3 3 0 0 0-2.122-.88 3 3 0 0 0-2.121.88M12.98 12.499l3.182 3.182"
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx("defs", {
+                children: /*#__PURE__*/ jsx("clipPath", {
+                    id: "magnifying-glass_svg__a",
+                    children: /*#__PURE__*/ jsx("path", {
+                        fill: "#fff",
+                        d: "M.522.04h18v18h-18z"
+                    })
+                })
+            })
+        ]
+    });
+const magnifying_glass = SvgMagnifyingGlass;
+export { magnifying_glass as default };

package/dist/es/icons/setting.mjs

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+const SvgSetting = (props)=>/*#__PURE__*/ jsx("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 27,
+        height: 27,
+        fill: "none",
+        viewBox: "0 0 27 27",
+        ...props,
+        children: /*#__PURE__*/ jsx("path", {
+            stroke: "#000",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeOpacity: 0.85,
+            strokeWidth: 1.333,
+            d: "M19.527 8.855h-2M14.86 7.522v2.667M14.86 8.855H7.527M10.194 13.522H7.527M12.86 12.189v2.666M20.193 13.522H12.86M19.527 18.189h-2M14.86 16.855v2.667M14.86 18.189H7.527"
+        })
+    });
+const setting = SvgSetting;
+export { setting as default };