lua-cli 3.15.2 → 3.16.0

package/dist/compiler/utils/path-resolver.d.ts

@@ -1,83 +0,0 @@
-/**
- * Path Resolver Utilities
- *
- * Resolves TypeScript path aliases (e.g., @/, ~/) from a project's
- * tsconfig.json and resolves relative/aliased module specifiers to
- * absolute file paths.
- *
- * Design notes:
- * - Every entry point that reads a tsconfig is keyed by `rootDir`. A
- *   single Node process can compile multiple projects (tests do this,
- *   and future "Compiler as library" consumers will too); the earlier
- *   implementation cached mappings in module scope and mixed aliases
- *   across projects. That's fixed here — the cache is a `Map<rootDir,
- *   mappings | null>`.
- * - `resolveModuleSpecifier` is the single source of truth for
- *   "specifier → absolute path". Previously the resolver and the agent
- *   traverser each reimplemented the same logic; now both go through
- *   this one helper.
- * - A `registerProjectRootDir(project, rootDir)` side-channel lets
- *   downstream code (plugins, resolver) recover the correct rootDir
- *   from a ts-morph Project without threading it through every call
- *   signature. The Compiler sets it once in its constructor.
- */
-import type { Project } from 'ts-morph';
-interface PathMappings {
-    /** The tsconfig's `baseUrl` (falls back to `.`). */
-    baseUrl: string;
-    /** Raw `paths` mapping from the tsconfig. */
-    paths: Record<string, string[]>;
-    /** Absolute rootDir the tsconfig was loaded from. */
-    rootDir: string;
-}
-/**
- * Read the tsconfig at `<rootDir>/tsconfig.json` and extract its
- * `paths` mappings. Returns null when no paths are configured or the
- * tsconfig is missing/unreadable. Result is cached keyed by the
- * normalized rootDir.
- */
-export declare function getTsConfigPathMappings(rootDir: string): PathMappings | null;
-/**
- * Resolve a TypeScript path alias (e.g. `@/tools/MyTool`) to an
- * absolute path. Returns null if no alias matches.
- *
- * `rootDir` is required — it's the project's root, the directory that
- * contains the tsconfig.json whose `paths` we're consulting.
- */
-export declare function resolvePathAlias(specifier: string, rootDir: string): string | null;
-/**
- * Resolve a module specifier (`./foo`, `../bar`, `@/tools/Xyz`) to an
- * absolute file path, trying each of our supported extensions.
- *
- * This is the single consolidated helper that replaces:
- * - `reference-resolver.ts::resolveSpecifierToPath`
- * - `agent-traverser.ts::resolveImportPath`
- *
- * Both previously duplicated this logic; drift between them was a real
- * bug surface. Returns undefined when nothing resolves — callers
- * interpret that as a deopt or a warning depending on context.
- */
-export declare function resolveModuleSpecifier(specifier: string, fromFile: string, rootDir: string): string | undefined;
-/**
- * Associate a ts-morph Project with its source `rootDir`. Called once
- * by the Compiler constructor. Downstream code that only has a
- * SourceFile can recover the rootDir via `getProjectRootDir`.
- */
-export declare function registerProjectRootDir(project: Project, rootDir: string): void;
-/**
- * Look up the registered rootDir for a project, or `undefined` if the
- * project wasn't registered. Callers that need a rootDir but can't
- * tolerate undefined should fall back to a sensible default (e.g.
- * process.cwd() for standalone tooling, or a field on the plugin
- * context for in-compiler use).
- */
-export declare function getProjectRootDir(project: Project): string | undefined;
-/**
- * Test-only: clear the path-alias cache. Tests that compile multiple
- * projects back-to-back in the same process should call this between
- * compilations to avoid stale aliases; the Compiler itself doesn't
- * need to call this because the cache is keyed by rootDir.
- */
-export declare function clearPathResolverCacheForTests(): void;
-export {};
-//# sourceMappingURL=path-resolver.d.ts.map

package/dist/compiler/utils/path-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-resolver.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,UAAU,YAAY;IACpB,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAChC,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;CACjB;AAcD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAgC5E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAqBlF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoB/G;AAUD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE9E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,IAAI,IAAI,CAErD"}

