@react-native-harness/jest 1.0.0-canary.1766225407244 → 1.1.0-rc.1

package/dist/__tests__/client-log-handler.test.d.ts

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

package/dist/__tests__/client-log-handler.test.d.ts.map

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

package/dist/__tests__/client-log-handler.test.js

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatClientLogMessage, formatClientLogLine, handleClientLogEvent, createClientLogListener, } from '../client-log-handler.js';
+// Mock the log function
+vi.mock('../logs.js', () => ({
+    log: vi.fn(),
+}));
+import { log } from '../logs.js';
+describe('client-log-handler', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('formatClientLogMessage', () => {
+        it('should format a single string', () => {
+            const result = formatClientLogMessage(['Hello, world!']);
+            expect(result).toBe('Hello, world!');
+        });
+        it('should join multiple strings with spaces', () => {
+            const result = formatClientLogMessage(['Hello', 'world', '!']);
+            expect(result).toBe('Hello world !');
+        });
+        it('should format objects', () => {
+            const result = formatClientLogMessage([{ key: 'value' }]);
+            // util.format uses inspect-style output for objects
+            expect(result).toContain('key');
+            expect(result).toContain('value');
+        });
+        it('should format arrays', () => {
+            const result = formatClientLogMessage([[1, 2, 3]]);
+            expect(result).toContain('1');
+            expect(result).toContain('2');
+            expect(result).toContain('3');
+        });
+        it('should handle mixed types', () => {
+            const result = formatClientLogMessage([
+                'Message:',
+                { count: 42 },
+                'items',
+            ]);
+            expect(result).toContain('Message:');
+            expect(result).toContain('count');
+            expect(result).toContain('42');
+            expect(result).toContain('items');
+        });
+        it('should format numbers', () => {
+            const result = formatClientLogMessage([123, 456]);
+            expect(result).toBe('123 456');
+        });
+        it('should format booleans', () => {
+            const result = formatClientLogMessage([true, false]);
+            expect(result).toBe('true false');
+        });
+        it('should format null and undefined', () => {
+            const result = formatClientLogMessage([null, undefined]);
+            expect(result).toBe('null undefined');
+        });
+        it('should handle empty array', () => {
+            const result = formatClientLogMessage([]);
+            expect(result).toBe('');
+        });
+        describe('printf-style format specifiers', () => {
+            it('should handle %s string substitution', () => {
+                const result = formatClientLogMessage(['%s world', 'hello']);
+                expect(result).toBe('hello world');
+            });
+            it('should handle %d integer substitution', () => {
+                const result = formatClientLogMessage(['Count: %d', 42]);
+                expect(result).toBe('Count: 42');
+            });
+            it('should handle %i integer substitution', () => {
+                const result = formatClientLogMessage(['Value: %i', 123]);
+                expect(result).toBe('Value: 123');
+            });
+            it('should handle %f float substitution', () => {
+                const result = formatClientLogMessage(['Pi: %f', 3.14159]);
+                expect(result).toContain('3.14159');
+            });
+            it('should handle multiple substitutions', () => {
+                const result = formatClientLogMessage(['Hello %s, you have %d messages', 'Alice', 5]);
+                expect(result).toBe('Hello Alice, you have 5 messages');
+            });
+            it('should handle %j JSON substitution', () => {
+                const result = formatClientLogMessage(['Data: %j', { key: 'value' }]);
+                expect(result).toBe('Data: {"key":"value"}');
+            });
+            it('should handle %o object substitution', () => {
+                const result = formatClientLogMessage(['Object: %o', { a: 1 }]);
+                // %o produces inspect-style output, just check it contains the key
+                expect(result).toContain('a');
+            });
+            it('should handle %% as literal percent when substituting', () => {
+                // %% is only converted to % when there are substitutions
+                const result = formatClientLogMessage(['%s is 100%% complete', 'Task']);
+                expect(result).toBe('Task is 100% complete');
+            });
+            it('should append extra arguments after substitution', () => {
+                const result = formatClientLogMessage(['Hello %s', 'world', 'extra', 'args']);
+                expect(result).toBe('Hello world extra args');
+            });
+        });
+    });
+    describe('formatClientLogLine', () => {
+        it('should format log level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['Test message'],
+            };
+            const result = formatClientLogLine(event);
+            // The result will contain ANSI codes for styling, so we check it contains the message
+            expect(result).toContain('Test message');
+        });
+        it('should format error level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'error',
+                data: ['Error occurred'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Error occurred');
+        });
+        it('should format warn level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'warn',
+                data: ['Warning message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Warning message');
+        });
+        it('should format info level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'info',
+                data: ['Info message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Info message');
+        });
+        it('should format debug level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'debug',
+                data: ['Debug message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Debug message');
+        });
+        it('should format trace level event', () => {
+            const event = {
+                type: 'client_log',
+                level: 'trace',
+                data: ['Trace message'],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('Trace message');
+        });
+        it('should handle multiple data items', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['User:', { id: 1, name: 'Test' }],
+            };
+            const result = formatClientLogLine(event);
+            expect(result).toContain('User:');
+            expect(result).toContain('id');
+            expect(result).toContain('Test');
+        });
+    });
+    describe('handleClientLogEvent', () => {
+        it('should handle client_log events and call log', () => {
+            const event = {
+                type: 'client_log',
+                level: 'log',
+                data: ['Test message'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).toHaveBeenCalledTimes(1);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Test message'));
+        });
+        it('should return false for non-client_log events', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const event = { type: 'bundle_build_started' };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(false);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle error level logs', () => {
+            const event = {
+                type: 'client_log',
+                level: 'error',
+                data: ['Something went wrong'],
+            };
+            handleClientLogEvent(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
+        });
+        it('should handle warn level logs', () => {
+            const event = {
+                type: 'client_log',
+                level: 'warn',
+                data: ['Deprecation warning'],
+            };
+            handleClientLogEvent(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Deprecation warning'));
+        });
+    });
+    describe('createClientLogListener', () => {
+        it('should create a listener function', () => {
+            const listener = createClientLogListener();
+            expect(typeof listener).toBe('function');
+        });
+        it('should handle client_log events when called', () => {
+            const listener = createClientLogListener();
+            const event = {
+                type: 'client_log',
+                level: 'info',
+                data: ['Listener test'],
+            };
+            listener(event);
+            expect(log).toHaveBeenCalledWith(expect.stringContaining('Listener test'));
+        });
+        it('should ignore non-client_log events', () => {
+            const listener = createClientLogListener();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const event = { type: 'initialize_done' };
+            listener(event);
+            expect(log).not.toHaveBeenCalled();
+        });
+    });
+    describe('group events', () => {
+        it('should handle group events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'group',
+                data: ['Group label'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle groupCollapsed events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'groupCollapsed',
+                data: ['Collapsed'],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+        it('should handle groupEnd events without logging', () => {
+            const event = {
+                type: 'client_log',
+                level: 'groupEnd',
+                data: [],
+            };
+            const result = handleClientLogEvent(event);
+            expect(result).toBe(true);
+            expect(log).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/__tests__/crash-supervisor.test.d.ts

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

package/dist/__tests__/crash-supervisor.test.d.ts.map

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

package/dist/__tests__/crash-supervisor.test.js

@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+const createMockAppMonitor = (options) => {
+    const listeners = new Set();
+    const noop = async () => undefined;
+    const appMonitor = {
+        start: noop,
+        stop: noop,
+        dispose: noop,
+        addListener: (listener) => {
+            listeners.add(listener);
+        },
+        removeListener: (listener) => {
+            listeners.delete(listener);
+        },
+    };
+    if (options?.getCrashDetails) {
+        appMonitor.getCrashDetails = options.getCrashDetails;
+    }
+    const emit = (event) => {
+        for (const listener of listeners) {
+            listener(event);
+        }
+    };
+    return {
+        appMonitor,
+        emit,
+    };
+};
+const createPlatformRunner = ({ isAppRunning, getCrashDetails, }) => ({
+    startApp: async () => undefined,
+    restartApp: async () => undefined,
+    stopApp: async () => undefined,
+    dispose: async () => undefined,
+    isAppRunning,
+    createAppMonitor: () => {
+        throw new Error('Not used in unit tests');
+    },
+    getCrashDetails,
+});
+describe('crash-supervisor', () => {
+    it('rejects the active test when the app exits during launch', async () => {
+        const monitor = createMockAppMonitor();
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+            }),
+        });
+        supervisor.beginLaunch('/tmp/startup.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/startup.harness.ts');
+        const expectation = expect(crashPromise).rejects.toMatchObject({
+            name: 'NativeCrashError',
+            phase: 'startup',
+            details: {
+                signal: 'SIGSEGV',
+                processName: 'com.harnessplayground',
+            },
+        });
+        monitor.emit({
+            type: 'app_exited',
+            source: 'logs',
+            crashDetails: {
+                source: 'logs',
+                signal: 'SIGSEGV',
+                processName: 'com.harnessplayground',
+                rawLines: ['Fatal signal 11 (SIGSEGV)'],
+            },
+        });
+        await expectation;
+        await supervisor.dispose();
+    });
+    it('treats polling exit events as immediately confirmed crashes', async () => {
+        const monitor = createMockAppMonitor();
+        const isAppRunning = vi.fn().mockResolvedValue(true);
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning,
+            }),
+        });
+        supervisor.beginLaunch('/tmp/polling-exit.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/polling-exit.harness.ts');
+        monitor.emit({ type: 'app_exited', source: 'polling' });
+        await expect(crashPromise).rejects.toMatchObject({
+            name: 'NativeCrashError',
+            phase: 'startup',
+        });
+        expect(isAppRunning).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+    it('does not reject when monitoring is stopped', async () => {
+        const monitor = createMockAppMonitor();
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+            }),
+        });
+        supervisor.beginTestRun('/tmp/restart.harness.ts');
+        await supervisor.stop();
+        const reject = vi.fn();
+        void supervisor.waitForCrash('/tmp/restart.harness.ts').catch(reject);
+        monitor.emit({ type: 'app_exited', source: 'polling' });
+        await Promise.resolve();
+        expect(reject).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+    it('prefers crash details from the started app monitor over the runner', async () => {
+        const monitorGetCrashDetails = vi.fn().mockResolvedValue({
+            source: 'logs',
+            summary: 'full crash block',
+            rawLines: ['full crash block'],
+        });
+        const runnerGetCrashDetails = vi.fn().mockResolvedValue({
+            source: 'logs',
+            summary: 'runner details',
+            rawLines: ['runner details'],
+        });
+        const monitor = createMockAppMonitor({
+            getCrashDetails: monitorGetCrashDetails,
+        });
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+                getCrashDetails: runnerGetCrashDetails,
+            }),
+        });
+        supervisor.beginTestRun('/tmp/monitor-details.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/monitor-details.harness.ts');
+        monitor.emit({
+            type: 'possible_crash',
+            source: 'logs',
+            crashDetails: {
+                source: 'logs',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+                rawLines: ['partial line'],
+            },
+        });
+        await expect(crashPromise).rejects.toMatchObject({
+            details: {
+                summary: 'full crash block',
+            },
+        });
+        expect(monitorGetCrashDetails).toHaveBeenCalled();
+        expect(runnerGetCrashDetails).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+});

