@shrkcrft/inspector 0.1.0-alpha.1

package/dist/onboarding-agent-import.d.ts

@@ -0,0 +1,40 @@
+/**
+ * One entry as emitted into the imported-agent-rules draft. Strips importer
+ * machinery (KnowledgeType / KnowledgePriority enums) to plain strings that
+ * the draft renderer can splat into the generated TypeScript without
+ * needing to import importer types at runtime.
+ */
+export interface IDraftAgentEntry {
+    id: string;
+    type: string;
+    title: string;
+    content: string;
+    tags: readonly string[];
+    scope?: readonly string[];
+    source?: {
+        origin: string;
+    };
+    /** True when the importer flagged the bullet as ambiguous. */
+    flaggedAmbiguous?: boolean;
+}
+export interface IImportedAgentRulesBundle {
+    sourceFiles: readonly string[];
+    entries: readonly IDraftAgentEntry[];
+    warnings: readonly string[];
+    /** Per-source counts the report can echo back. */
+    perSource: readonly {
+        kind: 'agents-md' | 'claude-md' | 'cursor-rules';
+        path: string;
+        entryCount: number;
+    }[];
+}
+export interface IImportAgentRulesOptions {
+    projectRoot: string;
+}
+/**
+ * Probe AGENTS.md, CLAUDE.md, and .cursor/rules under projectRoot and return
+ * a single bundle the onboarding flow can render to a draft. Read-only:
+ * never writes a file.
+ */
+export declare function importAgentRulesForOnboarding(options: IImportAgentRulesOptions): IImportedAgentRulesBundle;
+//# sourceMappingURL=onboarding-agent-import.d.ts.map

package/dist/onboarding-agent-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-agent-import.d.ts","sourceRoot":"","sources":["../src/onboarding-agent-import.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5B,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACrC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,kDAAkD;IAClD,SAAS,EAAE,SAAS;QAClB,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC;QACjD,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;KACpB,EAAE,CAAC;CACL;AAED,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,wBAAwB,GAChC,yBAAyB,CA+D3B"}

package/dist/onboarding-agent-import.js

