@addfox/common 0.1.1-beta.2

package/dist/esm/index.js

@@ -0,0 +1,567 @@
+import { format } from "node:util";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import cli_table3 from "cli-table3";
+const ANSI_COLORS = {
+    ORANGE: "\x1b[38;5;208m",
+    DONE: "\x1b[1m\x1b[32m",
+    TIME: "\x1b[38;5;245m",
+    VALUE: "\x1b[38;5;75m",
+    PURPLE: "\x1b[38;5;141m",
+    ERROR_BADGE: "\x1b[41m\x1b[93m",
+    RED: "\x1b[31m",
+    RESET: "\x1b[0m"
+};
+class Logger {
+    prefix;
+    showTimestamp;
+    useColors;
+    rawWrites = null;
+    constructor(options = {}){
+        this.prefix = options.prefix ?? "[Addfox]";
+        this.showTimestamp = options.showTimestamp ?? false;
+        this.useColors = options.useColors ?? true;
+        this.rawWrites = options.rawWrites ?? null;
+    }
+    setRawWrites(writes) {
+        this.rawWrites = writes;
+    }
+    getWrites() {
+        if (this.rawWrites) return this.rawWrites;
+        return {
+            stdout: process.stdout.write.bind(process.stdout),
+            stderr: process.stderr.write.bind(process.stderr)
+        };
+    }
+    formatPrefix() {
+        if (!this.useColors) return `${this.prefix} `;
+        return `${ANSI_COLORS.ORANGE}${this.prefix}${ANSI_COLORS.RESET} `;
+    }
+    formatTimestamp() {
+        if (!this.showTimestamp) return "";
+        const now = new Date();
+        const timeStr = now.toLocaleTimeString();
+        return this.useColors ? `${ANSI_COLORS.TIME}${timeStr}${ANSI_COLORS.RESET} ` : `${timeStr} `;
+    }
+    writeLines(stream, text) {
+        const w = this.getWrites()[stream];
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        for (const line of text.split("\n"))w(prefix + line + "\n", "utf8");
+    }
+    info(...args) {
+        this.writeLines("stdout", format(...args));
+    }
+    log(...args) {
+        this.info(...args);
+    }
+    success(...args) {
+        const text = format(...args);
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        for (const line of text.split("\n"))w(prefix + donePrefix + line + "\n", "utf8");
+    }
+    successWithValue(label, value) {
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        const valueColored = this.useColors ? `${ANSI_COLORS.VALUE}${value}${ANSI_COLORS.RESET}` : value;
+        const line = donePrefix + label + " " + valueColored;
+        w(prefix + line + "\n", "utf8");
+    }
+    successWithDuration(message, ms) {
+        const timeStr = this.formatDuration(ms);
+        const w = this.getWrites().stdout;
+        const prefix = this.formatPrefix() + this.formatTimestamp();
+        const donePrefix = this.useColors ? `${ANSI_COLORS.DONE}●${ANSI_COLORS.RESET} ` : "● ";
+        const timeColored = this.useColors ? `${ANSI_COLORS.TIME}${timeStr}${ANSI_COLORS.RESET}` : timeStr;
+        const line = donePrefix + message + " " + timeColored;
+        w(prefix + line + "\n", "utf8");
+    }
+    warn(...args) {
+        this.writeLines("stderr", format(...args));
+    }
+    error(...args) {
+        const text = format(...args);
+        const w = this.getWrites().stderr;
+        const lines = text.split("\n");
+        const errorBadge = this.useColors ? `${ANSI_COLORS.ERROR_BADGE} error ${ANSI_COLORS.RESET} ` : " error  ";
+        const redPrefix = this.useColors ? ANSI_COLORS.RED : "";
+        const resetSuffix = this.useColors ? ANSI_COLORS.RESET : "";
+        w("\n", "utf8");
+        if (lines.length > 0) {
+            w(errorBadge + redPrefix + lines[0] + resetSuffix + "\n", "utf8");
+            for(let i = 1; i < lines.length; i++)w(redPrefix + lines[i] + resetSuffix + "\n", "utf8");
+        }
+        w("\n", "utf8");
+    }
+    writeErrorBlock(lines) {
+        const w = this.getWrites().stderr;
+        const errorBadge = this.useColors ? `${ANSI_COLORS.ERROR_BADGE} error ${ANSI_COLORS.RESET} ` : " error  ";
+        const redPrefix = this.useColors ? ANSI_COLORS.RED : "";
+        const resetSuffix = this.useColors ? ANSI_COLORS.RESET : "";
+        w("\n", "utf8");
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i];
+            w(0 === i ? errorBadge + redPrefix + line + resetSuffix + "\n" : redPrefix + line + resetSuffix + "\n", "utf8");
+        }
+        w("\n", "utf8");
+    }
+    formatDuration(ms) {
+        if (ms >= 1000) return (ms / 1000).toFixed(2) + "s";
+        return ms + "ms";
+    }
+    logEntriesTable(entries, options) {
+        if (0 === entries.length) return;
+        const root = options?.root;
+        const headColor = this.useColors ? ANSI_COLORS.PURPLE : "";
+        const resetColor = this.useColors ? ANSI_COLORS.RESET : "";
+        const table = new cli_table3({
+            head: [
+                headColor + "Entry" + resetColor,
+                headColor + "File" + resetColor
+            ],
+            style: {
+                head: [],
+                border: []
+            },
+            chars: {
+                top: "╌",
+                "top-mid": "┬",
+                "top-left": "┌",
+                "top-right": "┐",
+                bottom: "╌",
+                "bottom-mid": "┴",
+                "bottom-left": "└",
+                "bottom-right": "┘",
+                left: "│",
+                "left-mid": "├",
+                mid: "╌",
+                "mid-mid": "┼",
+                right: "│",
+                "right-mid": "┤",
+                middle: "│"
+            }
+        });
+        for (const e of entries){
+            const fileDisplay = void 0 !== root ? this.fileLink(e.scriptPath, node_path.relative(root, e.scriptPath).replace(/\\/g, "/")) : e.scriptPath;
+            table.push([
+                e.name,
+                fileDisplay
+            ]);
+        }
+        const w = this.getWrites().stdout;
+        w(table.toString() + "\n", "utf8");
+    }
+    fileLink(absolutePath, displayText) {
+        const url = pathToFileURL(absolutePath).href;
+        if (!this.useColors) return displayText;
+        return "\x1b]8;;" + url + "\x07" + displayText + "\x1b]8;;\x07";
+    }
+}
+const logger = new Logger();
+function log(...args) {
+    logger.log(...args);
+}
+function logDone(...args) {
+    logger.success(...args);
+}
+function logDoneTimed(message, ms) {
+    logger.successWithDuration(message, ms);
+}
+function logDoneWithValue(label, value) {
+    logger.successWithValue(label, value);
+}
+function formatDuration(ms) {
+    return logger.formatDuration(ms);
+}
+function warn(...args) {
+    logger.warn(...args);
+}
+function logger_error(...args) {
+    logger.error(...args);
+}
+function writeExtensionErrorBlock(lines) {
+    logger.writeErrorBlock(lines);
+}
+function logEntriesTable(entries, options) {
+    logger.logEntriesTable(entries, options);
+}
+function setAddfoxLoggerRawWrites(writes) {
+    logger.setRawWrites(writes);
+}
+const ADDFOX_ERROR_CODES = {
+    CONFIG_NOT_FOUND: "ADDFOX_CONFIG_NOT_FOUND",
+    CONFIG_LOAD_FAILED: "ADDFOX_CONFIG_LOAD_FAILED",
+    MANIFEST_MISSING: "ADDFOX_MANIFEST_MISSING",
+    APP_DIR_MISSING: "ADDFOX_APP_DIR_MISSING",
+    NO_ENTRIES: "ADDFOX_NO_ENTRIES",
+    ENTRY_SCRIPT_FROM_HTML: "ADDFOX_ENTRY_SCRIPT_FROM_HTML",
+    INVALID_BROWSER: "ADDFOX_INVALID_BROWSER",
+    UNKNOWN_COMMAND: "ADDFOX_UNKNOWN_COMMAND",
+    RSTEST_CONFIG_NOT_FOUND: "ADDFOX_RSTEST_CONFIG_NOT_FOUND",
+    RSDOCTOR_NOT_INSTALLED: "ADDFOX_RSDOCTOR_NOT_INSTALLED",
+    RSBUILD_CONFIG_ERROR: "ADDFOX_RSBUILD_CONFIG_ERROR",
+    BUILD_ERROR: "ADDFOX_BUILD_ERROR",
+    ZIP_OUTPUT: "ADDFOX_ZIP_OUTPUT",
+    ZIP_ARCHIVE: "ADDFOX_ZIP_ARCHIVE"
+};
+class AddfoxError extends Error {
+    code;
+    details;
+    hint;
+    cause;
+    constructor(options){
+        super(options.message);
+        this.name = "AddfoxError";
+        this.code = options.code;
+        this.details = options.details;
+        this.hint = options.hint;
+        this.cause = options.cause;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            details: this.details,
+            hint: this.hint,
+            stack: this.stack,
+            cause: this.cause
+        };
+    }
+    format() {
+        const parts = [
+            `[${this.code}] ${this.message}`
+        ];
+        if (this.details) parts.push(`  Details: ${this.details}`);
+        if (this.hint) parts.push(`  Hint: ${this.hint}`);
+        return parts.join("\n");
+    }
+    toString() {
+        return this.format();
+    }
+}
+function createError(code, message, options) {
+    return new AddfoxError({
+        code,
+        message,
+        ...options
+    });
+}
+function isAddfoxError(error) {
+    return error instanceof AddfoxError;
+}
+function formatError(error) {
+    if (isAddfoxError(error)) return error.format();
+    if (error instanceof Error) return error.stack ?? error.message;
+    return String(error);
+}
+function exitWithError(_err, exitCode = 1) {
+    process.exit(exitCode);
+}
+function createCache() {
+    const store = new Map();
+    return {
+        get (key) {
+            const entry = store.get(key);
+            if (!entry) return;
+            if (entry.expiresAt && Date.now() > entry.expiresAt) return void store.delete(key);
+            return entry.value;
+        },
+        set (key, value, ttlMs) {
+            const entry = {
+                value,
+                expiresAt: ttlMs ? Date.now() + ttlMs : void 0
+            };
+            store.set(key, entry);
+        },
+        has (key) {
+            const entry = store.get(key);
+            if (!entry) return false;
+            if (entry.expiresAt && Date.now() > entry.expiresAt) {
+                store.delete(key);
+                return false;
+            }
+            return true;
+        },
+        delete (key) {
+            return store.delete(key);
+        },
+        clear () {
+            store.clear();
+        },
+        keys () {
+            const now = Date.now();
+            const keys = [];
+            for (const [key, entry] of store)if (!entry.expiresAt || now <= entry.expiresAt) keys.push(key);
+            return keys;
+        },
+        size () {
+            return this.keys().length;
+        }
+    };
+}
+function memoize(fn, keyFn) {
+    const cache = createCache();
+    return (...args)=>{
+        const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+        if (cache.has(key)) return cache.get(key);
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+function memoizeAsync(fn, keyFn) {
+    const cache = createCache();
+    const pending = new Map();
+    return async (...args)=>{
+        const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+        if (cache.has(key)) return cache.get(key);
+        if (pending.has(key)) return pending.get(key);
+        const promise = fn(...args).finally(()=>{
+            pending.delete(key);
+        });
+        pending.set(key, promise);
+        const result = await promise;
+        cache.set(key, result);
+        return result;
+    };
+}
+function pipe(...fns) {
+    return (x)=>fns.reduce((v, f)=>f(v), x);
+}
+function pipeAsync(...fns) {
+    return async (x)=>{
+        let result = x;
+        for (const fn of fns)result = await fn(result);
+        return result;
+    };
+}
+function compose(...fns) {
+    return (x)=>fns.reduceRight((v, f)=>f(v), x);
+}
+function createPipeline(...steps) {
+    return async (input)=>{
+        let result = input;
+        for (const step of steps)result = await step(result);
+        return result;
+    };
+}
+function applyMiddleware(value, middlewares) {
+    let index = 0;
+    function next() {
+        if (index >= middlewares.length) return value;
+        const middleware = middlewares[index++];
+        return middleware(value, next);
+    }
+    return next();
+}
+function curry(fn) {
+    return (a)=>(b)=>fn(a, b);
+}
+function partial(fn, a) {
+    return (...rest)=>fn(a, ...rest);
+}
+function tap(fn) {
+    return (x)=>{
+        fn(x);
+        return x;
+    };
+}
+function tryCatch(fn, onError) {
+    try {
+        return fn();
+    } catch (error) {
+        return onError?.(error);
+    }
+}
+async function tryCatchAsync(fn, onError) {
+    try {
+        return await fn();
+    } catch (error) {
+        return onError?.(error);
+    }
+}
+function deepMerge(target, source) {
+    const result = {
+        ...target
+    };
+    for (const key of Object.keys(source)){
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (null === sourceValue || 'object' != typeof sourceValue || Array.isArray(sourceValue) || null === targetValue || 'object' != typeof targetValue || Array.isArray(targetValue)) result[key] = sourceValue;
+        else result[key] = deepMerge(targetValue, sourceValue);
+    }
+    return result;
+}
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys)if (key in obj) result[key] = obj[key];
+    return result;
+}
+function omit(obj, keys) {
+    const result = {
+        ...obj
+    };
+    for (const key of keys)delete result[key];
+    return result;
+}
+function get(obj, path, defaultValue) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (null == current) return defaultValue;
+        current = current[key];
+    }
+    return current ?? defaultValue;
+}
+function set(obj, path, value) {
+    const keys = path.split('.');
+    const result = {
+        ...obj
+    };
+    let current = result;
+    for(let i = 0; i < keys.length - 1; i++){
+        const key = keys[i];
+        if (!(key in current) || 'object' != typeof current[key]) current[key] = {};
+        current = current[key];
+    }
+    current[keys[keys.length - 1]] = value;
+    return result;
+}
+function has(obj, path) {
+    const keys = path.split('.');
+    let current = obj;
+    for (const key of keys){
+        if (null == current || 'object' != typeof current || !(key in current)) return false;
+        current = current[key];
+    }
+    return true;
+}
+function flatten(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)){
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (null === value || 'object' != typeof value || Array.isArray(value)) result[newKey] = value;
+        else Object.assign(result, flatten(value, newKey));
+    }
+    return result;
+}
+function unflatten(obj) {
+    let result = {};
+    for (const [key, value] of Object.entries(obj))result = set(result, key, value);
+    return result;
+}
+function filter(obj, predicate) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj))if (predicate(key, value)) result[key] = value;
+    return result;
+}
+function mapValues(obj, fn) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj))result[key] = fn(value, key);
+    return result;
+}
+function isPlainObject(value) {
+    if (null === value || 'object' != typeof value) return false;
+    const proto = Object.getPrototypeOf(value);
+    return null === proto || proto === Object.prototype;
+}
+function isEmpty(value) {
+    if (null == value) return true;
+    if ('string' == typeof value || Array.isArray(value)) return 0 === value.length;
+    if (isPlainObject(value)) return 0 === Object.keys(value).length;
+    return false;
+}
+class HookManager {
+    registry = new Map();
+    options;
+    constructor(options = {}){
+        this.options = {
+            parallel: false,
+            bail: false,
+            ...options
+        };
+    }
+    register(stage, phase, handler) {
+        const key = this.getKey(stage, phase);
+        if (!this.registry.has(key)) this.registry.set(key, []);
+        const hooks = this.registry.get(key);
+        hooks.push(handler);
+        return ()=>{
+            const index = hooks.indexOf(handler);
+            if (index > -1) hooks.splice(index, 1);
+        };
+    }
+    async execute(stage, phase, payload) {
+        const key = this.getKey(stage, phase);
+        const hooks = this.registry.get(key) || [];
+        if (0 === hooks.length) return;
+        if (this.options.parallel) if (this.options.bail) await Promise.all(hooks.map((hook)=>hook(payload)));
+        else {
+            const results = await Promise.allSettled(hooks.map((hook)=>hook(payload)));
+            const errors = results.filter((r)=>'rejected' === r.status).map((r)=>r.reason);
+            if (errors.length > 0) throw new AggregateError(errors, `Hook execution failed for ${String(stage)}:${phase}`);
+        }
+        else for (const hook of hooks)try {
+            await hook(payload);
+        } catch (error) {
+            if (this.options.bail) throw error;
+            console.error(`Hook error in ${String(stage)}:${phase}:`, error);
+        }
+    }
+    has(stage, phase) {
+        const key = this.getKey(stage, phase);
+        return (this.registry.get(key)?.length || 0) > 0;
+    }
+    count(stage, phase) {
+        const key = this.getKey(stage, phase);
+        return this.registry.get(key)?.length || 0;
+    }
+    clear(stage, phase) {
+        if (void 0 === stage) this.registry.clear();
+        else if (void 0 === phase) {
+            this.registry.delete(this.getKey(stage, 'before'));
+            this.registry.delete(this.getKey(stage, 'after'));
+        } else this.registry.delete(this.getKey(stage, phase));
+    }
+    getKey(stage, phase) {
+        return `${String(stage)}:${phase}`;
+    }
+    for(stage) {
+        return new StageHookManager(this, stage);
+    }
+}
+class StageHookManager {
+    manager;
+    stage;
+    constructor(manager, stage){
+        this.manager = manager;
+        this.stage = stage;
+    }
+    before(handler) {
+        return this.manager.register(this.stage, 'before', handler);
+    }
+    after(handler) {
+        return this.manager.register(this.stage, 'after', handler);
+    }
+    async runBefore(payload) {
+        return this.manager.execute(this.stage, 'before', payload);
+    }
+    async runAfter(payload) {
+        return this.manager.execute(this.stage, 'after', payload);
+    }
+}
+let webExtStdoutOriginDepth = 0;
+function pushWebExtStdoutOrigin() {
+    webExtStdoutOriginDepth += 1;
+}
+function popWebExtStdoutOrigin() {
+    webExtStdoutOriginDepth = Math.max(0, webExtStdoutOriginDepth - 1);
+}
+function getWebExtStdoutOriginDepth() {
+    return webExtStdoutOriginDepth;
+}
+export { ADDFOX_ERROR_CODES, ANSI_COLORS, AddfoxError, HookManager, Logger, StageHookManager, applyMiddleware, compose, createCache, createError, createPipeline, curry, deepMerge, exitWithError, filter, flatten, formatDuration, formatError, get, getWebExtStdoutOriginDepth, has, isAddfoxError, isEmpty, isPlainObject, log, logDone, logDoneTimed, logDoneWithValue, logEntriesTable, logger, logger_error as error, mapValues, memoize, memoizeAsync, omit, partial, pick, pipe, pipeAsync, popWebExtStdoutOrigin, pushWebExtStdoutOrigin, set, setAddfoxLoggerRawWrites, tap, tryCatch, tryCatchAsync, unflatten, warn, writeExtensionErrorBlock };

