@shrkcrft/inspector 0.1.0-alpha.1

package/dist/pack-symbol-compat.js

@@ -0,0 +1,519 @@
+/**
+ * Plugin-api symbol compatibility diff.
+ *
+ * Reads `import { … } from '@shrkcrft/plugin-api'` lines from each pack
+ * contribution file, resolves the consumer's installed plugin-api source,
+ * and reports which symbols the pack uses that the consumer's plugin-api
+ * does not export.
+ *
+ * Default mode (`'ts'`) walks ESM exports with the TypeScript compiler
+ * API — multi-line export blocks, multi-declarator `export const`,
+ * `export type { … }`, and transitive `export * from` re-exports are
+ * resolved correctly. CJS bundles (`Object.defineProperty(exports, 'X')`,
+ * `exports.X = …`) still use the regex scanner, since those shapes don't
+ * surface as `ExportDeclaration` nodes in the AST.
+ *
+ * `mode: 'fast'` falls back to the legacy regex-only scanner — useful
+ * when the typescript module can't be loaded or when speed matters more
+ * than completeness.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import * as ts from 'typescript';
+export const PACK_SYMBOL_COMPAT_SCHEMA = 'sharkcraft.pack-symbol-compat/v1';
+const NAMED_IMPORT_RE = /^\s*import\s*(?:type\s+)?\{([^}]+)\}\s*from\s*['"]@shrkcrft\/plugin-api['"]/;
+const DEFAULT_IMPORT_RE = /^\s*import\s+(\w+)\s*(?:,\s*\{([^}]+)\})?\s*from\s*['"]@shrkcrft\/plugin-api['"]/;
+function listContributionFiles(packPath) {
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === 'node_modules' || entry.startsWith('.'))
+                continue;
+            const full = nodePath.join(dir, entry);
+            let stat;
+            try {
+                stat = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory())
+                walk(full);
+            else if (/\.(ts|tsx|mts|cts|js|mjs|cjs)$/.test(entry) && !entry.endsWith('.d.ts')) {
+                out.push(full);
+            }
+        }
+    };
+    const srcDir = nodePath.join(packPath, 'src');
+    walk(existsSync(srcDir) ? srcDir : packPath);
+    return out;
+}
+function extractImports(file) {
+    let body;
+    try {
+        body = readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const names = [];
+    for (const raw of body.split(/\r?\n/)) {
+        const named = raw.match(NAMED_IMPORT_RE);
+        if (named) {
+            for (const symbol of named[1].split(',')) {
+                const clean = symbol.replace(/\s+as\s+\w+/, '').trim();
+                if (clean)
+                    names.push(clean);
+            }
+            continue;
+        }
+        const def = raw.match(DEFAULT_IMPORT_RE);
+        if (def) {
+            // Default import — track as a symbol name. Plugin-api has no default
+            // export today, so this is mostly diagnostic.
+            names.push(def[1]);
+            if (def[2]) {
+                for (const symbol of def[2].split(',')) {
+                    const clean = symbol.replace(/\s+as\s+\w+/, '').trim();
+                    if (clean)
+                        names.push(clean);
+                }
+            }
+        }
+    }
+    return names;
+}
+function inferSourceMode(rel) {
+    if (rel.startsWith('src/'))
+        return 'source';
+    if (rel.endsWith('.d.ts'))
+        return 'declaration';
+    if (rel.endsWith('.js') || rel.endsWith('.cjs') || rel.endsWith('.mjs'))
+        return 'dist-js';
+    return 'fallback';
+}
+function resolvePluginApi(consumerRoot, packPath) {
+    const candidates = [];
+    if (consumerRoot) {
+        candidates.push({
+            dir: nodePath.join(consumerRoot, 'node_modules', '@shrkcrft', 'plugin-api'),
+            resolution: 'consumer-node-modules',
+        });
+    }
+    candidates.push({
+        dir: nodePath.join(packPath, 'node_modules', '@shrkcrft', 'plugin-api'),
+        resolution: 'pack-node-modules',
+    });
+    for (const c of candidates) {
+        if (!existsSync(c.dir))
+            continue;
+        // Prefer the source `src/index.ts` (symlinked monorepo); fall back to
+        // `dist/index.js` / `dist/index.d.ts`.
+        const choices = [
+            'src/index.ts',
+            'dist/index.d.ts',
+            'dist/index.js',
+            'dist/index.mjs',
+            'dist/index.cjs',
+            'index.d.ts',
+            'index.js',
+            'index.cjs',
+        ];
+        for (const rel of choices) {
+            const full = nodePath.join(c.dir, rel);
+            if (existsSync(full)) {
+                const resolution = rel.startsWith('src/') && c.resolution === 'consumer-node-modules'
+                    ? 'consumer-symlink'
+                    : c.resolution;
+                return { source: full, resolution, sourceMode: inferSourceMode(rel) };
+            }
+        }
+    }
+    return { source: '', resolution: 'not-found', sourceMode: 'none' };
+}
+/**
+ * Collect CJS/UMD-style exports from a built JavaScript bundle.
+ * Handles the patterns that bun, tsc, esbuild and rollup emit:
+ *   - `Object.defineProperty(exports, "X", { ... })`
+ *   - `exports.X = ...`
+ *   - `module.exports.X = ...`
+ *   - `module.exports = { X, Y }`
+ *   - ESM bundles: `export const X`, `export { X }`, `export function X`
+ */
+const CJS_DEFINE_PROP_RE = /Object\.defineProperty\(\s*exports\s*,\s*['"]([A-Za-z_$][\w$]*)['"]/g;
+const CJS_EXPORTS_ASSIGN_RE = /\bexports\s*\.\s*([A-Za-z_$][\w$]*)\s*=/g;
+const CJS_MODULE_EXPORTS_PROP_RE = /\bmodule\s*\.\s*exports\s*\.\s*([A-Za-z_$][\w$]*)\s*=/g;
+const CJS_MODULE_EXPORTS_OBJECT_RE = /\bmodule\s*\.\s*exports\s*=\s*\{([^}]+)\}/;
+function collectJsExports(file) {
+    const out = new Set();
+    let body;
+    try {
+        body = readFileSync(file, 'utf8');
+    }
+    catch {
+        return out;
+    }
+    for (const m of body.matchAll(CJS_DEFINE_PROP_RE)) {
+        if (m[1] && m[1] !== '__esModule')
+            out.add(m[1]);
+    }
+    for (const m of body.matchAll(CJS_EXPORTS_ASSIGN_RE)) {
+        if (m[1] && m[1] !== '__esModule')
+            out.add(m[1]);
+    }
+    for (const m of body.matchAll(CJS_MODULE_EXPORTS_PROP_RE)) {
+        if (m[1] && m[1] !== '__esModule')
+            out.add(m[1]);
+    }
+    const objMatch = body.match(CJS_MODULE_EXPORTS_OBJECT_RE);
+    if (objMatch && objMatch[1]) {
+        for (const piece of objMatch[1].split(',')) {
+            const name = piece.split(':')[0]?.trim();
+            if (name && /^[A-Za-z_$][\w$]*$/.test(name))
+                out.add(name);
+        }
+    }
+    // Also pick up ESM-style `export const`/`export function`/`export { X }`
+    for (const raw of body.split(/\r?\n/)) {
+        const named = raw.match(EXPORT_NAMED_RE);
+        if (named && named[1])
+            out.add(named[1]);
+        const block = raw.match(EXPORT_BLOCK_RE);
+        if (block && !/from\s+['"]/.test(raw)) {
+            for (const symbol of block[1].split(',')) {
+                const clean = symbol.replace(/\s+as\s+(\w+)/, '$1').trim();
+                if (clean && /^[A-Za-z_$][\w$]*$/.test(clean))
+                    out.add(clean);
+            }
+        }
+    }
+    return out;
+}
+const EXPORT_NAMED_RE = /^\s*export\s+(?:async\s+)?(?:declare\s+)?(?:function|class|interface|enum|type|const|let|var)\s+(\w+)/;
+const EXPORT_BLOCK_RE = /^\s*export\s*\{([^}]+)\}/;
+const RE_EXPORT_RE = /^\s*export\s*\*\s+from\s*['"]([^'"]+)['"]/;
+const RE_EXPORT_NAMED_RE = /^\s*export\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/;
+function scriptKindFor(file) {
+    if (file.endsWith('.tsx'))
+        return ts.ScriptKind.TSX;
+    if (file.endsWith('.jsx'))
+        return ts.ScriptKind.JSX;
+    if (file.endsWith('.js') || file.endsWith('.mjs') || file.endsWith('.cjs'))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function hasExportModifier(node) {
+    const modifiers = (ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined) ?? [];
+    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+}
+function collectBindingNames(name, out) {
+    if (ts.isIdentifier(name)) {
+        out.add(name.text);
+        return;
+    }
+    if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+        for (const element of name.elements) {
+            if (ts.isBindingElement(element)) {
+                collectBindingNames(element.name, out);
+            }
+        }
+    }
+}
+/**
+ * Walk ESM exports of `file` using the TypeScript compiler API, following
+ * `export * from` re-exports transitively. CJS-specific shapes are NOT
+ * resolved here — call {@link collectJsExports} alongside for those.
+ *
+ * Returns an empty set on parse failure so callers can union with the
+ * regex fallback.
+ */
+function collectExportsTs(file, visited) {
+    if (visited.has(file))
+        return new Set();
+    visited.add(file);
+    const out = new Set();
+    let body;
+    try {
+        body = readFileSync(file, 'utf8');
+    }
+    catch {
+        return out;
+    }
+    let source;
+    try {
+        source = ts.createSourceFile(file, body, ts.ScriptTarget.Latest, /*setParentNodes*/ false, scriptKindFor(file));
+    }
+    catch {
+        return out;
+    }
+    for (const stmt of source.statements) {
+        if (ts.isExportDeclaration(stmt)) {
+            const moduleSpec = stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : null;
+            if (!stmt.exportClause) {
+                // `export * from '...'` — recurse through the barrel.
+                if (moduleSpec) {
+                    const target = resolveRelative(file, moduleSpec);
+                    if (target) {
+                        for (const sym of collectExportsTs(target, visited))
+                            out.add(sym);
+                    }
+                }
+                continue;
+            }
+            if (ts.isNamedExports(stmt.exportClause)) {
+                for (const spec of stmt.exportClause.elements) {
+                    out.add(spec.name.text);
+                }
+                continue;
+            }
+            if (ts.isNamespaceExport(stmt.exportClause)) {
+                // `export * as ns from '...'` — the namespace itself is the export.
+                out.add(stmt.exportClause.name.text);
+                continue;
+            }
+        }
+        else if (ts.isFunctionDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+            out.add(stmt.name.text);
+        }
+        else if (ts.isClassDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+            out.add(stmt.name.text);
+        }
+        else if (ts.isInterfaceDeclaration(stmt) && hasExportModifier(stmt)) {
+            out.add(stmt.name.text);
+        }
+        else if (ts.isTypeAliasDeclaration(stmt) && hasExportModifier(stmt)) {
+            out.add(stmt.name.text);
+        }
+        else if (ts.isEnumDeclaration(stmt) && hasExportModifier(stmt)) {
+            out.add(stmt.name.text);
+        }
+        else if (ts.isModuleDeclaration(stmt) && stmt.name && hasExportModifier(stmt)) {
+            if (ts.isIdentifier(stmt.name))
+                out.add(stmt.name.text);
+        }
+        else if (ts.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                collectBindingNames(decl.name, out);
+            }
+        }
+    }
+    return out;
+}
+function collectExports(file, visited) {
+    if (visited.has(file))
+        return new Set();
+    visited.add(file);
+    const out = new Set();
+    let body;
+    try {
+        body = readFileSync(file, 'utf8');
+    }
+    catch {
+        return out;
+    }
+    for (const raw of body.split(/\r?\n/)) {
+        const named = raw.match(EXPORT_NAMED_RE);
+        if (named) {
+            out.add(named[1]);
+            continue;
+        }
+        const block = raw.match(EXPORT_BLOCK_RE);
+        if (block && !/from\s+['"]/.test(raw)) {
+            for (const symbol of block[1].split(',')) {
+                const clean = symbol.replace(/\s+as\s+(\w+)/, '$1').trim();
+                if (clean)
+                    out.add(clean);
+            }
+            continue;
+        }
+        const reExport = raw.match(RE_EXPORT_RE);
+        if (reExport) {
+            const childRel = reExport[1];
+            const candidate = resolveRelative(file, childRel);
+            if (candidate) {
+                for (const symbol of collectExports(candidate, visited))
+                    out.add(symbol);
+            }
+            continue;
+        }
+        const reExportNamed = raw.match(RE_EXPORT_NAMED_RE);
+        if (reExportNamed) {
+            for (const symbol of reExportNamed[1].split(',')) {
+                const clean = symbol.replace(/\s+as\s+(\w+)/, '$1').trim();
+                if (clean)
+                    out.add(clean);
+            }
+        }
+    }
+    return out;
+}
+function resolveRelative(fromFile, rel) {
+    if (!rel.startsWith('.'))
+        return null;
+    const base = nodePath.resolve(nodePath.dirname(fromFile), rel);
+    const candidates = [
+        base, // Verbatim with extension (e.g. './foo.ts' under NodeNext).
+        base + '.ts',
+        base + '.tsx',
+        base + '.d.ts',
+        base + '.mts',
+        base + '.cts',
+        base + '.js',
+        base + '.mjs',
+        base + '.cjs',
+        nodePath.join(base, 'index.ts'),
+        nodePath.join(base, 'index.tsx'),
+        nodePath.join(base, 'index.d.ts'),
+        nodePath.join(base, 'index.mts'),
+        nodePath.join(base, 'index.js'),
+        nodePath.join(base, 'index.mjs'),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c)) {
+            try {
+                if (statSync(c).isFile())
+                    return c;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+function confidenceFor(mode, count) {
+    if (mode === 'source' || mode === 'declaration')
+        return 'high';
+    if (mode === 'dist-js' && count >= 3)
+        return 'medium';
+    if (mode === 'dist-js')
+        return 'low';
+    if (mode === 'none')
+        return 'low';
+    return 'low';
+}
+export function checkPackSymbolCompat(input) {
+    const packAbs = nodePath.resolve(input.packPath);
+    const consumerRoot = input.consumerRoot ? nodePath.resolve(input.consumerRoot) : null;
+    const resolved = resolvePluginApi(consumerRoot, packAbs);
+    const filesInspected = [];
+    let availableSet = new Set();
+    let usedMode = resolved.sourceMode;
+    const useTs = (input.mode ?? 'ts') === 'ts';
+    if (resolved.source.length > 0) {
+        if (resolved.sourceMode === 'dist-js') {
+            // CJS shapes only show up in the regex scanner; ESM shapes show up
+            // in either. Union the two so a bundle that mixes both is covered.
+            availableSet = collectJsExports(resolved.source);
+            if (useTs) {
+                for (const sym of collectExportsTs(resolved.source, new Set()))
+                    availableSet.add(sym);
+            }
+            filesInspected.push(resolved.source);
+        }
+        else if (useTs) {
+            availableSet = collectExportsTs(resolved.source, new Set());
+            // Fallback union — if the TS walker returns nothing (parse failure),
+            // we still want a best-effort symbol list from the regex scanner.
+            if (availableSet.size === 0) {
+                availableSet = collectExports(resolved.source, new Set());
+            }
+            filesInspected.push(resolved.source);
+        }
+        else {
+            availableSet = collectExports(resolved.source, new Set());
+            filesInspected.push(resolved.source);
+        }
+    }
+    // Dist-aware mode — when explicitly requested, also scan dist/*.js to
+    // pick up exports a declaration file omits.
+    if (input.distAware && consumerRoot) {
+        const distDir = nodePath.join(consumerRoot, 'node_modules', '@shrkcrft', 'plugin-api', 'dist');
+        if (existsSync(distDir)) {
+            for (const entry of safeReaddir(distDir)) {
+                if (!/\.(js|cjs|mjs)$/.test(entry))
+                    continue;
+                const full = nodePath.join(distDir, entry);
+                for (const s of collectJsExports(full))
+                    availableSet.add(s);
+                if (useTs) {
+                    for (const s of collectExportsTs(full, new Set()))
+                        availableSet.add(s);
+                }
+                filesInspected.push(full);
+            }
+            if (resolved.sourceMode === 'declaration')
+                usedMode = 'dist-js';
+        }
+    }
+    const importsByFile = [];
+    const symbolToFiles = new Map();
+    for (const file of listContributionFiles(packAbs)) {
+        const symbols = extractImports(file);
+        if (symbols.length === 0)
+            continue;
+        importsByFile.push({ file, importedSymbols: symbols });
+        for (const s of symbols) {
+            let list = symbolToFiles.get(s);
+            if (!list) {
+                list = new Set();
+                symbolToFiles.set(s, list);
+            }
+            list.add(file);
+        }
+    }
+    const findings = [];
+    for (const [symbol, files] of symbolToFiles) {
+        const status = availableSet.has(symbol) ? 'available' : 'missing';
+        findings.push({ symbol, files: [...files], status });
+    }
+    findings.sort((a, b) => a.symbol.localeCompare(b.symbol));
+    const missingSymbols = findings.filter((f) => f.status === 'missing').map((f) => f.symbol);
+    const suggestions = [];
+    if (missingSymbols.length === 0) {
+        if (resolved.resolution === 'not-found') {
+            suggestions.push('No installed @shrkcrft/plugin-api was found. Pass --consumer-root to point at the consumer workspace if symbols differ across versions.');
+        }
+    }
+    else {
+        suggestions.push(`Pack imports ${missingSymbols.length} symbol(s) that the consumer's @shrkcrft/plugin-api does not export.`);
+        suggestions.push(`1. Bump @shrkcrft/plugin-api in the consumer workspace to a version that exports ${missingSymbols
+            .slice(0, 4)
+            .map((s) => '`' + s + '`')
+            .join(', ')}${missingSymbols.length > 4 ? ', …' : ''}.`);
+        suggestions.push('2. Widen `peerDependencies."@shrkcrft/plugin-api"` only if those symbols are stable across the range.');
+        suggestions.push('3. Replace the helper imports with plain structural object literals (`export default ([...] as const)`).');
+        suggestions.push('4. Drop the import entirely if the helper is no longer needed by your contributions.');
+    }
+    return {
+        schema: PACK_SYMBOL_COMPAT_SCHEMA,
+        packPath: packAbs,
+        consumerRoot,
+        pluginApiSource: resolved.source || null,
+        pluginApiResolution: resolved.resolution,
+        availableSymbols: [...availableSet].sort(),
+        findings,
+        missingSymbols,
+        imports: importsByFile,
+        compatible: missingSymbols.length === 0,
+        suggestions,
+        sourceMode: usedMode,
+        confidence: confidenceFor(usedMode, availableSet.size),
+        filesInspected,
+    };
+}
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/pack-test-runner.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Pack test runner.
+ *
+ * Test case model: `definePackTest({ id, task, expect*Ids?, mustNotIncludeIds?, maxTokens? })`.
+ * Test cases live in either:
+ *   <packRoot>/sharkcraft/pack-tests.ts
+ *   <packRoot>/src/assets/pack-tests.ts
+ *
+ * The runner:
+ *   1. Loads the pack tests via dynamic import (Bun handles TS natively).
+ *   2. For each test case, builds a task packet against an isolated inspection.
+ *   3. Validates the packet contains every `expect*Ids` and none of the
+ *      `mustNotIncludeIds`, optionally capping the token budget.
+ *   4. Emits a structured diagnostic report.
+ */
+export interface IPackTestCase {
+    id: string;
+    task: string;
+    description?: string;
+    expectKnowledgeIds?: ReadonlyArray<string>;
+    expectRuleIds?: ReadonlyArray<string>;
+    expectTemplateIds?: ReadonlyArray<string>;
+    expectPipelineIds?: ReadonlyArray<string>;
+    expectPlaybookIds?: ReadonlyArray<string>;
+    expectConstructIds?: ReadonlyArray<string>;
+    mustNotIncludeIds?: ReadonlyArray<string>;
+    maxTokens?: number;
+}
+export declare function definePackTest<T extends IPackTestCase>(t: T): T;
+export interface IPackTestResult {
+    id: string;
+    task: string;
+    passed: boolean;
+    diagnostics: ReadonlyArray<{
+        code: 'missing-id' | 'unexpected-id' | 'token-budget' | 'load-error';
+        field?: string;
+        expected?: string;
+        actual?: string;
+        suggestion?: string;
+        message: string;
+    }>;
+    tokenEstimate?: number;
+}
+export interface IPackTestReport {
+    schema: 'sharkcraft.pack-test-report/v1';
+    packPath: string;
+    testsFile: string | null;
+    ran: number;
+    passed: number;
+    failed: number;
+    cases: ReadonlyArray<IPackTestResult>;
+}
+export declare function runPackTests(input: {
+    packPath: string;
+    caseId?: string;
+    updateSnapshots?: boolean;
+}): Promise<IPackTestReport>;
+export declare function renderPackTestReportText(report: IPackTestReport): string;
+//# sourceMappingURL=pack-test-runner.d.ts.map

package/dist/pack-test-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-test-runner.d.ts","sourceRoot":"","sources":["../src/pack-test-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,kBAAkB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAE/D;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,aAAa,CAAC;QACzB,IAAI,EAAE,YAAY,GAAG,eAAe,GAAG,cAAc,GAAG,YAAY,CAAC;QACrE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,gCAAgC,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;CACvC;AA4HD,wBAAsB,YAAY,CAAC,KAAK,EAAE;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,GAAG,OAAO,CAAC,eAAe,CAAC,CAgE3B;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAiBxE"}