@wdio/image-comparison-core 1.0.0

package/dist/commands/checkTabbablePage.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkTabbablePage from './checkTabbablePage.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+vi.mock('../clientSideScripts/drawTabbableOnCanvas.js', () => ({
+    default: vi.fn()
+}));
+vi.mock('../clientSideScripts/removeElementFromDom.js', () => ({
+    default: vi.fn()
+}));
+vi.mock('./checkFullPageScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        fileName: 'test-tabbable.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+describe('checkTabbablePage', () => {
+    let checkFullPageScreenSpy;
+    const baseOptions = {
+        checkTabbableOptions: {
+            wic: {
+                ...BASE_CHECK_OPTIONS.wic,
+                tabbableOptions: {
+                    circle: {
+                        backgroundColor: 'red',
+                        borderColor: 'blue',
+                        borderWidth: 2,
+                        fontColor: 'white',
+                        fontFamily: 'Arial',
+                        fontSize: 10,
+                        size: 10,
+                        showNumber: true,
+                    },
+                    line: {
+                        color: 'green',
+                        width: 2,
+                    },
+                }
+            },
+            method: {
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                enableLegacyScreenshotMethod: false,
+                fullPageScrollTimeout: 1500,
+                hideAfterFirstScroll: [],
+                hideScrollBars: true,
+                hideElements: [],
+                removeElements: [],
+                waitForFontsLoaded: true,
+            }
+        },
+        browserInstance: {
+            isAndroid: false,
+            execute: vi.fn().mockResolvedValue(undefined)
+        },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: false,
+        tag: 'test-tabbable',
+        testContext: BASE_CHECK_OPTIONS.testContext
+    };
+    beforeEach(async () => {
+        const checkFullPageScreen = (await import('./checkFullPageScreen.js')).default;
+        checkFullPageScreenSpy = vi.mocked(checkFullPageScreen);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should throw error when used in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: true
+        };
+        await expect(checkTabbablePage(options)).rejects.toThrow('The method checkTabbablePage is not supported in native context for native mobile apps!');
+    });
+    it('should execute checkTabbablePage with basic options', async () => {
+        const result = await checkTabbablePage(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(baseOptions.browserInstance.execute).toMatchSnapshot();
+        expect(checkFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: {
+                isAndroid: true,
+                execute: vi.fn().mockResolvedValue(undefined)
+            },
+            instanceData: {
+                ...baseOptions.instanceData,
+                deviceName: 'Pixel 4',
+                isAndroid: true,
+                isIOS: false,
+                platformName: 'Android',
+                platformVersion: '11.0'
+            },
+            testContext: {
+                ...baseOptions.testContext,
+                instanceData: {
+                    ...baseOptions.testContext.instanceData,
+                    deviceName: 'Pixel 4',
+                    platform: { name: 'Android', version: '11.0' },
+                    isAndroid: true,
+                    isIOS: false
+                }
+            }
+        };
+        await checkTabbablePage(options);
+        expect(checkFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle custom tabbable options', async () => {
+        const options = {
+            ...baseOptions,
+            checkTabbableOptions: {
+                ...baseOptions.checkTabbableOptions,
+                wic: {
+                    ...baseOptions.checkTabbableOptions.wic,
+                    tabbableOptions: {
+                        circle: {
+                            backgroundColor: 'yellow',
+                            borderColor: 'black',
+                            borderWidth: 3,
+                            fontColor: 'black',
+                            fontFamily: 'Helvetica',
+                            fontSize: 12,
+                            size: 15,
+                            showNumber: false,
+                        },
+                        line: {
+                            color: 'red',
+                            width: 3,
+                        },
+                    }
+                }
+            }
+        };
+        await checkTabbablePage(options);
+        expect(baseOptions.browserInstance.execute).toMatchSnapshot();
+    });
+    it('should handle errors during execution', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: {
+                ...baseOptions.browserInstance,
+                execute: vi.fn().mockRejectedValue(new Error('Execution failed')),
+                sessionStatus: vi.fn(),
+                sessionNew: vi.fn(),
+                sessionEnd: vi.fn(),
+                sessionSubscribe: vi.fn(),
+            }
+        };
+        await expect(checkTabbablePage(options)).rejects.toThrow('Execution failed');
+    });
+    it('should handle hybrid app options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkTabbableOptions: {
+                ...baseOptions.checkTabbableOptions,
+                wic: {
+                    ...baseOptions.checkTabbableOptions.wic,
+                    isHybridApp: true
+                }
+            }
+        };
+        await checkTabbablePage(options);
+        expect(checkFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle default tabbable options', async () => {
+        const options = {
+            ...baseOptions,
+            checkTabbableOptions: {
+                ...baseOptions.checkTabbableOptions,
+                wic: {
+                    ...baseOptions.checkTabbableOptions.wic,
+                    tabbableOptions: {
+                        circle: {
+                            backgroundColor: 'red',
+                            borderColor: 'blue',
+                            borderWidth: 2,
+                            fontColor: 'white',
+                            fontFamily: 'Arial',
+                            fontSize: 10,
+                            size: 10,
+                            showNumber: true,
+                        },
+                        line: {
+                            color: 'green',
+                            width: 2,
+                        },
+                    }
+                }
+            }
+        };
+        await checkTabbablePage(options);
+        expect(baseOptions.browserInstance.execute).toMatchSnapshot();
+    });
+});