@@ -0,0 +1,114 @@
+import { existsSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { importAgentsMd, importClaudeMd, importCursorRules, } from '@shrkcrft/importer';
+/**
+ * Probe AGENTS.md, CLAUDE.md, and .cursor/rules under projectRoot and return
+ * a single bundle the onboarding flow can render to a draft. Read-only:
+ * never writes a file.
+ */
+export function importAgentRulesForOnboarding(options) {
+    const root = options.projectRoot;
+    const sourceFiles = [];
+    const entries = [];
+    const warnings = [];
+    const perSource = [];
+    // AGENTS.md
+    const agentsPath = nodePath.join(root, 'AGENTS.md');
+    if (existsSync(agentsPath)) {
+        const result = importAgentsMd({ filePath: agentsPath, projectRoot: root });
+        sourceFiles.push(...result.sourceFiles);
+        const mapped = result.entries.map((e) => toDraftEntry(e, 'agents-md'));
+        entries.push(...mapped);
+        for (const w of result.warnings)
+            warnings.push(formatWarning(w));
+        perSource.push({
+            kind: 'agents-md',
+            path: 'AGENTS.md',
+            entryCount: mapped.length,
+        });
+    }
+    // CLAUDE.md
+    const claudePath = nodePath.join(root, 'CLAUDE.md');
+    if (existsSync(claudePath)) {
+        const result = importClaudeMd({ filePath: claudePath, projectRoot: root });
+        sourceFiles.push(...result.sourceFiles);
+        const mapped = result.entries.map((e) => toDraftEntry(e, 'claude-md'));
+        entries.push(...mapped);
+        for (const w of result.warnings)
+            warnings.push(formatWarning(w));
+        perSource.push({
+            kind: 'claude-md',
+            path: 'CLAUDE.md',
+            entryCount: mapped.length,
+        });
+    }
+    // .cursor/rules — directory; the cursor importer walks the dir itself.
+    const cursorRoot = nodePath.join(root, '.cursor', 'rules');
+    if (existsSync(cursorRoot) && safeIsDir(cursorRoot)) {
+        const result = importCursorRules({
+            filePath: cursorRoot,
+            projectRoot: root,
+        });
+        sourceFiles.push(...result.sourceFiles);
+        const mapped = result.entries.map((e) => toDraftEntry(e, 'cursor-rules'));
+        entries.push(...mapped);
+        for (const w of result.warnings)
+            warnings.push(formatWarning(w));
+        perSource.push({
+            kind: 'cursor-rules',
+            path: '.cursor/rules',
+            entryCount: mapped.length,
+        });
+    }
+    return {
+        sourceFiles: dedupe(sourceFiles),
+        entries: dedupeById(entries),
+        warnings,
+        perSource,
+    };
+}
+// ── Helpers ──────────────────────────────────────────────────────────────
+function toDraftEntry(entry, source) {
+    const flaggedAmbiguous = (entry.importerNotes ?? []).some((n) => n.toLowerCase().includes('ambiguous'));
+    return {
+        id: prefixId(entry.id, source),
+        type: String(entry.type),
+        title: entry.title,
+        content: entry.content,
+        tags: [...new Set(['imported', source, ...entry.tags])],
+        ...(entry.origin ? { source: { origin: entry.origin } } : {}),
+        ...(flaggedAmbiguous ? { flaggedAmbiguous: true } : {}),
+    };
+}
+function prefixId(id, source) {
+    if (id.startsWith(`imported.${source}.`))
+        return id;
+    if (id.includes('.'))
+        return `imported.${source}.${id}`;
+    return `imported.${source}.${id}`;
+}
+function formatWarning(w) {
+    return `${w.origin}: ${w.message}`;
+}
+function dedupe(xs) {
+    return [...new Set(xs)];
+}
+function dedupeById(xs) {
+    const seen = new Set();
+    const out = [];
+    for (const e of xs) {
+        if (seen.has(e.id))
+            continue;
+        seen.add(e.id);
+        out.push(e);
+    }
+    return out;
+}
+function safeIsDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/onboarding-diff.d.ts

@@ -0,0 +1,39 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+import type { IOnboardingPlan } from './onboarding.js';
+export type DiffStatus = 'already-covered' | 'missing' | 'conflicting' | 'low-confidence-only';
+export interface IDiffEntry {
+    id: string;
+    status: DiffStatus;
+    /** Short description of what this entry would add. */
+    summary: string;
+    /** Optional manual merge hint (e.g. file to edit). */
+    mergeHint?: string;
+}
+export interface IDiffCategory {
+    /** Category name shown in the report. */
+    name: string;
+    entries: readonly IDiffEntry[];
+    counts: {
+        alreadyCovered: number;
+        missing: number;
+        conflicting: number;
+        lowConfidenceOnly: number;
+    };
+}
+export interface IOnboardingDiff {
+    rules: IDiffCategory;
+    paths: IDiffCategory;
+    templates: IDiffCategory;
+    pipelines: IDiffCategory;
+    boundaries: IDiffCategory;
+    verificationCommands: IDiffCategory;
+    /** Suggested manual steps the user can run to adopt the missing entries. */
+    manualMergeSteps: readonly string[];
+}
+/**
+ * Compare the inferred plan against the live SharkCraft configuration.
+ * Does NOT mutate anything. The output is intended for the `--diff` CLI flag.
+ */
+export declare function buildOnboardingDiff(inspection: ISharkcraftInspection, plan: IOnboardingPlan): IOnboardingDiff;
+export declare function renderOnboardingDiff(diff: IOnboardingDiff): string;
+//# sourceMappingURL=onboarding-diff.d.ts.map

package/dist/onboarding-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-diff.d.ts","sourceRoot":"","sources":["../src/onboarding-diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,MAAM,UAAU,GAAG,iBAAiB,GAAG,SAAS,GAAG,aAAa,GAAG,qBAAqB,CAAC;AAE/F,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,UAAU,CAAC;IACnB,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAC/B,MAAM,EAAE;QACN,cAAc,EAAE,MAAM,CAAC;QACvB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,aAAa,CAAC;IACzB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,oBAAoB,EAAE,aAAa,CAAC;IACpC,4EAA4E;IAC5E,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,eAAe,GACpB,eAAe,CAkKjB;AAiDD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CA0ClE"}

package/dist/onboarding-diff.js

@@ -0,0 +1,240 @@
+/**
+ * Compare the inferred plan against the live SharkCraft configuration.
+ * Does NOT mutate anything. The output is intended for the `--diff` CLI flag.
+ */
+export function buildOnboardingDiff(inspection, plan) {
+    // ── Rules ─────────────────────────────────────────────────────────────
+    const liveRuleIds = new Set(inspection.ruleService.list().map((r) => r.id));
+    const rulesEntries = [];
+    for (const r of plan.inferredRules) {
+        if (liveRuleIds.has(r.id)) {
+            rulesEntries.push({
+                id: r.id,
+                status: 'already-covered',
+                summary: `Rule ${r.id} already present in sharkcraft/rules.ts.`,
+            });
+        }
+        else {
+            rulesEntries.push({
+                id: r.id,
+                status: 'missing',
+                summary: `${r.priority} priority — ${r.title}`,
+                mergeHint: 'Copy keepers from sharkcraft/onboarding/inferred-rules.draft.ts into sharkcraft/rules.ts.',
+            });
+        }
+    }
+    // ── Paths ─────────────────────────────────────────────────────────────
+    const livePathIds = new Set(inspection.pathService.list().map((p) => p.id));
+    const pathsEntries = [];
+    for (const p of plan.inferredPathConventions) {
+        if (livePathIds.has(p.id)) {
+            pathsEntries.push({
+                id: p.id,
+                status: 'already-covered',
+                summary: `Path convention ${p.id} already present.`,
+            });
+        }
+        else {
+            pathsEntries.push({
+                id: p.id,
+                status: 'missing',
+                summary: p.title,
+                mergeHint: 'Add to sharkcraft/paths.ts from the draft.',
+            });
+        }
+    }
+    // ── Templates ─────────────────────────────────────────────────────────
+    const liveTemplateIds = new Set(inspection.templateRegistry.list().map((t) => t.id));
+    const templatesEntries = [];
+    for (const t of plan.inferredTemplateCandidates) {
+        // High-confidence templates with scaffolds are "missing" candidates.
+        // Low-confidence templates without scaffolds are flagged as such.
+        const live = liveTemplateIds.has(t.id) || liveTemplateIds.has(t.scaffold?.id ?? '');
+        if (live) {
+            templatesEntries.push({
+                id: t.id,
+                status: 'already-covered',
+                summary: `Template ${t.id} already registered.`,
+            });
+        }
+        else if (t.confidence === 'low' && !t.scaffold) {
+            templatesEntries.push({
+                id: t.id,
+                status: 'low-confidence-only',
+                summary: `${t.name} — only ${t.reason}; not promoted.`,
+                mergeHint: 'Add another sample file or scaffold manually before promoting.',
+            });
+        }
+        else {
+            templatesEntries.push({
+                id: t.id,
+                status: 'missing',
+                summary: t.scaffold
+                    ? `${t.name} scaffold available in inferred-templates.draft.ts (${t.confidence} confidence).`
+                    : `${t.name} candidate — fill in body before adopting.`,
+                mergeHint: t.scaffold
+                    ? 'Move scaffold.content into sharkcraft/templates.ts via defineTemplate().'
+                    : 'Re-run `shrk onboard --write-drafts --scaffold-templates` to draft the body.',
+            });
+        }
+    }
+    // ── Pipelines ─────────────────────────────────────────────────────────
+    const livePipelineIds = new Set(inspection.pipelineRegistry.list().map((p) => p.id));
+    const pipelinesEntries = [];
+    for (const p of plan.inferredPipelines) {
+        if (livePipelineIds.has(p.id)) {
+            pipelinesEntries.push({
+                id: p.id,
+                status: 'already-covered',
+                summary: `Pipeline ${p.id} already present.`,
+            });
+        }
+        else {
+            pipelinesEntries.push({
+                id: p.id,
+                status: 'missing',
+                summary: p.title,
+                mergeHint: 'Add to sharkcraft/pipelines.ts via definePipeline().',
+            });
+        }
+    }
+    // ── Boundary rules ────────────────────────────────────────────────────
+    const liveBoundaryIds = new Set(inspection.boundaryRegistry.list().map((b) => b.id));
+    const boundariesEntries = [];
+    for (const b of plan.inferredBoundaryRules) {
+        if (liveBoundaryIds.has(b.id)) {
+            boundariesEntries.push({
+                id: b.id,
+                status: 'already-covered',
+                summary: `Boundary rule ${b.id} already registered.`,
+            });
+        }
+        else {
+            boundariesEntries.push({
+                id: b.id,
+                status: 'missing',
+                summary: b.title,
+                mergeHint: 'Add the rule to sharkcraft/boundaries.ts (or your pack) and register via boundaryFiles.',
+            });
+        }
+    }
+    // ── Verification commands ─────────────────────────────────────────────
+    const liveVerificationIds = collectLiveVerificationIds(inspection);
+    const verificationEntries = [];
+    for (const v of plan.inferredVerificationCommands) {
+        if (liveVerificationIds.has(v.id)) {
+            verificationEntries.push({
+                id: v.id,
+                status: 'already-covered',
+                summary: `Verification "${v.id}" already configured.`,
+            });
+        }
+        else {
+            verificationEntries.push({
+                id: v.id,
+                status: 'missing',
+                summary: `${v.label} (${v.command})`,
+                mergeHint: 'Add to sharkcraft.config.ts verificationCommands[] to make it trusted for `apply --validate`.',
+            });
+        }
+    }
+    const manualMergeSteps = buildManualMergeSteps([
+        { name: 'rules', entries: rulesEntries },
+        { name: 'paths', entries: pathsEntries },
+        { name: 'templates', entries: templatesEntries },
+        { name: 'pipelines', entries: pipelinesEntries },
+        { name: 'boundaries', entries: boundariesEntries },
+        { name: 'verification commands', entries: verificationEntries },
+    ]);
+    return {
+        rules: toCategory('Rules', rulesEntries),
+        paths: toCategory('Path conventions', pathsEntries),
+        templates: toCategory('Templates', templatesEntries),
+        pipelines: toCategory('Pipelines', pipelinesEntries),
+        boundaries: toCategory('Boundary rules', boundariesEntries),
+        verificationCommands: toCategory('Verification commands', verificationEntries),
+        manualMergeSteps,
+    };
+}
+function toCategory(name, entries) {
+    const counts = {
+        alreadyCovered: 0,
+        missing: 0,
+        conflicting: 0,
+        lowConfidenceOnly: 0,
+    };
+    for (const e of entries) {
+        if (e.status === 'already-covered')
+            counts.alreadyCovered += 1;
+        else if (e.status === 'missing')
+            counts.missing += 1;
+        else if (e.status === 'conflicting')
+            counts.conflicting += 1;
+        else if (e.status === 'low-confidence-only')
+            counts.lowConfidenceOnly += 1;
+    }
+    return { name, entries, counts };
+}
+function collectLiveVerificationIds(inspection) {
+    const out = new Set();
+    const cfg = inspection.config;
+    for (const vc of cfg?.verificationCommands ?? []) {
+        if (typeof vc?.id === 'string')
+            out.add(vc.id);
+    }
+    return out;
+}
+function buildManualMergeSteps(categories) {
+    const out = [];
+    for (const c of categories) {
+        const missing = c.entries.filter((e) => e.status === 'missing').length;
+        if (missing > 0) {
+            out.push(`Review ${missing} missing ${c.name} entr${missing === 1 ? 'y' : 'ies'} in the draft and copy keepers into the live config.`);
+        }
+    }
+    if (out.length === 0) {
+        out.push('No missing entries — the live config already covers the inferred plan.');
+    }
+    return out;
+}
+export function renderOnboardingDiff(diff) {
+    const out = [];
+    out.push('# SharkCraft onboarding diff');
+    out.push('');
+    out.push('Compares the inferred plan against the live SharkCraft config. Nothing is changed.');
+    out.push('');
+    for (const cat of [
+        diff.rules,
+        diff.paths,
+        diff.templates,
+        diff.pipelines,
+        diff.boundaries,
+        diff.verificationCommands,
+    ]) {
+        out.push(`## ${cat.name}`);
+        out.push('');
+        out.push(`- already covered: ${cat.counts.alreadyCovered}` +
+            `, missing: ${cat.counts.missing}` +
+            `, low-confidence only: ${cat.counts.lowConfidenceOnly}` +
+            `, conflicting: ${cat.counts.conflicting}`);
+        out.push('');
+        if (cat.entries.length === 0) {
+            out.push('_No entries._');
+            out.push('');
+            continue;
+        }
+        for (const e of cat.entries) {
+            out.push(`- **${e.id}** — ${e.status}`);
+            out.push(`  - ${e.summary}`);
+            if (e.mergeHint)
+                out.push(`  - hint: ${e.mergeHint}`);
+        }
+        out.push('');
+    }
+    out.push('## Suggested manual merge steps');
+    out.push('');
+    for (const s of diff.manualMergeSteps)
+        out.push(`- ${s}`);
+    out.push('');
+    return out.join('\n');
+}

package/dist/onboarding-drafts-merge.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Three-way merge for onboarding drafts.
+ *
+ * When `shrk onboard --write-drafts` re-runs against a project that has
+ * hand-edited drafts, the safe behaviour is to merge the new proposal
+ * against the user's current file and the snapshot we wrote last time:
+ *
+ *   - base    : `.sharkcraft/onboarding-drafts-snapshots/<file>` (what we
+ *               wrote last). When absent, the merge degrades to a strict
+ *               "matches proposal → no-op, otherwise conflict" rule.
+ *   - ours    : the current `sharkcraft/onboarding/<file>` content.
+ *   - theirs  : the freshly rendered proposal we are about to write.
+ *
+ * The merge always returns an intended `body`. The caller decides whether
+ * to write it (e.g. `abortOnConflict` keeps the file unchanged).
+ */
+export declare enum DraftMergeStatus {
+    /** File did not exist; the proposal was written verbatim. */
+    Created = "created",
+    /** Current file already matches the proposal — nothing to do. */
+    Unchanged = "unchanged",
+    /** Current file matches the snapshot; the proposal was applied. */
+    CleanUpdate = "clean-update",
+    /** Proposal matches the snapshot; the user's edits were kept. */
+    UserKept = "user-kept",
+    /** Disjoint single-region edits on both sides; auto-merged. */
+    AutoMerged = "auto-merged",
+    /** Both sides changed the same region — conflict markers emitted. */
+    Conflict = "conflict",
+    /** Both sides changed but `abortOnConflict` was set — file untouched. */
+    Aborted = "aborted"
+}
+export interface IDraftMergeOptions {
+    /** When true, return status=Aborted and leave the file unchanged on conflict. */
+    abortOnConflict?: boolean;
+    /** Header line in the `<<<<<<< ours` marker. Default 'ours'. */
+    oursLabel?: string;
+    /** Header line in the `>>>>>>> theirs` marker. Default 'incoming proposal'. */
+    theirsLabel?: string;
+}
+export interface IDraftMergeResult {
+    status: DraftMergeStatus;
+    /** What should be written. For Aborted, this is the unchanged `ours`. */
+    body: string;
+    /** Number of conflict regions in `body` (0 unless status=Conflict). */
+    conflictRegions: number;
+}
+/**
+ * Resolve the snapshot path for a given draft file.
+ *
+ * @param projectRoot Absolute repo root.
+ * @param draftPath   Absolute path of the draft file.
+ */
+export declare function snapshotPathFor(projectRoot: string, draftPath: string): string;
+export declare function readSnapshot(snapshotPath: string): string | null;
+export declare function writeSnapshot(snapshotPath: string, body: string): void;
+/**
+ * Three-way merge a single draft file.
+ *
+ * Truth table:
+ *   - !exists(ours)           → Created (body = theirs)
+ *   - ours === theirs         → Unchanged
+ *   - base === null:
+ *       - ours === theirs     → Unchanged
+ *       - otherwise           → Conflict (or Aborted)
+ *   - ours === base           → CleanUpdate (body = theirs)
+ *   - theirs === base         → UserKept (body = ours)
+ *   - otherwise               → diff3Lines → AutoMerged | Conflict | Aborted
+ */
+export declare function threeWayMergeDraft(base: string | null, ours: string | null, theirs: string, options?: IDraftMergeOptions): IDraftMergeResult;
+//# sourceMappingURL=onboarding-drafts-merge.d.ts.map

package/dist/onboarding-drafts-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-drafts-merge.d.ts","sourceRoot":"","sources":["../src/onboarding-drafts-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,oBAAY,gBAAgB;IAC1B,6DAA6D;IAC7D,OAAO,YAAY;IACnB,iEAAiE;IACjE,SAAS,cAAc;IACvB,mEAAmE;IACnE,WAAW,iBAAiB;IAC5B,iEAAiE;IACjE,QAAQ,cAAc;IACtB,+DAA+D;IAC/D,UAAU,gBAAgB;IAC1B,qEAAqE;IACrE,QAAQ,aAAa;IACrB,yEAAyE;IACzE,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,iFAAiF;IACjF,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,gBAAgB,CAAC;IACzB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG9E;AAED,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOhE;AAED,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAGtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB,CAiBnB"}