recker 1.0.19-next.f5bb375 → 1.0.20-next.595cc59

package/dist/testing/mock-ftp-server.js

@@ -0,0 +1,562 @@
+import { EventEmitter } from 'node:events';
+import * as net from 'node:net';
+export class MockFtpServer extends EventEmitter {
+    options;
+    server = null;
+    sessions = new Map();
+    files = new Map();
+    started = false;
+    sessionCounter = 0;
+    dataPortCounter = 30000;
+    stats = {
+        connectionsTotal: 0,
+        commandsReceived: 0,
+        filesDownloaded: 0,
+        filesUploaded: 0,
+        bytesTransferred: 0,
+        commandLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 2121,
+            host: '127.0.0.1',
+            anonymous: true,
+            username: 'user',
+            password: 'pass',
+            welcomeMessage: 'Welcome to Recker Mock FTP Server',
+            delay: 0,
+            ...options,
+        };
+        this.addDefaultFiles();
+    }
+    get isRunning() {
+        return this.started;
+    }
+    get port() {
+        return this.options.port;
+    }
+    get host() {
+        return this.options.host;
+    }
+    get url() {
+        return `ftp://${this.options.host}:${this.options.port}`;
+    }
+    get statistics() {
+        return { ...this.stats };
+    }
+    addFile(path, content) {
+        const normalizedPath = this.normalizePath(path);
+        const data = typeof content === 'string' ? content : content;
+        this.files.set(normalizedPath, {
+            content: data,
+            size: typeof content === 'string' ? Buffer.byteLength(content) : content.length,
+            modified: new Date(),
+            isDirectory: false,
+        });
+        const parts = normalizedPath.split('/').filter(Boolean);
+        let currentPath = '';
+        for (let i = 0; i < parts.length - 1; i++) {
+            currentPath += '/' + parts[i];
+            if (!this.files.has(currentPath)) {
+                this.files.set(currentPath, {
+                    content: '',
+                    size: 0,
+                    modified: new Date(),
+                    isDirectory: true,
+                });
+            }
+        }
+    }
+    addDirectory(path) {
+        const normalizedPath = this.normalizePath(path);
+        this.files.set(normalizedPath, {
+            content: '',
+            size: 0,
+            modified: new Date(),
+            isDirectory: true,
+        });
+    }
+    removeFile(path) {
+        return this.files.delete(this.normalizePath(path));
+    }
+    getFile(path) {
+        return this.files.get(this.normalizePath(path));
+    }
+    listDirectory(path) {
+        const normalizedPath = this.normalizePath(path);
+        const prefix = normalizedPath === '/' ? '/' : normalizedPath + '/';
+        const entries = [];
+        for (const [filePath] of this.files) {
+            if (filePath.startsWith(prefix) && filePath !== normalizedPath) {
+                const relative = filePath.substring(prefix.length);
+                const firstPart = relative.split('/')[0];
+                if (firstPart && !entries.includes(firstPart)) {
+                    entries.push(firstPart);
+                }
+            }
+        }
+        return entries.sort();
+    }
+    clearFiles() {
+        this.files.clear();
+        this.addDefaultFiles();
+    }
+    normalizePath(path) {
+        let normalized = path.replace(/\/+/g, '/');
+        if (!normalized.startsWith('/')) {
+            normalized = '/' + normalized;
+        }
+        if (normalized.length > 1 && normalized.endsWith('/')) {
+            normalized = normalized.slice(0, -1);
+        }
+        return normalized;
+    }
+    addDefaultFiles() {
+        this.addDirectory('/');
+        this.addFile('/welcome.txt', 'Welcome to the FTP server!\nThis is a test file.');
+        this.addFile('/readme.md', '# Mock FTP Server\n\nThis is a mock FTP server for testing.');
+        this.addDirectory('/data');
+        this.addFile('/data/sample.json', JSON.stringify({ message: 'Hello', count: 42 }, null, 2));
+        this.addFile('/data/config.txt', 'host=localhost\nport=8080\ndebug=true');
+        this.addDirectory('/public');
+        this.addFile('/public/index.html', '<html><body><h1>Public Files</h1></body></html>');
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('Server already started');
+        }
+        return new Promise((resolve, reject) => {
+            this.server = net.createServer((socket) => {
+                this.handleConnection(socket);
+            });
+            this.server.on('error', (err) => {
+                this.emit('error', err);
+                if (!this.started) {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.options.port, this.options.host, () => {
+                this.started = true;
+                this.emit('start');
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this.started || !this.server)
+            return;
+        for (const session of this.sessions.values()) {
+            session.passiveSocket?.close();
+            session.socket.end();
+        }
+        this.sessions.clear();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.server = null;
+                this.started = false;
+                this.emit('stop');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.stats = {
+            connectionsTotal: 0,
+            commandsReceived: 0,
+            filesDownloaded: 0,
+            filesUploaded: 0,
+            bytesTransferred: 0,
+            commandLog: [],
+        };
+        this.clearFiles();
+        this.emit('reset');
+    }
+    handleConnection(socket) {
+        const sessionId = `ftp-${++this.sessionCounter}`;
+        const session = {
+            id: sessionId,
+            socket,
+            authenticated: false,
+            username: null,
+            currentDir: '/',
+            transferMode: 'BINARY',
+            passiveSocket: null,
+            connectedAt: new Date(),
+        };
+        this.sessions.set(sessionId, session);
+        this.stats.connectionsTotal++;
+        this.emit('connect', session);
+        this.sendResponse(socket, 220, this.options.welcomeMessage);
+        let inputBuffer = '';
+        socket.on('data', async (data) => {
+            inputBuffer += data.toString('utf8');
+            while (inputBuffer.includes('\r\n')) {
+                const lineEnd = inputBuffer.indexOf('\r\n');
+                const line = inputBuffer.substring(0, lineEnd);
+                inputBuffer = inputBuffer.substring(lineEnd + 2);
+                if (line) {
+                    await this.handleCommand(line, session);
+                }
+            }
+        });
+        socket.on('close', () => {
+            session.passiveSocket?.close();
+            this.sessions.delete(sessionId);
+            this.emit('disconnect', session);
+        });
+        socket.on('error', (err) => {
+            this.emit('error', err, session);
+            this.sessions.delete(sessionId);
+        });
+    }
+    async handleCommand(line, session) {
+        this.stats.commandsReceived++;
+        const spaceIndex = line.indexOf(' ');
+        const command = (spaceIndex > 0 ? line.substring(0, spaceIndex) : line).toUpperCase();
+        const args = spaceIndex > 0 ? line.substring(spaceIndex + 1) : '';
+        this.stats.commandLog.push({
+            command: line,
+            sessionId: session.id,
+            timestamp: Date.now(),
+        });
+        this.emit('command', command, args, session);
+        if (this.options.delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+        }
+        switch (command) {
+            case 'USER':
+                this.handleUser(args, session);
+                break;
+            case 'PASS':
+                this.handlePass(args, session);
+                break;
+            case 'SYST':
+                this.sendResponse(session.socket, 215, 'UNIX Type: L8');
+                break;
+            case 'FEAT':
+                this.sendMultilineResponse(session.socket, 211, ['Features:', ' PASV', ' SIZE', ' UTF8', 'End']);
+                break;
+            case 'PWD':
+            case 'XPWD':
+                this.sendResponse(session.socket, 257, `"${session.currentDir}" is current directory`);
+                break;
+            case 'CWD':
+            case 'XCWD':
+                this.handleCwd(args, session);
+                break;
+            case 'CDUP':
+            case 'XCUP':
+                this.handleCdup(session);
+                break;
+            case 'TYPE':
+                this.handleType(args, session);
+                break;
+            case 'PASV':
+                await this.handlePasv(session);
+                break;
+            case 'LIST':
+                await this.handleList(args, session);
+                break;
+            case 'NLST':
+                await this.handleNlst(args, session);
+                break;
+            case 'RETR':
+                await this.handleRetr(args, session);
+                break;
+            case 'STOR':
+                await this.handleStor(args, session);
+                break;
+            case 'SIZE':
+                this.handleSize(args, session);
+                break;
+            case 'MDTM':
+                this.handleMdtm(args, session);
+                break;
+            case 'MKD':
+            case 'XMKD':
+                this.handleMkd(args, session);
+                break;
+            case 'RMD':
+            case 'XRMD':
+                this.handleRmd(args, session);
+                break;
+            case 'DELE':
+                this.handleDele(args, session);
+                break;
+            case 'NOOP':
+                this.sendResponse(session.socket, 200, 'NOOP ok');
+                break;
+            case 'QUIT':
+                this.sendResponse(session.socket, 221, 'Goodbye');
+                session.socket.end();
+                break;
+            default:
+                this.sendResponse(session.socket, 502, `Command not implemented: ${command}`);
+        }
+    }
+    handleUser(username, session) {
+        session.username = username;
+        if (this.options.anonymous && (username.toLowerCase() === 'anonymous' || username.toLowerCase() === 'ftp')) {
+            session.authenticated = true;
+            this.sendResponse(session.socket, 230, 'Anonymous access granted');
+        }
+        else {
+            this.sendResponse(session.socket, 331, 'Password required');
+        }
+    }
+    handlePass(password, session) {
+        if (session.authenticated) {
+            this.sendResponse(session.socket, 230, 'Already logged in');
+            return;
+        }
+        if (session.username === this.options.username && password === this.options.password) {
+            session.authenticated = true;
+            this.sendResponse(session.socket, 230, 'Login successful');
+        }
+        else if (this.options.anonymous && session.username?.toLowerCase() === 'anonymous') {
+            session.authenticated = true;
+            this.sendResponse(session.socket, 230, 'Anonymous access granted');
+        }
+        else {
+            this.sendResponse(session.socket, 530, 'Login incorrect');
+        }
+    }
+    handleCwd(path, session) {
+        if (!this.requireAuth(session))
+            return;
+        const newPath = this.resolvePath(path, session.currentDir);
+        const dir = this.files.get(newPath);
+        if (dir && dir.isDirectory) {
+            session.currentDir = newPath;
+            this.sendResponse(session.socket, 250, 'Directory changed');
+        }
+        else {
+            this.sendResponse(session.socket, 550, 'Directory not found');
+        }
+    }
+    handleCdup(session) {
+        if (!this.requireAuth(session))
+            return;
+        if (session.currentDir !== '/') {
+            const parts = session.currentDir.split('/').filter(Boolean);
+            parts.pop();
+            session.currentDir = '/' + parts.join('/') || '/';
+        }
+        this.sendResponse(session.socket, 250, 'Directory changed');
+    }
+    handleType(type, session) {
+        const mode = type.toUpperCase();
+        if (mode === 'A' || mode === 'A N') {
+            session.transferMode = 'ASCII';
+            this.sendResponse(session.socket, 200, 'Type set to ASCII');
+        }
+        else if (mode === 'I' || mode === 'L 8') {
+            session.transferMode = 'BINARY';
+            this.sendResponse(session.socket, 200, 'Type set to Binary');
+        }
+        else {
+            this.sendResponse(session.socket, 504, 'Type not supported');
+        }
+    }
+    async handlePasv(session) {
+        if (!this.requireAuth(session))
+            return;
+        session.passiveSocket?.close();
+        const dataPort = this.dataPortCounter++;
+        if (this.dataPortCounter > 32000)
+            this.dataPortCounter = 30000;
+        return new Promise((resolve) => {
+            session.passiveSocket = net.createServer();
+            session.passiveSocket.listen(dataPort, this.options.host, () => {
+                const p1 = Math.floor(dataPort / 256);
+                const p2 = dataPort % 256;
+                const hostParts = this.options.host.split('.');
+                this.sendResponse(session.socket, 227, `Entering Passive Mode (${hostParts.join(',')},${p1},${p2})`);
+                resolve();
+            });
+        });
+    }
+    async handleList(path, session) {
+        if (!this.requireAuth(session))
+            return;
+        const targetPath = path ? this.resolvePath(path, session.currentDir) : session.currentDir;
+        const entries = this.listDirectory(targetPath);
+        this.sendResponse(session.socket, 150, 'Opening data connection');
+        const dataSocket = await this.waitForDataConnection(session);
+        if (!dataSocket) {
+            this.sendResponse(session.socket, 425, 'No data connection');
+            return;
+        }
+        const lines = [];
+        for (const entry of entries) {
+            const entryPath = targetPath === '/' ? `/${entry}` : `${targetPath}/${entry}`;
+            const file = this.files.get(entryPath);
+            if (file) {
+                const type = file.isDirectory ? 'd' : '-';
+                const size = file.size.toString().padStart(8);
+                const date = file.modified.toISOString().substring(0, 10);
+                lines.push(`${type}rw-r--r-- 1 user group ${size} ${date} ${entry}`);
+            }
+        }
+        dataSocket.write(lines.join('\r\n') + '\r\n');
+        dataSocket.end();
+        this.sendResponse(session.socket, 226, 'Transfer complete');
+    }
+    async handleNlst(path, session) {
+        if (!this.requireAuth(session))
+            return;
+        const targetPath = path ? this.resolvePath(path, session.currentDir) : session.currentDir;
+        const entries = this.listDirectory(targetPath);
+        this.sendResponse(session.socket, 150, 'Opening data connection');
+        const dataSocket = await this.waitForDataConnection(session);
+        if (!dataSocket) {
+            this.sendResponse(session.socket, 425, 'No data connection');
+            return;
+        }
+        dataSocket.write(entries.join('\r\n') + '\r\n');
+        dataSocket.end();
+        this.sendResponse(session.socket, 226, 'Transfer complete');
+    }
+    async handleRetr(filename, session) {
+        if (!this.requireAuth(session))
+            return;
+        const filePath = this.resolvePath(filename, session.currentDir);
+        const file = this.files.get(filePath);
+        if (!file || file.isDirectory) {
+            this.sendResponse(session.socket, 550, 'File not found');
+            return;
+        }
+        this.sendResponse(session.socket, 150, 'Opening data connection');
+        const dataSocket = await this.waitForDataConnection(session);
+        if (!dataSocket) {
+            this.sendResponse(session.socket, 425, 'No data connection');
+            return;
+        }
+        const content = typeof file.content === 'string' ? Buffer.from(file.content) : file.content;
+        dataSocket.write(content);
+        dataSocket.end();
+        this.stats.filesDownloaded++;
+        this.stats.bytesTransferred += content.length;
+        this.sendResponse(session.socket, 226, 'Transfer complete');
+    }
+    async handleStor(filename, session) {
+        if (!this.requireAuth(session))
+            return;
+        const filePath = this.resolvePath(filename, session.currentDir);
+        this.sendResponse(session.socket, 150, 'Opening data connection');
+        const dataSocket = await this.waitForDataConnection(session);
+        if (!dataSocket) {
+            this.sendResponse(session.socket, 425, 'No data connection');
+            return;
+        }
+        const chunks = [];
+        dataSocket.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        dataSocket.on('end', () => {
+            const content = Buffer.concat(chunks);
+            this.addFile(filePath, content);
+            this.stats.filesUploaded++;
+            this.stats.bytesTransferred += content.length;
+            this.sendResponse(session.socket, 226, 'Transfer complete');
+        });
+    }
+    handleSize(filename, session) {
+        if (!this.requireAuth(session))
+            return;
+        const filePath = this.resolvePath(filename, session.currentDir);
+        const file = this.files.get(filePath);
+        if (!file || file.isDirectory) {
+            this.sendResponse(session.socket, 550, 'File not found');
+        }
+        else {
+            this.sendResponse(session.socket, 213, file.size.toString());
+        }
+    }
+    handleMdtm(filename, session) {
+        if (!this.requireAuth(session))
+            return;
+        const filePath = this.resolvePath(filename, session.currentDir);
+        const file = this.files.get(filePath);
+        if (!file) {
+            this.sendResponse(session.socket, 550, 'File not found');
+        }
+        else {
+            const date = file.modified.toISOString().replace(/[-:T]/g, '').substring(0, 14);
+            this.sendResponse(session.socket, 213, date);
+        }
+    }
+    handleMkd(dirname, session) {
+        if (!this.requireAuth(session))
+            return;
+        const dirPath = this.resolvePath(dirname, session.currentDir);
+        this.addDirectory(dirPath);
+        this.sendResponse(session.socket, 257, `"${dirPath}" created`);
+    }
+    handleRmd(dirname, session) {
+        if (!this.requireAuth(session))
+            return;
+        const dirPath = this.resolvePath(dirname, session.currentDir);
+        if (this.removeFile(dirPath)) {
+            this.sendResponse(session.socket, 250, 'Directory removed');
+        }
+        else {
+            this.sendResponse(session.socket, 550, 'Directory not found');
+        }
+    }
+    handleDele(filename, session) {
+        if (!this.requireAuth(session))
+            return;
+        const filePath = this.resolvePath(filename, session.currentDir);
+        if (this.removeFile(filePath)) {
+            this.sendResponse(session.socket, 250, 'File deleted');
+        }
+        else {
+            this.sendResponse(session.socket, 550, 'File not found');
+        }
+    }
+    requireAuth(session) {
+        if (!session.authenticated) {
+            this.sendResponse(session.socket, 530, 'Please login first');
+            return false;
+        }
+        return true;
+    }
+    resolvePath(path, currentDir) {
+        if (path.startsWith('/')) {
+            return this.normalizePath(path);
+        }
+        return this.normalizePath(currentDir + '/' + path);
+    }
+    sendResponse(socket, code, message) {
+        socket.write(`${code} ${message}\r\n`);
+    }
+    sendMultilineResponse(socket, code, lines) {
+        for (let i = 0; i < lines.length - 1; i++) {
+            socket.write(`${code}-${lines[i]}\r\n`);
+        }
+        socket.write(`${code} ${lines[lines.length - 1]}\r\n`);
+    }
+    async waitForDataConnection(session) {
+        if (!session.passiveSocket)
+            return null;
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                session.passiveSocket?.close();
+                resolve(null);
+            }, 5000);
+            session.passiveSocket.once('connection', (socket) => {
+                clearTimeout(timeout);
+                session.passiveSocket.close();
+                session.passiveSocket = null;
+                resolve(socket);
+            });
+        });
+    }
+    static async create(options = {}) {
+        const server = new MockFtpServer(options);
+        await server.start();
+        return server;
+    }
+}

