@remix-run/cli 0.0.0 → 0.1.0

package/dist/lib/reporter.js

@@ -0,0 +1,357 @@
+import * as process from 'node:process';
+import { bold, canUseAnsi, clearCurrentLine, lightGray, lightGreen, lightRed, lightYellow, remixWordmark, } from "./terminal.js";
+const BULLET = '•';
+const DOT_FRAMES = ['.', '..', '...'];
+const DEFAULT_INDENT = '  ';
+const DEFAULT_STATUS_FRAME_INTERVAL_MS = 250;
+export function createCommandReporter(options = {}) {
+    let stdout = options.stdout ?? process.stdout;
+    let stderr = options.stderr ?? process.stderr;
+    let session = new ReporterSessionState();
+    let states = new Map();
+    let getState = (stream) => {
+        let state = states.get(stream);
+        if (state != null) {
+            return state;
+        }
+        state = new ReporterStreamState(stream, session);
+        states.set(stream, state);
+        return state;
+    };
+    return {
+        finish() {
+            for (let state of states.values()) {
+                state.finish();
+            }
+        },
+        out: new ReporterTextChannel(stdout, getState(stdout)),
+        status: new ReporterStatusChannel(stderr, getState(stderr), options.statusFrameIntervalMs ?? DEFAULT_STATUS_FRAME_INTERVAL_MS, options.remixVersion),
+    };
+}
+export function createStepProgressReporter(status, labels) {
+    return {
+        fail(step) {
+            status.failStep(getCompleteLabel(labels[step]));
+        },
+        skip(step, reason) {
+            status.skipStep(getCompleteLabel(labels[step]), reason);
+        },
+        start(step) {
+            status.startStep(getRunningLabel(labels[step]));
+        },
+        succeed(step) {
+            status.succeedStep(getCompleteLabel(labels[step]));
+        },
+        writeSummaryGap() {
+            status.summaryGap();
+        },
+    };
+}
+export async function runProgressStep(progress, step, callback) {
+    progress?.start(step);
+    try {
+        let result = await callback();
+        progress?.succeed(step);
+        return result;
+    }
+    catch (error) {
+        progress?.fail(step);
+        throw error;
+    }
+}
+class ReporterTextChannel {
+    #indentLevel = 0;
+    #state;
+    #stream;
+    constructor(stream, state) {
+        this.#stream = stream;
+        this.#state = state;
+    }
+    blank() {
+        if (!this.#state.hasWrittenContent()) {
+            return;
+        }
+        this.#state.queueBlank();
+    }
+    bullet(text) {
+        this.line(`${BULLET} ${text}`);
+    }
+    bullets(items) {
+        for (let item of items) {
+            this.bullet(item);
+        }
+    }
+    dedent() {
+        this.#indentLevel = Math.max(0, this.#indentLevel - 1);
+    }
+    indent() {
+        this.#indentLevel += 1;
+    }
+    label(tag, text, options) {
+        let line = text.length === 0 ? formatLabel(tag) : `${formatLabel(tag)} ${text}`;
+        if (options?.tone === 'warn') {
+            return lightYellow(line, this.#stream);
+        }
+        if (options?.tone === 'error') {
+            return lightRed(line, this.#stream);
+        }
+        return line;
+    }
+    line(text = '') {
+        if (text.length === 0) {
+            this.blank();
+            return;
+        }
+        this.#flushPendingBlank();
+        this.#write(`${this.#getIndent()}${text}\n`);
+    }
+    section(title, callback) {
+        this.line(title);
+        if (callback == null) {
+            return;
+        }
+        this.withIndent(callback);
+    }
+    table({ formatRow, headers, noHeaders = false, rows }) {
+        let columnCount = Math.max(headers.length, ...rows.map((row) => row.length));
+        let widths = Array.from({ length: columnCount }, (_, columnIndex) => {
+            let headerWidth = headers[columnIndex]?.length ?? 0;
+            let rowWidth = rows.reduce((width, row) => Math.max(width, row[columnIndex]?.length ?? 0), 0);
+            return Math.max(headerWidth, rowWidth);
+        });
+        if (!noHeaders) {
+            this.line(headers
+                .map((header, columnIndex) => bold(header.padEnd(widths[columnIndex] ?? header.length), this.#stream))
+                .join('  '));
+        }
+        rows.forEach((row, rowIndex) => {
+            let line = row
+                .map((cell, columnIndex) => cell.padEnd(widths[columnIndex] ?? cell.length))
+                .join('  ');
+            this.line(formatRow == null ? line : formatRow(line, rowIndex));
+        });
+    }
+    withIndent(callback) {
+        this.indent();
+        try {
+            return callback();
+        }
+        finally {
+            this.dedent();
+        }
+    }
+    getStream() {
+        return this.#stream;
+    }
+    writeImmediate(text) {
+        this.#state.writeImmediate(text);
+    }
+    getIndentText() {
+        return this.#getIndent();
+    }
+    #flushPendingBlank() {
+        this.#state.flushPendingBlank();
+    }
+    #getIndent() {
+        return DEFAULT_INDENT.repeat(this.#indentLevel);
+    }
+    #write(text) {
+        this.#state.write(text);
+    }
+}
+class ReporterStatusChannel extends ReporterTextChannel {
+    #activeLabel = null;
+    #activeTimer = null;
+    #frameIndex = 0;
+    #frameIntervalMs;
+    #hasRenderedStep = false;
+    #hasWrittenSummaryGap = false;
+    #remixVersion;
+    constructor(stream, state, frameIntervalMs, remixVersion) {
+        super(stream, state);
+        this.#frameIntervalMs = frameIntervalMs;
+        this.#remixVersion = remixVersion;
+    }
+    async commandHeader(commandLabel) {
+        if (!this.getStream().isTTY || this.#remixVersion == null) {
+            return;
+        }
+        this.writeImmediate(`${remixWordmark(this.getStream())} v${this.#remixVersion} - ${commandLabel}\n\n`);
+    }
+    failStep(label = this.#activeLabel ?? '') {
+        this.#stopAnimation();
+        this.#activeLabel = null;
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatFailedLine(label));
+    }
+    skipStep(label, reason) {
+        this.#stopAnimation();
+        if (this.#activeLabel === label) {
+            this.#activeLabel = null;
+        }
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatSkippedLine(label, reason));
+    }
+    startStep(label) {
+        this.#stopAnimation();
+        this.#activeLabel = label;
+        this.#noteStepOutput();
+        if (this.#isInteractive()) {
+            this.#frameIndex = 0;
+            this.writeImmediate(this.#renderLiveLine(this.#formatRunningLine(label, DOT_FRAMES[0])));
+            this.#activeTimer = setInterval(() => {
+                if (this.#activeLabel == null) {
+                    return;
+                }
+                this.#frameIndex = (this.#frameIndex + 1) % DOT_FRAMES.length;
+                this.writeImmediate(this.#renderLiveLine(this.#formatRunningLine(this.#activeLabel, DOT_FRAMES[this.#frameIndex])));
+            }, this.#frameIntervalMs);
+            this.#activeTimer.unref?.();
+            return;
+        }
+        this.writeImmediate(`${this.#formatRunningLine(label, '...')}\n`);
+    }
+    succeedStep(label = this.#activeLabel ?? '') {
+        this.#stopAnimation();
+        this.#activeLabel = null;
+        this.#noteStepOutput();
+        this.#writeFinalLine(this.#formatSucceededLine(label));
+    }
+    summaryGap() {
+        if (!this.#hasRenderedStep || this.#hasWrittenSummaryGap) {
+            return;
+        }
+        this.writeImmediate('\n');
+        this.#hasWrittenSummaryGap = true;
+    }
+    #formatFailedLine(label) {
+        return `${this.getIndentText()}${lightRed('✗', this.getStream())} ${lightGray(label, this.getStream())}`;
+    }
+    #formatRunningLine(label, dots) {
+        return lightGray(`${this.getIndentText()}${BULLET} ${label}${dots}`, this.getStream());
+    }
+    #formatSkippedLine(label, reason) {
+        let line = reason == null ? `${BULLET} ${label}` : `${BULLET} ${label} (skipped: ${reason})`;
+        return lightGray(`${this.getIndentText()}${line}`, this.getStream());
+    }
+    #formatSucceededLine(label) {
+        return `${this.getIndentText()}${lightGreen('✓', this.getStream())} ${lightGray(label, this.getStream())}`;
+    }
+    #isInteractive() {
+        return canUseAnsi(this.getStream());
+    }
+    #noteStepOutput() {
+        this.#hasRenderedStep = true;
+        this.#hasWrittenSummaryGap = false;
+    }
+    #renderLiveLine(line) {
+        return `${clearCurrentLine()}${line}`;
+    }
+    #stopAnimation() {
+        if (this.#activeTimer != null) {
+            clearInterval(this.#activeTimer);
+            this.#activeTimer = null;
+        }
+    }
+    #writeFinalLine(line) {
+        if (this.#isInteractive()) {
+            this.writeImmediate(`${this.#renderLiveLine(line)}\n`);
+            return;
+        }
+        this.writeImmediate(`${line}\n`);
+    }
+}
+class ReporterStreamState {
+    #hasWrittenContent = false;
+    #pendingBlank = false;
+    #session;
+    #stream;
+    #trailingNewlineCount = 0;
+    constructor(stream, session) {
+        this.#session = session;
+        this.#stream = stream;
+    }
+    finish() {
+        if (!this.#hasWrittenContent) {
+            return;
+        }
+        if (this.#trailingNewlineCount >= 2) {
+            return;
+        }
+        this.#writeRaw('\n');
+        this.#pendingBlank = false;
+    }
+    flushPendingBlank() {
+        if (!this.#pendingBlank) {
+            return;
+        }
+        this.#writeRaw('\n');
+        this.#pendingBlank = false;
+    }
+    hasWrittenContent() {
+        return this.#hasWrittenContent;
+    }
+    queueBlank() {
+        this.#pendingBlank = true;
+    }
+    write(text) {
+        if (!this.#session.hasWrittenPreamble()) {
+            this.#writeRaw('\n');
+            this.#session.markPreambleWritten();
+        }
+        this.#writeRaw(text);
+        this.#hasWrittenContent = true;
+    }
+    writeImmediate(text) {
+        if (!this.#session.hasWrittenPreamble()) {
+            this.#writeRaw('\n');
+            this.#session.markPreambleWritten();
+        }
+        this.#writeRaw(text);
+        this.#hasWrittenContent = true;
+        this.#pendingBlank = false;
+    }
+    #writeRaw(text) {
+        this.#stream.write(text);
+        this.#updateTrailingNewlines(text);
+    }
+    #updateTrailingNewlines(text) {
+        let trailingNewlines = 0;
+        for (let index = text.length - 1; index >= 0; index--) {
+            if (text[index] !== '\n') {
+                break;
+            }
+            trailingNewlines += 1;
+        }
+        if (trailingNewlines === 0) {
+            this.#trailingNewlineCount = 0;
+            return;
+        }
+        if (trailingNewlines === text.length) {
+            this.#trailingNewlineCount += trailingNewlines;
+            return;
+        }
+        this.#trailingNewlineCount = trailingNewlines;
+    }
+}
+class ReporterSessionState {
+    #hasWrittenPreamble = false;
+    hasWrittenPreamble() {
+        return this.#hasWrittenPreamble;
+    }
+    markPreambleWritten() {
+        this.#hasWrittenPreamble = true;
+    }
+}
+function formatLabel(tag) {
+    if (tag.startsWith('[') && tag.endsWith(']')) {
+        return tag;
+    }
+    return `[${tag}]`;
+}
+function getCompleteLabel(label) {
+    return typeof label === 'string' ? label : label.complete;
+}
+function getRunningLabel(label) {
+    return typeof label === 'string' ? label : (label.running ?? label.complete);
+}

