ushman-equiv 0.4.0

package/dist/tier-i-import-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-i-import-graph.d.ts","sourceRoot":"","sources":["../src/tier-i-import-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACvG,OAAO,KAAK,EAAE,gBAAgB,EAAgB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGrF,QAAA,MAAM,2BAA2B,GAC7B,SAAS,kBAAkB,EAC3B,SAAS,qBAAqB,KAC/B,OAAO,CAAC,gBAAgB,CA8B1B,CAAC;AAEF,eAAO,MAAM,gBAAgB,GACzB,SAAS,kBAAkB,KAC5B,OAAO,CAAC,gBAAgB,CAAwE,CAAC;AAEpG,OAAO,EAAE,2BAA2B,EAAE,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/tier-i-import-graph.js

@@ -0,0 +1,34 @@
+import { createEquivExecutionContext } from "./equiv-execution-context.js";
+import { displayPath } from "./workspace.js";
+const checkImportGraphWithContext = async (options, context) => {
+    const start = Date.now();
+    const analysis = await context.getImportGraph(options);
+    const missing = analysis.imports.filter((entry) => !entry.resolved);
+    const details = [
+        ...analysis.parseFindings,
+        ...missing.map((entry) => ({
+            evidence: {
+                importer: displayPath(options.workspaceRoot, entry.importerPath),
+                specifier: entry.specifier,
+            },
+            message: entry.message ?? `Unresolved import: ${entry.specifier}`,
+            path: displayPath(options.workspaceRoot, entry.importerPath),
+        })),
+        ...analysis.warnings,
+    ];
+    const severity = analysis.parseFindings.length > 0 || missing.length > 0
+        ? 'red'
+        : analysis.imports.length === 0 || analysis.warnings.length > 0
+            ? 'yellow'
+            : 'green';
+    const resolvedCount = analysis.imports.filter((entry) => entry.resolved).length;
+    return {
+        details: details.length > 0 ? details : undefined,
+        elapsedMs: Date.now() - start,
+        severity,
+        summary: `imports=${analysis.imports.length}, resolved=${resolvedCount}, missing=${missing.length}`,
+        tier: 'I',
+    };
+};
+export const checkImportGraph = async (options) => checkImportGraphWithContext(options, createEquivExecutionContext());
+export { checkImportGraphWithContext };

package/dist/tier-l-child-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const createModuleLoadChildScript: (resultSentinel: string) => string;
+//# sourceMappingURL=tier-l-child-runtime.d.ts.map

package/dist/tier-l-child-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-l-child-runtime.d.ts","sourceRoot":"","sources":["../src/tier-l-child-runtime.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,2BAA2B,GAAI,gBAAgB,MAAM,KAAG,MA4D7D,CAAC"}

package/dist/tier-l-child-runtime.js