package/dist/commands/checkWebElement.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../methods/images.interfaces.js';
+import type { InternalCheckElementMethodOptions } from './check.interfaces.js';
+/**
+ * Compare  an image of the element
+ */
+export default function checkWebElement({ browserInstance, instanceData, folders, element, tag, checkElementOptions, testContext, isNativeContext, }: InternalCheckElementMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkWebElement.d.ts.map

package/dist/commands/checkWebElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkWebElement.d.ts","sourceRoot":"","sources":["../../src/commands/checkWebElement.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAIzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,uBAAuB,CAAA;AAE9E;;GAEG;AACH,wBAA8B,eAAe,CACzC,EACI,eAAe,EACf,YAAY,EACZ,OAAO,EACP,OAAO,EACP,GAAG,EACH,mBAAmB,EACnB,WAAW,EACX,eAAuB,GAC1B,EAAE,iCAAiC,GACrC,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAyDtC"}

package/dist/commands/checkWebElement.js

@@ -0,0 +1,52 @@
+import { executeImageCompare } from '../methods/images.js';
+import saveWebElement from './saveWebElement.js';
+import { methodCompareOptions } from '../helpers/options.js';
+import { extractCommonCheckVariables, buildBaseExecuteCompareOptions } from '../helpers/utils.js';
+/**
+ * Compare  an image of the element
+ */
+export default async function checkWebElement({ browserInstance, instanceData, folders, element, tag, checkElementOptions, testContext, isNativeContext = false, }) {
+    // 1. Extract common variables
+    const commonCheckVariables = extractCommonCheckVariables({ folders, instanceData, wicOptions: checkElementOptions.wic });
+    const { disableBlinkingCursor, disableCSSAnimation, enableLayoutTesting, enableLegacyScreenshotMethod, hideScrollBars, resizeDimensions, hideElements = [], removeElements = [], waitForFontsLoaded = false, } = checkElementOptions.method;
+    // 2. Take the actual element screenshot and retrieve the needed data
+    const saveElementOptions = {
+        wic: checkElementOptions.wic,
+        method: {
+            disableBlinkingCursor,
+            disableCSSAnimation,
+            enableLayoutTesting,
+            enableLegacyScreenshotMethod,
+            hideScrollBars,
+            resizeDimensions,
+            hideElements,
+            removeElements,
+            waitForFontsLoaded,
+        },
+    };
+    const { devicePixelRatio, fileName } = await saveWebElement({
+        browserInstance,
+        instanceData,
+        folders,
+        element,
+        tag,
+        saveElementOptions,
+    });
+    // 3. Determine the options
+    const compareOptions = methodCompareOptions(checkElementOptions.method);
+    const executeCompareOptions = buildBaseExecuteCompareOptions({
+        commonCheckVariables,
+        wicCompareOptions: checkElementOptions.wic.compareOptions,
+        methodCompareOptions: compareOptions,
+        devicePixelRatio,
+        fileName,
+        isElementScreenshot: true,
+    });
+    // 4. Now execute the compare and return the data
+    return executeImageCompare({
+        isViewPortScreenshot: true,
+        isNativeContext,
+        options: executeCompareOptions,
+        testContext,
+    });
+}

package/dist/commands/checkWebElement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkWebElement.test.d.ts.map

package/dist/commands/checkWebElement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkWebElement.test.d.ts","sourceRoot":"","sources":["../../src/commands/checkWebElement.test.ts"],"names":[],"mappings":""}

package/dist/commands/checkWebElement.test.js

@@ -0,0 +1,278 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkWebElement from './checkWebElement.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+vi.mock('../methods/images.js', () => ({
+    executeImageCompare: vi.fn().mockResolvedValue({
+        fileName: 'test-element.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('./saveWebElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-element.png'
+    })
+}));
+vi.mock('../helpers/options.js', () => ({
+    methodCompareOptions: vi.fn().mockReturnValue({
+        ignoreAlpha: false,
+        ignoreAntialiasing: false,
+        ignoreColors: false,
+        ignoreLess: false,
+        ignoreNothing: false,
+        rawMisMatchPercentage: false,
+        returnAllCompareData: false,
+        saveAboveTolerance: 0,
+        scaleImagesToSameSize: false,
+    })
+}));
+vi.mock('../helpers/utils.js', () => ({
+    extractCommonCheckVariables: vi.fn().mockReturnValue({
+        actualFolder: '/mock/actual',
+        baselineFolder: '/mock/baseline',
+        diffFolder: '/mock/diff',
+        browserName: 'chrome',
+        deviceName: 'Desktop',
+        deviceRectangles: { screenSize: { width: 1280, height: 720 } },
+        isAndroid: false,
+        isMobile: false,
+        isAndroidNativeWebScreenshot: false,
+        platformName: 'Windows',
+        autoSaveBaseline: false,
+        savePerInstance: false,
+    }),
+    buildBaseExecuteCompareOptions: vi.fn().mockImplementation((params) => {
+        const wicOptions = params.isElementScreenshot ? {
+            ...params.wicCompareOptions,
+            blockOutSideBar: false,
+            blockOutStatusBar: false,
+            blockOutToolBar: false,
+        } : params.wicCompareOptions;
+        return {
+            compareOptions: {
+                wic: wicOptions,
+                method: params.methodCompareOptions,
+            },
+            devicePixelRatio: params.devicePixelRatio,
+            deviceRectangles: { screenSize: { width: 1280, height: 720 } },
+            fileName: params.fileName,
+            folderOptions: {
+                autoSaveBaseline: false,
+                actualFolder: '/mock/actual',
+                baselineFolder: '/mock/baseline',
+                diffFolder: '/mock/diff',
+                browserName: 'chrome',
+                deviceName: 'Desktop',
+                isMobile: false,
+                savePerInstance: false,
+            },
+            isAndroid: false,
+            isAndroidNativeWebScreenshot: false,
+            platformName: 'Windows',
+        };
+    }),
+}));
+describe('checkWebElement', () => {
+    let executeImageCompareSpy;
+    let saveWebElementSpy;
+    const baseOptions = {
+        checkElementOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: {
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                enableLegacyScreenshotMethod: false,
+                hideScrollBars: true,
+                resizeDimensions: undefined,
+                hideElements: [],
+                removeElements: [],
+                waitForFontsLoaded: true,
+            }
+        },
+        browserInstance: {
+            isAndroid: false,
+            isMobile: false
+        },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        element: { elementId: 'test-element' },
+        tag: 'test-element',
+        testContext: BASE_CHECK_OPTIONS.testContext
+    };
+    beforeEach(async () => {
+        const { executeImageCompare } = await import('../methods/images.js');
+        const saveWebElement = (await import('./saveWebElement.js')).default;
+        executeImageCompareSpy = vi.mocked(executeImageCompare);
+        saveWebElementSpy = vi.mocked(saveWebElement);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should execute checkWebElement with basic options', async () => {
+        const result = await checkWebElement(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(saveWebElementSpy.mock.calls[0]).toMatchSnapshot();
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: {
+                isAndroid: true,
+                isMobile: true
+            },
+            instanceData: {
+                ...baseOptions.instanceData,
+                deviceName: 'Pixel 4',
+                isAndroid: true,
+                isIOS: false,
+                platformName: 'Android',
+                platformVersion: '11.0',
+                nativeWebScreenshot: true
+            },
+            testContext: {
+                ...baseOptions.testContext,
+                instanceData: {
+                    ...baseOptions.testContext.instanceData,
+                    deviceName: 'Pixel 4',
+                    platform: { name: 'Android', version: '11.0' },
+                    isAndroid: true,
+                    isIOS: false
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle custom element options', async () => {
+        const mockElement = {
+            elementId: 'hide-element',
+            selector: '#hide-element',
+            isDisplayed: vi.fn().mockResolvedValue(true),
+            getSize: vi.fn().mockResolvedValue({ width: 100, height: 100 }),
+            getLocation: vi.fn().mockResolvedValue({ x: 0, y: 0 })
+        };
+        const mockRemoveElement = {
+            elementId: 'remove-element',
+            selector: '#remove-element',
+            isDisplayed: vi.fn().mockResolvedValue(true),
+            getSize: vi.fn().mockResolvedValue({ width: 100, height: 100 }),
+            getLocation: vi.fn().mockResolvedValue({ x: 0, y: 0 })
+        };
+        const options = {
+            ...baseOptions,
+            checkElementOptions: {
+                ...baseOptions.checkElementOptions,
+                method: {
+                    disableBlinkingCursor: true,
+                    disableCSSAnimation: true,
+                    enableLayoutTesting: true,
+                    enableLegacyScreenshotMethod: true,
+                    hideScrollBars: false,
+                    resizeDimensions: {
+                        width: 100,
+                        height: 100,
+                        top: 0,
+                        left: 0,
+                        right: 0,
+                        bottom: 0
+                    },
+                    hideElements: [mockElement],
+                    removeElements: [mockRemoveElement],
+                    waitForFontsLoaded: false,
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(saveWebElementSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle compare options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkElementOptions: {
+                ...baseOptions.checkElementOptions,
+                wic: {
+                    ...baseOptions.checkElementOptions.wic,
+                    compareOptions: {
+                        ignoreAlpha: true,
+                        ignoreAntialiasing: true,
+                        ignoreColors: true,
+                        ignoreLess: true,
+                        ignoreNothing: false,
+                        rawMisMatchPercentage: true,
+                        returnAllCompareData: true,
+                        saveAboveTolerance: 0.1,
+                        scaleImagesToSameSize: true,
+                        blockOutSideBar: false,
+                        blockOutStatusBar: false,
+                        blockOutToolBar: false,
+                        createJsonReportFiles: false,
+                        diffPixelBoundingBoxProximity: 0
+                    }
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle device rectangles correctly', async () => {
+        const options = {
+            ...baseOptions,
+            instanceData: {
+                ...baseOptions.instanceData,
+                deviceRectangles: {
+                    statusBar: { x: 0, y: 0, width: 100, height: 20 },
+                    toolBar: { x: 0, y: 20, width: 100, height: 40 },
+                    sideBar: { x: 0, y: 60, width: 20, height: 100 },
+                    bottomBar: { x: 0, y: 80, width: 100, height: 20 },
+                    homeBar: { x: 0, y: 100, width: 100, height: 20 },
+                    leftSidePadding: { x: 0, y: 0, width: 10, height: 100 },
+                    rightSidePadding: { x: 90, y: 0, width: 10, height: 100 },
+                    topSidePadding: { x: 0, y: 0, width: 100, height: 10 },
+                    bottomSidePadding: { x: 0, y: 90, width: 100, height: 10 },
+                    screenSize: { x: 0, y: 0, width: 100, height: 120 },
+                    statusBarAndAddressBar: { x: 0, y: 0, width: 100, height: 60 },
+                    viewport: { x: 0, y: 60, width: 100, height: 60 }
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle hybrid app options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkElementOptions: {
+                ...baseOptions.checkElementOptions,
+                wic: {
+                    ...baseOptions.checkElementOptions.wic,
+                    isHybridApp: true
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle undefined method options with fallbacks', async () => {
+        const options = {
+            ...baseOptions,
+            checkElementOptions: {
+                ...baseOptions.checkElementOptions,
+                method: {
+                    disableBlinkingCursor: false,
+                    disableCSSAnimation: false,
+                    enableLayoutTesting: false,
+                    enableLegacyScreenshotMethod: false,
+                    hideScrollBars: true,
+                    waitForFontsLoaded: true,
+                }
+            }
+        };
+        await checkWebElement(options);
+        expect(saveWebElementSpy.mock.calls[0]).toMatchSnapshot();
+    });
+});

package/dist/commands/checkWebScreen.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../methods/images.interfaces.js';
+import type { InternalCheckScreenMethodOptions } from './check.interfaces.js';
+/**
+ * Compare an image of the viewport of the screen
+ */
+export default function checkWebScreen({ browserInstance, instanceData, folders, tag, checkScreenOptions, isNativeContext, testContext, }: InternalCheckScreenMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkWebScreen.d.ts.map

package/dist/commands/checkWebScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkWebScreen.d.ts","sourceRoot":"","sources":["../../src/commands/checkWebScreen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAIzE,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAA;AAE7E;;GAEG;AACH,wBAA8B,cAAc,CACxC,EACI,eAAe,EACf,YAAY,EACZ,OAAO,EACP,GAAG,EACH,kBAAkB,EAClB,eAAuB,EACvB,WAAW,GACd,EAAE,gCAAgC,GACpC,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAsDtC"}

package/dist/commands/checkWebScreen.js

@@ -0,0 +1,50 @@
+import saveWebScreen from './saveWebScreen.js';
+import { executeImageCompare } from '../methods/images.js';
+import { screenMethodCompareOptions } from '../helpers/options.js';
+import { extractCommonCheckVariables, buildBaseExecuteCompareOptions } from '../helpers/utils.js';
+/**
+ * Compare an image of the viewport of the screen
+ */
+export default async function checkWebScreen({ browserInstance, instanceData, folders, tag, checkScreenOptions, isNativeContext = false, testContext, }) {
+    // 1. Extract common variables
+    const commonCheckVariables = extractCommonCheckVariables({ folders, instanceData, wicOptions: checkScreenOptions.wic });
+    const { disableBlinkingCursor, disableCSSAnimation, enableLayoutTesting, enableLegacyScreenshotMethod, hideScrollBars, hideElements = [], removeElements = [], waitForFontsLoaded, } = checkScreenOptions.method;
+    // 2. Take the actual screenshot and retrieve the needed data
+    const saveScreenOptions = {
+        wic: checkScreenOptions.wic,
+        method: {
+            disableBlinkingCursor,
+            disableCSSAnimation,
+            enableLayoutTesting,
+            enableLegacyScreenshotMethod,
+            hideScrollBars,
+            hideElements,
+            removeElements,
+            waitForFontsLoaded,
+        },
+    };
+    const { devicePixelRatio, fileName } = await saveWebScreen({
+        browserInstance,
+        instanceData,
+        folders,
+        tag,
+        saveScreenOptions,
+        isNativeContext,
+    });
+    // 3. Determine the compare options
+    const methodCompareOptions = screenMethodCompareOptions(checkScreenOptions.method);
+    const executeCompareOptions = buildBaseExecuteCompareOptions({
+        commonCheckVariables,
+        wicCompareOptions: checkScreenOptions.wic.compareOptions,
+        methodCompareOptions,
+        devicePixelRatio,
+        fileName,
+    });
+    // 4. Now execute the compare and return the data
+    return executeImageCompare({
+        isViewPortScreenshot: true,
+        isNativeContext,
+        options: executeCompareOptions,
+        testContext,
+    });
+}

package/dist/commands/checkWebScreen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkWebScreen.test.d.ts.map

package/dist/commands/checkWebScreen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkWebScreen.test.d.ts","sourceRoot":"","sources":["../../src/commands/checkWebScreen.test.ts"],"names":[],"mappings":""}