@hazeljs/data 0.2.0-beta.68 → 0.2.0-beta.69

package/dist/streaming/stream.processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.processor.d.ts","sourceRoot":"","sources":["../../src/streaming/stream.processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAGtD;;;GAGG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE7C,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAIlE,aAAa,CAAC,CAAC,EACpB,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC;CAUrB"}
+{"version":3,"file":"stream.processor.d.ts","sourceRoot":"","sources":["../../src/streaming/stream.processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAGtD,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE7C,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAIlE,aAAa,CAAC,CAAC,EACpB,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,cAAc,CAAC,CAAC,CAAC;IAapB;;;;;;OAMG;IACI,cAAc,CAAC,CAAC,EACrB,MAAM,EAAE,aAAa,CAAC;QAAE,KAAK,EAAE,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,EACtD,QAAQ,EAAE,MAAM,GACf,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IA2BnC;;;;;;OAMG;IACI,aAAa,CAAC,CAAC,EACpB,MAAM,EAAE,aAAa,CAAC;QAAE,KAAK,EAAE,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,EACtD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IA6BnC;;;;;;;OAOG;IACI,aAAa,CAAC,CAAC,EACpB,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,GAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAyB,GACnD,cAAc,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAwBnC;;;;;;;;;;OAUG;IACI,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAC1B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC7B,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,GAAG,EAC1B,QAAQ,SAAS,GAChB,cAAc,CAAC,GAAG,CAAC;CAuCvB"}

package/dist/streaming/stream.processor.js

@@ -6,8 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamProcessor = void 0;
 const core_1 = __importDefault(require("@hazeljs/core"));
 /**
- * Stream Processor - In-process stream processing logic
- * Processes items through pipeline without Flink (for testing/simple use cases)
+ * Stream Processor — in-process stream processing.
+ *
+ * Features:
+ * - `processItem` / `processStream` — single-item and async-generator streaming
+ * - `tumblingWindow` — non-overlapping time windows
+ * - `slidingWindow` — overlapping time windows
+ * - `sessionWindow` — gap-based grouping (items grouped when gap > idleMs)
+ * - `joinStreams` — merge two async iterables by matching key
  */
 class StreamProcessor {
     constructor(etlService) {
@@ -27,5 +33,146 @@ class StreamProcessor {
             }
         }
     }
+    // ─── Windowing ─────────────────────────────────────────────────────────────
+    /**
+     * Tumbling window — collects items into non-overlapping fixed-size time windows.
+     * Each item is assigned to exactly one window.
+     *
+     * @param source    Async iterable of `{ value: T; timestamp: number }` items
+     * @param windowMs  Window duration in milliseconds
+     */
+    async *tumblingWindow(source, windowMs) {
+        let windowStart = null;
+        let buffer = [];
+        for await (const item of source) {
+            if (windowStart === null) {
+                windowStart = item.timestamp - (item.timestamp % windowMs);
+            }
+            const itemWindow = item.timestamp - (item.timestamp % windowMs);
+            if (itemWindow > windowStart) {
+                if (buffer.length > 0) {
+                    yield { items: buffer, windowStart, windowEnd: windowStart + windowMs };
+                }
+                windowStart = itemWindow;
+                buffer = [];
+            }
+            buffer.push(item.value);
+        }
+        if (buffer.length > 0 && windowStart !== null) {
+            yield { items: buffer, windowStart, windowEnd: windowStart + windowMs };
+        }
+    }
+    /**
+     * Sliding window — each item may appear in multiple windows.
+     *
+     * @param source   Async iterable of `{ value: T; timestamp: number }` items
+     * @param windowMs Window size in milliseconds
+     * @param slideMs  Slide interval in milliseconds (how often a new window starts)
+     */
+    async *slidingWindow(source, windowMs, slideMs) {
+        const buffer = [];
+        const emittedWindows = new Set();
+        for await (const item of source) {
+            buffer.push(item);
+            // Remove items outside the largest possible window
+            const oldest = item.timestamp - windowMs;
+            while (buffer.length > 0 && buffer[0].timestamp < oldest) {
+                buffer.shift();
+            }
+            // Determine which sliding window this item triggers
+            const windowKey = Math.floor(item.timestamp / slideMs) * slideMs;
+            if (!emittedWindows.has(windowKey)) {
+                emittedWindows.add(windowKey);
+                const windowStart = windowKey;
+                const windowEnd = windowStart + windowMs;
+                const items = buffer
+                    .filter((b) => b.timestamp >= windowStart && b.timestamp < windowEnd)
+                    .map((b) => b.value);
+                if (items.length > 0) {
+                    yield { items, windowStart, windowEnd };
+                }
+            }
+        }
+    }
+    /**
+     * Session window — groups items by inactivity gaps.
+     * A new window starts when no item is received for longer than `idleMs`.
+     *
+     * @param source  Async iterable of items (with optional `.timestamp`)
+     * @param idleMs  Gap duration that triggers a new session (default: 30_000ms)
+     * @param getTimestamp Function to extract timestamp from an item (default: Date.now())
+     */
+    async *sessionWindow(source, idleMs, getTimestamp = () => Date.now()) {
+        let buffer = [];
+        let lastTimestamp = null;
+        let windowStart = null;
+        for await (const item of source) {
+            const ts = getTimestamp(item);
+            if (lastTimestamp !== null && ts - lastTimestamp > idleMs && buffer.length > 0) {
+                yield { items: buffer, windowStart: windowStart, windowEnd: lastTimestamp };
+                buffer = [];
+                windowStart = null;
+            }
+            if (windowStart === null)
+                windowStart = ts;
+            buffer.push(item);
+            lastTimestamp = ts;
+        }
+        if (buffer.length > 0 && windowStart !== null && lastTimestamp !== null) {
+            yield { items: buffer, windowStart, windowEnd: lastTimestamp };
+        }
+    }
+    /**
+     * Join two async streams by a key function.
+     * Items from `left` are buffered; when a matching `right` item arrives, they are emitted together.
+     *
+     * @param left       Left stream
+     * @param right      Right stream
+     * @param leftKey    Extract join key from left items
+     * @param rightKey   Extract join key from right items
+     * @param merge      Combine matched left + right items
+     * @param windowMs   How long to buffer unmatched left items (default: 60_000ms)
+     */
+    async *joinStreams(left, right, leftKey, rightKey, merge, windowMs = 60000) {
+        const leftBuffer = new Map();
+        const rightBuffer = new Map();
+        const now = () => Date.now();
+        // Flatten both streams into a single tagged stream sequentially
+        // For a true concurrent join, use a more complex scheduler —
+        // this simpler version drains left first, then right, checking buffers on both sides.
+        for await (const lItem of left) {
+            const key = leftKey(lItem);
+            if (rightBuffer.has(key)) {
+                const { item: rItem } = rightBuffer.get(key);
+                rightBuffer.delete(key);
+                yield merge(lItem, rItem);
+            }
+            else {
+                leftBuffer.set(key, { item: lItem, ts: now() });
+            }
+            // Expire stale unmatched left items
+            const expiry = now() - windowMs;
+            for (const [k, v] of leftBuffer) {
+                if (v.ts < expiry)
+                    leftBuffer.delete(k);
+            }
+        }
+        for await (const rItem of right) {
+            const key = rightKey(rItem);
+            if (leftBuffer.has(key)) {
+                const { item: lItem } = leftBuffer.get(key);
+                leftBuffer.delete(key);
+                yield merge(lItem, rItem);
+            }
+            else {
+                rightBuffer.set(key, { item: rItem, ts: now() });
+            }
+            const expiry = now() - windowMs;
+            for (const [k, v] of rightBuffer) {
+                if (v.ts < expiry)
+                    rightBuffer.delete(k);
+            }
+        }
+    }
 }
 exports.StreamProcessor = StreamProcessor;

