@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/kernel/ServiceManager.js

@@ -0,0 +1,302 @@
+import { parseUnitFile } from './unit-parser.js';
+const UNIT_DIR = '/etc/systemd/system';
+const WANTS_DIR = '/etc/systemd/system/multi-user.target.wants';
+const LOG_DIR = '/var/log';
+let nextPid = 1000;
+export class ServiceManager {
+    vfs;
+    registry;
+    defaultEnv;
+    services = new Map();
+    unitCache = new Map();
+    constructor(vfs, registry, defaultEnv) {
+        this.vfs = vfs;
+        this.registry = registry;
+        this.defaultEnv = defaultEnv;
+    }
+    /** Reload unit files from disk */
+    daemonReload() {
+        this.unitCache.clear();
+    }
+    resolveUnit(name) {
+        const svcName = name.endsWith('.service') ? name : name + '.service';
+        if (this.unitCache.has(svcName)) {
+            return this.unitCache.get(svcName);
+        }
+        const path = UNIT_DIR + '/' + svcName;
+        if (!this.vfs.exists(path))
+            return null;
+        const content = this.vfs.readFileString(path);
+        const unit = parseUnitFile(content);
+        this.unitCache.set(svcName, unit);
+        return unit;
+    }
+    baseName(name) {
+        return name.endsWith('.service') ? name.slice(0, -8) : name;
+    }
+    async start(name) {
+        const base = this.baseName(name);
+        const existing = this.services.get(base);
+        if (existing && existing.exitCode === null) {
+            return { ok: true, message: '' }; // already running
+        }
+        const unit = this.resolveUnit(name);
+        if (!unit) {
+            return { ok: false, message: `Unit ${base}.service not found.` };
+        }
+        if (!unit.Service.ExecStart) {
+            return { ok: false, message: `Unit ${base}.service has no ExecStart.` };
+        }
+        const pid = nextPid++;
+        const abortController = new AbortController();
+        const logPath = LOG_DIR + '/' + base + '.log';
+        // Build an isolated CommandContext for the service
+        const logStream = {
+            write: (text) => {
+                try {
+                    const existing = this.vfs.exists(logPath)
+                        ? this.vfs.readFileString(logPath)
+                        : '';
+                    this.vfs.writeFile(logPath, existing + text);
+                }
+                catch { /* ignore log failures */ }
+            },
+        };
+        const env = {
+            ...this.defaultEnv,
+            ...(unit.Service.Environment ?? {}),
+        };
+        const cwd = unit.Service.WorkingDirectory ?? this.defaultEnv.HOME ?? '/';
+        // Parse ExecStart into command name + args
+        const parts = unit.Service.ExecStart.split(/\s+/);
+        const cmdName = parts[0];
+        const cmdArgs = parts.slice(1);
+        const cmd = await this.registry.resolve(cmdName);
+        if (!cmd) {
+            return { ok: false, message: `Command '${cmdName}' not found for ExecStart.` };
+        }
+        const ctx = {
+            pid,
+            cred: { uid: 1000, gid: 1000, groups: [1000], umask: 0o022 },
+            args: cmdArgs,
+            env,
+            cwd,
+            vfs: this.vfs,
+            stdout: logStream,
+            stderr: logStream,
+            signal: abortController.signal,
+            setUmask: () => { },
+            runAs: async () => 126,
+        };
+        const promise = cmd(ctx).catch((err) => {
+            if (abortController.signal.aborted)
+                return -1;
+            logStream.write(`Service error: ${err}\n`);
+            return 1;
+        });
+        const svc = {
+            name: base,
+            unit,
+            pid,
+            startedAt: Date.now(),
+            abortController,
+            promise,
+            exitCode: null,
+            restartTimer: null,
+        };
+        this.services.set(base, svc);
+        // Handle service completion
+        promise.then((code) => {
+            svc.exitCode = code;
+            this.handleServiceExit(svc);
+        });
+        return { ok: true, message: '' };
+    }
+    handleServiceExit(svc) {
+        const restart = svc.unit.Service.Restart ?? 'no';
+        const shouldRestart = restart === 'always' ||
+            (restart === 'on-failure' && svc.exitCode !== 0);
+        if (shouldRestart && !svc.abortController.signal.aborted) {
+            const delaySec = svc.unit.Service.RestartSec ?? 1;
+            svc.restartTimer = setTimeout(() => {
+                if (!svc.abortController.signal.aborted) {
+                    this.start(svc.name);
+                }
+            }, delaySec * 1000);
+        }
+    }
+    async stop(name) {
+        const base = this.baseName(name);
+        const svc = this.services.get(base);
+        if (!svc) {
+            return { ok: false, message: `Unit ${base}.service not loaded.` };
+        }
+        // Cancel restart timer
+        if (svc.restartTimer) {
+            clearTimeout(svc.restartTimer);
+            svc.restartTimer = null;
+        }
+        if (svc.exitCode !== null) {
+            // Already stopped
+            svc.exitCode = svc.exitCode;
+            return { ok: true, message: '' };
+        }
+        // If there's an ExecStop command, try to run it
+        if (svc.unit.Service.ExecStop) {
+            const parts = svc.unit.Service.ExecStop.split(/\s+/);
+            const cmd = await this.registry.resolve(parts[0]);
+            if (cmd) {
+                const noop = { write: () => { } };
+                try {
+                    await cmd({
+                        pid: svc.pid,
+                        cred: { uid: 1000, gid: 1000, groups: [1000], umask: 0o022 },
+                        args: parts.slice(1),
+                        env: { ...this.defaultEnv },
+                        cwd: this.defaultEnv.HOME ?? '/',
+                        vfs: this.vfs,
+                        stdout: noop,
+                        stderr: noop,
+                        signal: AbortSignal.timeout(5000),
+                        setUmask: () => { },
+                        runAs: async () => 126,
+                    });
+                }
+                catch { /* ignore */ }
+            }
+        }
+        // Abort the running command
+        svc.abortController.abort();
+        svc.exitCode = -1;
+        return { ok: true, message: '' };
+    }
+    async restart(name) {
+        const base = this.baseName(name);
+        const svc = this.services.get(base);
+        if (svc && svc.exitCode === null) {
+            await this.stop(base);
+        }
+        return this.start(base);
+    }
+    status(name) {
+        const base = this.baseName(name);
+        const svc = this.services.get(base);
+        const unit = this.resolveUnit(name);
+        const enabled = this.isEnabled(base);
+        if (!svc) {
+            return {
+                name: base,
+                description: unit?.Unit.Description ?? '',
+                loaded: unit !== null,
+                active: 'inactive',
+                sub: 'dead',
+                enabled,
+                pid: null,
+                startedAt: null,
+                exitCode: null,
+            };
+        }
+        let active;
+        let sub;
+        if (svc.exitCode === null) {
+            active = 'active';
+            sub = 'running';
+        }
+        else if (svc.exitCode === 0) {
+            active = 'inactive';
+            sub = 'exited';
+        }
+        else if (svc.abortController.signal.aborted) {
+            active = 'inactive';
+            sub = 'dead';
+        }
+        else {
+            active = 'failed';
+            sub = 'dead';
+        }
+        // Check if restarting
+        if (svc.restartTimer) {
+            active = 'activating';
+            sub = 'auto-restart';
+        }
+        return {
+            name: base,
+            description: unit?.Unit.Description ?? svc.unit.Unit.Description ?? '',
+            loaded: true,
+            active,
+            sub,
+            enabled,
+            pid: svc.exitCode === null ? svc.pid : null,
+            startedAt: svc.startedAt,
+            exitCode: svc.exitCode,
+        };
+    }
+    enable(name) {
+        const base = this.baseName(name);
+        const unit = this.resolveUnit(name);
+        if (!unit) {
+            return { ok: false, message: `Unit ${base}.service not found.` };
+        }
+        const linkPath = WANTS_DIR + '/' + base + '.service';
+        try {
+            this.vfs.writeFile(linkPath, '');
+        }
+        catch {
+            return { ok: false, message: `Failed to enable ${base}.service.` };
+        }
+        return { ok: true, message: `Created symlink ${linkPath}.` };
+    }
+    disable(name) {
+        const base = this.baseName(name);
+        const linkPath = WANTS_DIR + '/' + base + '.service';
+        if (!this.vfs.exists(linkPath)) {
+            return { ok: true, message: '' };
+        }
+        try {
+            this.vfs.unlink(linkPath);
+        }
+        catch {
+            return { ok: false, message: `Failed to disable ${base}.service.` };
+        }
+        return { ok: true, message: `Removed ${linkPath}.` };
+    }
+    isEnabled(base) {
+        return this.vfs.exists(WANTS_DIR + '/' + base + '.service');
+    }
+    listUnits() {
+        const units = [];
+        const seen = new Set();
+        // Running services
+        for (const [base] of this.services) {
+            seen.add(base);
+            units.push(this.status(base));
+        }
+        // Unit files on disk
+        try {
+            const entries = this.vfs.readdir(UNIT_DIR);
+            for (const entry of entries) {
+                if (entry.type === 'file' && entry.name.endsWith('.service')) {
+                    const base = entry.name.slice(0, -8);
+                    if (!seen.has(base)) {
+                        seen.add(base);
+                        units.push(this.status(base));
+                    }
+                }
+            }
+        }
+        catch { /* UNIT_DIR may not exist */ }
+        return units;
+    }
+    async bootEnabledServices() {
+        try {
+            const entries = this.vfs.readdir(WANTS_DIR);
+            for (const entry of entries) {
+                if (entry.type === 'file' && entry.name.endsWith('.service')) {
+                    const base = entry.name.slice(0, -8);
+                    await this.start(base);
+                }
+            }
+        }
+        catch { /* WANTS_DIR may not exist yet */ }
+    }
+}

