@remix-run/test 0.0.0 → 0.2.0

package/dist/lib/config.js

@@ -0,0 +1,255 @@
+import * as fsp from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as util from 'node:util';
+import { importModule } from "./import-module.js";
+export const IS_RUNNING_FROM_SRC = path.extname(new URL(import.meta.url).pathname) === '.ts';
+/*
+ * The root directory for the test code. Coverage URLs are emitted as
+ * `/scripts/<rel-from-rootDir>` and resolved back via the same anchor.
+ *
+ *   - In a published install: `process.cwd()`, since deps and user source all
+ *     live under it.
+ *   - In monorepo src mode: the monorepo root, computed by walking back from
+ *     the resolved `@remix-run/test` source path. `process.cwd()` doesn't work
+ *     here because workspace deps and node_modules live above the per-package
+ *     cwd.
+ */
+export function getBrowserTestRootDir() {
+    return IS_RUNNING_FROM_SRC
+        ? // Resolve to packages/test/src/index.ts and the pop 3 directories off to the repo root
+            path
+                .dirname(fileURLToPath(import.meta.resolve('@remix-run/test')))
+                .split(path.sep)
+                .slice(0, -3)
+                .join(path.sep)
+        : process.cwd();
+}
+// prettier-ignore
+// Note: `description` is not a field used by parseArgs(), it's an additional field
+// we use for `--help`
+const cliOptions = {
+    'browser.echo': {
+        type: 'boolean',
+        description: 'Echo browser console output to stdout',
+    },
+    'browser.open': {
+        type: 'boolean',
+        description: 'Open browser window and keep open after tests finish',
+    },
+    'glob.browser': {
+        type: 'string',
+        description: 'Glob pattern for browser test files',
+    },
+    'glob.e2e': {
+        type: 'string',
+        description: 'Glob pattern for E2E test files',
+    },
+    'glob.exclude': {
+        type: 'string',
+        description: 'Glob pattern for paths to exclude from discovery',
+    },
+    'glob.test': {
+        type: 'string',
+        description: 'Glob pattern for all test files',
+    },
+    concurrency: {
+        type: 'string',
+        short: 'c',
+        description: 'Max number of concurrent test workers (default: os.availableParallelism())',
+    },
+    config: {
+        type: 'string',
+        description: 'Path to config file (default: remix-test.config.ts)',
+    },
+    coverage: {
+        type: 'boolean',
+        description: 'Enable or disable coverage collection (default: false)',
+    },
+    'coverage.dir': {
+        type: 'string',
+        description: 'Directory to output coverage reports (default: .coverage)',
+    },
+    'coverage.include': {
+        type: 'string',
+        multiple: true,
+        description: 'Glob pattern(s) for files to include in coverage',
+    },
+    'coverage.exclude': {
+        type: 'string',
+        multiple: true,
+        description: 'Glob pattern(s) for files to exclude from coverage',
+    },
+    'coverage.branches': {
+        type: 'string',
+        description: 'Branches coverage threshold percentage',
+    },
+    'coverage.functions': {
+        type: 'string',
+        description: 'Functions coverage threshold percentage',
+    },
+    'coverage.lines': {
+        type: 'string',
+        description: 'Lines coverage threshold percentage',
+    },
+    'coverage.statements': {
+        type: 'string',
+        description: 'Statements coverage threshold percentage',
+    },
+    setup: {
+        type: 'string',
+        short: 's',
+        description: 'Path to a setup module exporting globalSetup/globalTeardown',
+    },
+    playwrightConfig: {
+        type: 'string',
+        description: 'Path to a Playwright config file',
+    },
+    project: {
+        type: 'string',
+        short: 'p',
+        description: 'Filter to a specific Playwright project (comma-separated)',
+    },
+    reporter: {
+        type: 'string',
+        short: 'r',
+        description: 'Test reporter: spec, files, tap, dot (default: spec)',
+    },
+    type: {
+        type: 'string',
+        short: 't',
+        description: 'Comma-separated test types to run (default: server,browser,e2e)',
+    },
+    watch: {
+        type: 'boolean',
+        short: 'w',
+        description: 'Re-run tests on file changes',
+    },
+};
+const defaultValues = {
+    browser: {
+        echo: false,
+        open: false,
+    },
+    concurrency: os.availableParallelism(),
+    coverage: {
+        dir: '.coverage',
+        include: undefined,
+        exclude: undefined,
+        statements: undefined,
+        lines: undefined,
+        branches: undefined,
+        functions: undefined,
+    },
+    glob: {
+        test: '**/*.test{,.e2e,.browser}.{ts,tsx}',
+        browser: '**/*.test.browser.{ts,tsx}',
+        e2e: '**/*.test.e2e.{ts,tsx}',
+        exclude: 'node_modules/**',
+    },
+    reporter: process.env.CI === 'true' ? 'files' : 'spec',
+    type: 'server,browser,e2e',
+    setup: undefined,
+    playwrightConfig: undefined,
+    project: undefined,
+    watch: false,
+};
+export async function loadConfig(args = process.argv.slice(2), cwd = process.cwd()) {
+    let parsed = parseCliArgs(args);
+    let fileConfig = await loadConfigFile(parsed.values.config, cwd);
+    let config = resolveConfig(fileConfig, parsed);
+    return config;
+}
+export function getRemixTestHelpText(_target = process.stdout) {
+    let lines = [
+        'Usage: remix-test [glob] [options]',
+        '',
+        'Arguments:',
+        `  glob                     Glob pattern for test files (default: "${defaultValues.glob.test}")`,
+        '',
+        'Options:',
+    ];
+    for (let [long, opt] of Object.entries(cliOptions)) {
+        let short = 'short' in opt ? `/-${opt.short}` : '';
+        let label = opt.type === 'string' ? `--${long}${short} <value>` : `--${long}${short}`;
+        lines.push(`  ${label.padEnd(30)} ${opt.description}`);
+    }
+    lines.push(`  ${'-h, --help'.padEnd(30)} Show this help message`);
+    return lines.join('\n');
+}
+function parseCliArgs(args) {
+    return util.parseArgs({ args, options: cliOptions, allowPositionals: true });
+}
+function resolveConfig(fileConfig, { values: cliValues, positionals }) {
+    let fileCoverage = typeof fileConfig.coverage === 'boolean' ? {} : fileConfig.coverage || {};
+    return {
+        glob: {
+            test: positionals[0] ??
+                cliValues['glob.test'] ??
+                fileConfig.glob?.test ??
+                defaultValues.glob.test,
+            browser: cliValues['glob.browser'] ?? fileConfig.glob?.browser ?? defaultValues.glob.browser,
+            e2e: cliValues['glob.e2e'] ?? fileConfig.glob?.e2e ?? defaultValues.glob.e2e,
+            exclude: cliValues['glob.exclude'] ?? fileConfig.glob?.exclude ?? defaultValues.glob.exclude,
+        },
+        browser: {
+            echo: cliValues['browser.echo'] ?? fileConfig.browser?.echo ?? defaultValues.browser.echo,
+            open: cliValues['browser.open'] ?? fileConfig.browser?.open ?? defaultValues.browser.open,
+        },
+        concurrency: Number(cliValues.concurrency ?? fileConfig.concurrency ?? defaultValues.concurrency),
+        coverage: cliValues.coverage === true || !!fileConfig.coverage
+            ? {
+                dir: cliValues['coverage.dir'] ?? fileCoverage.dir ?? defaultValues.coverage.dir,
+                include: cliValues['coverage.include'] ??
+                    fileCoverage.include ??
+                    defaultValues.coverage.include,
+                exclude: cliValues['coverage.exclude'] ??
+                    fileCoverage.exclude ??
+                    defaultValues.coverage.exclude,
+                statements: cliValues['coverage.statements'] !== undefined
+                    ? Number(cliValues['coverage.statements'])
+                    : fileCoverage.statements !== undefined
+                        ? Number(fileCoverage.statements)
+                        : undefined,
+                lines: cliValues['coverage.lines'] !== undefined
+                    ? Number(cliValues['coverage.lines'])
+                    : fileCoverage.lines !== undefined
+                        ? Number(fileCoverage.lines)
+                        : undefined,
+                branches: cliValues['coverage.branches'] !== undefined
+                    ? Number(cliValues['coverage.branches'])
+                    : fileCoverage.branches !== undefined
+                        ? Number(fileCoverage.branches)
+                        : undefined,
+                functions: cliValues['coverage.functions'] !== undefined
+                    ? Number(cliValues['coverage.functions'])
+                    : fileCoverage.functions !== undefined
+                        ? Number(fileCoverage.functions)
+                        : undefined,
+            }
+            : undefined,
+        setup: cliValues.setup ?? fileConfig.setup ?? defaultValues.setup,
+        playwrightConfig: cliValues.playwrightConfig ?? fileConfig.playwrightConfig ?? defaultValues.playwrightConfig,
+        project: cliValues.project ?? fileConfig.project ?? defaultValues.project,
+        reporter: cliValues.reporter ?? fileConfig.reporter ?? defaultValues.reporter,
+        type: cliValues.type ?? fileConfig.type ?? defaultValues.type,
+        watch: cliValues.watch ?? fileConfig.watch ?? defaultValues.watch,
+    };
+}
+async function loadConfigFile(configPath, cwd) {
+    let candidates = configPath
+        ? [path.resolve(cwd, configPath)]
+        : [path.join(cwd, 'remix-test.config.ts'), path.join(cwd, 'remix-test.config.js')];
+    for (let candidate of candidates) {
+        try {
+            await fsp.access(candidate);
+            let mod = await importModule(candidate, import.meta);
+            return mod.default ?? mod;
+        }
+        catch {
+            // not found or failed to load — try next
+        }
+    }
+    return {};
+}