package/dist/streaming/stream.processor.test.js

@@ -49,4 +49,103 @@ describe('StreamProcessor', () => {
         }
         expect(results).toEqual([{ v: 2 }, { v: 3 }]);
     });
+    it('processStream throws when item fails', async () => {
+        let FailPipeline = class FailPipeline {
+            fail() {
+                throw new Error('Item failed');
+            }
+        };
+        __decorate([
+            (0, decorators_1.Transform)({ step: 1, name: 'fail' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], FailPipeline.prototype, "fail", null);
+        FailPipeline = __decorate([
+            (0, decorators_1.Pipeline)('fail-proc')
+        ], FailPipeline);
+        async function* gen() {
+            yield {};
+        }
+        await expect((async () => {
+            for await (const _ of processor.processStream(new FailPipeline(), gen())) {
+                break;
+            }
+        })()).rejects.toThrow('Item failed');
+    });
+    it('tumblingWindow groups items by time window', async () => {
+        async function* source() {
+            yield { value: 1, timestamp: 100 };
+            yield { value: 2, timestamp: 150 };
+            yield { value: 3, timestamp: 250 };
+        }
+        const batches = [];
+        for await (const b of processor.tumblingWindow(source(), 100)) {
+            batches.push({ items: b.items, windowStart: b.windowStart });
+        }
+        expect(batches).toHaveLength(2);
+        expect(batches[0].items).toEqual([1, 2]);
+        expect(batches[0].windowStart).toBe(100);
+        expect(batches[1].items).toEqual([3]);
+        expect(batches[1].windowStart).toBe(200);
+    });
+    it('slidingWindow emits overlapping windows', async () => {
+        async function* source() {
+            yield { value: 1, timestamp: 0 };
+            yield { value: 2, timestamp: 50 };
+        }
+        const batches = [];
+        for await (const b of processor.slidingWindow(source(), 100, 50)) {
+            batches.push(b);
+        }
+        expect(batches.length).toBeGreaterThanOrEqual(1);
+        expect(batches[0].items).toContain(1);
+    });
+    it('sessionWindow groups by gap', async () => {
+        const items = [
+            { v: 1, ts: 0 },
+            { v: 2, ts: 10 },
+            { v: 3, ts: 100 },
+        ];
+        async function* gen() {
+            for (const x of items)
+                yield x;
+        }
+        const batches = [];
+        for await (const b of processor.sessionWindow(gen(), 50, (x) => x.ts)) {
+            batches.push(b);
+        }
+        expect(batches).toHaveLength(2);
+        expect(batches[0].items).toHaveLength(2);
+        expect(batches[1].items).toHaveLength(1);
+    });
+    it('joinStreams merges by key', async () => {
+        async function* left() {
+            yield { id: 'a', name: 'Alice' };
+        }
+        async function* right() {
+            yield { id: 'a', score: 100 };
+        }
+        const results = [];
+        for await (const r of processor.joinStreams(left(), right(), (l) => l.id, (r) => r.id, (l, r) => ({ name: l.name, score: r.score }))) {
+            results.push(r);
+        }
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ name: 'Alice', score: 100 });
+    });
+    it('joinStreams when right arrives first buffers and matches', async () => {
+        async function* left() {
+            await new Promise((r) => setTimeout(r, 10));
+            yield { id: 'x', leftVal: 1 };
+        }
+        async function* right() {
+            yield { id: 'x', rightVal: 2 };
+        }
+        const results = [];
+        for await (const r of processor.joinStreams(left(), right(), (l) => l.id, (r) => r.id, (l, r) => ({ leftVal: l.leftVal, rightVal: r.rightVal }), 5000)) {
+            results.push(r);
+        }
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ leftVal: 1, rightVal: 2 });
+    });
 });