package/dist/lib/route-map.d.ts

@@ -0,0 +1,38 @@
+export type RouteOwnerKind = 'action' | 'controller';
+export type RouteTreeNodeKind = 'group' | 'route';
+export interface RouteTreeOwner {
+    exists: boolean;
+    kind: RouteOwnerKind;
+    path: string;
+}
+export interface RouteTreeNode {
+    children: RouteTreeNode[];
+    key: string;
+    kind: RouteTreeNodeKind;
+    method?: string;
+    name: string;
+    owner: RouteTreeOwner;
+    pattern?: string;
+}
+export interface LoadedRouteMap {
+    appRoot: string;
+    routesFile: string;
+    tree: RouteTreeNode[];
+}
+export interface LoadedRouteManifest {
+    appRoot: string;
+    routesFile: string;
+    tree: RawRouteTreeNode[];
+}
+export interface RawRouteTreeNode {
+    children: RawRouteTreeNode[];
+    key: string;
+    kind: RouteTreeNodeKind;
+    method?: string;
+    name: string;
+    pattern?: string;
+}
+export declare function loadRouteMap(cwd?: string): Promise<LoadedRouteMap>;
+export declare function loadRouteManifest(cwd?: string): Promise<LoadedRouteManifest>;
+export declare function loadRouteManifestFromAppRoot(appRoot: string): Promise<LoadedRouteManifest>;
+//# sourceMappingURL=route-map.d.ts.map