package/dist/lib/context.d.ts

@@ -0,0 +1,93 @@
+import type { Browser, Page } from 'playwright';
+import type { V8CoverageEntry } from './coverage.ts';
+import { type FakeTimers } from './fake-timers.ts';
+import { type MockCall, type MockContext, type MockFunction } from './mock.ts';
+import type { getPlaywrightPageOptions } from './playwright.ts';
+/**
+ * The shape `t.serve()` consumes. Matches the result of `createTestServer`
+ * from `@remix-run/node-fetch-server/test`, but any object with a `baseUrl`
+ * and async `close()` works.
+ */
+export interface TestServer {
+    baseUrl: string;
+    close(): Promise<void>;
+}
+/**
+ * Test Context providing utilities for testing via remix-test.  The context is
+ * passed as the first argument to the {@link test}/{@link it} functions.
+ *
+ * @example
+ * describe('my test suite', () => {
+ *   it('my test case', async (t) => {
+ *     let mockFn = t.mock.fn(() => 'mocked value')
+ *     // ...
+ *   })
+ * })
+ */
+export interface TestContext {
+    /**
+     * Registers a cleanup function to be called after the test completes.
+     *
+     * @param {() => void} fn - The cleanup function to execute
+     * @returns {void}
+     */
+    after(fn: () => void): void;
+    /**
+     * Mock tracker for the current test. Mirrors the shape of Node's
+     * `t.mock`. Method mocks created here are auto-restored on test completion.
+     */
+    mock: {
+        /**
+         * Creates a mock function with an optional implementation.
+         *
+         * @template T - The function type to be mocked
+         * @param {T} [impl] - Optional custom implementation for the mock
+         * @returns {MockFunction<T>} A mock function instance
+         */
+        fn<T extends (...args: any[]) => any>(impl?: T): MockFunction<T>;
+        /**
+         * Replaces `obj[methodName]` with a mock and records every call. The
+         * original method is restored automatically after the test completes.
+         *
+         * @template T - The object type
+         * @template K - The method key of the object
+         * @param {T} obj - The object to mock
+         * @param {K} methodName - The method name to mock
+         * @param {Function} [impl] - Optional implementation override (must be a function)
+         * @returns {MockFunction} A mock function instance for the mocked method
+         */
+        method<T extends object, K extends keyof T>(obj: T, methodName: K, impl?: Function): MockFunction;
+    };
+    /**
+     * Activates fake timers for testing time-dependent code.
+     *
+     * @returns {FakeTimers} A fake timers instance for controlling time
+     */
+    useFakeTimers(): FakeTimers;
+    /**
+     * Wires a running test server up to a Playwright page so the test can drive
+     * it. The server is closed automatically when the test ends. Pair with
+     * `createTestServer` from `@remix-run/node-fetch-server/test` (or any other
+     * source of a `{ baseUrl, close }` handle) to spin up the server first.
+     *
+     * @param server - The running server the page should target
+     * @returns A `Page` whose `baseURL` is set to `server.baseUrl`.
+     */
+    serve(server: TestServer): Promise<Page>;
+}
+export interface CreateTestContextOptions {
+    addE2ECoverageEntries: (value: {
+        entries: V8CoverageEntry[];
+        baseUrl: string;
+    }) => void;
+    browser: Browser;
+    coverage: boolean;
+    open: boolean;
+    playwrightPageOptions: ReturnType<typeof getPlaywrightPageOptions>;
+}
+export declare function createTestContext(options?: CreateTestContextOptions): {
+    testContext: TestContext;
+    cleanup(): Promise<void>;
+};
+export type { MockCall, MockContext, MockFunction };
+//# sourceMappingURL=context.d.ts.map