package/dist/__tests__/errors.test.d.ts

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

package/dist/__tests__/errors.test.d.ts.map

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

package/dist/__tests__/errors.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { NativeCrashError } from '../errors.js';
+describe('NativeCrashError', () => {
+    it('formats the extracted stack trace in the error message', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'execution',
+            processName: 'HarnessPlayground',
+            pid: 1234,
+            signal: 'SIGTRAP',
+            exceptionType: 'EXC_BREAKPOINT',
+            stackTrace: [
+                '0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)',
+                '1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)',
+            ],
+        });
+        expect(error.message).toContain('  0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)');
+        expect(error.message).toContain('  1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)');
+    });
+    it('omits single-line iOS summaries from the rendered error message', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            artifactType: 'ios-crash-report',
+            summary: '2026-03-12 13:46:18.154 Df HarnessPlayground[18007:65e716] [com.apple.dt.xctest:Default] notify_get_state check indicated test daemon not ready.',
+            processName: 'HarnessPlayground',
+            pid: 18007,
+            signal: 'SIGABRT',
+            exceptionType: 'EXC_CRASH',
+        });
+        expect(error.message).not.toContain('notify_get_state check indicated test daemon not ready');
+        expect(error.message).toContain('Signal: SIGABRT');
+        expect(error.message).toContain('Exception: EXC_CRASH');
+        expect(error.message).toContain('Process: HarnessPlayground (pid 18007)');
+    });
+    it('does not duplicate stack frames when the summary already contains a crash block', () => {
+        const frame = '03-13 07:59:44.943 20373 20373 E AndroidRuntime: \tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)';
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            summary: [
+                '--------- beginning of crash',
+                '03-13 07:59:44.943 20373 20373 E AndroidRuntime: FATAL EXCEPTION: main',
+                frame,
+            ].join('\n'),
+            stackTrace: [frame],
+        });
+        expect(error.message.match(/MainActivity\.onCreate\(MainActivity\.kt:38\)/g)).toHaveLength(1);
+    });
+    it('collapses the native crash stack header so jest does not reprint multiline messages', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            summary: ['line one', 'line two'].join('\n'),
+        });
+        expect(error.stack).toBe('NativeCrashError: The native app crashed while preparing to run this test file.');
+    });
+});

