@sqaitech/visualizer 0.30.10

package/dist/lib/store/history.js

@@ -0,0 +1,96 @@
+"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__, {
+    useHistoryStore: ()=>useHistoryStore
+});
+const external_zustand_namespaceObject = require("zustand");
+const { create } = external_zustand_namespaceObject;
+const HISTORY_KEY = 'midscene-prompt-history-v2';
+const LAST_SELECTED_TYPE_KEY = 'midscene-last-selected-type';
+const getHistoryFromLocalStorage = ()=>{
+    const historyString = localStorage.getItem(HISTORY_KEY);
+    return historyString ? JSON.parse(historyString) : {};
+};
+const getLastSelectedType = ()=>localStorage.getItem(LAST_SELECTED_TYPE_KEY) || 'aiAction';
+const setLastSelectedType = (type)=>{
+    localStorage.setItem(LAST_SELECTED_TYPE_KEY, type);
+};
+const useHistoryStore = create((set, get)=>({
+        history: getHistoryFromLocalStorage(),
+        lastSelectedType: getLastSelectedType(),
+        clearHistory: (type)=>{
+            const newHistory = {
+                ...get().history
+            };
+            delete newHistory[type];
+            set({
+                history: newHistory
+            });
+            localStorage.setItem(HISTORY_KEY, JSON.stringify(newHistory));
+        },
+        addHistory: (historyItem)=>{
+            const { type } = historyItem;
+            const currentHistory = get().history;
+            const typeHistory = currentHistory[type] || [];
+            const stringifiedNewItem = JSON.stringify({
+                prompt: historyItem.prompt,
+                params: historyItem.params
+            });
+            const newTypeHistory = [
+                historyItem,
+                ...typeHistory.filter((h)=>{
+                    const stringifiedOldItem = JSON.stringify({
+                        prompt: h.prompt,
+                        params: h.params
+                    });
+                    return stringifiedOldItem !== stringifiedNewItem;
+                })
+            ];
+            if (newTypeHistory.length > 10) newTypeHistory.length = 10;
+            const newHistory = {
+                ...currentHistory,
+                [type]: newTypeHistory
+            };
+            set({
+                history: newHistory
+            });
+            localStorage.setItem(HISTORY_KEY, JSON.stringify(newHistory));
+        },
+        getHistoryForType: (type)=>get().history[type] || [],
+        setLastSelectedType: (type)=>{
+            set({
+                lastSelectedType: type
+            });
+            setLastSelectedType(type);
+        }
+    }));
+exports.useHistoryStore = __webpack_exports__.useHistoryStore;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useHistoryStore"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/store/store.js