package/dist/lib/route-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-map.d.ts","sourceRoot":"","sources":["../../src/lib/route-map.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,YAAY,CAAA;AACpD,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAA;AAEjD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,cAAc,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,aAAa,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,gBAAgB,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,wBAAsB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,cAAc,CAAC,CAUvF;AAED,wBAAsB,iBAAiB,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAGjG;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAShG"}

package/dist/lib/route-map.js

@@ -0,0 +1,195 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { inspectControllerOwnership } from "./controller-ownership.js";
+import { routeMapLoaderFailed, routeMapLoaderInvalidJson, routeMapLoaderSignal, routeOwnerPlanUnresolved, routesFileNotFound, } from "./errors.js";
+export async function loadRouteMap(cwd = process.cwd()) {
+    let manifest = await loadRouteManifest(cwd);
+    let ownership = await inspectControllerOwnership(manifest.appRoot, manifest.tree);
+    let tree = decorateRouteTree(manifest.tree, ownership.subtrees);
+    return {
+        appRoot: manifest.appRoot,
+        routesFile: manifest.routesFile,
+        tree,
+    };
+}
+export async function loadRouteManifest(cwd = process.cwd()) {
+    let appRoot = await findRemixAppRoot(cwd);
+    return loadRouteManifestFromAppRoot(appRoot);
+}
+export async function loadRouteManifestFromAppRoot(appRoot) {
+    let routesFile = path.join(appRoot, 'app', 'routes.ts');
+    let tree = await loadRawRouteMap(appRoot, routesFile);
+    return {
+        appRoot,
+        routesFile,
+        tree,
+    };
+}
+async function loadRawRouteMap(appRoot, routesFile) {
+    let workerPath = getRouteMapWorkerPath();
+    let child = spawn(process.execPath, [workerPath, routesFile], {
+        cwd: appRoot,
+        env: createRouteMapWorkerEnv(),
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    let exitResult = await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            resolve({ code, signal });
+        });
+    });
+    if (exitResult.signal != null) {
+        throw routeMapLoaderSignal(exitResult.signal);
+    }
+    if (exitResult.code !== 0) {
+        let message = stderr.trim();
+        if (message.length === 0) {
+            message = 'Route-map loader failed.';
+        }
+        throw routeMapLoaderFailed(message);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw routeMapLoaderInvalidJson();
+    }
+    return assertRawRouteTree(parsed);
+}
+function decorateRouteTree(rawTree, subtrees, parentSegments = []) {
+    let subtreesByRouteName = new Map(subtrees.map((subtree) => [subtree.routeName, subtree]));
+    return decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments);
+}
+function decorateRouteTreeWithLookup(rawTree, subtreesByRouteName, parentSegments = []) {
+    return rawTree.map((rawNode) => {
+        let owner = getRouteOwner(rawNode, parentSegments, subtreesByRouteName);
+        let nextParentSegments = rawNode.kind === 'group' ? [...parentSegments, rawNode.key] : parentSegments;
+        return {
+            children: rawNode.kind === 'group'
+                ? decorateRouteTreeWithLookup(rawNode.children, subtreesByRouteName, nextParentSegments)
+                : [],
+            key: rawNode.key,
+            kind: rawNode.kind,
+            method: rawNode.method,
+            name: rawNode.name,
+            owner,
+            pattern: rawNode.pattern,
+        };
+    });
+}
+function getRouteOwner(rawNode, parentSegments, subtreesByRouteName) {
+    let ownerRouteName = rawNode.kind === 'group'
+        ? rawNode.name
+        : parentSegments.length === 0
+            ? rawNode.name
+            : parentSegments.join('.');
+    let subtree = subtreesByRouteName.get(ownerRouteName);
+    if (subtree == null) {
+        throw routeOwnerPlanUnresolved(rawNode.name);
+    }
+    return {
+        exists: subtree.actualEntryPath != null,
+        kind: subtree.kind,
+        path: subtree.actualEntryPath ?? subtree.entryDisplayPath,
+    };
+}
+function assertRawRouteTree(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Route-map loader returned an invalid tree.');
+    }
+    return value.map((entry) => assertRawRouteTreeNode(entry));
+}
+function assertRawRouteTreeNode(value) {
+    if (typeof value !== 'object' || value == null) {
+        throw new Error('Route-map loader returned an invalid route node.');
+    }
+    let key = Reflect.get(value, 'key');
+    let name = Reflect.get(value, 'name');
+    let kind = Reflect.get(value, 'kind');
+    let children = Reflect.get(value, 'children');
+    if (typeof key !== 'string' || typeof name !== 'string') {
+        throw new Error('Route-map loader returned a route node without a valid name.');
+    }
+    if (kind !== 'group' && kind !== 'route') {
+        throw new Error(`Route-map loader returned an unknown node kind for "${name}".`);
+    }
+    if (!Array.isArray(children)) {
+        throw new Error(`Route-map loader returned invalid children for "${name}".`);
+    }
+    if (kind === 'group') {
+        return {
+            children: children.map((child) => assertRawRouteTreeNode(child)),
+            key,
+            kind,
+            name,
+        };
+    }
+    let method = Reflect.get(value, 'method');
+    let pattern = Reflect.get(value, 'pattern');
+    if (typeof method !== 'string' || typeof pattern !== 'string') {
+        throw new Error(`Route-map loader returned an invalid route leaf for "${name}".`);
+    }
+    return {
+        children: [],
+        key,
+        kind,
+        method,
+        name,
+        pattern,
+    };
+}
+async function findRemixAppRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(currentDir, 'app', 'routes.ts'))) {
+            return currentDir;
+        }
+        let parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw routesFileNotFound(startDir);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function getRouteMapWorkerPath() {
+    let currentFilePath = fileURLToPath(import.meta.url);
+    let extension = currentFilePath.endsWith('.ts') ? '.ts' : '.js';
+    return fileURLToPath(new URL(`./load-route-map-worker${extension}`, import.meta.url));
+}
+function createRouteMapWorkerEnv() {
+    let env = { ...process.env };
+    for (let key of Object.keys(env)) {
+        if (key.startsWith('NODE_TEST_')) {
+            delete env[key];
+        }
+    }
+    return env;
+}

package/dist/lib/skills-cache.d.ts

@@ -0,0 +1,19 @@
+export interface SkillsCacheFileEntry {
+    localHash: string;
+    remoteSha: string;
+}
+export interface SkillsCacheSkillEntry {
+    files: Record<string, SkillsCacheFileEntry>;
+}
+export interface SkillsCacheManifest {
+    ref: string;
+    repo: string;
+    skills: Record<string, SkillsCacheSkillEntry>;
+    skillsDir: string;
+    version: number;
+}
+export declare function createSkillsCacheManifest(skillsDir: string, skills: Record<string, SkillsCacheSkillEntry>): SkillsCacheManifest;
+export declare function getSkillsCacheFilePath(skillsDir: string): string;
+export declare function readSkillsCache(skillsDir: string): Promise<SkillsCacheManifest | null>;
+export declare function writeSkillsCache(skillsDir: string, manifest: SkillsCacheManifest): Promise<void>;
+//# sourceMappingURL=skills-cache.d.ts.map

package/dist/lib/skills-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills-cache.d.ts","sourceRoot":"","sources":["../../src/lib/skills-cache.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;CAC5C;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAA;IAC7C,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC5C,mBAAmB,CAQrB;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAiB5F;AAED,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAOf"}