package/dist/__tests__/harness.test.d.ts

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

package/dist/__tests__/harness.test.d.ts.map

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

package/dist/__tests__/harness.test.js

@@ -0,0 +1,106 @@
+import { EventEmitter } from 'node:events';
+import { describe, expect, it, vi } from 'vitest';
+import { waitForAppReady } from '../harness.js';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+const createBridgeServer = () => {
+    const emitter = new EventEmitter();
+    return {
+        serverBridge: {
+            on: emitter.on.bind(emitter),
+            once: emitter.once.bind(emitter),
+            off: emitter.off.bind(emitter),
+        },
+        emitReady: () => {
+            emitter.emit('ready');
+        },
+    };
+};
+const createAppMonitor = () => {
+    const listeners = new Set();
+    return {
+        start: async () => undefined,
+        stop: async () => undefined,
+        dispose: async () => undefined,
+        addListener: (listener) => {
+            listeners.add(listener);
+        },
+        removeListener: (listener) => {
+            listeners.delete(listener);
+        },
+    };
+};
+const createPlatformRunner = (restartApp) => ({
+    startApp: async () => undefined,
+    restartApp,
+    stopApp: async () => undefined,
+    dispose: async () => undefined,
+    isAppRunning: async () => true,
+    createAppMonitor: createAppMonitor,
+});
+describe('waitForAppReady', () => {
+    it('passes launch options to the initial launch', async () => {
+        const { serverBridge, emitReady } = createBridgeServer();
+        const restartApp = vi.fn().mockResolvedValue(undefined);
+        const platformInstance = createPlatformRunner(restartApp);
+        const crashSupervisor = createCrashSupervisor({
+            appMonitor: createAppMonitor(),
+            platformRunner: platformInstance,
+        });
+        const promise = waitForAppReady({
+            serverBridge,
+            platformInstance,
+            bridgeTimeout: 5000,
+            testFilePath: '/tmp/test.harness.ts',
+            crashSupervisor,
+            appLaunchOptions: {
+                extras: {
+                    mode: 'startup',
+                },
+            },
+        });
+        await Promise.resolve();
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                mode: 'startup',
+            },
+        });
+        emitReady();
+        await promise;
+        await crashSupervisor.dispose();
+    });
+    it('does not retry launch when the app never becomes ready', async () => {
+        vi.useFakeTimers();
+        const { serverBridge } = createBridgeServer();
+        const restartApp = vi.fn().mockResolvedValue(undefined);
+        const platformInstance = createPlatformRunner(restartApp);
+        const crashSupervisor = createCrashSupervisor({
+            appMonitor: createAppMonitor(),
+            platformRunner: platformInstance,
+        });
+        const promise = waitForAppReady({
+            serverBridge,
+            platformInstance,
+            bridgeTimeout: 1000,
+            testFilePath: '/tmp/test.harness.ts',
+            crashSupervisor,
+            appLaunchOptions: {
+                extras: {
+                    mode: 'startup',
+                },
+            },
+        });
+        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(1000);
+        await expect(promise).rejects.toMatchObject({
+            name: 'AbortError',
+        });
+        expect(restartApp).toHaveBeenCalledTimes(1);
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                mode: 'startup',
+            },
+        });
+        await crashSupervisor.dispose();
+        vi.useRealTimers();
+    });
+});