package/dist/compiler/utils/path-resolver.js

@@ -1,162 +0,0 @@
-/**
- * Path Resolver Utilities
- *
- * Resolves TypeScript path aliases (e.g., @/, ~/) from a project's
- * tsconfig.json and resolves relative/aliased module specifiers to
- * absolute file paths.
- *
- * Design notes:
- * - Every entry point that reads a tsconfig is keyed by `rootDir`. A
- *   single Node process can compile multiple projects (tests do this,
- *   and future "Compiler as library" consumers will too); the earlier
- *   implementation cached mappings in module scope and mixed aliases
- *   across projects. That's fixed here — the cache is a `Map<rootDir,
- *   mappings | null>`.
- * - `resolveModuleSpecifier` is the single source of truth for
- *   "specifier → absolute path". Previously the resolver and the agent
- *   traverser each reimplemented the same logic; now both go through
- *   this one helper.
- * - A `registerProjectRootDir(project, rootDir)` side-channel lets
- *   downstream code (plugins, resolver) recover the correct rootDir
- *   from a ts-morph Project without threading it through every call
- *   signature. The Compiler sets it once in its constructor.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-// Per-rootDir cache. `null` means "tsconfig exists but has no paths" or
-// "tsconfig unreadable"; both cases still benefit from caching so we
-// don't hit the filesystem repeatedly.
-const mappingsCache = new Map();
-// ts-morph Project → rootDir. Populated by the Compiler constructor.
-// Lets plugin code that only has a SourceFile/Project in hand recover
-// the correct rootDir without changing every plugin API signature.
-const projectRootDirs = new WeakMap();
-const MODULE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'];
-/**
- * Read the tsconfig at `<rootDir>/tsconfig.json` and extract its
- * `paths` mappings. Returns null when no paths are configured or the
- * tsconfig is missing/unreadable. Result is cached keyed by the
- * normalized rootDir.
- */
-export function getTsConfigPathMappings(rootDir) {
-    const resolvedRoot = path.resolve(rootDir);
-    if (mappingsCache.has(resolvedRoot)) {
-        return mappingsCache.get(resolvedRoot) ?? null;
-    }
-    const tsconfigPath = path.join(resolvedRoot, 'tsconfig.json');
-    if (!fs.existsSync(tsconfigPath)) {
-        mappingsCache.set(resolvedRoot, null);
-        return null;
-    }
-    try {
-        const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf-8');
-        const tsconfig = JSON.parse(tsconfigContent);
-        const compilerOptions = tsconfig.compilerOptions || {};
-        if (compilerOptions.paths) {
-            const mappings = {
-                baseUrl: compilerOptions.baseUrl || '.',
-                paths: compilerOptions.paths,
-                rootDir: resolvedRoot,
-            };
-            mappingsCache.set(resolvedRoot, mappings);
-            return mappings;
-        }
-    }
-    catch {
-        // Ignore parsing errors — treat as "no paths configured".
-    }
-    mappingsCache.set(resolvedRoot, null);
-    return null;
-}
-/**
- * Resolve a TypeScript path alias (e.g. `@/tools/MyTool`) to an
- * absolute path. Returns null if no alias matches.
- *
- * `rootDir` is required — it's the project's root, the directory that
- * contains the tsconfig.json whose `paths` we're consulting.
- */
-export function resolvePathAlias(specifier, rootDir) {
-    const mappings = getTsConfigPathMappings(rootDir);
-    if (!mappings)
-        return null;
-    // Sort patterns by specificity (longest first) — mirrors TypeScript's
-    // own order-of-precedence for overlapping patterns.
-    const sortedPatterns = Object.entries(mappings.paths).sort(([a], [b]) => b.length - a.length);
-    for (const [pattern, targets] of sortedPatterns) {
-        // Convert a TS path pattern to regex: `@/*` → /^@\/(.*)$/
-        const patternRegex = new RegExp('^' + pattern.replace(/\*/g, '(.*)').replace(/\//g, '\\/') + '$');
-        const match = specifier.match(patternRegex);
-        if (match) {
-            const captured = match[1] || '';
-            const targetPath = targets[0].replace('*', captured);
-            return path.join(mappings.rootDir, mappings.baseUrl, targetPath);
-        }
-    }
-    return null;
-}
-/**
- * Resolve a module specifier (`./foo`, `../bar`, `@/tools/Xyz`) to an
- * absolute file path, trying each of our supported extensions.
- *
- * This is the single consolidated helper that replaces:
- * - `reference-resolver.ts::resolveSpecifierToPath`
- * - `agent-traverser.ts::resolveImportPath`
- *
- * Both previously duplicated this logic; drift between them was a real
- * bug surface. Returns undefined when nothing resolves — callers
- * interpret that as a deopt or a warning depending on context.
- */
-export function resolveModuleSpecifier(specifier, fromFile, rootDir) {
-    // Strip trailing `.js` which NodeNext users write for runtime
-    // compatibility (`import foo from './foo.js'` refers to `foo.ts`
-    // during compilation).
-    const normalized = specifier.endsWith('.js') ? specifier.slice(0, -3) : specifier;
-    // Path alias wins when configured — matches TypeScript's resolver order.
-    const aliasResolved = resolvePathAlias(normalized, rootDir);
-    if (aliasResolved) {
-        return tryExtensions(aliasResolved);
-    }
-    if (normalized.startsWith('./') || normalized.startsWith('../')) {
-        const basePath = path.resolve(path.dirname(fromFile), normalized);
-        return tryExtensions(basePath);
-    }
-    // Bare specifiers (npm packages) aren't resolved here — they're
-    // someone else's responsibility.
-    return undefined;
-}
-function tryExtensions(basePath) {
-    for (const ext of MODULE_EXTENSIONS) {
-        const full = ext.startsWith('/') ? path.join(basePath, ext) : basePath + ext;
-        if (fs.existsSync(full))
-            return full;
-    }
-    return undefined;
-}
-/**
- * Associate a ts-morph Project with its source `rootDir`. Called once
- * by the Compiler constructor. Downstream code that only has a
- * SourceFile can recover the rootDir via `getProjectRootDir`.
- */
-export function registerProjectRootDir(project, rootDir) {
-    projectRootDirs.set(project, path.resolve(rootDir));
-}
-/**
- * Look up the registered rootDir for a project, or `undefined` if the
- * project wasn't registered. Callers that need a rootDir but can't
- * tolerate undefined should fall back to a sensible default (e.g.
- * process.cwd() for standalone tooling, or a field on the plugin
- * context for in-compiler use).
- */
-export function getProjectRootDir(project) {
-    return projectRootDirs.get(project);
-}
-/**
- * Test-only: clear the path-alias cache. Tests that compile multiple
- * projects back-to-back in the same process should call this between
- * compilations to avoid stale aliases; the Compiler itself doesn't
- * need to call this because the cache is keyed by rootDir.
- */
-export function clearPathResolverCacheForTests() {
-    mappingsCache.clear();
-}
-//# sourceMappingURL=path-resolver.js.map

package/dist/compiler/utils/path-resolver.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-resolver.js","sourceRoot":"","sources":["../../../src/compiler/utils/path-resolver.ts"],"names":[],"mappings":"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"}

package/dist/compiler/utils/reference-resolver.d.ts

@@ -1,196 +0,0 @@
-/**
- * Primitive Reference Resolver
- *
- * Statically resolves a TypeScript expression that is expected to yield an
- * array of primitive instances (e.g. `mcpServers: [luaDocsMcpServer, ...more]`)
- * into a list of named references (`ResolvedRef[]`), without executing user
- * code.
- *
- * ## Supported expression shapes
- *
- * - Inline:         `[new LuaMCPServer({...}), foo]`
- * - Variable ref:   `const servers = [...]; mcpServers: servers`
- * - Spread:         `[...base, new LuaMCPServer({...})]`
- * - Cross-file:     `import servers from './servers'; mcpServers: servers`
- * - Re-export:      `export { servers } from './impl'`
- * - Barrel chains:  `export * from './servers'` + same-name imports
- * - Path aliases:   `@shared/tools`, `~/lib/tools`, etc. (via tsconfig paths)
- * - Property read:  `const all = { mcp: [...] }; mcpServers: all.mcp`
- * - Identifier chains: `const a = inner; const b = a; mcpServers: b`
- *
- * ## Result shape (Babel's `path.evaluate()` convention)
- *
- *     { confident: true; value: ResolvedRef[] }
- *   | { confident: false; value: ResolvedRef[]; deopt: Node; reason: string;
- *       ruleId: 'lua/unresolved-primitive-ref' }
- *
- * The `deopt` field pinpoints the AST node that defeated resolution so the
- * compiler can emit an actionable `file:line:col` diagnostic. Partial results
- * (`value`) are returned even on deopt so the compiler can emit whatever was
- * resolvable up to the unknown shape.
- *
- * ## Resolution strategy
- *
- * 1. **AST fast path** (primary). Traverse ArrayLiteralExpression, follow
- *    Identifiers to their VariableDeclaration (same-file or via ImportDeclaration
- *    → getModuleSpecifierSourceFile()), recursively expand spreads. This is
- *    the idiomatic ts-morph pattern (see ts-morph issue #644 — manual iteration
- *    is ~1000x faster than getExportedDeclarations() because it doesn't trigger
- *    full symbol binding). Files are added to the project on demand via
- *    `addSourceFileAtPath()` as the walk discovers them.
- * 2. **Symbol fallback** (only when fast path exhausts). Uses
- *    `getAliasedSymbol()` + `symbol.getDeclarations()[0]` to handle exotic
- *    re-export chains the manual walk can't follow.
- *
- * ## Escape hatch
- *
- * A leading `/* @lua-ignore-ref *\/` comment on the expression silences the
- * deopt diagnostic for users who intentionally construct the array dynamically.
- *
- * ## Why we don't evaluate code
- *
- * Earlier iterations used `ts-evaluator` to sandbox-evaluate array expressions.
- * That path loses the link to the compile-time identifier (it yields runtime
- * `.name` strings, not the class/variable name needed for import resolution)
- * and adds a sandboxed-RCE surface (cf. CVE-2023-45133 in Babel). The AST
- * approach covers every case the evaluator did, cheaper and safer.
- */
-import { Node, Project, SourceFile, VariableDeclaration, ClassDeclaration, FunctionDeclaration, NewExpression } from 'ts-morph';
-/**
- * A resolved primitive reference.
- *
- * Carries enough information for downstream consumers (AgentTraverser,
- * SkillPlugin) to locate both the identifier name and the source file
- * where the primitive is declared — no second pass through `findImportSource`
- * needed.
- */
-export interface ResolvedRef {
-    /**
-     * The identifier name as written in user code (`luaDocsMcpServer`,
-     * `MyToolClass`, `default`). Used for plugin detect() matching and
-     * manifest lookup.
-     */
-    identifierName: string;
-    /**
-     * The source file containing the ultimate declaration. May be different
-     * from the agent's source file when the ref came from an import or
-     * re-export chain.
-     */
-    sourceFile: SourceFile;
-    /**
-     * The underlying declaration node. For `new LuaMCPServer({...})` assigned
-     * to a `const`, this is the VariableDeclaration. For a bare `new X()` inline
-     * element, this is undefined and `newExpression` carries the node.
-     */
-    declaration?: VariableDeclaration | ClassDeclaration | FunctionDeclaration;
-    /**
-     * For inline `new X({...})` elements that aren't bound to a variable,
-     * this is the NewExpression itself. Lets the agent traverser report
-     * them with a synthetic name (`__inline_<n>`) rather than dropping them.
-     */
-    newExpression?: NewExpression;
-    /**
-     * True when the ref reached this source file through a default import
-     * (`import x from './target'`). Downstream detect-match logic uses this
-     * to prefer the target file's default export over a name-based match,
-     * because the local binding name (`x`) is chosen by the consumer and
-     * is unrelated to any exportName on the target side.
-     */
-    viaDefaultImport?: boolean;
-}
-/**
- * Babel-style evaluation result. `confident: true` means the resolver is
- * certain it saw every ref in the expression. `confident: false` means the
- * walk hit something it couldn't statically understand — `value` holds what
- * was resolvable up to that point.
- */
-export type EvaluationResult = {
-    confident: true;
-    value: ResolvedRef[];
-} | {
-    confident: false;
-    value: ResolvedRef[];
-    deopt: Node;
-    reason: string;
-    ruleId: 'lua/unresolved-primitive-ref';
-};
-/**
- * Shared state for a single `resolveArrayRefs()` invocation: carries the
- * ts-morph project for on-demand file loading, a cycle-detection set, and
- * an optional debug logger.
- */
-export interface ResolverContext {
-    /** ts-morph project — resolver may call addSourceFileAtPath() on it. */
-    project: Project;
-    /**
-     * Project rootDir used for resolving tsconfig `paths` aliases and
-     * relative imports. When omitted, the resolver falls back to
-     * `getProjectRootDir(project)` — which the Compiler populates in its
-     * constructor. Tests or direct callers can pass it explicitly.
-     */
-    rootDir?: string;
-    /**
-     * Set of `<absolutePath>#<identifier>` pairs we've already visited in this
-     * walk, used to break cycles (A imports B, B re-exports A, etc.).
-     */
-    visited?: Set<string>;
-    /** Optional debug logger. */
-    log?: (message: string) => void;
-}
-/**
- * Resolve an expression node that represents an array of primitive references.
- *
- * Typical usage from a plugin/traverser:
- *
- *     const prop = configObj.getProperty('mcpServers');
- *     const init = (prop as PropertyAssignment).getInitializer();
- *     const result = resolveArrayRefs(init, { project });
- *     if (!result.confident) { log.warn(reportDeopt(result, 'mcpServers')); }
- *     const refs = result.value;
- *
- * @param expression - The expression node whose value is expected to be an
- *   array of primitive instances. Typically the initializer of a
- *   `skills` / `tools` / `mcpServers` property.
- * @param ctx - Resolver context carrying the project and optional logger.
- * @returns An `EvaluationResult` — confident + full value on success,
- *   confident:false + partial value + deopt node on unknown shapes.
- */
-export declare function resolveArrayRefs(expression: Node | undefined, ctx: ResolverContext): EvaluationResult;
-/**
- * Format an `EvaluationResult.deopt` as a SARIF-style diagnostic string
- * for `log.warn()`. Includes the rule id, file:line:col, reason, and a
- * remediation hint pointing the user at the escape hatch.
- *
- * Call sites log this rather than constructing the string inline so every
- * resolver deopt surfaces with the same shape.
- */
-export declare function reportDeopt(result: Extract<EvaluationResult, {
-    confident: false;
-}>, propertyName: string): string;
-/**
- * Rule IDs used by resolver/traverser diagnostics. SARIF requires every
- * issued warning to carry a stable, human-meaningful id so tools
- * (CI, editor integrations) can filter or suppress them individually.
- * Keep this list small and descriptive — new rules should follow the
- * `lua/<kebab-case-category>` naming convention.
- */
-export type DiagnosticRuleId = 'lua/unresolved-primitive-ref' | 'lua/missing-primitive-declaration' | 'lua/missing-tool-import';
-/**
- * Format a SARIF-style diagnostic that isn't anchored on an AST node we
- * parsed directly (e.g. "tried to find a tool in this file and the
- * plugin returned nothing"). For node-anchored deopts, use
- * `reportDeopt()` instead — it produces richer output.
- *
- * All resolver/traverser warnings should flow through either this
- * helper or `reportDeopt`, so every line the user sees has a rule id
- * and follows the same shape.
- */
-export declare function formatSarifWarning(args: {
-    ruleId: DiagnosticRuleId;
-    filePath: string;
-    line?: number;
-    column?: number;
-    message: string;
-    hint?: string;
-}): string;
-//# sourceMappingURL=reference-resolver.d.ts.map

package/dist/compiler/utils/reference-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reference-resolver.d.ts","sourceRoot":"","sources":["../../../src/compiler/utils/reference-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH,OAAO,EACL,IAAI,EACJ,OAAO,EACP,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EAId,MAAM,UAAU,CAAC;AAOlB;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;IAC3E;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,GACzC;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,KAAK,EAAE,IAAI,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,8BAA8B,CAAC;CACxC,CAAC;AAEN;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,6BAA6B;IAC7B,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,gBAAgB,CA+CrG;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,EAAE;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAcjH;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB,8BAA8B,GAC9B,mCAAmC,GACnC,yBAAyB,CAAC;AAE9B;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAOT"}