@@ -0,0 +1,62 @@
+import { createBrowserShimSource, createStubFactorySource, createStubHelperModuleSource, TIER_L_STUB_HELPER_SPECIFIER, } from "./tier-l-stub-source.js";
+const MODULE_LOAD_CONFIG_ENV = 'USHMAN_EQUIV_MODULE_LOAD_CONFIG';
+export const createModuleLoadChildScript = (resultSentinel) => `
+import { registerHooks } from 'node:module';
+import { format } from 'node:util';
+
+const config = JSON.parse(process.env.${MODULE_LOAD_CONFIG_ENV} ?? '{}');
+
+// registerHooks keeps the loader fully in-process so Tier L does not need to
+// write a temporary loader file to disk before importing the candidate entrypoint.
+const writeConsole = (...args) => {
+    process.stderr.write(\`\${format(...args)}\\n\`);
+};
+console.log = writeConsole;
+console.info = writeConsole;
+console.warn = writeConsole;
+console.error = writeConsole;
+console.debug = writeConsole;
+
+${createStubFactorySource()}
+
+${createBrowserShimSource()}
+
+// Keep one helper payload in the child and let each vendor stub import it
+// instead of embedding the full proxy factory into every generated module.
+const stubHelperUrl = \`data:text/javascript;charset=utf-8,\${encodeURIComponent(${JSON.stringify(createStubHelperModuleSource())})}\`;
+const stubModuleUrls = new Map(
+    [
+        [${JSON.stringify(TIER_L_STUB_HELPER_SPECIFIER)}, stubHelperUrl],
+        ...Object.entries(config.stubModules ?? {}).map(([specifier, source]) => [
+            specifier,
+            \`data:text/javascript;charset=utf-8,\${encodeURIComponent(source)}\`,
+        ]),
+    ],
+);
+
+registerHooks({
+    resolve(specifier, context, nextResolve) {
+        if (stubModuleUrls.has(specifier)) {
+            return {
+                shortCircuit: true,
+                url: stubModuleUrls.get(specifier),
+            };
+        }
+        return nextResolve(specifier, context);
+    },
+});
+
+try {
+    await import(config.entrypointUrl);
+    process.stdout.write(${JSON.stringify(resultSentinel)} + JSON.stringify({ loaded: true }) + '\\n');
+} catch (error) {
+    process.stdout.write(
+        ${JSON.stringify(resultSentinel)} +
+            JSON.stringify({
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                loaded: false,
+            }) +
+            '\\n',
+    );
+}
+`.trim();

package/dist/tier-l-module-load.d.ts

@@ -0,0 +1,6 @@
+import { type EquivExecutionContext } from './equiv-execution-context.ts';
+import type { EquivCheckResult, ModuleLoadOptions } from './types.ts';
+declare const checkModuleLoadWithContext: (options: ModuleLoadOptions, context: EquivExecutionContext) => Promise<EquivCheckResult>;
+export declare const checkModuleLoad: (options: ModuleLoadOptions) => Promise<EquivCheckResult>;
+export { checkModuleLoadWithContext };
+//# sourceMappingURL=tier-l-module-load.d.ts.map

package/dist/tier-l-module-load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-l-module-load.d.ts","sourceRoot":"","sources":["../src/tier-l-module-load.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAEvG,OAAO,KAAK,EAAE,gBAAgB,EAAgB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAwIpF,QAAA,MAAM,0BAA0B,GAC5B,SAAS,iBAAiB,EAC1B,SAAS,qBAAqB,KAC/B,OAAO,CAAC,gBAAgB,CAwC1B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,SAAS,iBAAiB,KAAG,OAAO,CAAC,gBAAgB,CACrB,CAAC;AAEvE,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/tier-l-module-load.js