package/dist/testing/mock-hls-server.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'node:events';
+import type { Transport } from '../types/index.js';
+export interface MockHlsServerOptions {
+    mode?: 'vod' | 'live' | 'event';
+    segmentDuration?: number;
+    segmentCount?: number;
+    windowSize?: number;
+    startSequence?: number;
+    realtime?: boolean;
+    segmentInterval?: number;
+    multiQuality?: boolean;
+    variants?: MockHlsVariant[];
+    encrypted?: boolean;
+    baseUrl?: string;
+    delay?: number;
+    segmentDataGenerator?: (sequence: number, variant?: string) => Uint8Array;
+}
+export interface MockHlsVariant {
+    name: string;
+    bandwidth: number;
+    resolution?: string;
+    codecs?: string;
+}
+export interface MockHlsSegment {
+    sequence: number;
+    duration: number;
+    data: Uint8Array;
+    addedAt: number;
+    programDateTime?: Date;
+    discontinuity?: boolean;
+}
+export interface MockHlsStats {
+    playlistRequests: number;
+    segmentRequests: number;
+    segmentsServed: number;
+    bytesServed: number;
+    requestLog: Array<{
+        url: string;
+        timestamp: number;
+    }>;
+}
+export declare class MockHlsServer extends EventEmitter {
+    private options;
+    private segments;
+    private currentSequence;
+    private ended;
+    private started;
+    private realtimeInterval;
+    private startTime;
+    private stats;
+    constructor(options?: MockHlsServerOptions);
+    get isRunning(): boolean;
+    get isEnded(): boolean;
+    get manifestUrl(): string;
+    get segmentCount(): number;
+    get statistics(): MockHlsStats;
+    get transport(): Transport;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    endStream(): void;
+    reset(): void;
+    addSegment(variant?: string, options?: Partial<MockHlsSegment>): MockHlsSegment;
+    addDiscontinuity(variant?: string): void;
+    getSegments(variant?: string): MockHlsSegment[];
+    private handleRequest;
+    private handleMasterPlaylist;
+    private handleMediaPlaylist;
+    private handleSegment;
+    private handleKey;
+    private createResponse;
+    private initializeVodSegments;
+    private initializeLiveSegments;
+    private addSegmentToAllVariants;
+    private startRealtimeSegmentGeneration;
+    private defaultSegmentGenerator;
+    static create(options?: MockHlsServerOptions): Promise<MockHlsServer>;
+}
+export declare function createMockHlsVod(segmentCount?: number, options?: Omit<MockHlsServerOptions, 'mode' | 'segmentCount'>): Promise<MockHlsServer>;
+export declare function createMockHlsLive(options?: Omit<MockHlsServerOptions, 'mode'>): Promise<MockHlsServer>;
+export declare function createMockHlsMultiQuality(options?: Omit<MockHlsServerOptions, 'multiQuality'>): Promise<MockHlsServer>;
+//# sourceMappingURL=mock-hls-server.d.ts.map