@@ -0,0 +1,196 @@
+"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__, {
+    useBlackboardPreference: ()=>useBlackboardPreference,
+    useEnvConfig: ()=>useEnvConfig
+});
+const external_zustand_namespaceObject = require("zustand");
+const { create } = external_zustand_namespaceObject;
+const AUTO_ZOOM_KEY = 'midscene-auto-zoom';
+const BACKGROUND_VISIBLE_KEY = 'midscene-background-visible';
+const ELEMENTS_VISIBLE_KEY = 'midscene-elements-visible';
+const parseBooleanParam = (value)=>{
+    if (null === value) return;
+    const normalized = value.trim().toLowerCase();
+    if ([
+        '1',
+        'true',
+        'yes',
+        'on'
+    ].includes(normalized)) return true;
+    if ([
+        '0',
+        'false',
+        'no',
+        'off'
+    ].includes(normalized)) return false;
+};
+const getQueryPreference = (paramName)=>{
+    if ('undefined' == typeof window) return;
+    const searchParams = new URLSearchParams(window.location.search);
+    return parseBooleanParam(searchParams.get(paramName));
+};
+const useBlackboardPreference = create((set)=>{
+    const savedAutoZoom = 'false' !== localStorage.getItem(AUTO_ZOOM_KEY);
+    const savedBackgroundVisible = 'false' !== localStorage.getItem(BACKGROUND_VISIBLE_KEY);
+    const savedElementsVisible = 'false' !== localStorage.getItem(ELEMENTS_VISIBLE_KEY);
+    const autoZoomFromQuery = getQueryPreference('focusOnCursor');
+    const elementsVisibleFromQuery = getQueryPreference('showElementMarkers');
+    return {
+        backgroundVisible: savedBackgroundVisible,
+        elementsVisible: void 0 === elementsVisibleFromQuery ? savedElementsVisible : elementsVisibleFromQuery,
+        autoZoom: void 0 === autoZoomFromQuery ? savedAutoZoom : autoZoomFromQuery,
+        setBackgroundVisible: (visible)=>{
+            set({
+                backgroundVisible: visible
+            });
+            localStorage.setItem(BACKGROUND_VISIBLE_KEY, visible.toString());
+        },
+        setElementsVisible: (visible)=>{
+            set({
+                elementsVisible: visible
+            });
+            localStorage.setItem(ELEMENTS_VISIBLE_KEY, visible.toString());
+        },
+        setAutoZoom: (enabled)=>{
+            set({
+                autoZoom: enabled
+            });
+            localStorage.setItem(AUTO_ZOOM_KEY, enabled.toString());
+        }
+    };
+});
+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 SCREENSHOT_INCLUDED_KEY = 'midscene-screenshot-included';
+const DOM_INCLUDED_KEY = 'midscene-dom-included';
+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 = 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);
+    const savedScreenshotIncluded = 'false' !== localStorage.getItem(SCREENSHOT_INCLUDED_KEY);
+    const savedDomIncluded = localStorage.getItem(DOM_INCLUDED_KEY) || 'false';
+    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());
+        },
+        screenshotIncluded: savedScreenshotIncluded,
+        setScreenshotIncluded: (screenshotIncluded)=>{
+            set({
+                screenshotIncluded
+            });
+            localStorage.setItem(SCREENSHOT_INCLUDED_KEY, screenshotIncluded.toString());
+        },
+        domIncluded: 'visible-only' === savedDomIncluded ? 'visible-only' : 'true' === savedDomIncluded,
+        setDomIncluded: (domIncluded)=>{
+            set({
+                domIncluded
+            });
+            localStorage.setItem(DOM_INCLUDED_KEY, domIncluded.toString());
+        },
+        popupTab: 'playground',
+        setPopupTab: (tab)=>{
+            set({
+                popupTab: tab
+            });
+        }
+    };
+});
+exports.useBlackboardPreference = __webpack_exports__.useBlackboardPreference;
+exports.useEnvConfig = __webpack_exports__.useEnvConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "useBlackboardPreference",
+    "useEnvConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/types.js

