@push.rocks/smartregistry 1.1.1 → 1.4.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartregistry',
-    version: '1.1.1',
+    version: '1.4.0',
     description: 'a registry for npm modules and oci images'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSwyQkFBMkI7SUFDakMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDJDQUEyQztDQUN6RCxDQUFBIn0=

package/dist_ts/cargo/classes.cargoregistry.d.ts

@@ -0,0 +1,79 @@
+import { BaseRegistry } from '../core/classes.baseregistry.js';
+import { RegistryStorage } from '../core/classes.registrystorage.js';
+import { AuthManager } from '../core/classes.authmanager.js';
+import type { IRequestContext, IResponse, IAuthToken } from '../core/interfaces.core.js';
+/**
+ * Cargo/crates.io registry implementation
+ * Implements the sparse HTTP-based protocol
+ * Spec: https://doc.rust-lang.org/cargo/reference/registry-index.html
+ */
+export declare class CargoRegistry extends BaseRegistry {
+    private storage;
+    private authManager;
+    private basePath;
+    private registryUrl;
+    private logger;
+    constructor(storage: RegistryStorage, authManager: AuthManager, basePath?: string, registryUrl?: string);
+    init(): Promise<void>;
+    getBasePath(): string;
+    handleRequest(context: IRequestContext): Promise<IResponse>;
+    /**
+     * Check if token has permission for resource
+     */
+    protected checkPermission(token: IAuthToken | null, resource: string, action: string): Promise<boolean>;
+    /**
+     * Handle API requests (/api/v1/*)
+     */
+    private handleApiRequest;
+    /**
+     * Handle index file requests
+     * Paths: /1/{name}, /2/{name}, /3/{c}/{name}, /{p1}/{p2}/{name}
+     */
+    private handleIndexRequest;
+    /**
+     * Serve config.json
+     */
+    private handleConfigJson;
+    /**
+     * Serve index file for a crate
+     */
+    private handleIndexFile;
+    /**
+     * Parse binary publish request
+     * Format: [4 bytes JSON len][JSON][4 bytes crate len][.crate file]
+     */
+    private parsePublishRequest;
+    /**
+     * Handle crate publish
+     */
+    private handlePublish;
+    /**
+     * Handle crate download
+     */
+    private handleDownload;
+    /**
+     * Handle yank operation
+     */
+    private handleYank;
+    /**
+     * Handle unyank operation
+     */
+    private handleUnyank;
+    /**
+     * Handle yank/unyank operation
+     */
+    private handleYankOperation;
+    /**
+     * Handle search
+     */
+    private handleSearch;
+    /**
+     * Validate crate name
+     * Rules: lowercase alphanumeric + _ and -, length 1-64
+     */
+    private validateCrateName;
+    /**
+     * Create error response
+     */
+    private createError;
+}

package/dist_ts/cargo/classes.cargoregistry.js

