fln 1.0.0

package/dist/infra/countTokens.js

@@ -0,0 +1,186 @@
+var CharCategory;
+(function (CharCategory) {
+    CharCategory[CharCategory["Other"] = 0] = "Other";
+    CharCategory[CharCategory["Whitespace"] = 1] = "Whitespace";
+    CharCategory[CharCategory["Digit"] = 2] = "Digit";
+    CharCategory[CharCategory["Latin"] = 3] = "Latin";
+    CharCategory[CharCategory["Cyrillic"] = 4] = "Cyrillic";
+    CharCategory[CharCategory["Arabic"] = 5] = "Arabic";
+    CharCategory[CharCategory["CJK"] = 6] = "CJK";
+    CharCategory[CharCategory["Punctuation"] = 7] = "Punctuation";
+})(CharCategory || (CharCategory = {}));
+const CYRILLIC_CHARS_PER_TOKEN = 3.3;
+const ARABIC_CHARS_PER_TOKEN = 2.7;
+const LATIN_CHARS_PER_TOKEN = 4.7;
+const CYR_START = 0x0400;
+const CYR_END = 0x04FF;
+const ARABIC_START = 0x0600;
+const ARABIC_END = 0x06FF;
+const CJK_MAIN_START = 0x4E00;
+const CJK_MAIN_END = 0x9FFF;
+const KANA_START = 0x3040;
+const KANA_END = 0x30FF;
+const SURROGATE_HIGH_START = 0xD800;
+const SURROGATE_HIGH_END = 0xDBFF;
+const LOWERCASE_MASK = 0x20;
+const APOSTROPHE = 0x27;
+const ASCII_MAP = new Uint8Array(128);
+const COMMON_WORDS = new Set([
+    "the", "be", "to", "of", "and", "a", "in", "that", "have", "I",
+    "it", "for", "not", "on", "with", "he", "as", "you", "do", "at",
+    "this", "but", "his", "by", "from", "they", "we", "say", "her", "she",
+    "or", "an", "will", "my", "one", "all", "would", "there", "their",
+    "if", "const", "let", "var", "function", "return", "while", "for",
+    "async", "await", "class", "import", "export", "default", "new",
+    "else", "case", "break", "continue", "switch", "typeof", "void"
+]);
+(function initializeAsciiMap() {
+    ASCII_MAP[0x09] = CharCategory.Whitespace;
+    ASCII_MAP[0x0A] = CharCategory.Whitespace;
+    ASCII_MAP[0x0D] = CharCategory.Whitespace;
+    ASCII_MAP[0x20] = CharCategory.Whitespace;
+    for (let i = 0x30; i <= 0x39; i++)
+        ASCII_MAP[i] = CharCategory.Digit;
+    for (let i = 0x41; i <= 0x5A; i++)
+        ASCII_MAP[i] = CharCategory.Latin;
+    for (let i = 0x61; i <= 0x7A; i++)
+        ASCII_MAP[i] = CharCategory.Latin;
+    const punctuation = "!\"#$%&()*+,-./:;<=>?@[\\]^_`{|}~";
+    for (let i = 0; i < punctuation.length; i++)
+        ASCII_MAP[punctuation.charCodeAt(i)] = CharCategory.Punctuation;
+})();
+export function countTokens(text) {
+    if (!text)
+        return 0;
+    const { length } = text;
+    let tokenCount = 0;
+    let index = 0;
+    while (index < length) {
+        const code = text.charCodeAt(index);
+        let category;
+        if (code < 128)
+            category = ASCII_MAP[code];
+        else if (code >= CYR_START && code <= CYR_END)
+            category = CharCategory.Cyrillic;
+        else if (code >= ARABIC_START && code <= ARABIC_END)
+            category = CharCategory.Arabic;
+        else if ((code >= CJK_MAIN_START && code <= CJK_MAIN_END) ||
+            (code >= KANA_START && code <= KANA_END))
+            category = CharCategory.CJK;
+        else {
+            if (code >= SURROGATE_HIGH_START && code <= SURROGATE_HIGH_END) {
+                index += 2;
+                tokenCount++;
+                continue;
+            }
+            category = CharCategory.Other;
+        }
+        switch (category) {
+            case CharCategory.Latin: {
+                let wordEnd = index + 1;
+                let nextCode;
+                while (wordEnd < length &&
+                    (((nextCode = text.charCodeAt(wordEnd)) >= 0x61 && nextCode <= 0x7A) ||
+                        (nextCode >= 0x41 && nextCode <= 0x5A)))
+                    wordEnd++;
+                let hasContraction = false;
+                if (wordEnd < length && text.charCodeAt(wordEnd) === APOSTROPHE) {
+                    const suffixStart = wordEnd + 1;
+                    if (suffixStart < length) {
+                        const char1 = text.charCodeAt(suffixStart) | LOWERCASE_MASK;
+                        if (char1 === 0x73 || char1 === 0x74 || char1 === 0x6D || char1 === 0x64) {
+                            wordEnd = suffixStart + 1;
+                            hasContraction = true;
+                        }
+                        else if (suffixStart + 1 < length) {
+                            const char2 = text.charCodeAt(suffixStart + 1) | LOWERCASE_MASK;
+                            if ((char1 === 0x72 && char2 === 0x65) ||
+                                (char1 === 0x76 && char2 === 0x65) ||
+                                (char1 === 0x6C && char2 === 0x6C)) {
+                                wordEnd = suffixStart + 2;
+                                hasContraction = true;
+                            }
+                        }
+                    }
+                }
+                const wordLength = wordEnd - index;
+                const word = text.slice(index, wordEnd).toLowerCase();
+                if (COMMON_WORDS.has(word) || wordLength <= 3)
+                    tokenCount++;
+                else
+                    tokenCount += Math.max(1, Math.round(wordLength / LATIN_CHARS_PER_TOKEN));
+                if (hasContraction)
+                    tokenCount++;
+                index = wordEnd;
+                break;
+            }
+            case CharCategory.Whitespace: {
+                index++;
+                break;
+            }
+            case CharCategory.Digit: {
+                let digitEnd = index + 1;
+                let hasHexPrefix = false;
+                if (index > 0 && text.charCodeAt(index - 1) === 0x78 && index > 1 && text.charCodeAt(index - 2) === 0x30) {
+                    hasHexPrefix = true;
+                    while (digitEnd < length) {
+                        const nextCode = text.charCodeAt(digitEnd);
+                        if (!((nextCode >= 0x30 && nextCode <= 0x39) || (nextCode >= 0x41 && nextCode <= 0x46) || (nextCode >= 0x61 && nextCode <= 0x66)))
+                            break;
+                        digitEnd++;
+                    }
+                }
+                else
+                    while (digitEnd < length) {
+                        const nextCode = text.charCodeAt(digitEnd);
+                        if (nextCode < 0x30 || nextCode > 0x39)
+                            break;
+                        digitEnd++;
+                    }
+                const digitCount = digitEnd - index;
+                if (hasHexPrefix || digitCount === 4)
+                    tokenCount++;
+                else if (digitCount <= 2)
+                    tokenCount++;
+                else
+                    tokenCount += Math.ceil(digitCount / 3);
+                index = digitEnd;
+                break;
+            }
+            case CharCategory.Cyrillic: {
+                const start = index;
+                do
+                    index++;
+                while (index < length && text.charCodeAt(index) >= CYR_START && text.charCodeAt(index) <= CYR_END);
+                const charCount = index - start;
+                tokenCount += Math.max(1, Math.round(charCount / CYRILLIC_CHARS_PER_TOKEN));
+                break;
+            }
+            case CharCategory.Arabic: {
+                const start = index;
+                do
+                    index++;
+                while (index < length && text.charCodeAt(index) >= ARABIC_START && text.charCodeAt(index) <= ARABIC_END);
+                const charCount = index - start;
+                tokenCount += Math.max(1, Math.round(charCount / ARABIC_CHARS_PER_TOKEN));
+                break;
+            }
+            case CharCategory.CJK: {
+                tokenCount++;
+                index++;
+                break;
+            }
+            case CharCategory.Punctuation: {
+                tokenCount++;
+                index++;
+                break;
+            }
+            default: {
+                tokenCount++;
+                index++;
+                break;
+            }
+        }
+    }
+    return tokenCount;
+}