@@ -0,0 +1,116 @@
+"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__, {
+    VALIDATION_CONSTANTS: ()=>VALIDATION_CONSTANTS,
+    extractDefaultValue: ()=>extractDefaultValue,
+    isLocateField: ()=>isLocateField,
+    isZodObjectSchema: ()=>isZodObjectSchema,
+    unwrapZodType: ()=>unwrapZodType
+});
+const VALIDATION_CONSTANTS = {
+    ZOD_TYPES: {
+        OPTIONAL: 'ZodOptional',
+        DEFAULT: 'ZodDefault',
+        NULLABLE: 'ZodNullable',
+        OBJECT: 'ZodObject',
+        ENUM: 'ZodEnum',
+        NUMBER: 'ZodNumber',
+        STRING: 'ZodString',
+        BOOLEAN: 'ZodBoolean'
+    },
+    FIELD_FLAGS: {
+        LOCATION: 'midscene_location_field_flag'
+    },
+    DEFAULT_VALUES: {
+        ACTION_TYPE: 'aiAction',
+        TIMEOUT_MS: 15000,
+        CHECK_INTERVAL_MS: 3000
+    }
+};
+const isZodObjectSchema = (schema)=>'object' == typeof schema && null !== schema && ('shape' in schema || 'ZodObject' === schema.type);
+const isLocateField = (field)=>{
+    var _field__def;
+    const fieldWithRuntime = field;
+    if ((null == (_field__def = field._def) ? void 0 : _field__def.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.OBJECT) {
+        var _field__def1;
+        let shape;
+        if (field._def.shape) shape = 'function' == typeof field._def.shape ? field._def.shape() : field._def.shape;
+        if (!shape && fieldWithRuntime.shape) shape = fieldWithRuntime.shape;
+        if (shape && VALIDATION_CONSTANTS.FIELD_FLAGS.LOCATION in shape) return true;
+        const description = (null == (_field__def1 = field._def) ? void 0 : _field__def1.description) || fieldWithRuntime.description || '';
+        if ('string' == typeof description && description.toLowerCase().includes('input field')) return true;
+    }
+    if ('object' == typeof field && null !== field) {
+        var _fieldWithRuntime__def;
+        const description = fieldWithRuntime.description || (null == (_fieldWithRuntime__def = fieldWithRuntime._def) ? void 0 : _fieldWithRuntime__def.description) || '';
+        if ('string' == typeof description) {
+            const desc = description.toLowerCase();
+            if (desc.includes('input field') || desc.includes('element') || desc.includes('locate')) return true;
+        }
+        if ('ZodObject' === fieldWithRuntime.typeName || 'ZodObject' === fieldWithRuntime.type) return 'string' == typeof description && description.toLowerCase().includes('input field');
+    }
+    return false;
+};
+const unwrapZodType = (field)=>{
+    var _actualField__def, _actualField__def1, _actualField__def2;
+    let actualField = field;
+    let isOptional = false;
+    let hasDefault = false;
+    while((null == (_actualField__def = actualField._def) ? void 0 : _actualField__def.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.OPTIONAL || (null == (_actualField__def1 = actualField._def) ? void 0 : _actualField__def1.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.DEFAULT || (null == (_actualField__def2 = actualField._def) ? void 0 : _actualField__def2.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.NULLABLE){
+        var _actualField__def3, _actualField__def4;
+        if ((null == (_actualField__def3 = actualField._def) ? void 0 : _actualField__def3.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.OPTIONAL) isOptional = true;
+        if ((null == (_actualField__def4 = actualField._def) ? void 0 : _actualField__def4.typeName) === VALIDATION_CONSTANTS.ZOD_TYPES.DEFAULT) hasDefault = true;
+        actualField = actualField._def.innerType || actualField;
+    }
+    return {
+        actualField,
+        isOptional,
+        hasDefault
+    };
+};
+const extractDefaultValue = (field)=>{
+    var _currentField__def;
+    let currentField = field;
+    while(null == (_currentField__def = currentField._def) ? void 0 : _currentField__def.innerType){
+        if (currentField._def.typeName === VALIDATION_CONSTANTS.ZOD_TYPES.DEFAULT && currentField._def.defaultValue) return currentField._def.defaultValue();
+        currentField = currentField._def.innerType;
+    }
+};
+exports.VALIDATION_CONSTANTS = __webpack_exports__.VALIDATION_CONSTANTS;
+exports.extractDefaultValue = __webpack_exports__.extractDefaultValue;
+exports.isLocateField = __webpack_exports__.isLocateField;
+exports.isZodObjectSchema = __webpack_exports__.isZodObjectSchema;
+exports.unwrapZodType = __webpack_exports__.unwrapZodType;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "VALIDATION_CONSTANTS",
+    "extractDefaultValue",
+    "isLocateField",
+    "isZodObjectSchema",
+    "unwrapZodType"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/utils/color.js

@@ -0,0 +1,75 @@
+"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__, {
+    colorForName: ()=>colorForName,
+    globalThemeConfig: ()=>globalThemeConfig,
+    highlightColorForType: ()=>highlightColorForType
+});
+const elementColor = [
+    '#01204E'
+];
+const highlightColorForSearchArea = '#028391';
+const highlightColorForElement = '#fd5907';
+function djb2Hash(str) {
+    if (!str) str = 'unnamed';
+    let hash = 5381;
+    for(let i = 0; i < str.length; i++)hash = (hash << 5) + hash + str.charCodeAt(i);
+    return hash >>> 0;
+}
+function colorForName(name) {
+    const hashNumber = djb2Hash(name);
+    return elementColor[hashNumber % elementColor.length];
+}
+function highlightColorForType(type) {
+    if ('searchArea' === type) return highlightColorForSearchArea;
+    return highlightColorForElement;
+}
+function globalThemeConfig() {
+    return {
+        token: {
+            colorPrimary: '#2B83FF'
+        },
+        components: {
+            Layout: {
+                headerHeight: 60,
+                headerPadding: '0 30px',
+                headerBg: '#FFF',
+                bodyBg: '#FFF'
+            }
+        }
+    };
+}
+exports.colorForName = __webpack_exports__.colorForName;
+exports.globalThemeConfig = __webpack_exports__.globalThemeConfig;
+exports.highlightColorForType = __webpack_exports__.highlightColorForType;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "colorForName",
+    "globalThemeConfig",
+    "highlightColorForType"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/utils/constants.js

@@ -0,0 +1,154 @@
+"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__, {
+    BLANK_RESULT: ()=>BLANK_RESULT,
+    WELCOME_MESSAGE_TEMPLATE: ()=>WELCOME_MESSAGE_TEMPLATE,
+    apiMetadata: ()=>apiMetadata,
+    deepThinkTip: ()=>deepThinkTip,
+    defaultMainButtons: ()=>defaultMainButtons,
+    domIncludedTip: ()=>domIncludedTip,
+    screenshotIncludedTip: ()=>screenshotIncludedTip,
+    trackingTip: ()=>trackingTip
+});
+const trackingTip = 'limit popup to current tab';
+const deepThinkTip = 'deep think';
+const screenshotIncludedTip = 'include screenshot in request';
+const domIncludedTip = 'include DOM info in request';
+const apiMetadata = {
+    aiAction: {
+        group: 'interaction',
+        title: 'Auto Planning: plan the steps and execute'
+    },
+    aiTap: {
+        group: 'interaction',
+        title: 'Click an element'
+    },
+    aiDoubleClick: {
+        group: 'interaction',
+        title: 'Double-click an element'
+    },
+    aiHover: {
+        group: 'interaction',
+        title: 'Hover over an element'
+    },
+    aiInput: {
+        group: 'interaction',
+        title: 'Input text into an element'
+    },
+    aiRightClick: {
+        group: 'interaction',
+        title: 'Right-click an element'
+    },
+    aiKeyboardPress: {
+        group: 'interaction',
+        title: 'Press keyboard keys'
+    },
+    aiScroll: {
+        group: 'interaction',
+        title: 'Scroll the page or element'
+    },
+    aiLocate: {
+        group: 'interaction',
+        title: 'Locate an element on the page'
+    },
+    aiQuery: {
+        group: 'extraction',
+        title: 'Extract data directly from the UI'
+    },
+    aiBoolean: {
+        group: 'extraction',
+        title: 'Get true/false answer'
+    },
+    aiNumber: {
+        group: 'extraction',
+        title: 'Extract numeric value'
+    },
+    aiString: {
+        group: 'extraction',
+        title: 'Extract text value'
+    },
+    aiAsk: {
+        group: 'extraction',
+        title: 'Ask a question about the UI'
+    },
+    aiAssert: {
+        group: 'validation',
+        title: 'Assert a condition is true'
+    },
+    aiWaitFor: {
+        group: 'validation',
+        title: 'Wait for a condition to be met'
+    }
+};
+const defaultMainButtons = [
+    'aiAction',
+    'aiTap',
+    'aiQuery',
+    'aiAssert'
+];
+const WELCOME_MESSAGE_TEMPLATE = {
+    type: 'system',
+    content: `
+      Welcome to Midscene.js Playground!
+      
+      This is a panel for experimenting and testing Midscene.js features. You can use natural language instructions to operate the web page, such as clicking buttons, filling in forms, querying information, etc.
+      
+      Please enter your instructions in the input box below to start experiencing.
+    `,
+    loading: false,
+    result: void 0,
+    replayScriptsInfo: null,
+    replayCounter: 0,
+    loadingProgressText: '',
+    verticalMode: false
+};
+const BLANK_RESULT = {
+    result: void 0,
+    dump: null,
+    reportHTML: null,
+    error: null
+};
+exports.BLANK_RESULT = __webpack_exports__.BLANK_RESULT;
+exports.WELCOME_MESSAGE_TEMPLATE = __webpack_exports__.WELCOME_MESSAGE_TEMPLATE;
+exports.apiMetadata = __webpack_exports__.apiMetadata;
+exports.deepThinkTip = __webpack_exports__.deepThinkTip;
+exports.defaultMainButtons = __webpack_exports__.defaultMainButtons;
+exports.domIncludedTip = __webpack_exports__.domIncludedTip;
+exports.screenshotIncludedTip = __webpack_exports__.screenshotIncludedTip;
+exports.trackingTip = __webpack_exports__.trackingTip;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "BLANK_RESULT",
+    "WELCOME_MESSAGE_TEMPLATE",
+    "apiMetadata",
+    "deepThinkTip",
+    "defaultMainButtons",
+    "domIncludedTip",
+    "screenshotIncludedTip",
+    "trackingTip"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});