package/dist/substrate/lifo/kernel/index.d.ts

@@ -0,0 +1,40 @@
+import { VFS } from './vfs/index.js';
+import type { PersistenceBackend } from './persistence/backends.js';
+import { ProcessRegistry } from '../shell/ProcessRegistry.js';
+import { NetworkStack } from './network/NetworkStack.js';
+import { PortBridge } from './network/PortBridge.js';
+import { ServiceManager } from './ServiceManager.js';
+import type { CommandRegistry } from '../commands/registry.js';
+export interface VirtualRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export interface VirtualResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+}
+export type VirtualRequestHandler = (req: VirtualRequest, res: VirtualResponse) => void;
+export type LoopbackRouter = (port: number, request: Request) => Promise<Response | null>;
+export declare function isLoopbackHost(host: string): boolean;
+export declare class Kernel {
+    vfs: VFS;
+    portRegistry: Map<number, VirtualRequestHandler>;
+    routeLoopback?: LoopbackRouter;
+    portBridge: PortBridge;
+    processRegistry: ProcessRegistry;
+    networkStack: NetworkStack;
+    serviceManager: ServiceManager | null;
+    private persistence;
+    constructor(backend?: PersistenceBackend);
+    boot(options?: {
+        persist?: boolean;
+    }): Promise<void>;
+    initFilesystem(): void;
+    initServiceManager(registry: CommandRegistry, defaultEnv: Record<string, string>): void;
+    bootServices(): Promise<void>;
+    getDefaultEnv(): Record<string, string>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/substrate/lifo/kernel/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/substrate/lifo/kernel/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAKrC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AA4C/D,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;AAExF,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;AAE1F,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,qBAAa,MAAM;IAClB,GAAG,EAAE,GAAG,CAAC;IACT,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAa;IAC7D,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,GAAG,IAAI,CAAQ;IAC7C,OAAO,CAAC,WAAW,CAAqB;gBAE5B,OAAO,CAAC,EAAE,kBAAkB;IAUlC,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB1D,cAAc,IAAI,IAAI;IAoEtB,kBAAkB,CAAC,QAAQ,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAIjF,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAMnC,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAWvC"}

package/dist/substrate/lifo/kernel/index.js

@@ -0,0 +1,170 @@
+import { VFS } from './vfs/index.js';
+import { ProcProvider } from './vfs/providers/ProcProvider.js';
+import { DevProvider } from './vfs/providers/DevProvider.js';
+import { PersistenceManager } from './persistence/PersistenceManager.js';
+import { MemoryPersistenceBackend } from './persistence/backends.js';
+import { ProcessRegistry } from '../shell/ProcessRegistry.js';
+import { NetworkStack } from './network/NetworkStack.js';
+import { PortBridge } from './network/PortBridge.js';
+import { installSamples } from './samples.js';
+import { ServiceManager } from './ServiceManager.js';
+import { DEFAULT_PATH } from '../../../constants.js';
+const MOTD = `\x1b[1;36m
+ _     _  __
+| |   (_)/ _| ___
+| |   | | |_ / _ \\
+| |___| |  _| (_) |
+|_____|_|_|  \\___/
+\x1b[0m
+\x1b[2mA Linux-like OS running natively in your browser.\x1b[0m
+\x1b[2mType 'help' or try: ls, cd, cat, mkdir, touch\x1b[0m
+\x1b[2mExplore examples: ls ~/examples/scripts\x1b[0m
+`;
+const DEFAULT_PROFILE = `export PATH=${DEFAULT_PATH}
+export EDITOR=nano
+`;
+const DEFAULT_LIFORC = `# ~/.liforc - Lifo shell configuration
+# This file is sourced on shell startup. Edit it to customize your shell.
+# Changes take effect on next shell start (refresh the page).
+
+# ─── Aliases ───
+alias ll='ls -la'
+alias la='ls -a'
+alias l='ls -1'
+alias ..='cd ..'
+alias ...='cd ../..'
+alias cls='clear'
+alias h='history'
+alias q='exit'
+alias md='mkdir -p'
+alias rd='rmdir'
+
+# ─── Environment ───
+export EDITOR=nano
+export PAGER=less
+`;
+const DEFAULT_HOSTS = `127.0.0.1       localhost
+::1             localhost ip6-localhost ip6-loopback
+`;
+export function isLoopbackHost(host) {
+    return host === 'localhost' || host === '127.0.0.1' || host === '0.0.0.0' || host === '[::1]';
+}
+export class Kernel {
+    vfs;
+    portRegistry = new Map();
+    routeLoopback;
+    portBridge;
+    processRegistry;
+    networkStack;
+    serviceManager = null;
+    persistence;
+    constructor(backend) {
+        this.vfs = new VFS();
+        this.processRegistry = new ProcessRegistry();
+        this.networkStack = new NetworkStack();
+        this.portBridge = new PortBridge(this.portRegistry);
+        this.persistence = new PersistenceManager(backend ?? new MemoryPersistenceBackend());
+    }
+    async boot(options) {
+        const persist = options?.persist ?? true;
+        if (persist) {
+            // 1. Load persisted filesystem
+            await this.persistence.open();
+            const saved = await this.persistence.load();
+            if (saved) {
+                this.vfs.loadFromSerialized(saved);
+            }
+        }
+        // 2. Initialize standard dirs (idempotent)
+        this.initFilesystem();
+        if (persist) {
+            // 4. Hook persistence via watch events
+            this.vfs.watch(() => {
+                this.persistence.scheduleSave(this.vfs.getRoot());
+            });
+        }
+    }
+    initFilesystem() {
+        // /proc and /dev are synthesised, never persisted. They belong to the
+        // filesystem tree itself, so they are registered here rather than in
+        // boot() — sessions that build the kernel by hand call initFilesystem()
+        // directly and must get the same namespace.
+        this.vfs.registerProvider('/proc', new ProcProvider());
+        this.vfs.registerProvider('/dev', new DevProvider());
+        const dirs = [
+            '/bin',
+            '/etc',
+            '/home',
+            '/home/user',
+            '/tmp',
+            '/var',
+            '/var/log',
+            '/usr',
+            '/usr/bin',
+            '/usr/share',
+            '/usr/share/pkg',
+            '/usr/share/pkg/node_modules',
+            '/etc/systemd/system',
+            '/etc/systemd/system/multi-user.target.wants',
+        ];
+        for (const dir of dirs) {
+            try {
+                this.vfs.mkdir(dir, { recursive: true });
+            }
+            catch {
+                // Directory already exists -- ignore
+            }
+        }
+        // Write system files (always overwrite MOTD/hostname)
+        this.vfs.writeFile('/etc/motd', MOTD);
+        this.vfs.writeFile('/etc/hostname', 'lifo\n');
+        // Write default config files only if they don't exist
+        if (!this.vfs.exists('/etc/profile')) {
+            this.vfs.writeFile('/etc/profile', DEFAULT_PROFILE);
+        }
+        // Migrate old .bashrc to .liforc
+        if (this.vfs.exists('/home/user/.bashrc') && !this.vfs.exists('/home/user/.liforc')) {
+            // Preserve user's existing .bashrc content by renaming it
+            try {
+                const existing = this.vfs.readFileString('/home/user/.bashrc');
+                this.vfs.writeFile('/home/user/.liforc', existing);
+            }
+            catch { /* ignore */ }
+        }
+        if (!this.vfs.exists('/home/user/.liforc')) {
+            this.vfs.writeFile('/home/user/.liforc', DEFAULT_LIFORC);
+        }
+        if (!this.vfs.exists('/etc/hosts')) {
+            this.vfs.writeFile('/etc/hosts', DEFAULT_HOSTS);
+        }
+        // Load hosts file into DNS resolver
+        try {
+            const hostsContent = this.vfs.readFileString('/etc/hosts');
+            this.networkStack.getDNS().loadHostsFile(hostsContent);
+        }
+        catch {
+            // Ignore if hosts file doesn't exist
+        }
+        // Install example files
+        installSamples(this.vfs);
+    }
+    initServiceManager(registry, defaultEnv) {
+        this.serviceManager = new ServiceManager(this.vfs, registry, defaultEnv);
+    }
+    async bootServices() {
+        if (this.serviceManager) {
+            await this.serviceManager.bootEnabledServices();
+        }
+    }
+    getDefaultEnv() {
+        return {
+            HOME: '/home/user',
+            USER: 'user',
+            HOSTNAME: 'lifo',
+            SHELL: '/bin/sh',
+            PATH: '/usr/bin:/bin',
+            TERM: 'xterm-256color',
+            PWD: '/home/user',
+        };
+    }
+}

package/dist/substrate/lifo/kernel/network/Bridge.d.ts

@@ -0,0 +1,110 @@
+import type { Packet } from './types.js';
+import { NetworkInterface } from './NetworkInterface.js';
+import type { NetworkStack } from './NetworkStack.js';
+/**
+ * Bridge Device - Virtual Network Switch (like Linux bridge)
+ *
+ * Acts as a Layer 2 switch, forwarding packets between connected interfaces.
+ * Similar to Linux 'ip link add br0 type bridge' or Docker's docker0 bridge.
+ *
+ * Example:
+ *   ip link add br0 type bridge
+ *   ip link set veth0 master br0
+ *   ip link set veth1 master br0
+ */
+export declare class Bridge {
+    name: string;
+    interface: NetworkInterface;
+    state: 'up' | 'down';
+    private ports;
+    private macTable;
+    private ageingTime;
+    private lastSeen;
+    constructor(name: string, _networkStack: NetworkStack, namespace?: string);
+    /**
+     * Bring bridge up
+     */
+    up(): Promise<void>;
+    /**
+     * Bring bridge down
+     */
+    down(): Promise<void>;
+    /**
+     * Add interface to bridge (make it a bridge port)
+     */
+    addPort(iface: NetworkInterface): void;
+    /**
+     * Remove interface from bridge
+     */
+    removePort(ifaceName: string): boolean;
+    /**
+     * Get all bridge ports
+     */
+    getPorts(): NetworkInterface[];
+    /**
+     * Check if interface is a bridge port
+     */
+    hasPort(ifaceName: string): boolean;
+    /**
+     * Forward packet through bridge (like a network switch)
+     *
+     * This is the core bridge logic:
+     * 1. Learn source MAC address
+     * 2. Look up destination MAC in forwarding table
+     * 3. Forward to specific port or flood to all ports
+     */
+    forward(packet: Packet, ingressPort: string): Promise<void>;
+    /**
+     * Learn MAC address -> port mapping
+     */
+    private learn;
+    /**
+     * Forward packet to specific port
+     */
+    private forwardToPort;
+    /**
+     * Flood packet to all ports except ingress
+     */
+    private flood;
+    /**
+     * Age out old MAC table entries
+     */
+    private ageEntries;
+    /**
+     * Get source MAC from packet (simplified)
+     */
+    private getSourceMAC;
+    /**
+     * Get destination MAC from packet (simplified)
+     */
+    private getDestMAC;
+    /**
+     * Show bridge MAC address table
+     */
+    showFdb(): string[];
+    /**
+     * Get bridge status string
+     */
+    toString(): string;
+    /**
+     * Get detailed bridge info
+     */
+    getInfo(): string[];
+    /**
+     * Set ageing time
+     */
+    setAgeingTime(seconds: number): void;
+    /**
+     * Clear MAC table
+     */
+    clearFdb(): void;
+    /**
+     * Generate MAC address for bridge
+     */
+    private generateBridgeMAC;
+    /**
+     * Get statistics
+     */
+    getStats(): import("./types.js").InterfaceStats;
+}
+//# sourceMappingURL=Bridge.d.ts.map

package/dist/substrate/lifo/kernel/network/Bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bridge.d.ts","sourceRoot":"","sources":["../../../../../src/substrate/lifo/kernel/network/Bridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,gBAAgB,CAAC;IAC5B,KAAK,EAAE,IAAI,GAAG,MAAM,CAAU;IAG9B,OAAO,CAAC,KAAK,CAAuC;IAGpD,OAAO,CAAC,QAAQ,CAA6B;IAG7C,OAAO,CAAC,UAAU,CAAO;IAGzB,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,SAAY;IAQ5E;;OAEG;IACG,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAczB;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAYtC;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAkBtC;;OAEG;IACH,QAAQ,IAAI,gBAAgB,EAAE;IAI9B;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAInC;;;;;;;OAOG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BjE;;OAEG;IACH,OAAO,CAAC,KAAK;IAQb;;OAEG;YACW,aAAa;IAe3B;;OAEG;YACW,KAAK;IAoBnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAYlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAKpB;;OAEG;IACH,OAAO,CAAC,UAAU;IAMlB;;OAEG;IACH,OAAO,IAAI,MAAM,EAAE;IAuBnB;;OAEG;IACH,QAAQ,IAAI,MAAM;IAQlB;;OAEG;IACH,OAAO,IAAI,MAAM,EAAE;IAwBnB;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIpC;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,QAAQ;CAGT"}