@@ -0,0 +1,139 @@
+import { spawn } from 'node:child_process';
+import { createEquivExecutionContext } from "./equiv-execution-context.js";
+import { captureChildText, readPositiveIntegerEnv } from "./shared.js";
+import { DEFAULT_EQUIV_MODE, displayPath, importMapMatchesSpecifier, toFileImportUrl, } from "./workspace.js";
+import { createModuleLoadChildScript } from "./tier-l-child-runtime.js";
+import { createStubModuleSource } from "./tier-l-stub-source.js";
+const MODULE_LOAD_CHILD_TIMEOUT_MS = readPositiveIntegerEnv('USHMAN_EQUIV_MODULE_LOAD_TIMEOUT_MS', 30_000);
+const MODULE_LOAD_MAX_LOG_BYTES = readPositiveIntegerEnv('USHMAN_EQUIV_MAX_LOG_BYTES', 32 * 1024);
+const RESULT_SENTINEL = '__USHMAN_EQUIV_MODULE_LOAD_RESULT__';
+const parseChildResult = (stdout, stderr) => {
+    const sentinelIndex = stdout.lastIndexOf(RESULT_SENTINEL);
+    if (sentinelIndex === -1) {
+        throw new Error(stderr.trim() || stdout.trim() || 'Module-load child did not emit a result payload.');
+    }
+    const payload = stdout.slice(sentinelIndex + RESULT_SENTINEL.length).trim();
+    return JSON.parse(payload);
+};
+const runChild = async ({ entrypointUrl, stubModules, }) => new Promise((resolve, reject) => {
+    const runtimeBinary = process.env.USHMAN_EQUIV_NODE_BINARY ??
+        process.env.NODE_BINARY ??
+        (process.versions.bun ? 'node' : process.execPath);
+    const child = spawn(runtimeBinary, ['--input-type=module', '--eval', createModuleLoadChildScript(RESULT_SENTINEL)], {
+        env: {
+            ...process.env,
+            NODE_NO_WARNINGS: '1',
+            USHMAN_EQUIV_MODULE_LOAD_CONFIG: JSON.stringify({
+                entrypointUrl,
+                stubModules,
+            }),
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const readStdout = captureChildText({
+        maxBytes: MODULE_LOAD_MAX_LOG_BYTES,
+        stream: child.stdout,
+    });
+    const readStderr = captureChildText({
+        maxBytes: MODULE_LOAD_MAX_LOG_BYTES,
+        stream: child.stderr,
+    });
+    const timeoutId = setTimeout(() => {
+        child.kill('SIGKILL');
+        reject(new Error(`Module-load child timed out after ${MODULE_LOAD_CHILD_TIMEOUT_MS}ms.`));
+    }, MODULE_LOAD_CHILD_TIMEOUT_MS);
+    child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+    });
+    child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        const stdout = readStdout();
+        const stderr = readStderr();
+        if (code !== 0) {
+            reject(new Error(stderr || stdout || `Module-load child exited with code ${code}`));
+            return;
+        }
+        try {
+            resolve({
+                result: parseChildResult(stdout, stderr),
+                stderr,
+                stdout,
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+});
+const createBootFailureResult = ({ diagnostics, elapsedMs, mode, }) => ({
+    details: [
+        {
+            evidence: diagnostics,
+            message: `Candidate ${mode} boot failed before tier L could import the entrypoint.`,
+        },
+    ],
+    elapsedMs,
+    severity: 'red',
+    summary: `mode=${mode}, booted=false, loaded=false, warnings=0`,
+    tier: 'L',
+});
+const buildStubModules = (analysis) => {
+    const stubModules = {};
+    const warnings = [];
+    for (const [specifier, usage] of analysis.bareUsages.entries()) {
+        stubModules[specifier] = createStubModuleSource(specifier, [...usage.namedImports]);
+        if (importMapMatchesSpecifier(analysis.importMap, specifier) === null) {
+            warnings.push({
+                message: `Vendor ${specifier} is not present in the importmap; using an empty-shape stub.`,
+                symbol: specifier,
+            });
+        }
+    }
+    return {
+        stubModules,
+        warnings,
+    };
+};
+const checkModuleLoadWithContext = async (options, context) => {
+    const start = Date.now();
+    const mode = options.mode ?? DEFAULT_EQUIV_MODE;
+    const bootResult = await context.getCandidateBoot({
+        mode,
+        workspaceRoot: options.workspaceRoot,
+    });
+    if (!bootResult.ok) {
+        return createBootFailureResult({
+            diagnostics: bootResult.diagnostics,
+            elapsedMs: Date.now() - start,
+            mode,
+        });
+    }
+    const analysis = await context.getImportGraph(options);
+    const { stubModules, warnings } = buildStubModules(analysis);
+    const childResult = await runChild({
+        entrypointUrl: toFileImportUrl(analysis.entrypointPath, `${Date.now()}`),
+        stubModules,
+    });
+    const details = [...warnings];
+    if (!childResult.result.loaded) {
+        details.push({
+            evidence: {
+                error: childResult.result.error,
+                stderr: childResult.stderr || undefined,
+                stdout: childResult.stdout || undefined,
+            },
+            message: childResult.result.error ?? 'Module load failed.',
+            path: displayPath(options.workspaceRoot, analysis.entrypointPath),
+        });
+    }
+    return {
+        details: details.length > 0 ? details : undefined,
+        elapsedMs: Date.now() - start,
+        severity: childResult.result.loaded ? (warnings.length > 0 ? 'yellow' : 'green') : 'red',
+        summary: `mode=${mode}, booted=true, loaded=${childResult.result.loaded}, warnings=${warnings.length}, entrypoint=${displayPath(options.workspaceRoot, analysis.entrypointPath)}`,
+        tier: 'L',
+    };
+};
+export const checkModuleLoad = async (options) => checkModuleLoadWithContext(options, createEquivExecutionContext());
+export { checkModuleLoadWithContext };

package/dist/tier-l-stub-source.d.ts

@@ -0,0 +1,11 @@
+type StubFactoryNames = {
+    readonly callableFactoryName: string;
+    readonly objectFactoryName: string;
+};
+export declare const TIER_L_STUB_HELPER_SPECIFIER = "ushman-equiv/tier-l-stub-helper";
+export declare const createStubFactorySource: (names?: Partial<StubFactoryNames>) => string;
+export declare const createBrowserShimSource: (names?: Partial<StubFactoryNames>) => string;
+export declare const createStubHelperModuleSource: () => string;
+export declare const createStubModuleSource: (specifier: string, names: readonly string[], helperSpecifier?: string) => string;
+export {};
+//# sourceMappingURL=tier-l-stub-source.d.ts.map

package/dist/tier-l-stub-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-l-stub-source.d.ts","sourceRoot":"","sources":["../src/tier-l-stub-source.ts"],"names":[],"mappings":"AAEA,KAAK,gBAAgB,GAAG;IACpB,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACtC,CAAC;AAYF,eAAO,MAAM,4BAA4B,oCAAoC,CAAC;AAE9E,eAAO,MAAM,uBAAuB,GAAI,QAAO,OAAO,CAAC,gBAAgB,CAAM,KAAG,MAsF/E,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAO,OAAO,CAAC,gBAAgB,CAAM,KAAG,MAiI/E,CAAC;AAEF,eAAO,MAAM,4BAA4B,QAAO,MAKhC,CAAC;AAEjB,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,OAAO,SAAS,MAAM,EAAE,EACxB,wBAA8C,KAC/C,MAaF,CAAC"}

package/dist/tier-l-stub-source.js

@@ -0,0 +1,246 @@
+import { compareStrings } from "./shared.js";
+const DEFAULT_FACTORY_NAMES = {
+    callableFactoryName: 'createCallableStub',
+    objectFactoryName: 'createObjectStub',
+};
+const serializeFactoryNames = (names) => ({
+    callableFactoryName: names.callableFactoryName ?? DEFAULT_FACTORY_NAMES.callableFactoryName,
+    objectFactoryName: names.objectFactoryName ?? DEFAULT_FACTORY_NAMES.objectFactoryName,
+});
+export const TIER_L_STUB_HELPER_SPECIFIER = 'ushman-equiv/tier-l-stub-helper';
+export const createStubFactorySource = (names = {}) => {
+    const { callableFactoryName, objectFactoryName } = serializeFactoryNames(names);
+    return `
+const ${callableFactoryName} = (label = 'stub') => {
+    const target = function () {};
+    return new Proxy(target, {
+        apply() {
+            return ${callableFactoryName}(\`\${label}()\`);
+        },
+        construct() {
+            return ${objectFactoryName}(\`new \${label}\`);
+        },
+        get(_target, property) {
+            if (property === 'then') {
+                return undefined;
+            }
+            if (property === 'prototype') {
+                return {};
+            }
+            if (property === Symbol.iterator) {
+                return undefined;
+            }
+            if (property === Symbol.toPrimitive) {
+                return () => label;
+            }
+            return ${callableFactoryName}(\`\${label}.\${String(property)}\`);
+        },
+        getOwnPropertyDescriptor() {
+            return {
+                configurable: true,
+                enumerable: true,
+                value: undefined,
+                writable: true,
+            };
+        },
+        has() {
+            return true;
+        },
+        ownKeys() {
+            return [];
+        },
+        set() {
+            return true;
+        },
+    });
+};
+
+const ${objectFactoryName} = (label = 'stub', base = {}) =>
+    new Proxy(base, {
+        get(target, property) {
+            if (property === 'then') {
+                return undefined;
+            }
+            if (property === Symbol.iterator) {
+                return undefined;
+            }
+            if (property === Symbol.toPrimitive) {
+                return () => label;
+            }
+            if (property in target) {
+                return Reflect.get(target, property);
+            }
+            return ${callableFactoryName}(\`\${label}.\${String(property)}\`);
+        },
+        getOwnPropertyDescriptor(target, property) {
+            return (
+                Reflect.getOwnPropertyDescriptor(target, property) ?? {
+                    configurable: true,
+                    enumerable: true,
+                    value: undefined,
+                    writable: true,
+                }
+            );
+        },
+        has() {
+            return true;
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target);
+        },
+        set(target, property, value) {
+            target[property] = value;
+            return true;
+        },
+    });
+`.trim();
+};
+export const createBrowserShimSource = (names = {}) => {
+    const { objectFactoryName } = serializeFactoryNames(names);
+    return `
+const createStorage = () => {
+    const values = new Map();
+    return {
+        clear() {
+            values.clear();
+        },
+        get length() {
+            return values.size;
+        },
+        getItem(key) {
+            return values.has(String(key)) ? values.get(String(key)) : null;
+        },
+        key(index) {
+            return [...values.keys()][index] ?? null;
+        },
+        removeItem(key) {
+            values.delete(String(key));
+        },
+        setItem(key, value) {
+            values.set(String(key), String(value));
+        },
+    };
+};
+
+class HTMLCanvasElement {
+    constructor() {
+        this.height = 1;
+        this.width = 1;
+    }
+    getContext() {
+        return ${objectFactoryName}('canvas-context');
+    }
+}
+
+class OffscreenCanvas {
+    constructor(width = 1, height = 1) {
+        this.width = width;
+        this.height = height;
+    }
+    getContext() {
+        return ${objectFactoryName}('offscreen-canvas-context');
+    }
+}
+
+class HTMLImageElement {}
+class GPUCanvasContext {}
+class IntersectionObserver {
+    disconnect() {}
+    observe() {}
+    takeRecords() {
+        return [];
+    }
+    unobserve() {}
+}
+class ResizeObserver {
+    disconnect() {}
+    observe() {}
+    unobserve() {}
+}
+class WebGL2RenderingContext {}
+const CSS = { supports: () => false };
+
+const document = ${objectFactoryName}('document', {
+    addEventListener() {},
+    body: ${objectFactoryName}('document.body'),
+    createElement(tagName) {
+        if (String(tagName).toLowerCase() === 'canvas') {
+            return new HTMLCanvasElement();
+        }
+        return ${objectFactoryName}(\`element:\${String(tagName)}\`, {
+            tagName: String(tagName).toUpperCase(),
+        });
+    },
+    documentElement: ${objectFactoryName}('document.documentElement'),
+    getElementById() {
+        return null;
+    },
+    querySelector() {
+        return null;
+    },
+    removeEventListener() {},
+});
+
+const navigator = ${objectFactoryName}('navigator', {
+    gpu: ${objectFactoryName}('navigator.gpu'),
+    userAgent: 'ushman-equiv',
+});
+
+const requestAnimationFrame = (callback) => setTimeout(() => callback(Date.now()), 16);
+const cancelAnimationFrame = (handle) => clearTimeout(handle);
+
+const window = ${objectFactoryName}('window', {
+    addEventListener() {},
+    cancelAnimationFrame,
+    clearTimeout,
+    document,
+    localStorage: createStorage(),
+    navigator,
+    removeEventListener() {},
+    requestAnimationFrame,
+    sessionStorage: createStorage(),
+    setTimeout,
+});
+window.self = window;
+window.window = window;
+
+Object.defineProperty(globalThis, 'window', { configurable: true, value: window });
+Object.defineProperty(globalThis, 'document', { configurable: true, value: document });
+Object.defineProperty(globalThis, 'navigator', { configurable: true, value: navigator });
+Object.defineProperty(globalThis, 'requestAnimationFrame', { configurable: true, value: requestAnimationFrame });
+Object.defineProperty(globalThis, 'cancelAnimationFrame', { configurable: true, value: cancelAnimationFrame });
+Object.defineProperty(globalThis, 'localStorage', { configurable: true, value: window.localStorage });
+Object.defineProperty(globalThis, 'sessionStorage', { configurable: true, value: window.sessionStorage });
+Object.defineProperty(globalThis, 'HTMLCanvasElement', { configurable: true, value: HTMLCanvasElement });
+Object.defineProperty(globalThis, 'HTMLImageElement', { configurable: true, value: HTMLImageElement });
+Object.defineProperty(globalThis, 'IntersectionObserver', { configurable: true, value: IntersectionObserver });
+Object.defineProperty(globalThis, 'OffscreenCanvas', { configurable: true, value: OffscreenCanvas });
+Object.defineProperty(globalThis, 'GPUCanvasContext', { configurable: true, value: GPUCanvasContext });
+Object.defineProperty(globalThis, 'ResizeObserver', { configurable: true, value: ResizeObserver });
+Object.defineProperty(globalThis, 'WebGL2RenderingContext', { configurable: true, value: WebGL2RenderingContext });
+Object.defineProperty(globalThis, 'CSS', { configurable: true, value: CSS });
+Object.defineProperty(globalThis, 'performance', {
+    configurable: true,
+    value: globalThis.performance ?? { now: () => Date.now() },
+});
+`.trim();
+};
+export const createStubHelperModuleSource = () => [
+    createStubFactorySource(),
+    '',
+    'export { createCallableStub, createObjectStub };',
+].join('\n');
+export const createStubModuleSource = (specifier, names, helperSpecifier = TIER_L_STUB_HELPER_SPECIFIER) => {
+    const exportLines = names
+        .filter((name) => name !== 'default')
+        .sort(compareStrings)
+        .map((name) => `export { __stub as ${name} };`);
+    return `
+import { createCallableStub } from ${JSON.stringify(helperSpecifier)};
+
+const __stub = createCallableStub(${JSON.stringify(specifier)});
+export default __stub;
+export const __esModule = true;
+${exportLines.join('\n')}
+`.trim();
+};

package/dist/tier-r-replay.d.ts

@@ -0,0 +1,6 @@
+import { type EquivExecutionContext } from './equiv-execution-context.ts';
+import type { EquivCheckResult, ReplayOptions } from './types.ts';
+declare const checkReplayWithContext: (options: ReplayOptions, context: EquivExecutionContext) => Promise<EquivCheckResult>;
+export declare const checkReplay: (options: ReplayOptions) => Promise<EquivCheckResult>;
+export { checkReplayWithContext };
+//# sourceMappingURL=tier-r-replay.d.ts.map

package/dist/tier-r-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-r-replay.d.ts","sourceRoot":"","sources":["../src/tier-r-replay.ts"],"names":[],"mappings":"AAIA,OAAO,EAA+B,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAEvG,OAAO,KAAK,EAAE,gBAAgB,EAAkD,aAAa,EAAE,MAAM,YAAY,CAAC;AAqblH,QAAA,MAAM,sBAAsB,GACxB,SAAS,aAAa,EACtB,SAAS,qBAAqB,KAC/B,OAAO,CAAC,gBAAgB,CAwF1B,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,SAAS,aAAa,KAAG,OAAO,CAAC,gBAAgB,CACjB,CAAC;AAEnE,OAAO,EAAE,sBAAsB,EAAE,CAAC"}