package/dist/streaming/stream.processor.windowing.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stream.processor.windowing.test.d.ts.map

package/dist/streaming/stream.processor.windowing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.processor.windowing.test.d.ts","sourceRoot":"","sources":["../../src/streaming/stream.processor.windowing.test.ts"],"names":[],"mappings":""}

package/dist/streaming/stream.processor.windowing.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const etl_service_1 = require("../pipelines/etl.service");
+const schema_validator_1 = require("../validators/schema.validator");
+const stream_processor_1 = require("./stream.processor");
+async function* itemsWithTs(items) {
+    for (const item of items)
+        yield item;
+}
+describe('StreamProcessor windowing', () => {
+    let processor;
+    beforeEach(() => {
+        processor = new stream_processor_1.StreamProcessor(new etl_service_1.ETLService(new schema_validator_1.SchemaValidator()));
+    });
+    it('tumblingWindow groups by time', async () => {
+        const source = itemsWithTs([
+            { value: 1, timestamp: 0 },
+            { value: 2, timestamp: 10 },
+            { value: 3, timestamp: 100 },
+        ]);
+        const batches = [];
+        for await (const batch of processor.tumblingWindow(source, 50)) {
+            batches.push(batch.items);
+        }
+        expect(batches.length).toBeGreaterThanOrEqual(1);
+        expect(batches.flat()).toContain(1);
+        expect(batches.flat()).toContain(2);
+        expect(batches.flat()).toContain(3);
+    });
+    it('sessionWindow groups by gap', async () => {
+        const items = [1, 2, 3];
+        const getTs = (i) => (i === 2 ? 100 : i);
+        const source = (async function* () {
+            for (const v of items)
+                yield v;
+        })();
+        const batches = [];
+        for await (const batch of processor.sessionWindow(source, 50, getTs)) {
+            batches.push(batch.items);
+        }
+        expect(batches.length).toBeGreaterThanOrEqual(1);
+    });
+    it('slidingWindow yields overlapping windows', async () => {
+        const source = itemsWithTs([
+            { value: 1, timestamp: 0 },
+            { value: 2, timestamp: 50 },
+            { value: 3, timestamp: 100 },
+        ]);
+        const batches = [];
+        for await (const batch of processor.slidingWindow(source, 100, 50)) {
+            batches.push(batch.items);
+        }
+        expect(batches.length).toBeGreaterThanOrEqual(1);
+    });
+    it('joinStreams merges by key', async () => {
+        const left = (async function* () {
+            yield { id: 'a', name: 'Alice' };
+        })();
+        const right = (async function* () {
+            yield { id: 'a', score: 100 };
+        })();
+        const results = [];
+        for await (const r of processor.joinStreams(left, right, (l) => l.id, (r) => r.id, (l, r) => ({ name: l.name, score: r.score }))) {
+            results.push(r);
+        }
+        expect(results).toHaveLength(1);
+        expect(results[0]).toEqual({ name: 'Alice', score: 100 });
+    });
+});