package/dist/infra/datetime.d.ts

@@ -0,0 +1,3 @@
+export declare function formatDateTime(): string;
+export declare function parseGeneratedDate(value: string): string;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/infra/datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../src/infra/datetime.ts"],"names":[],"mappings":"AAEA,wBAAgB,cAAc,IAAI,MAAM,CASvC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/infra/datetime.js

@@ -0,0 +1,15 @@
+const generatedDateRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
+export function formatDateTime() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}`;
+}
+export function parseGeneratedDate(value) {
+    if (!generatedDateRegex.test(value.trim()))
+        throw new Error(`Invalid generated date: "${value}". Expected format: YYYY-MM-DD HH:mm`);
+    return value.trim();
+}

package/dist/infra/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./countTokens";
+export * from "./datetime";
+export * from "./logger";
+export * from "./outputWriter";
+export * from "./terminal";
+export * from "./usageTracker";
+//# sourceMappingURL=index.d.ts.map

package/dist/infra/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/infra/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/dist/infra/index.js

@@ -0,0 +1,6 @@
+export * from "./countTokens";
+export * from "./datetime";
+export * from "./logger";
+export * from "./outputWriter";
+export * from "./terminal";
+export * from "./usageTracker";

package/dist/infra/logger.d.ts

@@ -0,0 +1,19 @@
+import type { LogLevel } from "$core";
+type LoggerOptions = {
+    useAnsi: boolean;
+    logLevel: LogLevel;
+};
+export type Logger = {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    debug: (message: string) => void;
+    header: (text: string) => void;
+    section: (title: string, items: Record<string, number | string>) => void;
+    box: (title: string, content: string[], showDivider?: boolean) => void;
+    empty: () => void;
+};
+export declare function createLogger(options: LoggerOptions): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/infra/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/infra/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAStC,KAAK,aAAa,GAAG;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC;IACzE,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACvE,KAAK,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAiH3D"}

package/dist/infra/logger.js

@@ -0,0 +1,99 @@
+import { ansi, getTerminalInfo, renderBox, symbols } from "./terminal";
+export function createLogger(options) {
+    const { useAnsi, logLevel } = options;
+    const { width } = getTerminalInfo();
+    const isSilent = logLevel === "silent";
+    const isVerbose = logLevel === "verbose" || logLevel === "debug";
+    const formatMessage = (symbol, color, message) => {
+        if (!useAnsi)
+            return `${symbol} ${message}`;
+        return `  ${color}${symbol}${ansi.reset} ${message}`;
+    };
+    const writeInfo = (formatted) => {
+        if (!isSilent)
+            console.info(formatted);
+    };
+    return {
+        info: (message) => {
+            if (!isSilent)
+                if (useAnsi)
+                    console.info(`  ${ansi.dim}${message}${ansi.reset}`);
+                else
+                    console.info(message);
+        },
+        success: (message) => {
+            writeInfo(formatMessage(symbols.check, ansi.green, message));
+        },
+        warn: (message) => {
+            if (!isSilent)
+                console.warn(formatMessage(symbols.warning, ansi.yellow, message));
+        },
+        error: (message) => {
+            console.error(formatMessage(symbols.cross, ansi.red, message));
+        },
+        debug: (message) => {
+            if (!isSilent && isVerbose)
+                if (useAnsi)
+                    console.info(`  ${ansi.dim}${symbols.info} ${message}${ansi.reset}`);
+                else
+                    console.info(`${symbols.info} ${message}`);
+        },
+        header: (text) => {
+            if (isSilent)
+                return;
+            if (useAnsi) {
+                const boxWidth = Math.min(width - 4, 60);
+                const paddedText = text.padEnd(boxWidth - 4);
+                console.info("");
+                console.info(`${ansi.dim}${symbols.boxTopLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxTopRight}${ansi.reset}`);
+                console.info(`${ansi.dim}${symbols.boxVertical}${ansi.reset}${ansi.bold}${paddedText}${ansi.reset} ${ansi.dim}${symbols.boxVertical}${ansi.reset}`);
+                console.info(`${ansi.dim}${symbols.boxBottomLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxBottomRight}${ansi.reset}`);
+                console.info("");
+            }
+            else {
+                console.info("");
+                console.info(`=== ${text} ===`);
+                console.info("");
+            }
+        },
+        section: (title, items) => {
+            if (isSilent)
+                return;
+            if (useAnsi) {
+                console.info("");
+                console.info(`${ansi.bold}${title}${ansi.reset}`);
+                console.info("");
+            }
+            else {
+                console.info("");
+                console.info(title);
+            }
+            const maxKeyLength = Math.max(...Object.keys(items).map(key => key.length));
+            for (const [key, value] of Object.entries(items)) {
+                const paddedKey = key.padEnd(maxKeyLength);
+                if (useAnsi)
+                    console.info(`  ${ansi.dim}${paddedKey}${ansi.reset}  ${value}`);
+                else
+                    console.info(`  ${paddedKey}  ${value}`);
+            }
+        },
+        box: (title, content, showDivider = false) => {
+            if (isSilent)
+                return;
+            const boxWidth = Math.min(width - 4, 60);
+            const box = renderBox({
+                title,
+                content,
+                width: boxWidth,
+                useAnsi,
+                showDivider
+            });
+            console.info("");
+            console.info(box);
+        },
+        empty: () => {
+            if (!isSilent)
+                console.info("");
+        }
+    };
+}

package/dist/infra/outputWriter.d.ts

@@ -0,0 +1,15 @@
+type OutputWriter = {
+    write: (text: string) => Promise<void>;
+    writeLine: (text: string) => Promise<void>;
+    getStats: () => {
+        sizeBytes: number;
+        tokenCount: number;
+    };
+    close: () => Promise<{
+        sizeBytes: number;
+        tokenCount: number;
+    }>;
+};
+export declare function createOutputWriter(outputFile: string, maxSizeBytes?: number): Promise<OutputWriter>;
+export {};
+//# sourceMappingURL=outputWriter.d.ts.map

package/dist/infra/outputWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputWriter.d.ts","sourceRoot":"","sources":["../../src/infra/outputWriter.ts"],"names":[],"mappings":"AAOA,KAAK,YAAY,GAAG;IACnB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,QAAQ,EAAE,MAAM;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1D,KAAK,EAAE,MAAM,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChE,CAAC;AAEF,wBAAsB,kBAAkB,CACvC,UAAU,EAAE,MAAM,EAClB,YAAY,SAAI,GACd,OAAO,CAAC,YAAY,CAAC,CAoCvB"}

package/dist/infra/outputWriter.js

@@ -0,0 +1,35 @@
+import { once } from "node:events";
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { countTokens } from "./countTokens";
+export async function createOutputWriter(outputFile, maxSizeBytes = 0) {
+    const outputDirectory = dirname(outputFile);
+    if (outputDirectory !== ".")
+        await mkdir(outputDirectory, { recursive: true });
+    const stream = createWriteStream(outputFile, { encoding: "utf8" });
+    let bytesWritten = 0;
+    let totalTokenCount = 0;
+    const write = async (text) => {
+        const textBytes = Buffer.byteLength(text);
+        if (maxSizeBytes > 0 && bytesWritten + textBytes > maxSizeBytes)
+            throw new Error(`Output size would exceed maximum of ${maxSizeBytes} bytes`);
+        bytesWritten += textBytes;
+        totalTokenCount += countTokens(text);
+        if (!stream.write(text))
+            await once(stream, "drain");
+    };
+    return {
+        write,
+        writeLine: (text) => write(`${text}\n`),
+        getStats: () => ({ sizeBytes: bytesWritten, tokenCount: totalTokenCount }),
+        close: () => new Promise((resolve, reject) => {
+            stream.end((error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve({ sizeBytes: bytesWritten, tokenCount: totalTokenCount });
+            });
+        })
+    };
+}

package/dist/infra/terminal.d.ts

@@ -0,0 +1,91 @@
+type TerminalInfo = {
+    width: number;
+    supportsAnsi: boolean;
+};
+export declare function getTerminalInfo(): TerminalInfo;
+export declare function isTTY(): boolean;
+export declare function shouldUseColors(): boolean;
+export declare const ansi: {
+    cursorHide: string;
+    cursorShow: string;
+    cursorUp: (lines: number) => string;
+    cursorDown: (lines: number) => string;
+    cursorTo: (column: number) => string;
+    clearLine: string;
+    clearLineRight: string;
+    reset: string;
+    bold: string;
+    dim: string;
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    bgBlack: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+    bgBlue: string;
+    bgMagenta: string;
+    bgCyan: string;
+    bgWhite: string;
+    brightBlack: string;
+    brightRed: string;
+    brightGreen: string;
+    brightYellow: string;
+    brightBlue: string;
+    brightMagenta: string;
+    brightCyan: string;
+    brightWhite: string;
+};
+export declare const symbols: {
+    dot: string;
+    check: string;
+    cross: string;
+    warning: string;
+    info: string;
+    arrowRight: string;
+    boxTopLeft: string;
+    boxTopRight: string;
+    boxBottomLeft: string;
+    boxBottomRight: string;
+    boxVertical: string;
+    boxHorizontal: string;
+    boxCross: string;
+    boxTLeft: string;
+    boxTRight: string;
+    barFull: string;
+    barEmpty: string;
+    barQuarter: string;
+    barHalf: string;
+};
+type ProgressBarOptions = {
+    total: number;
+    current: number;
+    width: number;
+    useAnsi: boolean;
+    label?: string;
+    suffix?: string;
+};
+export declare function renderProgressBar(options: ProgressBarOptions): string;
+type BoxOptions = {
+    title?: string;
+    content: string[];
+    width?: number;
+    useAnsi: boolean;
+    showDivider?: boolean;
+};
+export declare function renderBox(options: BoxOptions): string;
+export type ProgressRenderer = {
+    start: () => void;
+    update: (current: number, total: number, suffix?: string) => void;
+    finish: (message?: string) => void;
+    cleanup: () => void;
+};
+export declare function createProgressRenderer(label: string, useAnsi: boolean, isQuiet: boolean): ProgressRenderer;
+export {};
+//# sourceMappingURL=terminal.d.ts.map

package/dist/infra/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/infra/terminal.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,eAAe,IAAI,YAAY,CAK9C;AAED,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED,eAAO,MAAM,IAAI;;;sBAGE,MAAM;wBACJ,MAAM;uBACP,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCzB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;CAsBnB,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAwBrE;AAED,KAAK,UAAU,GAAG;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CA4CrD;AAMD,MAAM,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAClE,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,gBAAgB,CAiF1G"}