package/dist/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACpE,OAAO,EAAQ,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AACpF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAE/D;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAE3B;;;OAGG;IACH,IAAI,EAAE;QACJ;;;;;;WAMG;QACH,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAA;QAEhE;;;;;;;;;;WAUG;QACH,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACxC,GAAG,EAAE,CAAC,EACN,UAAU,EAAE,CAAC,EACb,IAAI,CAAC,EAAE,QAAQ,GACd,YAAY,CAAA;KAChB,CAAA;IAED;;;;OAIG;IACH,aAAa,IAAI,UAAU,CAAA;IAE3B;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC;AAED,MAAM,WAAW,wBAAwB;IACvC,qBAAqB,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,eAAe,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IACvF,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,OAAO,CAAA;IACb,qBAAqB,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAA;CACnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG;IACrE,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAkEA;AAED,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAA"}

package/dist/lib/context.js

@@ -0,0 +1,65 @@
+import { createFakeTimers } from "./fake-timers.js";
+import { mock } from "./mock.js";
+export function createTestContext(options) {
+    let cleanups = [];
+    let testContext = {
+        mock: {
+            fn: mock.fn,
+            method(obj, methodName, impl) {
+                let mockFn = mock.method(obj, methodName, impl);
+                if (mockFn.mock.restore)
+                    cleanups.push(mockFn.mock.restore);
+                return mockFn;
+            },
+        },
+        after(fn) {
+            cleanups.push(fn);
+        },
+        useFakeTimers() {
+            let timers = createFakeTimers();
+            cleanups.push(timers.restore);
+            return timers;
+        },
+        async serve(server) {
+            if (!options || !options.browser) {
+                throw new Error('t.serve() is only available in E2E test suites');
+            }
+            let page = await options.browser.newPage({
+                ...options.playwrightPageOptions,
+                baseURL: server.baseUrl,
+            });
+            if (options.playwrightPageOptions?.navigationTimeout != null) {
+                page.setDefaultNavigationTimeout(options.playwrightPageOptions.navigationTimeout);
+            }
+            if (options.playwrightPageOptions?.actionTimeout != null) {
+                page.setDefaultTimeout(options.playwrightPageOptions.actionTimeout);
+            }
+            let coverageEnabled = options.coverage && options.browser.browserType().name() === 'chromium';
+            if (coverageEnabled) {
+                await page.coverage.startJSCoverage({ resetOnNavigation: false });
+                cleanups.push(async () => {
+                    let entries = await page.coverage.stopJSCoverage();
+                    options.addE2ECoverageEntries?.({
+                        entries: entries,
+                        baseUrl: server.baseUrl,
+                    });
+                });
+            }
+            cleanups.push(async () => {
+                if (!options.open) {
+                    await page.close();
+                }
+                await server.close();
+            });
+            return page;
+        },
+    };
+    return {
+        testContext,
+        async cleanup() {
+            for (let fn of cleanups)
+                await fn();
+            cleanups.length = 0;
+        },
+    };
+}