package/dist/cli-args.test.d.ts

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

package/dist/cli-args.test.d.ts.map

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

package/dist/cli-args.test.js

@@ -0,0 +1 @@
+export {};

package/dist/client-log-handler.d.ts

@@ -0,0 +1,23 @@
+import type { ReportableEvent } from '@react-native-harness/bundler-metro';
+export type ClientLogEvent = Extract<ReportableEvent, {
+    type: 'client_log';
+}>;
+/**
+ * Formats a client log event data array into a string message.
+ * Uses util.format for printf-style format specifier support (%s, %d, %j, etc.)
+ */
+export declare const formatClientLogMessage: (data: unknown[]) => string;
+/**
+ * Formats a client log event into a log line with styled level prefix.
+ */
+export declare const formatClientLogLine: (event: ClientLogEvent) => string;
+/**
+ * Handles a client_log event by formatting and logging it.
+ * Returns true if the event was handled, false otherwise.
+ */
+export declare const handleClientLogEvent: (event: ReportableEvent) => boolean;
+/**
+ * Creates a client log event listener that can be added to the Metro reporter.
+ */
+export declare const createClientLogListener: () => ((event: ReportableEvent) => void);
+//# sourceMappingURL=client-log-handler.d.ts.map

package/dist/client-log-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AA6C9E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAKxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,KAAG,MAI3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,eAAe,KAAG,OAiB7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAI3E,CAAC"}