@@ -0,0 +1,490 @@
+import { Smartlog } from '@push.rocks/smartlog';
+import { BaseRegistry } from '../core/classes.baseregistry.js';
+import { RegistryStorage } from '../core/classes.registrystorage.js';
+import { AuthManager } from '../core/classes.authmanager.js';
+/**
+ * Cargo/crates.io registry implementation
+ * Implements the sparse HTTP-based protocol
+ * Spec: https://doc.rust-lang.org/cargo/reference/registry-index.html
+ */
+export class CargoRegistry extends BaseRegistry {
+    storage;
+    authManager;
+    basePath = '/cargo';
+    registryUrl;
+    logger;
+    constructor(storage, authManager, basePath = '/cargo', registryUrl = 'http://localhost:5000/cargo') {
+        super();
+        this.storage = storage;
+        this.authManager = authManager;
+        this.basePath = basePath;
+        this.registryUrl = registryUrl;
+        // Initialize logger
+        this.logger = new Smartlog({
+            logContext: {
+                company: 'push.rocks',
+                companyunit: 'smartregistry',
+                containerName: 'cargo-registry',
+                environment: process.env.NODE_ENV || 'development',
+                runtime: 'node',
+                zone: 'cargo'
+            }
+        });
+        this.logger.enableConsole();
+    }
+    async init() {
+        // Initialize config.json if not exists
+        const existingConfig = await this.storage.getCargoConfig();
+        if (!existingConfig) {
+            const config = {
+                dl: `${this.registryUrl}/api/v1/crates/{crate}/{version}/download`,
+                api: this.registryUrl,
+            };
+            await this.storage.putCargoConfig(config);
+            this.logger.log('info', 'Initialized Cargo registry config', { config });
+        }
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+    async handleRequest(context) {
+        const path = context.path.replace(this.basePath, '');
+        // Extract token (Cargo uses Authorization header WITHOUT "Bearer" prefix)
+        const authHeader = context.headers['authorization'] || context.headers['Authorization'];
+        const token = authHeader ? await this.authManager.validateToken(authHeader, 'cargo') : null;
+        this.logger.log('debug', `handleRequest: ${context.method} ${path}`, {
+            method: context.method,
+            path,
+            hasAuth: !!token
+        });
+        // Config endpoint (required for sparse protocol)
+        if (path === '/config.json') {
+            return this.handleConfigJson();
+        }
+        // API endpoints
+        if (path.startsWith('/api/v1/')) {
+            return this.handleApiRequest(path, context, token);
+        }
+        // Index files (sparse protocol)
+        return this.handleIndexRequest(path);
+    }
+    /**
+     * Check if token has permission for resource
+     */
+    async checkPermission(token, resource, action) {
+        if (!token)
+            return false;
+        return this.authManager.authorize(token, `cargo:crate:${resource}`, action);
+    }
+    /**
+     * Handle API requests (/api/v1/*)
+     */
+    async handleApiRequest(path, context, token) {
+        // Publish: PUT /api/v1/crates/new
+        if (path === '/api/v1/crates/new' && context.method === 'PUT') {
+            return this.handlePublish(context.body, token);
+        }
+        // Download: GET /api/v1/crates/{crate}/{version}/download
+        const downloadMatch = path.match(/^\/api\/v1\/crates\/([^\/]+)\/([^\/]+)\/download$/);
+        if (downloadMatch && context.method === 'GET') {
+            return this.handleDownload(downloadMatch[1], downloadMatch[2]);
+        }
+        // Yank: DELETE /api/v1/crates/{crate}/{version}/yank
+        const yankMatch = path.match(/^\/api\/v1\/crates\/([^\/]+)\/([^\/]+)\/yank$/);
+        if (yankMatch && context.method === 'DELETE') {
+            return this.handleYank(yankMatch[1], yankMatch[2], token);
+        }
+        // Unyank: PUT /api/v1/crates/{crate}/{version}/unyank
+        const unyankMatch = path.match(/^\/api\/v1\/crates\/([^\/]+)\/([^\/]+)\/unyank$/);
+        if (unyankMatch && context.method === 'PUT') {
+            return this.handleUnyank(unyankMatch[1], unyankMatch[2], token);
+        }
+        // Search: GET /api/v1/crates?q={query}
+        if (path.startsWith('/api/v1/crates') && context.method === 'GET') {
+            const query = context.query?.q || '';
+            const perPage = parseInt(context.query?.per_page || '10', 10);
+            return this.handleSearch(query, perPage);
+        }
+        return {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' },
+            body: this.createError('API endpoint not found'),
+        };
+    }
+    /**
+     * Handle index file requests
+     * Paths: /1/{name}, /2/{name}, /3/{c}/{name}, /{p1}/{p2}/{name}
+     */
+    async handleIndexRequest(path) {
+        // Parse index paths to extract crate name
+        const pathParts = path.split('/').filter(p => p);
+        let crateName = null;
+        if (pathParts.length === 2 && pathParts[0] === '1') {
+            // 1-character names: /1/{name}
+            crateName = pathParts[1];
+        }
+        else if (pathParts.length === 2 && pathParts[0] === '2') {
+            // 2-character names: /2/{name}
+            crateName = pathParts[1];
+        }
+        else if (pathParts.length === 3 && pathParts[0] === '3') {
+            // 3-character names: /3/{c}/{name}
+            crateName = pathParts[2];
+        }
+        else if (pathParts.length === 3) {
+            // 4+ character names: /{p1}/{p2}/{name}
+            crateName = pathParts[2];
+        }
+        if (!crateName) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'text/plain' },
+                body: Buffer.from(''),
+            };
+        }
+        return this.handleIndexFile(crateName);
+    }
+    /**
+     * Serve config.json
+     */
+    async handleConfigJson() {
+        const config = await this.storage.getCargoConfig();
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: config || {
+                dl: `${this.registryUrl}/api/v1/crates/{crate}/{version}/download`,
+                api: this.registryUrl,
+            },
+        };
+    }
+    /**
+     * Serve index file for a crate
+     */
+    async handleIndexFile(crateName) {
+        const index = await this.storage.getCargoIndex(crateName);
+        if (!index || index.length === 0) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'text/plain' },
+                body: Buffer.from(''),
+            };
+        }
+        // Return newline-delimited JSON
+        const data = index.map(e => JSON.stringify(e)).join('\n') + '\n';
+        // Calculate ETag for caching
+        const crypto = await import('crypto');
+        const etag = `"${crypto.createHash('sha256').update(data).digest('hex')}"`;
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/plain',
+                'ETag': etag,
+            },
+            body: Buffer.from(data, 'utf-8'),
+        };
+    }
+    /**
+     * Parse binary publish request
+     * Format: [4 bytes JSON len][JSON][4 bytes crate len][.crate file]
+     */
+    parsePublishRequest(body) {
+        let offset = 0;
+        // Read JSON length (4 bytes, u32 little-endian)
+        if (body.length < 4) {
+            throw new Error('Invalid publish request: body too short');
+        }
+        const jsonLength = body.readUInt32LE(offset);
+        offset += 4;
+        // Read JSON metadata
+        if (body.length < offset + jsonLength) {
+            throw new Error('Invalid publish request: JSON data incomplete');
+        }
+        const jsonBuffer = body.slice(offset, offset + jsonLength);
+        const metadata = JSON.parse(jsonBuffer.toString('utf-8'));
+        offset += jsonLength;
+        // Read crate file length (4 bytes, u32 little-endian)
+        if (body.length < offset + 4) {
+            throw new Error('Invalid publish request: crate length missing');
+        }
+        const crateLength = body.readUInt32LE(offset);
+        offset += 4;
+        // Read crate file
+        if (body.length < offset + crateLength) {
+            throw new Error('Invalid publish request: crate data incomplete');
+        }
+        const crateFile = body.slice(offset, offset + crateLength);
+        return { metadata, crateFile };
+    }
+    /**
+     * Handle crate publish
+     */
+    async handlePublish(body, token) {
+        this.logger.log('info', 'handlePublish: received publish request', {
+            bodyLength: body?.length || 0,
+            hasAuth: !!token
+        });
+        // Check authorization
+        if (!token) {
+            return {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Authentication required'),
+            };
+        }
+        // Parse binary request
+        let metadata;
+        let crateFile;
+        try {
+            const parsed = this.parsePublishRequest(body);
+            metadata = parsed.metadata;
+            crateFile = parsed.crateFile;
+        }
+        catch (error) {
+            this.logger.log('error', 'handlePublish: parse error', { error: error.message });
+            return {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError(`Invalid request format: ${error.message}`),
+            };
+        }
+        // Validate crate name
+        if (!this.validateCrateName(metadata.name)) {
+            return {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Invalid crate name'),
+            };
+        }
+        // Check permission
+        const hasPermission = await this.checkPermission(token, metadata.name, 'write');
+        if (!hasPermission) {
+            this.logger.log('warn', 'handlePublish: unauthorized', {
+                crateName: metadata.name,
+                userId: token.userId
+            });
+            return {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Insufficient permissions'),
+            };
+        }
+        // Calculate SHA256 checksum
+        const crypto = await import('crypto');
+        const cksum = crypto.createHash('sha256').update(crateFile).digest('hex');
+        // Create index entry
+        const indexEntry = {
+            name: metadata.name,
+            vers: metadata.vers,
+            deps: metadata.deps,
+            cksum,
+            features: metadata.features,
+            yanked: false,
+            links: metadata.links || null,
+            v: 2,
+            rust_version: metadata.rust_version,
+        };
+        // Check for duplicate version
+        const existingIndex = await this.storage.getCargoIndex(metadata.name) || [];
+        if (existingIndex.some(e => e.vers === metadata.vers)) {
+            return {
+                status: 400,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError(`Version ${metadata.vers} already exists`),
+            };
+        }
+        // Store crate file
+        await this.storage.putCargoCrate(metadata.name, metadata.vers, crateFile);
+        // Update index (append new version)
+        existingIndex.push(indexEntry);
+        await this.storage.putCargoIndex(metadata.name, existingIndex);
+        this.logger.log('success', 'handlePublish: published crate', {
+            name: metadata.name,
+            version: metadata.vers,
+            checksum: cksum
+        });
+        const response = {
+            warnings: {
+                invalid_categories: [],
+                invalid_badges: [],
+                other: [],
+            },
+        };
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: response,
+        };
+    }
+    /**
+     * Handle crate download
+     */
+    async handleDownload(crateName, version) {
+        this.logger.log('debug', 'handleDownload', { crate: crateName, version });
+        const crateFile = await this.storage.getCargoCrate(crateName, version);
+        if (!crateFile) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Crate not found'),
+            };
+        }
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/gzip',
+                'Content-Length': crateFile.length.toString(),
+                'Content-Disposition': `attachment; filename="${crateName}-${version}.crate"`,
+            },
+            body: crateFile,
+        };
+    }
+    /**
+     * Handle yank operation
+     */
+    async handleYank(crateName, version, token) {
+        return this.handleYankOperation(crateName, version, token, true);
+    }
+    /**
+     * Handle unyank operation
+     */
+    async handleUnyank(crateName, version, token) {
+        return this.handleYankOperation(crateName, version, token, false);
+    }
+    /**
+     * Handle yank/unyank operation
+     */
+    async handleYankOperation(crateName, version, token, yank) {
+        this.logger.log('info', `handle${yank ? 'Yank' : 'Unyank'}`, {
+            crate: crateName,
+            version,
+            hasAuth: !!token
+        });
+        // Check authorization
+        if (!token) {
+            return {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Authentication required'),
+            };
+        }
+        // Check permission
+        const hasPermission = await this.checkPermission(token, crateName, 'write');
+        if (!hasPermission) {
+            return {
+                status: 403,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Insufficient permissions'),
+            };
+        }
+        // Load index
+        const index = await this.storage.getCargoIndex(crateName);
+        if (!index) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Crate not found'),
+            };
+        }
+        // Find version
+        const entry = index.find(e => e.vers === version);
+        if (!entry) {
+            return {
+                status: 404,
+                headers: { 'Content-Type': 'application/json' },
+                body: this.createError('Version not found'),
+            };
+        }
+        // Update yank status
+        entry.yanked = yank;
+        // Save index (NOTE: do NOT delete .crate file)
+        await this.storage.putCargoIndex(crateName, index);
+        this.logger.log('success', `${yank ? 'Yanked' : 'Unyanked'} version`, {
+            crate: crateName,
+            version
+        });
+        const response = { ok: true };
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: response,
+        };
+    }
+    /**
+     * Handle search
+     */
+    async handleSearch(query, perPage) {
+        this.logger.log('debug', 'handleSearch', { query, perPage });
+        const results = [];
+        try {
+            // List all index paths
+            const indexPaths = await this.storage.listObjects('cargo/index/');
+            // Extract unique crate names
+            const crateNames = new Set();
+            for (const path of indexPaths) {
+                // Parse path to extract crate name
+                const parts = path.split('/');
+                if (parts.length >= 3) {
+                    const name = parts[parts.length - 1];
+                    if (name && !name.includes('.')) {
+                        crateNames.add(name);
+                    }
+                }
+            }
+            this.logger.log('debug', `handleSearch: found ${crateNames.size} crates`, {
+                totalCrates: crateNames.size
+            });
+            // Filter and process matching crates
+            for (const name of crateNames) {
+                if (!query || name.toLowerCase().includes(query.toLowerCase())) {
+                    const index = await this.storage.getCargoIndex(name);
+                    if (index && index.length > 0) {
+                        // Find latest non-yanked version
+                        const nonYanked = index.filter(e => !e.yanked);
+                        if (nonYanked.length > 0) {
+                            // Sort by version (simplified - should use semver)
+                            const sorted = [...nonYanked].sort((a, b) => b.vers.localeCompare(a.vers));
+                            results.push({
+                                name: sorted[0].name,
+                                max_version: sorted[0].vers,
+                                description: '', // Would need to store separately
+                            });
+                            if (results.length >= perPage)
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.log('error', 'handleSearch: error', { error: error.message });
+        }
+        const response = {
+            crates: results,
+            meta: {
+                total: results.length,
+            },
+        };
+        return {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+            body: response,
+        };
+    }
+    /**
+     * Validate crate name
+     * Rules: lowercase alphanumeric + _ and -, length 1-64
+     */
+    validateCrateName(name) {
+        return /^[a-z0-9_-]+$/.test(name) && name.length >= 1 && name.length <= 64;
+    }
+    /**
+     * Create error response
+     */
+    createError(detail) {
+        return {
+            errors: [{ detail }],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.cargoregistry.js","sourceRoot":"","sources":["../../ts/cargo/classes.cargoregistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAa7D;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,YAAY;IACrC,OAAO,CAAkB;IACzB,WAAW,CAAc;IACzB,QAAQ,GAAW,QAAQ,CAAC;IAC5B,WAAW,CAAS;IACpB,MAAM,CAAW;IAEzB,YACE,OAAwB,EACxB,WAAwB,EACxB,WAAmB,QAAQ,EAC3B,cAAsB,6BAA6B;QAEnD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAE/B,oBAAoB;QACpB,IAAI,CAAC,MAAM,GAAG,IAAI,QAAQ,CAAC;YACzB,UAAU,EAAE;gBACV,OAAO,EAAE,YAAY;gBACrB,WAAW,EAAE,eAAe;gBAC5B,aAAa,EAAE,gBAAgB;gBAC/B,WAAW,EAAG,OAAO,CAAC,GAAG,CAAC,QAAgB,IAAI,aAAa;gBAC3D,OAAO,EAAE,MAAM;gBACf,IAAI,EAAE,OAAO;aACd;SACF,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,uCAAuC;QACvC,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAC3D,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,MAAM,GAAiB;gBAC3B,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,2CAA2C;gBAClE,GAAG,EAAE,IAAI,CAAC,WAAW;aACtB,CAAC;YACF,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAC1C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mCAAmC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IAEM,WAAW;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAAwB;QACjD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAErD,0EAA0E;QAC1E,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QACxF,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAE5F,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,kBAAkB,OAAO,CAAC,MAAM,IAAI,IAAI,EAAE,EAAE;YACnE,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,IAAI;YACJ,OAAO,EAAE,CAAC,CAAC,KAAK;SACjB,CAAC,CAAC;QAEH,iDAAiD;QACjD,IAAI,IAAI,KAAK,cAAc,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACjC,CAAC;QAED,gBAAgB;QAChB,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC;QAED,gCAAgC;QAChC,OAAO,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,eAAe,CAC7B,KAAwB,EACxB,QAAgB,EAChB,MAAc;QAEd,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,CAAC;QACzB,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,KAAK,EAAE,eAAe,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;IAC9E,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB,CAC5B,IAAY,EACZ,OAAwB,EACxB,KAAwB;QAExB,kCAAkC;QAClC,IAAI,IAAI,KAAK,oBAAoB,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC9D,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAc,EAAE,KAAK,CAAC,CAAC;QAC3D,CAAC;QAED,0DAA0D;QAC1D,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACtF,IAAI,aAAa,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC9C,OAAO,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,CAAC;QAED,qDAAqD;QACrD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC;QAC9E,IAAI,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC;QAED,sDAAsD;QACtD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;QAClF,IAAI,WAAW,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC5C,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAClE,CAAC;QAED,uCAAuC;QACvC,IAAI,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAClE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;YAC9D,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC3C,CAAC;QAED,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC;SACjD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,kBAAkB,CAAC,IAAY;QAC3C,0CAA0C;QAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACjD,IAAI,SAAS,GAAkB,IAAI,CAAC;QAEpC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YACnD,+BAA+B;YAC/B,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAC1D,+BAA+B;YAC/B,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAC1D,mCAAmC;YACnC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAClC,wCAAwC;YACxC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;gBACzC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;aACtB,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB;QAC5B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAEnD,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,MAAM,IAAI;gBACd,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,2CAA2C;gBAClE,GAAG,EAAE,IAAI,CAAC,WAAW;aACtB;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,SAAiB;QAC7C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAE1D,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,YAAY,EAAE;gBACzC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;aACtB,CAAC;QACJ,CAAC;QAED,gCAAgC;QAChC,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAEjE,6BAA6B;QAC7B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC;QAE3E,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE;gBACP,cAAc,EAAE,YAAY;gBAC5B,MAAM,EAAE,IAAI;aACb;YACD,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC;SACjC,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,mBAAmB,CAAC,IAAY;QAItC,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,gDAAgD;QAChD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC7C,MAAM,IAAI,CAAC,CAAC;QAEZ,qBAAqB;QACrB,IAAI,IAAI,CAAC,MAAM,GAAG,MAAM,GAAG,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC;QAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1D,MAAM,IAAI,UAAU,CAAC;QAErB,sDAAsD;QACtD,IAAI,IAAI,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC9C,MAAM,IAAI,CAAC,CAAC;QAEZ,kBAAkB;QAClB,IAAI,IAAI,CAAC,MAAM,GAAG,MAAM,GAAG,WAAW,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC;QAE3D,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,aAAa,CACzB,IAAY,EACZ,KAAwB;QAExB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,yCAAyC,EAAE;YACjE,UAAU,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;YAC7B,OAAO,EAAE,CAAC,CAAC,KAAK;SACjB,CAAC,CAAC;QAEH,sBAAsB;QACtB,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAAC;aAClD,CAAC;QACJ,CAAC;QAED,uBAAuB;QACvB,IAAI,QAA+B,CAAC;QACpC,IAAI,SAAiB,CAAC;QACtB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;YAC9C,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAC3B,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAC/B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjF,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,2BAA2B,KAAK,CAAC,OAAO,EAAE,CAAC;aACnE,CAAC;QACJ,CAAC;QAED,sBAAsB;QACtB,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3C,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAAC;aAC7C,CAAC;QACJ,CAAC;QAED,mBAAmB;QACnB,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAChF,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,EAAE;gBACrD,SAAS,EAAE,QAAQ,CAAC,IAAI;gBACxB,MAAM,EAAE,KAAK,CAAC,MAAM;aACrB,CAAC,CAAC;YACH,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAC;aACnD,CAAC;QACJ,CAAC;QAED,4BAA4B;QAC5B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAE1E,qBAAqB;QACrB,MAAM,UAAU,GAAqB;YACnC,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,KAAK;YACL,QAAQ,EAAE,QAAQ,CAAC,QAAQ;YAC3B,MAAM,EAAE,KAAK;YACb,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,IAAI;YAC7B,CAAC,EAAE,CAAC;YACJ,YAAY,EAAE,QAAQ,CAAC,YAAY;SACpC,CAAC;QAEF,8BAA8B;QAC9B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5E,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACtD,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW,QAAQ,CAAC,IAAI,iBAAiB,CAAC;aAClE,CAAC;QACJ,CAAC;QAED,mBAAmB;QACnB,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAE1E,oCAAoC;QACpC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC/B,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAE/D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,gCAAgC,EAAE;YAC3D,IAAI,EAAE,QAAQ,CAAC,IAAI;YACnB,OAAO,EAAE,QAAQ,CAAC,IAAI;YACtB,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;QAEH,MAAM,QAAQ,GAA0B;YACtC,QAAQ,EAAE;gBACR,kBAAkB,EAAE,EAAE;gBACtB,cAAc,EAAE,EAAE;gBAClB,KAAK,EAAE,EAAE;aACV;SACF,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,QAAQ;SACf,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,cAAc,CAC1B,SAAiB,EACjB,OAAe;QAEf,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;QAE1E,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAEvE,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC;aAC1C,CAAC;QACJ,CAAC;QAED,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,gBAAgB,EAAE,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE;gBAC7C,qBAAqB,EAAE,yBAAyB,SAAS,IAAI,OAAO,SAAS;aAC9E;YACD,IAAI,EAAE,SAAS;SAChB,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU,CACtB,SAAiB,EACjB,OAAe,EACf,KAAwB;QAExB,OAAO,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY,CACxB,SAAiB,EACjB,OAAe,EACf,KAAwB;QAExB,OAAO,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACpE,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAC/B,SAAiB,EACjB,OAAe,EACf,KAAwB,EACxB,IAAa;QAEb,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC3D,KAAK,EAAE,SAAS;YAChB,OAAO;YACP,OAAO,EAAE,CAAC,CAAC,KAAK;SACjB,CAAC,CAAC;QAEH,sBAAsB;QACtB,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAAC;aAClD,CAAC;QACJ,CAAC;QAED,mBAAmB;QACnB,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAC5E,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAC;aACnD,CAAC;QACJ,CAAC;QAED,aAAa;QACb,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC1D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC;aAC1C,CAAC;QACJ,CAAC;QAED,eAAe;QACf,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO;gBACL,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;gBAC/C,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC;aAC5C,CAAC;QACJ,CAAC;QAED,qBAAqB;QACrB,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;QAEpB,+CAA+C;QAC/C,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAEnD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,UAAU,EAAE;YACpE,KAAK,EAAE,SAAS;YAChB,OAAO;SACR,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAuB,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;QAElD,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,QAAQ;SACf,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY,CAAC,KAAa,EAAE,OAAe;QACvD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;QAE7D,MAAM,OAAO,GAAyB,EAAE,CAAC;QAEzC,IAAI,CAAC;YACH,uBAAuB;YACvB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;YAElE,6BAA6B;YAC7B,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;YACrC,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;gBAC9B,mCAAmC;gBACnC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;oBACtB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBACrC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;wBAChC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;oBACvB,CAAC;gBACH,CAAC;YACH,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,uBAAuB,UAAU,CAAC,IAAI,SAAS,EAAE;gBACxE,WAAW,EAAE,UAAU,CAAC,IAAI;aAC7B,CAAC,CAAC;YAEH,qCAAqC;YACrC,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;gBAC9B,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;oBAC/D,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBACrD,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC9B,iCAAiC;wBACjC,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;wBAC/C,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;4BACzB,mDAAmD;4BACnD,MAAM,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;4BAE3E,OAAO,CAAC,IAAI,CAAC;gCACX,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI;gCACpB,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI;gCAC3B,WAAW,EAAE,EAAE,EAAE,iCAAiC;6BACnD,CAAC,CAAC;4BAEH,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO;gCAAE,MAAM;wBACvC,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qBAAqB,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5E,CAAC;QAED,MAAM,QAAQ,GAAyB;YACrC,MAAM,EAAE,OAAO;YACf,IAAI,EAAE;gBACJ,KAAK,EAAE,OAAO,CAAC,MAAM;aACtB;SACF,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,GAAG;YACX,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,QAAQ;SACf,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,iBAAiB,CAAC,IAAY;QACpC,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;IAC7E,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,MAAc;QAChC,OAAO;YACL,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;SACrB,CAAC;IACJ,CAAC;CACF"}

package/dist_ts/cargo/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cargo/crates.io Registry module exports
+ */
+export { CargoRegistry } from './classes.cargoregistry.js';
+export * from './interfaces.cargo.js';

package/dist_ts/cargo/index.js

@@ -0,0 +1,6 @@
+/**
+ * Cargo/crates.io Registry module exports
+ */
+export { CargoRegistry } from './classes.cargoregistry.js';
+export * from './interfaces.cargo.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jYXJnby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUMzRCxjQUFjLHVCQUF1QixDQUFDIn0=