package/dist/telemetry/telemetry.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Telemetry — zero-dependency OpenTelemetry-compatible instrumentation.
+ *
+ * Works in two modes:
+ *  1. **Standalone** — emits structured events to an in-memory log / custom exporters.
+ *  2. **OTel** — when @opentelemetry/api is present in the host application,
+ *     wraps each pipeline step in an OTel span automatically.
+ *
+ * The package itself does NOT list @opentelemetry/* as dependencies; it uses
+ * dynamic optional `require()` so the feature activates transparently when
+ * the host already has it installed.
+ */
+export interface SpanContext {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+}
+export interface PipelineSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    pipeline: string;
+    step: number;
+    stepName: string;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    status: 'ok' | 'error';
+    error?: string;
+    skipped?: boolean;
+    attributes: Record<string, string | number | boolean>;
+}
+export interface MetricPoint {
+    name: string;
+    value: number;
+    labels: Record<string, string>;
+    timestamp: number;
+}
+export interface LineageEntry {
+    traceId: string;
+    pipeline: string;
+    input: unknown;
+    steps: Array<{
+        step: number;
+        name: string;
+        inputHash: string;
+        outputHash: string;
+        durationMs: number;
+    }>;
+    output: unknown;
+    timestamp: Date;
+}
+export type SpanExporter = (span: PipelineSpan) => void | Promise<void>;
+export type MetricExporter = (metric: MetricPoint) => void | Promise<void>;
+/**
+ * TelemetryService — collect spans, metrics, and lineage for pipeline executions.
+ *
+ * @example
+ * const telemetry = TelemetryService.getInstance();
+ * telemetry.addSpanExporter((span) => console.log(span));
+ * telemetry.enableLineage();
+ *
+ * // Automatically used by ETLService when registered
+ * DataModule.forRoot({ telemetry: { enabled: true, serviceName: 'orders-pipeline' } });
+ */
+export declare class TelemetryService {
+    private static instance;
+    private serviceName;
+    private spanExporters;
+    private metricExporters;
+    private spans;
+    private metrics;
+    private lineageStore;
+    private lineageEnabled;
+    private maxSpansInMemory;
+    private otelApi;
+    constructor(options?: {
+        serviceName?: string;
+        maxSpansInMemory?: number;
+    });
+    static getInstance(options?: {
+        serviceName?: string;
+    }): TelemetryService;
+    static reset(): void;
+    private tryLoadOtel;
+    addSpanExporter(exporter: SpanExporter): this;
+    addMetricExporter(exporter: MetricExporter): this;
+    enableLineage(): this;
+    startTrace(_pipelineName: string): {
+        traceId: string;
+        rootSpanId: string;
+    };
+    recordSpan(span: Omit<PipelineSpan, 'traceId' | 'spanId'> & Partial<SpanContext>): Promise<void>;
+    recordMetric(name: string, value: number, labels?: Record<string, string>): Promise<void>;
+    recordStepMetrics(pipeline: string, stepName: string, durationMs: number, success: boolean, recordCount?: number): Promise<void>;
+    startLineage(pipeline: string, input: unknown): LineageEntry;
+    recordLineageStep(entry: LineageEntry, step: number, name: string, input: unknown, output: unknown, durationMs: number): void;
+    finalizeLineage(entry: LineageEntry, output: unknown): void;
+    getSpans(pipeline?: string): PipelineSpan[];
+    getMetrics(name?: string): MetricPoint[];
+    getLineage(traceId?: string): LineageEntry[];
+    /** Compute summary stats for a pipeline across all recorded spans. */
+    getSummary(pipeline: string): {
+        totalRuns: number;
+        successRate: number;
+        avgDurationMs: number;
+        p95DurationMs: number;
+    };
+    clear(): void;
+}
+/**
+ * Prometheus-format metric exporter factory.
+ * Returns a metric exporter that formats points as Prometheus text.
+ *
+ * @example
+ * const { exporter, getText } = createPrometheusExporter();
+ * telemetry.addMetricExporter(exporter);
+ * // GET /metrics → getText()
+ */
+export declare function createPrometheusExporter(): {
+    exporter: MetricExporter;
+    getText: () => string;
+};
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/telemetry/telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAmB3E;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiC;IAExD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,gBAAgB,CAAS;IAGjC,OAAO,CAAC,OAAO,CAAoC;gBAEvC,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAO;IAM7E,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB;IAOxE,MAAM,CAAC,KAAK,IAAI,IAAI;IAIpB,OAAO,CAAC,WAAW;IAWnB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAK7C,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAKjD,aAAa,IAAI,IAAI;IAOrB,UAAU,CAAC,aAAa,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE;IAMpE,UAAU,CACd,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,GACpE,OAAO,CAAC,IAAI,CAAC;IA+CV,YAAY,CAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAClC,OAAO,CAAC,IAAI,CAAC;IAiBV,iBAAiB,CACrB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,EAChB,WAAW,SAAI,GACd,OAAO,CAAC,IAAI,CAAC;IAgBhB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,YAAY;IAW5D,iBAAiB,CACf,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,GACjB,IAAI;IAWP,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAQ3D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAI3C,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,WAAW,EAAE;IAIxC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE;IAM5C,sEAAsE;IACtE,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG;QAC5B,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;KACvB;IAmBD,KAAK,IAAI,IAAI;CAKd;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI;IAC1C,QAAQ,EAAE,cAAc,CAAC;IACzB,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB,CA0BA"}