package/dist/esm/interfaces/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared types and interfaces
+ */
+/** Logger interface (base interface for logging) */
+export interface ILogger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/** @deprecated Use ILogger instead */
+export type Logger = ILogger;
+/** Result type for operations that can fail */
+export interface Result<T, E = Error> {
+    success: boolean;
+    data?: T;
+    error?: E;
+}
+/** Validation result */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+/** Validation error */
+export interface ValidationError {
+    code: string;
+    message: string;
+    path?: string;
+}
+/** Validation warning */
+export interface ValidationWarning {
+    code: string;
+    message: string;
+    path?: string;
+}
+/** Cache entry */
+export interface CacheEntry<T> {
+    value: T;
+    expiresAt?: number;
+}
+/** Strategy pattern interface */
+export interface Strategy<TInput, TOutput> {
+    name: string;
+    execute(input: TInput): TOutput | Promise<TOutput>;
+    canExecute(input: TInput): boolean;
+}
+/** Builder function type */
+export type Builder<TInput, TOutput, TContext = unknown> = (input: TInput, context: TContext) => TOutput | Promise<TOutput>;
+/** Resolver function type */
+export type Resolver<TInput, TOutput> = (input: TInput) => TOutput | Promise<TOutput>;
+/** Middleware function type */
+export type Middleware<T> = (value: T, next: () => T | Promise<T>) => T | Promise<T>;
+/** Pipeline function type */
+export type Pipeline<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/interfaces/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,oDAAoD;AACpD,MAAM,WAAW,OAAO;IACtB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CAClD;AAED,sCAAsC;AACtC,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC;AAE7B,+CAA+C;AAC/C,MAAM,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,CAAC,CAAC;CACX;AAED,wBAAwB;AACxB,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,uBAAuB;AACvB,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,yBAAyB;AACzB,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,kBAAkB;AAClB,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC;IACT,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,iCAAiC;AACjC,MAAM,WAAW,QAAQ,CAAC,MAAM,EAAE,OAAO;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CACpC;AAED,4BAA4B;AAC5B,MAAM,MAAM,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,GAAG,OAAO,IAAI,CACzD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,KACd,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhC,6BAA6B;AAC7B,MAAM,MAAM,QAAQ,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtF,+BAA+B;AAC/B,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAErF,6BAA6B;AAC7B,MAAM,MAAM,QAAQ,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC"}