package/dist/lib/coverage-loader.d.ts

@@ -0,0 +1,16 @@
+export declare function load(url: string, context: {
+    format?: string;
+}, nextLoad: (url: string, context: {
+    format?: string;
+}) => Promise<{
+    format: string;
+    source: string;
+}>): Promise<{
+    format: string;
+    source: string;
+} | {
+    format: string;
+    source: string;
+    shortCircuit: boolean;
+}>;
+//# sourceMappingURL=coverage-loader.d.ts.map

package/dist/lib/coverage-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-loader.d.ts","sourceRoot":"","sources":["../../src/lib/coverage-loader.ts"],"names":[],"mappings":"AAYA,wBAAsB,IAAI,CACxB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5B,QAAQ,EAAE,CACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,KACzB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;;;;;;;GAYjD"}

package/dist/lib/coverage-loader.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformTypeScript } from "./ts-transform.js";
+// Custom ESM loader hook for TypeScript files.
+//
+// Replaces tsx's minified transformation with an un-minified esbuild transform
+// that preserves line structure. This ensures V8 coverage byte offsets map
+// cleanly to TypeScript source lines via the inline source map, giving
+// accurate per-line coverage rather than collapsing multiple statements onto
+// a single minified line.
+export async function load(url, context, nextLoad) {
+    let cleanUrl = url.includes('?') ? url.slice(0, url.indexOf('?')) : url;
+    if (!cleanUrl.endsWith('.ts') && !cleanUrl.endsWith('.tsx')) {
+        return nextLoad(url, context);
+    }
+    let filePath = fileURLToPath(cleanUrl);
+    let source = await readFile(filePath, 'utf-8');
+    let { code } = await transformTypeScript(source, filePath);
+    return { format: 'module', source: code, shortCircuit: true };
+}

