@wdio/image-comparison-core 1.0.0

package/dist/commands/checkElement.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkElement from './checkElement.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+vi.mock('./checkAppElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        fileName: 'test-app-element.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('./checkWebElement.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        fileName: 'test-web-element.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+describe('checkElement', () => {
+    let checkAppElementSpy;
+    let checkWebElementSpy;
+    const baseOptions = {
+        checkElementOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: {}
+        },
+        browserInstance: { isAndroid: false },
+        element: { selector: '#test-element' },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: true,
+        tag: 'test-element',
+        testContext: {
+            ...BASE_CHECK_OPTIONS.testContext,
+            commandName: 'checkElement'
+        }
+    };
+    beforeEach(async () => {
+        const checkAppElement = (await import('./checkAppElement.js')).default;
+        const checkWebElement = (await import('./checkWebElement.js')).default;
+        checkAppElementSpy = vi.mocked(checkAppElement);
+        checkWebElementSpy = vi.mocked(checkWebElement);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should call checkAppElement when isNativeContext is true', async () => {
+        const result = await checkElement(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(checkAppElementSpy.mock.calls[0]).toMatchSnapshot();
+        expect(checkWebElementSpy).not.toHaveBeenCalled();
+    });
+    it('should call checkWebElement', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: false
+        };
+        const result = await checkElement(options);
+        expect(result).toMatchSnapshot();
+        expect(checkWebElementSpy.mock.calls[0]).toMatchSnapshot();
+        expect(checkAppElementSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/checkFullPageScreen.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../methods/images.interfaces.js';
+import type { InternalCheckFullPageMethodOptions } from './check.interfaces.js';
+/**
+ * Compare a fullpage screenshot
+ */
+export default function checkFullPageScreen({ browserInstance, checkFullPageOptions, folders, instanceData, isNativeContext, tag, testContext, }: InternalCheckFullPageMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkFullPageScreen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkFullPageScreen.d.ts","sourceRoot":"","sources":["../../src/commands/checkFullPageScreen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAIzE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,uBAAuB,CAAA;AAE/E;;GAEG;AACH,wBAA8B,mBAAmB,CAC7C,EACI,eAAe,EACf,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,eAAuB,EACvB,GAAG,EACH,WAAW,GACd,EAAE,kCAAkC,GACtC,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CA+DtC"}

package/dist/commands/checkFullPageScreen.js

@@ -0,0 +1,56 @@
+import { executeImageCompare } from '../methods/images.js';
+import saveFullPageScreen from './saveFullPageScreen.js';
+import { methodCompareOptions } from '../helpers/options.js';
+import { extractCommonCheckVariables, buildBaseExecuteCompareOptions } from '../helpers/utils.js';
+/**
+ * Compare a fullpage screenshot
+ */
+export default async function checkFullPageScreen({ browserInstance, checkFullPageOptions, folders, instanceData, isNativeContext = false, tag, testContext, }) {
+    // 1. Extract common variables
+    const commonCheckVariables = extractCommonCheckVariables({ folders, instanceData, wicOptions: checkFullPageOptions.wic });
+    const { disableBlinkingCursor, disableCSSAnimation, enableLayoutTesting, enableLegacyScreenshotMethod, fullPageScrollTimeout, hideAfterFirstScroll = [], hideScrollBars, hideElements = [], removeElements = [], waitForFontsLoaded, } = checkFullPageOptions.method;
+    // 2. Check if the method is supported in native context
+    if (isNativeContext) {
+        throw new Error('The method checkFullPageScreen is not supported in native context for native mobile apps!');
+    }
+    // 3. Take the actual full page screenshot and retrieve the needed data
+    const saveFullPageOptions = {
+        wic: checkFullPageOptions.wic,
+        method: {
+            disableBlinkingCursor,
+            disableCSSAnimation,
+            enableLayoutTesting,
+            enableLegacyScreenshotMethod,
+            fullPageScrollTimeout,
+            hideAfterFirstScroll,
+            hideScrollBars,
+            hideElements,
+            removeElements,
+            waitForFontsLoaded,
+        },
+    };
+    const { devicePixelRatio, fileName } = await saveFullPageScreen({
+        browserInstance,
+        folders,
+        instanceData,
+        isNativeContext,
+        saveFullPageOptions,
+        tag,
+    });
+    // 4. Determine the options
+    const compareOptions = methodCompareOptions(checkFullPageOptions.method);
+    const executeCompareOptions = buildBaseExecuteCompareOptions({
+        commonCheckVariables,
+        wicCompareOptions: checkFullPageOptions.wic.compareOptions,
+        methodCompareOptions: compareOptions,
+        devicePixelRatio,
+        fileName,
+    });
+    // 5. Now execute the compare and return the data
+    return executeImageCompare({
+        isViewPortScreenshot: false,
+        isNativeContext,
+        options: executeCompareOptions,
+        testContext,
+    });
+}

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

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

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

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

package/dist/commands/checkFullPageScreen.test.js

@@ -0,0 +1,259 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkFullPageScreen from './checkFullPageScreen.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+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',
+        isIOS: false,
+        autoSaveBaseline: false,
+        savePerInstance: false,
+        isHybridApp: false,
+    }),
+    buildBaseExecuteCompareOptions: vi.fn().mockImplementation((params) => ({
+        compareOptions: {
+            wic: params.wicCompareOptions,
+            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,
+        isIOS: false,
+        isHybridApp: false,
+        platformName: 'Windows',
+    })),
+}));
+vi.mock('../methods/images.js', () => ({
+    executeImageCompare: vi.fn().mockResolvedValue({
+        fileName: 'test-result.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('./saveFullPageScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        devicePixelRatio: 2,
+        fileName: 'test-fullpage.png'
+    })
+}));
+describe('checkFullPageScreen', () => {
+    let executeImageCompareSpy;
+    let saveFullPageScreenSpy;
+    const baseOptions = {
+        checkFullPageOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: {
+                disableBlinkingCursor: false,
+                disableCSSAnimation: false,
+                enableLayoutTesting: false,
+                enableLegacyScreenshotMethod: false,
+                fullPageScrollTimeout: 1500,
+                hideAfterFirstScroll: [],
+                hideScrollBars: true,
+                hideElements: [],
+                removeElements: [],
+                waitForFontsLoaded: true,
+            }
+        },
+        browserInstance: { isAndroid: false },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: false,
+        tag: 'test-fullpage',
+        testContext: BASE_CHECK_OPTIONS.testContext
+    };
+    beforeEach(async () => {
+        const { executeImageCompare } = await import('../methods/images.js');
+        const saveFullPageScreen = (await import('./saveFullPageScreen.js')).default;
+        executeImageCompareSpy = vi.mocked(executeImageCompare);
+        saveFullPageScreenSpy = vi.mocked(saveFullPageScreen);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should throw error when used in native context', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: true
+        };
+        await expect(checkFullPageScreen(options)).rejects.toThrow('The method checkFullPageScreen is not supported in native context for native mobile apps!');
+    });
+    it('should execute checkFullPageScreen with basic options', async () => {
+        const result = await checkFullPageScreen(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(saveFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle Android device correctly', async () => {
+        const options = {
+            ...baseOptions,
+            browserInstance: { isAndroid: true },
+            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 checkFullPageScreen(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should merge compare options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                wic: {
+                    ...baseOptions.checkFullPageOptions.wic,
+                    compareOptions: {
+                        ...baseOptions.checkFullPageOptions.wic.compareOptions,
+                        ignoreAlpha: true,
+                        ignoreAntialiasing: true,
+                        ignoreColors: true,
+                    }
+                },
+                method: {
+                    ...baseOptions.checkFullPageOptions.method,
+                    disableBlinkingCursor: true,
+                    disableCSSAnimation: true,
+                    enableLayoutTesting: true,
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle hideElements and removeElements correctly', async () => {
+        const mockElement1 = { elementId: 'hide-element', selector: '#hide' };
+        const mockElement2 = { elementId: 'remove-element', selector: '#remove' };
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                method: {
+                    ...baseOptions.checkFullPageOptions.method,
+                    hideElements: [mockElement1],
+                    removeElements: [mockElement2],
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(saveFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle hideAfterFirstScroll correctly', async () => {
+        const mockElement = { elementId: 'hide-element', selector: '#hide' };
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                method: {
+                    ...baseOptions.checkFullPageOptions.method,
+                    hideAfterFirstScroll: [mockElement],
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(saveFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle all full page specific options', async () => {
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                method: {
+                    disableBlinkingCursor: true,
+                    disableCSSAnimation: true,
+                    enableLayoutTesting: true,
+                    enableLegacyScreenshotMethod: true,
+                    fullPageScrollTimeout: 2000,
+                    hideAfterFirstScroll: [],
+                    hideScrollBars: false,
+                    hideElements: [],
+                    removeElements: [],
+                    waitForFontsLoaded: false,
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(saveFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle hybrid app options correctly', async () => {
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                wic: {
+                    ...baseOptions.checkFullPageOptions.wic,
+                    isHybridApp: true
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(executeImageCompareSpy.mock.calls[0]).toMatchSnapshot();
+    });
+    it('should handle undefined method options with fallbacks', async () => {
+        const options = {
+            ...baseOptions,
+            checkFullPageOptions: {
+                ...baseOptions.checkFullPageOptions,
+                method: {
+                    disableBlinkingCursor: false,
+                    disableCSSAnimation: false,
+                    enableLayoutTesting: false,
+                    enableLegacyScreenshotMethod: false,
+                    fullPageScrollTimeout: 1500,
+                    hideScrollBars: true,
+                    waitForFontsLoaded: true,
+                }
+            }
+        };
+        await checkFullPageScreen(options);
+        expect(saveFullPageScreenSpy.mock.calls[0]).toMatchSnapshot();
+    });
+});

package/dist/commands/checkScreen.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 checkScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext, tag, testContext, }: InternalCheckScreenMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkScreen.d.ts.map

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

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

package/dist/commands/checkScreen.js

@@ -0,0 +1,10 @@
+import checkAppScreen from './checkAppScreen.js';
+import checkWebScreen from './checkWebScreen.js';
+/**
+ * Compare an image of the viewport of the screen
+ */
+export default async function checkScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext, tag, testContext, }) {
+    return isNativeContext
+        ? checkAppScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext, tag, testContext })
+        : checkWebScreen({ browserInstance, checkScreenOptions, folders, instanceData, isNativeContext, tag, testContext });
+}

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

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

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

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

package/dist/commands/checkScreen.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import checkScreen from './checkScreen.js';
+import { BASE_CHECK_OPTIONS } from '../mocks/mocks.js';
+vi.mock('./checkAppScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        fileName: 'test-app-screen.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+vi.mock('./checkWebScreen.js', () => ({
+    default: vi.fn().mockResolvedValue({
+        fileName: 'test-web-screen.png',
+        misMatchPercentage: 0,
+        isExactSameImage: true,
+        isNewBaseline: false,
+        isAboveTolerance: false,
+    })
+}));
+describe('checkScreen', () => {
+    let checkAppScreenSpy;
+    let checkWebScreenSpy;
+    const baseOptions = {
+        checkScreenOptions: {
+            wic: BASE_CHECK_OPTIONS.wic,
+            method: {}
+        },
+        browserInstance: { isAndroid: false },
+        folders: BASE_CHECK_OPTIONS.folders,
+        instanceData: BASE_CHECK_OPTIONS.instanceData,
+        isNativeContext: true,
+        tag: 'test-screen',
+        testContext: BASE_CHECK_OPTIONS.testContext
+    };
+    beforeEach(async () => {
+        const checkAppScreen = (await import('./checkAppScreen.js')).default;
+        const checkWebScreen = (await import('./checkWebScreen.js')).default;
+        checkAppScreenSpy = vi.mocked(checkAppScreen);
+        checkWebScreenSpy = vi.mocked(checkWebScreen);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should call checkAppScreen when isNativeContext is true', async () => {
+        const result = await checkScreen(baseOptions);
+        expect(result).toMatchSnapshot();
+        expect(checkAppScreenSpy.mock.calls[0]).toMatchSnapshot();
+        expect(checkWebScreenSpy).not.toHaveBeenCalled();
+    });
+    it('should call checkWebScreen when isNativeContext is false', async () => {
+        const options = {
+            ...baseOptions,
+            isNativeContext: false
+        };
+        const result = await checkScreen(options);
+        expect(result).toMatchSnapshot();
+        expect(checkWebScreenSpy.mock.calls[0]).toMatchSnapshot();
+        expect(checkAppScreenSpy).not.toHaveBeenCalled();
+    });
+});

package/dist/commands/checkTabbablePage.d.ts

@@ -0,0 +1,7 @@
+import type { ImageCompareResult } from '../index.js';
+import type { InternalCheckTabbablePageMethodOptions } from './check.interfaces.js';
+/**
+ * Compare an image with all tab executions
+ */
+export default function checkTabbablePage({ browserInstance, checkTabbableOptions, folders, instanceData, isNativeContext, tag, testContext, }: InternalCheckTabbablePageMethodOptions): Promise<ImageCompareResult | number>;
+//# sourceMappingURL=checkTabbablePage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkTabbablePage.d.ts","sourceRoot":"","sources":["../../src/commands/checkTabbablePage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,uBAAuB,CAAA;AAEnF;;GAEG;AACH,wBAA8B,iBAAiB,CAC3C,EACI,eAAe,EACf,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,eAAuB,EACvB,GAAG,EACH,WAAW,GACd,EAAE,sCAAsC,GAC1C,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,CAyBtC"}

package/dist/commands/checkTabbablePage.js

@@ -0,0 +1,28 @@
+import drawTabbableOnCanvas from '../clientSideScripts/drawTabbableOnCanvas.js';
+import removeElementFromDom from '../clientSideScripts/removeElementFromDom.js';
+import checkFullPageScreen from './checkFullPageScreen.js';
+/**
+ * Compare an image with all tab executions
+ */
+export default async function checkTabbablePage({ browserInstance, checkTabbableOptions, folders, instanceData, isNativeContext = false, tag, testContext, }) {
+    // 1a. Check if the method is supported in native context
+    if (isNativeContext) {
+        throw new Error('The method checkTabbablePage is not supported in native context for native mobile apps!');
+    }
+    // 1b. Inject drawing the tabbables
+    await browserInstance.execute(drawTabbableOnCanvas, checkTabbableOptions.wic.tabbableOptions);
+    // 2. Create the screenshot
+    const fullPageCompareData = await checkFullPageScreen({
+        browserInstance,
+        checkFullPageOptions: checkTabbableOptions,
+        instanceData,
+        folders,
+        isNativeContext,
+        testContext,
+        tag,
+    });
+    // 3. Remove the canvas
+    await browserInstance.execute(removeElementFromDom, 'wic-tabbable-canvas');
+    // 4. Return the data
+    return fullPageCompareData;
+}

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

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

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

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