@hazeljs/ml 0.2.3 → 0.3.0

package/dist/monitoring/drift.service.js

@@ -0,0 +1,360 @@
+"use strict";
+/**
+ * Drift Service - Statistical drift detection for ML model monitoring
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriftService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+let DriftService = class DriftService {
+    constructor() {
+        this.referenceDistributions = new Map();
+    }
+    /**
+     * Set reference distribution for a feature from training data
+     */
+    setReferenceDistribution(featureName, values) {
+        this.referenceDistributions.set(featureName, [...values]);
+        core_2.default.debug(`Set reference distribution for ${featureName} (${values.length} samples)`);
+    }
+    /**
+     * Calculate distribution statistics
+     */
+    calculateStats(values) {
+        const sorted = [...values].sort((a, b) => a - b);
+        const count = values.length;
+        const min = sorted[0];
+        const max = sorted[count - 1];
+        const mean = values.reduce((a, b) => a + b, 0) / count;
+        // Median
+        const mid = Math.floor(count / 2);
+        const median = count % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+        // Standard deviation
+        const variance = values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / count;
+        const std = Math.sqrt(variance);
+        // Histogram (10 bins)
+        const binWidth = (max - min) / 10 || 1;
+        const histogram = [];
+        for (let i = 0; i < 10; i++) {
+            const binMin = min + i * binWidth;
+            const binMax = binMin + binWidth;
+            const binCount = sorted.filter((v) => v >= binMin && v < binMax).length;
+            histogram.push({ bin: i, count: binCount });
+        }
+        // Percentiles
+        const percentiles = {};
+        for (const p of [5, 25, 50, 75, 95]) {
+            const idx = Math.floor((count * p) / 100);
+            percentiles[`p${p}`] = sorted[Math.min(idx, count - 1)];
+        }
+        return { count, min, max, mean, median, std, histogram, percentiles };
+    }
+    /**
+     * Population Stability Index (PSI) - measures shift between two distributions
+     * PSI < 0.1: no significant shift
+     * PSI 0.1-0.25: moderate shift
+     * PSI > 0.25: significant shift
+     */
+    calculatePSI(reference, current, bins = 10) {
+        const refStats = this.calculateStats(reference);
+        const currStats = this.calculateStats(current);
+        const min = Math.min(refStats.min, currStats.min);
+        const max = Math.max(refStats.max, currStats.max);
+        const binWidth = (max - min) / bins || 1;
+        let psi = 0;
+        for (let i = 0; i < bins; i++) {
+            const binMin = min + i * binWidth;
+            const binMax = binMin + binWidth;
+            const refCount = reference.filter((v) => v >= binMin && v < binMax).length;
+            const currCount = current.filter((v) => v >= binMin && v < binMax).length;
+            const refPct = refCount / reference.length;
+            const currPct = currCount / current.length;
+            // Avoid division by zero
+            if (refPct > 0 && currPct > 0) {
+                psi += (currPct - refPct) * Math.log(currPct / refPct);
+            }
+        }
+        return psi;
+    }
+    /**
+     * Kolmogorov-Smirnov test statistic
+     * Measures maximum distance between two cumulative distributions
+     * Returns D statistic (0-1) and approximate p-value
+     */
+    calculateKS(reference, current) {
+        const sortedRef = [...reference].sort((a, b) => a - b);
+        const sortedCurr = [...current].sort((a, b) => a - b);
+        const allValues = Array.from(new Set([...sortedRef, ...sortedCurr])).sort((a, b) => a - b);
+        let maxDiff = 0;
+        for (const value of allValues) {
+            const refCdf = sortedRef.filter((v) => v <= value).length / sortedRef.length;
+            const currCdf = sortedCurr.filter((v) => v <= value).length / sortedCurr.length;
+            const diff = Math.abs(refCdf - currCdf);
+            if (diff > maxDiff)
+                maxDiff = diff;
+        }
+        // Approximate p-value using Kolmogorov distribution
+        const n1 = sortedRef.length;
+        const n2 = sortedCurr.length;
+        const n = (n1 * n2) / (n1 + n2);
+        const lambda = (Math.sqrt(n) + 0.12 + 0.11 / Math.sqrt(n)) * maxDiff;
+        // Kolmogorov distribution approximation
+        const pValue = Math.max(0, 1 - Math.exp(-2 * lambda * lambda));
+        return { d: maxDiff, pValue };
+    }
+    /**
+     * Jensen-Shannon Divergence - symmetric version of KL divergence
+     * Range: 0 (identical) to ln(2) ≈ 0.693 (maximally different)
+     */
+    calculateJSD(reference, current, bins = 10) {
+        const refStats = this.calculateStats(reference);
+        const currStats = this.calculateStats(current);
+        const min = Math.min(refStats.min, currStats.min);
+        const max = Math.max(refStats.max, currStats.max);
+        const binWidth = (max - min) / bins || 1;
+        let jsd = 0;
+        for (let i = 0; i < bins; i++) {
+            const binMin = min + i * binWidth;
+            const binMax = binMin + binWidth;
+            const refCount = reference.filter((v) => v >= binMin && v < binMax).length;
+            const currCount = current.filter((v) => v >= binMin && v < binMax).length;
+            const refP = refCount / reference.length;
+            const currP = currCount / current.length;
+            const avgP = (refP + currP) / 2;
+            // KL divergence terms
+            if (refP > 0 && avgP > 0) {
+                jsd += refP * Math.log(refP / avgP) * 0.5;
+            }
+            if (currP > 0 && avgP > 0) {
+                jsd += currP * Math.log(currP / avgP) * 0.5;
+            }
+        }
+        return jsd;
+    }
+    /**
+     * Chi-square test for categorical features
+     */
+    calculateChiSquare(reference, current) {
+        const allCategories = new Set([...Object.keys(reference), ...Object.keys(current)]);
+        const refTotal = Object.values(reference).reduce((a, b) => a + b, 0);
+        const currTotal = Object.values(current).reduce((a, b) => a + b, 0);
+        let chi2 = 0;
+        let df = 0; // degrees of freedom
+        for (const category of allCategories) {
+            const refCount = reference[category] ?? 0;
+            const currCount = current[category] ?? 0;
+            const expectedRef = (refCount + currCount) * (refTotal / (refTotal + currTotal));
+            const expectedCurr = (refCount + currCount) * (currTotal / (refTotal + currTotal));
+            if (expectedRef > 0) {
+                chi2 += Math.pow(refCount - expectedRef, 2) / expectedRef;
+                df++;
+            }
+            if (expectedCurr > 0) {
+                chi2 += Math.pow(currCount - expectedCurr, 2) / expectedCurr;
+                df++;
+            }
+        }
+        df = Math.max(1, df - 1);
+        // Approximate p-value using chi-square CDF approximation
+        const pValue = this.chiSquarePValue(chi2, df);
+        return { chi2, pValue };
+    }
+    /**
+     * Wasserstein distance (Earth Mover's Distance)
+     * Measures how much "work" is needed to transform one distribution into another
+     */
+    calculateWasserstein(reference, current) {
+        const sortedRef = [...reference].sort((a, b) => a - b);
+        const sortedCurr = [...current].sort((a, b) => a - b);
+        const n = Math.min(sortedRef.length, sortedCurr.length);
+        let distance = 0;
+        for (let i = 0; i < n; i++) {
+            distance += Math.abs(sortedRef[i] - sortedCurr[i]);
+        }
+        return distance / n;
+    }
+    /**
+     * Detect drift for numeric features
+     */
+    detectDrift(featureName, currentValues, config) {
+        const referenceValues = this.referenceDistributions.get(featureName);
+        if (!referenceValues) {
+            throw new Error(`No reference distribution set for feature: ${featureName}`);
+        }
+        let score = 0;
+        let pValue;
+        let driftDetected = false;
+        switch (config.method) {
+            case 'psi': {
+                score = this.calculatePSI(referenceValues, currentValues);
+                driftDetected = score > config.threshold;
+                break;
+            }
+            case 'ks': {
+                const result = this.calculateKS(referenceValues, currentValues);
+                score = result.d;
+                pValue = result.pValue;
+                driftDetected = result.d > config.threshold || result.pValue < 0.05;
+                break;
+            }
+            case 'jsd': {
+                score = this.calculateJSD(referenceValues, currentValues);
+                driftDetected = score > config.threshold;
+                break;
+            }
+            case 'wasserstein': {
+                score = this.calculateWasserstein(referenceValues, currentValues);
+                // Normalize by standard deviation
+                const refStats = this.calculateStats(referenceValues);
+                score = refStats.std > 0 ? score / refStats.std : score;
+                driftDetected = score > config.threshold;
+                break;
+            }
+            default:
+                throw new Error(`Unsupported drift detection method: ${config.method}`);
+        }
+        const message = driftDetected
+            ? `Drift detected in ${featureName}: ${config.method}=${score.toFixed(4)} exceeds threshold ${config.threshold}`
+            : `No drift detected in ${featureName}: ${config.method}=${score.toFixed(4)}`;
+        return {
+            feature: featureName,
+            driftDetected,
+            score,
+            threshold: config.threshold,
+            method: config.method,
+            pValue,
+            message,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Detect drift for categorical features
+     */
+    detectCategoricalDrift(featureName, currentValues, config) {
+        // Count frequencies
+        const referenceValues = this.referenceDistributions.get(featureName);
+        if (!referenceValues) {
+            throw new Error(`No reference distribution set for feature: ${featureName}`);
+        }
+        const refCounts = this.countCategories(referenceValues);
+        const currCounts = this.countCategories(currentValues);
+        const { chi2, pValue } = this.calculateChiSquare(refCounts, currCounts);
+        // Normalize chi2 score
+        const score = chi2 / Math.max(1, Object.keys(refCounts).length);
+        const driftDetected = pValue < 0.05 || score > config.threshold;
+        return {
+            feature: featureName,
+            driftDetected,
+            score,
+            threshold: config.threshold,
+            method: 'chi2',
+            pValue,
+            message: driftDetected
+                ? `Drift detected in ${featureName}: chi2=${score.toFixed(4)}, p=${pValue?.toFixed(4)}`
+                : `No drift detected in ${featureName}: chi2=${score.toFixed(4)}`,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Run full drift detection report on multiple features
+     */
+    detectDriftReport(features, config) {
+        const results = [];
+        for (const [name, values] of Object.entries(features)) {
+            try {
+                const result = this.detectDrift(name, values, config);
+                results.push(result);
+            }
+            catch (error) {
+                core_2.default.warn(`Failed to detect drift for ${name}:`, error);
+            }
+        }
+        const driftedFeatures = results.filter((r) => r.driftDetected).length;
+        const totalFeatures = results.length;
+        const driftPercentage = totalFeatures > 0 ? (driftedFeatures / totalFeatures) * 100 : 0;
+        return {
+            timestamp: new Date(),
+            totalFeatures,
+            driftedFeatures,
+            driftPercentage,
+            results,
+            overallDrift: driftPercentage > 25, // Overall drift if >25% of features drifted
+        };
+    }
+    /**
+     * Detect prediction drift (monitor model output distribution)
+     */
+    detectPredictionDrift(referencePredictions, currentPredictions) {
+        // For numeric predictions (regression)
+        if (typeof referencePredictions[0] === 'number') {
+            this.setReferenceDistribution('__prediction__', referencePredictions);
+            return this.detectDrift('__prediction__', currentPredictions, {
+                method: 'ks',
+                threshold: 0.1,
+            });
+        }
+        // For categorical predictions (classification)
+        const refCounts = this.countCategories(referencePredictions);
+        const currCounts = this.countCategories(currentPredictions);
+        const { chi2, pValue } = this.calculateChiSquare(refCounts, currCounts);
+        const score = chi2 / Math.max(1, Object.keys(refCounts).length);
+        const driftDetected = pValue < 0.05;
+        return {
+            feature: 'prediction',
+            driftDetected,
+            score,
+            threshold: 0.05,
+            method: 'chi2',
+            pValue,
+            message: driftDetected
+                ? `Prediction drift detected: chi2=${score.toFixed(4)}, p=${pValue?.toFixed(4)}`
+                : `No prediction drift detected: chi2=${score.toFixed(4)}`,
+            timestamp: new Date(),
+        };
+    }
+    // ─── Helpers ─────────────────────────────────────────────────────────────────
+    countCategories(values) {
+        const counts = {};
+        for (const value of values) {
+            counts[value] = (counts[value] ?? 0) + 1;
+        }
+        return counts;
+    }
+    chiSquarePValue(chi2, df) {
+        // Wilson-Hilferty approximation for chi-square CDF
+        if (chi2 <= 0)
+            return 1;
+        if (df <= 0)
+            return 1;
+        const z = Math.sqrt(2 * chi2) - Math.sqrt(2 * df - 1);
+        // Standard normal CDF approximation
+        return 1 - this.normalCDF(z);
+    }
+    normalCDF(x) {
+        // Abramowitz and Stegun approximation
+        const a1 = 0.254829592;
+        const a2 = -0.284496736;
+        const a3 = 1.421413741;
+        const a4 = -1.453152027;
+        const a5 = 1.061405429;
+        const p = 0.3275911;
+        const sign = x < 0 ? -1 : 1;
+        const absX = Math.abs(x) / Math.sqrt(2);
+        const t = 1 / (1 + p * absX);
+        const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+        return 0.5 * (1 + sign * y);
+    }
+};
+exports.DriftService = DriftService;
+exports.DriftService = DriftService = __decorate([
+    (0, core_1.Service)()
+], DriftService);

package/dist/monitoring/drift.types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @hazeljs/ml - Drift Detection Types
+ */
+export type DriftType = 'data' | 'prediction' | 'concept';
+export interface DriftConfig {
+    type: DriftType;
+    features: string[];
+    method: 'psi' | 'ks' | 'jsd' | 'chi2' | 'wasserstein';
+    threshold: number;
+    windowSize?: number;
+    referenceDistribution?: Record<string, number[]>;
+}
+export interface DriftResult {
+    feature: string;
+    driftDetected: boolean;
+    score: number;
+    threshold: number;
+    method: DriftConfig['method'];
+    pValue?: number;
+    message: string;
+    timestamp: Date;
+}
+export interface DriftReport {
+    timestamp: Date;
+    totalFeatures: number;
+    driftedFeatures: number;
+    driftPercentage: number;
+    results: DriftResult[];
+    overallDrift: boolean;
+}
+export interface DistributionStats {
+    count: number;
+    min: number;
+    max: number;
+    mean: number;
+    median: number;
+    std: number;
+    histogram: Array<{
+        bin: number;
+        count: number;
+    }>;
+    percentiles: Record<string, number>;
+}
+//# sourceMappingURL=drift.types.d.ts.map

package/dist/monitoring/drift.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drift.types.d.ts","sourceRoot":"","sources":["../../src/monitoring/drift.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAAC;AAE1D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,MAAM,GAAG,aAAa,CAAC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,IAAI,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC"}

package/dist/monitoring/drift.types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * @hazeljs/ml - Drift Detection Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/monitoring/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @hazeljs/ml - Monitoring & Drift Detection
+ *
+ * Export all monitoring components
+ */
+export type { DriftType, DriftConfig, DriftResult, DriftReport, DistributionStats, } from './drift.types';
+export type { MonitorConfig, MonitorAlert, AlertHandler } from './monitor.service';
+export { DriftService } from './drift.service';
+export { MonitorService } from './monitor.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/monitoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/monitoring/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,WAAW,EACX,iBAAiB,GAClB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGnF,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/monitoring/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @hazeljs/ml - Monitoring & Drift Detection
+ *
+ * Export all monitoring components
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorService = exports.DriftService = void 0;
+// Services
+var drift_service_1 = require("./drift.service");
+Object.defineProperty(exports, "DriftService", { enumerable: true, get: function () { return drift_service_1.DriftService; } });
+var monitor_service_1 = require("./monitor.service");
+Object.defineProperty(exports, "MonitorService", { enumerable: true, get: function () { return monitor_service_1.MonitorService; } });

package/dist/monitoring/monitor.service.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Monitor Service - Ongoing model monitoring and alerting
+ */
+import type { DriftResult, DriftConfig } from './drift.types';
+import { DriftService } from './drift.service';
+export interface MonitorConfig {
+    modelName: string;
+    modelVersion?: string;
+    featureDrift?: Omit<DriftConfig, 'features' | 'type'>;
+    predictionDrift?: boolean;
+    accuracyMonitor?: {
+        threshold: number;
+        windowSize: number;
+    };
+    alertWebhook?: string;
+    checkIntervalMinutes?: number;
+}
+export interface MonitorAlert {
+    timestamp: Date;
+    modelName: string;
+    modelVersion?: string;
+    alertType: 'drift' | 'accuracy' | 'latency' | 'error_rate';
+    severity: 'warning' | 'critical';
+    message: string;
+    details: Record<string, unknown>;
+}
+export type AlertHandler = (alert: MonitorAlert) => void | Promise<void>;
+export declare class MonitorService {
+    private driftService;
+    private monitors;
+    private alertHandlers;
+    private checkIntervals;
+    private accuracyHistory;
+    constructor(driftService: DriftService);
+    /**
+     * Register a model for monitoring
+     */
+    registerModel(config: MonitorConfig): void;
+    /**
+     * Unregister a model from monitoring
+     */
+    unregisterModel(modelName: string, modelVersion?: string): void;
+    /**
+     * Add an alert handler
+     */
+    onAlert(handler: AlertHandler): void;
+    /**
+     * Remove an alert handler
+     */
+    offAlert(handler: AlertHandler): void;
+    /**
+     * Record prediction for drift monitoring
+     */
+    recordPrediction(modelName: string, features: Record<string, number>, prediction: number | string): void;
+    /**
+     * Record accuracy metric for accuracy monitoring
+     */
+    recordAccuracy(modelName: string, accuracy: number, modelVersion?: string): void;
+    /**
+     * Check a model for drift and other issues
+     */
+    checkModel(modelName: string, modelVersion?: string): Promise<DriftResult[]>;
+    /**
+     * Get monitoring status for all registered models
+     */
+    getStatus(): Array<{
+        modelName: string;
+        modelVersion?: string;
+        isActive: boolean;
+        checkInterval?: number;
+    }>;
+    /**
+     * Stop all monitoring
+     */
+    stop(): void;
+    private getMonitorKey;
+    private emitAlert;
+}
+//# sourceMappingURL=monitor.service.d.ts.map

package/dist/monitoring/monitor.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.service.d.ts","sourceRoot":"","sources":["../../src/monitoring/monitor.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,MAAM,CAAC,CAAC;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,CAAC;IAC3D,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzE,qBACa,cAAc;IACzB,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAA0C;IAChE,OAAO,CAAC,eAAe,CAAwE;gBAEnF,YAAY,EAAE,YAAY;IAItC;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAsB1C;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI;IAa/D;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAOrC;;OAEG;IACH,gBAAgB,CACd,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,UAAU,EAAE,MAAM,GAAG,MAAM,GAC1B,IAAI;IAMP;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI;IA2BhF;;OAEG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA0ClF;;OAEG;IACH,SAAS,IAAI,KAAK,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,EAAE,OAAO,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IASF;;OAEG;IACH,IAAI,IAAI,IAAI;IAQZ,OAAO,CAAC,aAAa;YAIP,SAAS;CASxB"}