@relazio/plugin-sdk 0.1.1 → 0.2.0

package/dist/utils/builders.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeBuilder = exports.EntityBuilder = void 0;
+exports.createEntity = createEntity;
+exports.createEdge = createEdge;
+exports.validateEntities = validateEntities;
+exports.validateEdges = validateEdges;
+exports.validateTransformResult = validateTransformResult;
+const id_generator_1 = require("./id-generator");
+/**
+ * Crea un'entità OSINT nel formato corretto
+ * Genera automaticamente un ID deterministico se non specificato
+ *
+ * @param type - Tipo di entità
+ * @param value - Valore dell'entità (obbligatorio)
+ * @param options - Opzioni aggiuntive (label, metadata, id)
+ * @returns Entità nel formato corretto
+ *
+ * @example
+ * ```ts
+ * // Esempio semplice
+ * createEntity('ip', '8.8.8.8')
+ *
+ * // Con label e metadata
+ * createEntity('ip', '8.8.8.8', {
+ *   label: 'Google DNS',
+ *   metadata: { country: 'US', isp: 'Google LLC' }
+ * })
+ *
+ * // Con ID personalizzato
+ * createEntity('location', 'Mountain View, CA', {
+ *   id: 'custom-location-id',
+ *   metadata: { latitude: 37.386, longitude: -122.084 }
+ * })
+ * ```
+ */
+function createEntity(type, value, options) {
+    if (!value || value.trim() === '') {
+        throw new Error('Entity value cannot be empty');
+    }
+    return {
+        id: options?.id || (0, id_generator_1.generateEntityId)(type, value),
+        type,
+        value: value.trim(),
+        ...(options?.label && { label: options.label }),
+        ...(options?.metadata && { metadata: options.metadata }),
+    };
+}
+/**
+ * Crea un edge tra due entità nel formato corretto
+ * Genera automaticamente un ID deterministico se non specificato
+ *
+ * @param sourceId - ID dell'entità sorgente
+ * @param targetId - ID dell'entità target
+ * @param label - Label visibile dell'edge (obbligatorio)
+ * @param options - Opzioni aggiuntive (id, relationship, metadata)
+ * @returns Edge nel formato corretto
+ *
+ * @example
+ * ```ts
+ * // Esempio semplice
+ * createEdge('ip-c909e98d', 'location-a3f42bc1', 'located in')
+ *
+ * // Con relationship e metadata
+ * createEdge('ip-c909e98d', 'org-5b3c1a2d', 'assigned by', {
+ *   relationship: 'isp_assignment',
+ *   metadata: { confidence: 0.98 }
+ * })
+ *
+ * // Con ID personalizzato
+ * createEdge('node-1', 'node-2', 'related to', {
+ *   id: 'custom-edge-id'
+ * })
+ * ```
+ */
+function createEdge(sourceId, targetId, label, options) {
+    if (!sourceId || sourceId.trim() === '') {
+        throw new Error('Edge sourceId cannot be empty');
+    }
+    if (!targetId || targetId.trim() === '') {
+        throw new Error('Edge targetId cannot be empty');
+    }
+    if (!label || label.trim() === '') {
+        throw new Error('Edge label cannot be empty');
+    }
+    return {
+        id: options?.id || (0, id_generator_1.generateEdgeId)(sourceId, targetId, label),
+        sourceId: sourceId.trim(),
+        targetId: targetId.trim(),
+        label: label.trim(),
+        ...(options?.relationship && { relationship: options.relationship }),
+        ...(options?.metadata && { metadata: options.metadata }),
+    };
+}
+/**
+ * NOTA: Gli helper specifici sono stati rimossi per rendere l'SDK più scalabile.
+ * Usa `createEntity(type, value, options)` per creare qualsiasi tipo di entità.
+ *
+ * Esempio:
+ * ```ts
+ * createEntity('ip', '8.8.8.8', { metadata: { country: 'US' } })
+ * createEntity('domain', 'example.com')
+ * createEntity('custom-type', 'value')  // Funziona anche con tipi futuri!
+ * ```
+ */
+/**
+ * Builder fluente per creare entità complesse
+ *
+ * @example
+ * ```ts
+ * const entity = EntityBuilder
+ *   .create('ip', '8.8.8.8')
+ *   .withLabel('Google DNS')
+ *   .withMetadata({ country: 'US', isp: 'Google LLC' })
+ *   .build();
+ * ```
+ */
+class EntityBuilder {
+    constructor(type, value) {
+        this.entity = {
+            type,
+            value: value.trim(),
+        };
+    }
+    static create(type, value) {
+        return new EntityBuilder(type, value);
+    }
+    withId(id) {
+        this.entity.id = id;
+        return this;
+    }
+    withLabel(label) {
+        this.entity.label = label;
+        return this;
+    }
+    withMetadata(metadata) {
+        this.entity.metadata = { ...this.entity.metadata, ...metadata };
+        return this;
+    }
+    addMetadata(key, value) {
+        if (!this.entity.metadata) {
+            this.entity.metadata = {};
+        }
+        this.entity.metadata[key] = value;
+        return this;
+    }
+    build() {
+        if (!this.entity.value) {
+            throw new Error('Entity value is required');
+        }
+        if (!this.entity.type) {
+            throw new Error('Entity type is required');
+        }
+        const id = this.entity.id || (0, id_generator_1.generateEntityId)(this.entity.type, this.entity.value);
+        return {
+            id,
+            type: this.entity.type,
+            value: this.entity.value,
+            ...(this.entity.label && { label: this.entity.label }),
+            ...(this.entity.metadata && { metadata: this.entity.metadata }),
+        };
+    }
+}
+exports.EntityBuilder = EntityBuilder;
+/**
+ * Builder fluente per creare edge complessi
+ *
+ * @example
+ * ```ts
+ * const edge = EdgeBuilder
+ *   .create('ip-abc', 'location-xyz', 'located in')
+ *   .withRelationship('geolocation')
+ *   .withMetadata({ confidence: 0.98 })
+ *   .build();
+ * ```
+ */
+class EdgeBuilder {
+    constructor(sourceId, targetId, label) {
+        this.edge = {
+            sourceId: sourceId.trim(),
+            targetId: targetId.trim(),
+            label: label.trim(),
+        };
+    }
+    static create(sourceId, targetId, label) {
+        return new EdgeBuilder(sourceId, targetId, label);
+    }
+    withId(id) {
+        this.edge.id = id;
+        return this;
+    }
+    withRelationship(relationship) {
+        this.edge.relationship = relationship;
+        return this;
+    }
+    withMetadata(metadata) {
+        this.edge.metadata = { ...this.edge.metadata, ...metadata };
+        return this;
+    }
+    addMetadata(key, value) {
+        if (!this.edge.metadata) {
+            this.edge.metadata = {};
+        }
+        this.edge.metadata[key] = value;
+        return this;
+    }
+    build() {
+        if (!this.edge.sourceId) {
+            throw new Error('Edge sourceId is required');
+        }
+        if (!this.edge.targetId) {
+            throw new Error('Edge targetId is required');
+        }
+        if (!this.edge.label) {
+            throw new Error('Edge label is required');
+        }
+        const id = this.edge.id || (0, id_generator_1.generateEdgeId)(this.edge.sourceId, this.edge.targetId, this.edge.label);
+        return {
+            id,
+            sourceId: this.edge.sourceId,
+            targetId: this.edge.targetId,
+            label: this.edge.label,
+            ...(this.edge.relationship && { relationship: this.edge.relationship }),
+            ...(this.edge.metadata && { metadata: this.edge.metadata }),
+        };
+    }
+}
+exports.EdgeBuilder = EdgeBuilder;
+/**
+ * Helper per validare un array di entità
+ * Controlla ID duplicati e campi obbligatori
+ */
+function validateEntities(entities) {
+    const errors = [];
+    const ids = new Set();
+    for (const entity of entities) {
+        // Verifica campi obbligatori
+        if (!entity.id) {
+            errors.push(`Entity missing required field: id`);
+        }
+        if (!entity.type) {
+            errors.push(`Entity missing required field: type`);
+        }
+        if (!entity.value) {
+            errors.push(`Entity missing required field: value`);
+        }
+        // Verifica ID duplicati
+        if (entity.id) {
+            if (ids.has(entity.id)) {
+                errors.push(`Duplicate entity ID: ${entity.id}`);
+            }
+            ids.add(entity.id);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Helper per validare un array di edge
+ * Controlla ID duplicati, campi obbligatori e riferimenti validi
+ */
+function validateEdges(edges, entities, inputEntityId) {
+    const errors = [];
+    const edgeIds = new Set();
+    const entityIds = new Set(entities.map(e => e.id));
+    // Aggiungi l'ID dell'entità di input se fornito
+    if (inputEntityId) {
+        entityIds.add(inputEntityId);
+    }
+    for (const edge of edges) {
+        // Verifica campi obbligatori
+        if (!edge.id) {
+            errors.push(`Edge missing required field: id`);
+        }
+        if (!edge.sourceId) {
+            errors.push(`Edge missing required field: sourceId`);
+        }
+        if (!edge.targetId) {
+            errors.push(`Edge missing required field: targetId`);
+        }
+        if (!edge.label) {
+            errors.push(`Edge missing required field: label`);
+        }
+        // Verifica ID duplicati
+        if (edge.id) {
+            if (edgeIds.has(edge.id)) {
+                errors.push(`Duplicate edge ID: ${edge.id}`);
+            }
+            edgeIds.add(edge.id);
+        }
+        // Verifica riferimenti validi
+        if (edge.targetId && !entityIds.has(edge.targetId)) {
+            errors.push(`Edge references non-existent target entity: ${edge.targetId}`);
+        }
+        if (edge.sourceId && !entityIds.has(edge.sourceId)) {
+            errors.push(`Edge references non-existent source entity: ${edge.sourceId}`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Helper per validare una risposta completa di transform
+ */
+function validateTransformResult(result, inputEntityId) {
+    const entityValidation = validateEntities(result.entities);
+    const edgeValidation = validateEdges(result.edges, result.entities, inputEntityId);
+    return {
+        valid: entityValidation.valid && edgeValidation.valid,
+        errors: [...entityValidation.errors, ...edgeValidation.errors],
+    };
+}

package/dist/utils/id-generator.d.ts

@@ -0,0 +1,81 @@
+import type { EntityType } from '../core/types';
+/**
+ * Genera un ID deterministico per un'entità
+ * Formato: {type}-{hash-short}
+ *
+ * @param type - Tipo di entità
+ * @param value - Valore dell'entità
+ * @returns ID univoco e deterministico
+ *
+ * @example
+ * ```ts
+ * generateEntityId('ip', '8.8.8.8')
+ * // => "ip-c909e98d"
+ *
+ * generateEntityId('location', 'Mountain View, CA')
+ * // => "location-a3f42bc1"
+ * ```
+ */
+export declare function generateEntityId(type: EntityType, value: string): string;
+/**
+ * Genera un ID deterministico per un edge
+ * Formato: edge-{hash-short}
+ *
+ * @param sourceId - ID dell'entità sorgente
+ * @param targetId - ID dell'entità target
+ * @param label - Label dell'edge (opzionale, per maggiore unicità)
+ * @returns ID univoco e deterministico
+ *
+ * @example
+ * ```ts
+ * generateEdgeId('ip-c909e98d', 'location-a3f42bc1')
+ * // => "edge-4f8a2d1c"
+ *
+ * generateEdgeId('ip-c909e98d', 'org-5b3c1a2d', 'assigned by')
+ * // => "edge-7e9b3f4a"
+ * ```
+ */
+export declare function generateEdgeId(sourceId: string, targetId: string, label?: string): string;
+/**
+ * Genera un ID casuale con prefisso
+ * Utile per entità temporanee o quando non serve deterministicità
+ *
+ * @param prefix - Prefisso per l'ID (es: 'note', 'temp')
+ * @returns ID univoco random
+ *
+ * @example
+ * ```ts
+ * generateRandomId('note')
+ * // => "note-1735123456789"
+ * ```
+ */
+export declare function generateRandomId(prefix: string): string;
+/**
+ * Normalizza un valore per la generazione di ID
+ * Rimuove spazi extra, converte a lowercase, rimuove caratteri speciali
+ *
+ * @param value - Valore da normalizzare
+ * @returns Valore normalizzato
+ *
+ * @example
+ * ```ts
+ * normalizeValue('  Mountain View, CA  ')
+ * // => "mountain-view-ca"
+ * ```
+ */
+export declare function normalizeValue(value: string): string;
+/**
+ * Valida un ID di entità
+ *
+ * @param id - ID da validare
+ * @returns true se l'ID è valido
+ */
+export declare function isValidEntityId(id: string): boolean;
+/**
+ * Valida un ID di edge
+ *
+ * @param id - ID da validare
+ * @returns true se l'ID è valido
+ */
+export declare function isValidEdgeId(id: string): boolean;
+//# sourceMappingURL=id-generator.d.ts.map

package/dist/utils/id-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.d.ts","sourceRoot":"","sources":["../../src/utils/id-generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQxE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,MAAM,GACb,MAAM,CAYR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEjD"}

package/dist/utils/id-generator.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEntityId = generateEntityId;
+exports.generateEdgeId = generateEdgeId;
+exports.generateRandomId = generateRandomId;
+exports.normalizeValue = normalizeValue;
+exports.isValidEntityId = isValidEntityId;
+exports.isValidEdgeId = isValidEdgeId;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Genera un ID deterministico per un'entità
+ * Formato: {type}-{hash-short}
+ *
+ * @param type - Tipo di entità
+ * @param value - Valore dell'entità
+ * @returns ID univoco e deterministico
+ *
+ * @example
+ * ```ts
+ * generateEntityId('ip', '8.8.8.8')
+ * // => "ip-c909e98d"
+ *
+ * generateEntityId('location', 'Mountain View, CA')
+ * // => "location-a3f42bc1"
+ * ```
+ */
+function generateEntityId(type, value) {
+    const hash = crypto_1.default
+        .createHash('md5')
+        .update(value.toLowerCase().trim())
+        .digest('hex')
+        .substring(0, 8);
+    return `${type}-${hash}`;
+}
+/**
+ * Genera un ID deterministico per un edge
+ * Formato: edge-{hash-short}
+ *
+ * @param sourceId - ID dell'entità sorgente
+ * @param targetId - ID dell'entità target
+ * @param label - Label dell'edge (opzionale, per maggiore unicità)
+ * @returns ID univoco e deterministico
+ *
+ * @example
+ * ```ts
+ * generateEdgeId('ip-c909e98d', 'location-a3f42bc1')
+ * // => "edge-4f8a2d1c"
+ *
+ * generateEdgeId('ip-c909e98d', 'org-5b3c1a2d', 'assigned by')
+ * // => "edge-7e9b3f4a"
+ * ```
+ */
+function generateEdgeId(sourceId, targetId, label) {
+    const content = label
+        ? `${sourceId}-${targetId}-${label}`
+        : `${sourceId}-${targetId}`;
+    const hash = crypto_1.default
+        .createHash('md5')
+        .update(content.toLowerCase().trim())
+        .digest('hex')
+        .substring(0, 8);
+    return `edge-${hash}`;
+}
+/**
+ * Genera un ID casuale con prefisso
+ * Utile per entità temporanee o quando non serve deterministicità
+ *
+ * @param prefix - Prefisso per l'ID (es: 'note', 'temp')
+ * @returns ID univoco random
+ *
+ * @example
+ * ```ts
+ * generateRandomId('note')
+ * // => "note-1735123456789"
+ * ```
+ */
+function generateRandomId(prefix) {
+    return `${prefix}-${Date.now()}-${crypto_1.default.randomBytes(4).toString('hex')}`;
+}
+/**
+ * Normalizza un valore per la generazione di ID
+ * Rimuove spazi extra, converte a lowercase, rimuove caratteri speciali
+ *
+ * @param value - Valore da normalizzare
+ * @returns Valore normalizzato
+ *
+ * @example
+ * ```ts
+ * normalizeValue('  Mountain View, CA  ')
+ * // => "mountain-view-ca"
+ * ```
+ */
+function normalizeValue(value) {
+    return value
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Valida un ID di entità
+ *
+ * @param id - ID da validare
+ * @returns true se l'ID è valido
+ */
+function isValidEntityId(id) {
+    return id.length > 0 && id.trim() === id;
+}
+/**
+ * Valida un ID di edge
+ *
+ * @param id - ID da validare
+ * @returns true se l'ID è valido
+ */
+function isValidEdgeId(id) {
+    return id.length > 0 && id.trim() === id;
+}

package/dist/utils/result-builder.d.ts

@@ -0,0 +1,109 @@
+import type { OSINTEntity, OSINTEdge, TransformResult, TransformInput } from '../core/types';
+/**
+ * Builder per costruire facilmente un TransformResult
+ * Gestisce automaticamente gli edge dall'entità di input alle nuove entità
+ *
+ * @example
+ * ```ts
+ * const result = new ResultBuilder(input)
+ *   .addEntity(createIP('8.8.8.8'), 'resolves to')
+ *   .addEntity(createLocation('Mountain View, CA'), 'located in')
+ *   .setMessage('Found IP information')
+ *   .build();
+ * ```
+ */
+export declare class ResultBuilder {
+    private entities;
+    private edges;
+    private message?;
+    private metadata?;
+    private inputEntityId;
+    constructor(input: TransformInput);
+    /**
+     * Aggiungi un'entità con edge automatico dall'input
+     *
+     * @param entity - Entità da aggiungere
+     * @param edgeLabel - Label dell'edge (opzionale)
+     * @param edgeOptions - Opzioni per l'edge
+     */
+    addEntity(entity: OSINTEntity, edgeLabel?: string, edgeOptions?: {
+        relationship?: string;
+        metadata?: Record<string, any>;
+    }): this;
+    /**
+     * Aggiungi multiple entità con lo stesso tipo di edge
+     *
+     * @param entities - Array di entità da aggiungere
+     * @param edgeLabel - Label dell'edge (opzionale)
+     * @param edgeOptions - Opzioni per l'edge
+     */
+    addEntities(entities: OSINTEntity[], edgeLabel?: string, edgeOptions?: {
+        relationship?: string;
+        metadata?: Record<string, any>;
+    }): this;
+    /**
+     * Aggiungi un'entità senza edge automatico
+     */
+    addEntityOnly(entity: OSINTEntity): this;
+    /**
+     * Aggiungi un edge manualmente
+     */
+    addEdge(edge: OSINTEdge): this;
+    /**
+     * Aggiungi multiple edges
+     */
+    addEdges(edges: OSINTEdge[]): this;
+    /**
+     * Imposta il messaggio di successo
+     */
+    setMessage(message: string): this;
+    /**
+     * Imposta metadata addizionali
+     */
+    setMetadata(metadata: Record<string, any>): this;
+    /**
+     * Aggiungi metadata
+     */
+    addMetadata(key: string, value: any): this;
+    /**
+     * Costruisci il risultato finale
+     */
+    build(): TransformResult;
+    /**
+     * Ottieni il numero di entità aggiunte
+     */
+    getEntityCount(): number;
+    /**
+     * Ottieni il numero di edge aggiunti
+     */
+    getEdgeCount(): number;
+    /**
+     * Verifica se ci sono risultati
+     */
+    hasResults(): boolean;
+}
+/**
+ * Helper veloce per creare un risultato vuoto (no results)
+ */
+export declare function emptyResult(message?: string): TransformResult;
+/**
+ * Helper veloce per creare un risultato di errore
+ */
+export declare function errorResult(error: string | Error): TransformResult;
+/**
+ * Helper per creare un risultato con una singola entità
+ */
+export declare function singleEntityResult(inputEntityId: string, entity: OSINTEntity, edgeLabel: string, options?: {
+    relationship?: string;
+    message?: string;
+    metadata?: Record<string, any>;
+}): TransformResult;
+/**
+ * Helper per creare un risultato con multiple entità dello stesso tipo
+ */
+export declare function multiEntityResult(inputEntityId: string, entities: OSINTEntity[], edgeLabel: string, options?: {
+    relationship?: string;
+    message?: string;
+    metadata?: Record<string, any>;
+}): TransformResult;
+//# sourceMappingURL=result-builder.d.ts.map

package/dist/utils/result-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-builder.d.ts","sourceRoot":"","sources":["../../src/utils/result-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG7F;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAC,CAAsB;IACvC,OAAO,CAAC,aAAa,CAAS;gBAElB,KAAK,EAAE,cAAc;IAIjC;;;;;;OAMG;IACH,SAAS,CACP,MAAM,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,GACA,IAAI;IAiBP;;;;;;OAMG;IACH,WAAW,CACT,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,GACA,IAAI;IAOP;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;IAKxC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAK9B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,IAAI;IAKlC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAKhD;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAQ1C;;OAEG;IACH,KAAK,IAAI,eAAe;IAUxB;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,UAAU,IAAI,OAAO;CAGtB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,eAAe,CAO7D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,eAAe,CAOlE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC,GACA,eAAe,CAYjB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC,GACA,eAAe,CAcjB"}