package/dist/testing/mock-hls-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-hls-server.d.ts","sourceRoot":"","sources":["../../src/testing/mock-hls-server.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAMnD,MAAM,WAAW,oBAAoB;IAQnC,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;IAMhC,eAAe,CAAC,EAAE,MAAM,CAAC;IAMzB,YAAY,CAAC,EAAE,MAAM,CAAC;IAMtB,UAAU,CAAC,EAAE,MAAM,CAAC;IAMpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAOvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAMnB,eAAe,CAAC,EAAE,MAAM,CAAC;IAMzB,YAAY,CAAC,EAAE,OAAO,CAAC;IAKvB,QAAQ,CAAC,EAAE,cAAc,EAAE,CAAC;IAM5B,SAAS,CAAC,EAAE,OAAO,CAAC;IAMpB,OAAO,CAAC,EAAE,MAAM,CAAC;IAMjB,KAAK,CAAC,EAAE,MAAM,CAAC;IAMf,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;CAC3E;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,IAAI,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvD;AAiBD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,KAAK,CAMX;gBAEU,OAAO,GAAE,oBAAyB;IA6B9C,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED,IAAI,YAAY,IAAI,MAAM,CAGzB;IAED,IAAI,UAAU,IAAI,YAAY,CAE7B;IAKD,IAAI,SAAS,IAAI,SAAS,CAIzB;IASK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAe3B,SAAS,IAAI,IAAI;IAgBjB,KAAK,IAAI,IAAI;IA8Bb,UAAU,CAAC,OAAO,GAAE,MAAkB,EAAE,OAAO,GAAE,OAAO,CAAC,cAAc,CAAM,GAAG,cAAc;IA6B9F,gBAAgB,CAAC,OAAO,GAAE,MAAkB,GAAG,IAAI;IAOnD,WAAW,CAAC,OAAO,GAAE,MAAkB,GAAG,cAAc,EAAE;YAQ5C,aAAa;IA+B3B,OAAO,CAAC,oBAAoB;IAwB5B,OAAO,CAAC,mBAAmB;IAkE3B,OAAO,CAAC,aAAa;IA8BrB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,cAAc;IAqBtB,OAAO,CAAC,qBAAqB;IA2B7B,OAAO,CAAC,sBAAsB;IAsB9B,OAAO,CAAC,uBAAuB;IA6B/B,OAAO,CAAC,8BAA8B;IAOtC,OAAO,CAAC,uBAAuB;WAmBlB,MAAM,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;CAKhF;AASD,wBAAsB,gBAAgB,CACpC,YAAY,SAAK,EACjB,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,cAAc,CAAM,GAChE,OAAO,CAAC,aAAa,CAAC,CAMxB;AAKD,wBAAsB,iBAAiB,CACrC,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAM,GAC/C,OAAO,CAAC,aAAa,CAAC,CAQxB;AAKD,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,cAAc,CAAM,GACvD,OAAO,CAAC,aAAa,CAAC,CAKxB"}