package/dist/lib/coverage.d.ts

@@ -0,0 +1,28 @@
+import type { createCoverageMap as CreateCoverageMap } from 'istanbul-lib-coverage';
+export interface CoverageConfig {
+    dir: string;
+    include?: string[];
+    exclude?: string[];
+    statements?: number;
+    lines?: number;
+    branches?: number;
+    functions?: number;
+}
+export interface V8CoverageEntry {
+    url: string;
+    source?: string;
+    functions: Array<{
+        functionName: string;
+        isBlockCoverage: boolean;
+        ranges: Array<{
+            startOffset: number;
+            endOffset: number;
+            count: number;
+        }>;
+    }>;
+}
+export type CoverageMap = ReturnType<typeof CreateCoverageMap>;
+export declare function collectServerCoverageMap(coverageDataDir: string, cwd: string, testFiles: Set<string>): Promise<CoverageMap | null>;
+export declare function collectCoverageMapFromPlaywright(entries: V8CoverageEntry[], rootDir: string, testFiles: Set<string>, resolveRelativePath: (url: string) => Promise<string | null>): Promise<CoverageMap | null>;
+export declare function generateCombinedCoverageReport(maps: (CoverageMap | null | undefined)[], cwd: string, config: CoverageConfig): Promise<boolean>;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/lib/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/lib/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAsCnF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,KAAK,CAAC;QACf,YAAY,EAAE,MAAM,CAAA;QACpB,eAAe,EAAE,OAAO,CAAA;QACxB,MAAM,EAAE,KAAK,CAAC;YAAE,WAAW,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACzE,CAAC,CAAA;CACH;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAmI9D,wBAAsB,wBAAwB,CAC5C,eAAe,EAAE,MAAM,EACvB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,GACrB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAuD7B;AAED,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,mBAAmB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAC3D,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA2C7B;AAED,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACxC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,OAAO,CAAC,CAelB"}