@pawells/nestjs-prometheus 1.0.0-dev.4c8c698

package/build/controllers/metrics.controller.d.ts

@@ -0,0 +1,84 @@
+import { Response } from 'express';
+import { PrometheusExporter } from '../prometheus.exporter.js';
+/**
+ * Metrics HTTP controller
+ *
+ * Exposes a `/metrics` endpoint that returns metrics in Prometheus text format
+ * (version 0.0.4). This endpoint is typically scraped by Prometheus servers
+ * or other monitoring systems.
+ *
+ * Endpoint: `GET /metrics`
+ *
+ * Response Headers:
+ * - `Content-Type: text/plain; version=0.0.4; charset=utf-8`
+ * - `X-Robots-Tag: noindex, nofollow` — prevents search engine indexing
+ *
+ * Security:
+ * - Protected by MetricsGuard from @pawells/nestjs-shared
+ * - Respects optional METRICS_API_KEY environment variable
+ * - No auth required if METRICS_API_KEY is not set
+ *
+ * @example
+ * ```
+ * GET /metrics
+ *
+ * Response:
+ * 200 OK
+ * Content-Type: text/plain; version=0.0.4; charset=utf-8
+ * X-Robots-Tag: noindex, nofollow
+ *
+ * # HELP http_request_duration_seconds Duration of HTTP requests in seconds
+ * # TYPE http_request_duration_seconds histogram
+ * http_request_duration_seconds_bucket{le="0.001",...} 0
+ * ...
+ * ```
+ */
+export declare class MetricsController {
+    private readonly exporter;
+    constructor(exporter: PrometheusExporter);
+    /**
+     * Get all metrics in Prometheus text format
+     *
+     * Returns the current state of all metrics in Prometheus text format (version 0.0.4).
+     * Metrics include:
+     * - Node.js default metrics (process CPU, memory, event loop, GC, file descriptors)
+     * - Custom metrics registered with InstrumentationRegistry
+     *
+     * Process:
+     * 1. MetricsGuard checks METRICS_API_KEY if configured
+     * 2. PrometheusExporter.getMetrics() is called to flush pending values and retrieve metrics
+     * 3. Response is sent with Prometheus text format (version 0.0.4)
+     *
+     * Authentication (via MetricsGuard):
+     * - If METRICS_API_KEY is set: requires Bearer token, X-API-Key header, or ?key= query param
+     * - If METRICS_API_KEY is not set: all requests are allowed
+     *
+     * Response Headers:
+     * - Content-Type: text/plain; version=0.0.4; charset=utf-8
+     * - X-Robots-Tag: noindex, nofollow
+     *
+     * @param response - Express response object
+     * @returns Promise that resolves when response is sent
+     *
+     * @example
+     * ```
+     * GET /metrics HTTP/1.1
+     * Authorization: Bearer secret-api-key
+     *
+     * HTTP/1.1 200 OK
+     * Content-Type: text/plain; version=0.0.4; charset=utf-8
+     * X-Robots-Tag: noindex, nofollow
+     *
+     * # HELP process_cpu_user_seconds_total Total user CPU time spent in seconds.
+     * # TYPE process_cpu_user_seconds_total counter
+     * process_cpu_user_seconds_total 0.123456
+     *
+     * # HELP process_resident_memory_bytes Resident memory size in bytes.
+     * # TYPE process_resident_memory_bytes gauge
+     * process_resident_memory_bytes 52428800
+     * ...
+     * ```
+     */
+    getMetrics(response: Response): Promise<void>;
+}
+//# sourceMappingURL=metrics.controller.d.ts.map

package/build/controllers/metrics.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.controller.d.ts","sourceRoot":"","sources":["../../src/controllers/metrics.controller.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qBACa,iBAAiB;IAE5B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,kBAAkB;IAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IAKU,UAAU,CAAQ,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAIjE"}

package/build/controllers/metrics.controller.js

@@ -0,0 +1,117 @@
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Header, Res, UseGuards } from '@nestjs/common';
+import { MetricsGuard } from '@pawells/nestjs-shared';
+import { PrometheusExporter } from '../prometheus.exporter.js';
+/**
+ * Metrics HTTP controller
+ *
+ * Exposes a `/metrics` endpoint that returns metrics in Prometheus text format
+ * (version 0.0.4). This endpoint is typically scraped by Prometheus servers
+ * or other monitoring systems.
+ *
+ * Endpoint: `GET /metrics`
+ *
+ * Response Headers:
+ * - `Content-Type: text/plain; version=0.0.4; charset=utf-8`
+ * - `X-Robots-Tag: noindex, nofollow` — prevents search engine indexing
+ *
+ * Security:
+ * - Protected by MetricsGuard from @pawells/nestjs-shared
+ * - Respects optional METRICS_API_KEY environment variable
+ * - No auth required if METRICS_API_KEY is not set
+ *
+ * @example
+ * ```
+ * GET /metrics
+ *
+ * Response:
+ * 200 OK
+ * Content-Type: text/plain; version=0.0.4; charset=utf-8
+ * X-Robots-Tag: noindex, nofollow
+ *
+ * # HELP http_request_duration_seconds Duration of HTTP requests in seconds
+ * # TYPE http_request_duration_seconds histogram
+ * http_request_duration_seconds_bucket{le="0.001",...} 0
+ * ...
+ * ```
+ */
+let MetricsController = class MetricsController {
+    exporter;
+    constructor(exporter) {
+        this.exporter = exporter;
+    }
+    /**
+     * Get all metrics in Prometheus text format
+     *
+     * Returns the current state of all metrics in Prometheus text format (version 0.0.4).
+     * Metrics include:
+     * - Node.js default metrics (process CPU, memory, event loop, GC, file descriptors)
+     * - Custom metrics registered with InstrumentationRegistry
+     *
+     * Process:
+     * 1. MetricsGuard checks METRICS_API_KEY if configured
+     * 2. PrometheusExporter.getMetrics() is called to flush pending values and retrieve metrics
+     * 3. Response is sent with Prometheus text format (version 0.0.4)
+     *
+     * Authentication (via MetricsGuard):
+     * - If METRICS_API_KEY is set: requires Bearer token, X-API-Key header, or ?key= query param
+     * - If METRICS_API_KEY is not set: all requests are allowed
+     *
+     * Response Headers:
+     * - Content-Type: text/plain; version=0.0.4; charset=utf-8
+     * - X-Robots-Tag: noindex, nofollow
+     *
+     * @param response - Express response object
+     * @returns Promise that resolves when response is sent
+     *
+     * @example
+     * ```
+     * GET /metrics HTTP/1.1
+     * Authorization: Bearer secret-api-key
+     *
+     * HTTP/1.1 200 OK
+     * Content-Type: text/plain; version=0.0.4; charset=utf-8
+     * X-Robots-Tag: noindex, nofollow
+     *
+     * # HELP process_cpu_user_seconds_total Total user CPU time spent in seconds.
+     * # TYPE process_cpu_user_seconds_total counter
+     * process_cpu_user_seconds_total 0.123456
+     *
+     * # HELP process_resident_memory_bytes Resident memory size in bytes.
+     * # TYPE process_resident_memory_bytes gauge
+     * process_resident_memory_bytes 52428800
+     * ...
+     * ```
+     */
+    async getMetrics(response) {
+        const metrics = await this.exporter.getMetrics();
+        response.send(metrics);
+    }
+};
+__decorate([
+    Get('metrics'),
+    UseGuards(MetricsGuard),
+    Header('Content-Type', 'text/plain; version=0.0.4; charset=utf-8'),
+    Header('X-Robots-Tag', 'noindex, nofollow'),
+    __param(0, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], MetricsController.prototype, "getMetrics", null);
+MetricsController = __decorate([
+    Controller(),
+    __metadata("design:paramtypes", [PrometheusExporter])
+], MetricsController);
+export { MetricsController };
+//# sourceMappingURL=metrics.controller.js.map

package/build/controllers/metrics.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.controller.js","sourceRoot":"","sources":["../../src/controllers/metrics.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEI,IAAM,iBAAiB,GAAvB,MAAM,iBAAiB;IAEX;IADlB,YACkB,QAA4B;QAA5B,aAAQ,GAAR,QAAQ,CAAoB;IAC3C,CAAC;IAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IAKU,AAAN,KAAK,CAAC,UAAU,CAAQ,QAAkB;QAChD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;QACjD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;CACD,CAAA;AAJa;IAJZ,GAAG,CAAC,SAAS,CAAC;IACd,SAAS,CAAC,YAAY,CAAC;IACvB,MAAM,CAAC,cAAc,EAAE,0CAA0C,CAAC;IAClE,MAAM,CAAC,cAAc,EAAE,mBAAmB,CAAC;IACnB,WAAA,GAAG,EAAE,CAAA;;;;mDAG7B;AAvDW,iBAAiB;IAD7B,UAAU,EAAE;qCAGgB,kBAAkB;GAFlC,iBAAiB,CAwD7B"}

package/build/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @pawells/nestjs-prometheus — Prometheus metrics exporter for NestJS
+ *
+ * Integrates with @pawells/nestjs-shared InstrumentationRegistry to export metrics
+ * in Prometheus text format via a GET /metrics endpoint.
+ *
+ * @example
+ * ```typescript
+ * import { PrometheusModule } from '@pawells/nestjs-prometheus';
+ *
+ * @Module({
+ *   imports: [PrometheusModule.forRoot()],
+ * })
+ * export class AppModule {}
+ * // Metrics are now available at: GET /metrics
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { PrometheusExporter } from './prometheus.exporter.js';
+export { PrometheusModule } from './prometheus.module.js';
+export { MetricsController } from './controllers/metrics.controller.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC"}

package/build/index.js

@@ -0,0 +1,23 @@
+/**
+ * @pawells/nestjs-prometheus — Prometheus metrics exporter for NestJS
+ *
+ * Integrates with @pawells/nestjs-shared InstrumentationRegistry to export metrics
+ * in Prometheus text format via a GET /metrics endpoint.
+ *
+ * @example
+ * ```typescript
+ * import { PrometheusModule } from '@pawells/nestjs-prometheus';
+ *
+ * @Module({
+ *   imports: [PrometheusModule.forRoot()],
+ * })
+ * export class AppModule {}
+ * // Metrics are now available at: GET /metrics
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { PrometheusExporter } from './prometheus.exporter.js';
+export { PrometheusModule } from './prometheus.module.js';
+export { MetricsController } from './controllers/metrics.controller.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC"}

package/build/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@pawells/nestjs-prometheus",
+  "displayName": "@pawells/nestjs-prometheus",
+  "version": "1.0.0-dev.4c8c698",
+  "description": "NestJS Prometheus metrics module with endpoint controller",
+  "type": "module",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run",
+    "test:coverage": "vitest --coverage",
+    "pipeline": "yarn typecheck && yarn lint && yarn test && yarn build"
+  },
+  "peerDependencies": {
+    "@nestjs/common": ">=10.0.0",
+    "@nestjs/config": ">=3.0.0",
+    "@nestjs/core": ">=10.0.0",
+    "@nestjs/throttler": ">=5.0.0",
+    "@opentelemetry/api": ">=1.0.0",
+    "class-transformer": ">=0.5.0",
+    "class-validator": ">=0.14.0",
+    "compression": ">=1.0.0",
+    "csrf-csrf": ">=3.0.0",
+    "express": ">=4.0.0",
+    "helmet": ">=7.0.0",
+    "joi": ">=17.0.0",
+    "prom-client": ">=15.0.0",
+    "rxjs": ">=7.0.0",
+    "xss": ">=1.0.0"
+  },
+  "dependencies": {
+    "@pawells/nestjs-shared": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "packageManager": "yarn@4.12.0",
+  "author": "Aaron Wells <69355326+PhillipAWells@users.noreply.github.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PhillipAWells/nestjs-common"
+  },
+  "files": [
+    "build/",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "./index.js"
+}

package/build/prometheus.exporter.d.ts

@@ -0,0 +1,187 @@
+import type { IMetricsExporter, MetricDescriptor, MetricValue } from '@pawells/nestjs-shared';
+/**
+ * Prometheus metrics exporter implementation
+ *
+ * Implements the IMetricsExporter interface for Prometheus pull-based metrics collection.
+ * Uses prom-client library to manage Prometheus instruments (Counter, Gauge, Histogram)
+ * and exports metrics in Prometheus text format on demand.
+ *
+ * Architecture:
+ * - **Event-based buffering**: Metric values are buffered as they are recorded
+ * - **Pull-based export**: Flushes all pending values when `/metrics` endpoint is scraped
+ * - **Atomic swaps**: Uses atomic array swaps during flush to prevent concurrent data loss
+ * - **Bounded memory**: Limits pending values to 1000 per metric to prevent unbounded growth
+ * - **Node.js defaults**: Automatically collects Node.js process metrics (CPU, memory, GC, etc.)
+ *
+ * Type mapping:
+ * - `counter` → prom-client Counter (monotonically increasing)
+ * - `gauge` → prom-client Gauge (point-in-time value)
+ * - `updown_counter` → prom-client Gauge (can increase or decrease)
+ * - `histogram` → prom-client Histogram (distribution with buckets)
+ *
+ * @example
+ * ```typescript
+ * const exporter = new PrometheusExporter();
+ * registry.registerExporter(exporter);
+ *
+ * // Later, get metrics for Prometheus scrape endpoint
+ * const prometheusMetrics = await exporter.getMetrics();
+ * ```
+ */
+export declare class PrometheusExporter implements IMetricsExporter {
+    /**
+     * This exporter buffers metric values as they are recorded and flushes
+     * them into prom-client instruments on each pull (getMetrics)
+     */
+    readonly supportsEventBased = true;
+    /**
+     * This exporter supports pull-based metric retrieval
+     */
+    readonly supportsPull = true;
+    /**
+     * Prom-client Registry instance for managing instruments
+     * @private
+     */
+    private readonly registry;
+    /**
+     * Cache of created prom-client instruments (Counter, Histogram, Gauge)
+     * Keyed by metric name
+     * @private
+     */
+    private readonly instruments;
+    /**
+     * Pending metric values to be flushed into prom-client instruments on next getMetrics()
+     * Keyed by metric name
+     * @private
+     */
+    private readonly pending;
+    /**
+     * Running totals for updown_counter metrics (persistent across scrapes)
+     * Keyed by metric name, then by normalized label key
+     * @private
+     */
+    private readonly gaugeValues;
+    /**
+     * Maximum number of pending metric values per metric before culling oldest entries
+     * Prevents unbounded memory growth if metrics are recorded much faster than pulled
+     * @private
+     */
+    private static readonly MAX_PENDING_PER_METRIC;
+    /**
+     * Logger instance for warnings and errors
+     */
+    private readonly logger;
+    /**
+     * Normalize label keys to handle consistent ordering regardless of insertion order
+     * @private
+     */
+    private static normalizeLabelKey;
+    /**
+     * Create a new PrometheusExporter instance
+     *
+     * Initializes a prom-client Registry and starts collecting Node.js default metrics
+     * (process CPU, memory, event loop, garbage collection, etc.).
+     */
+    constructor();
+    /**
+     * Called when a metric descriptor is registered in InstrumentationRegistry
+     *
+     * Pre-creates the corresponding prom-client instrument (Counter, Gauge, or Histogram)
+     * based on the descriptor's type. The created instrument is cached for future use.
+     * Initializes an empty pending array for the metric to buffer future recorded values.
+     *
+     * Type mapping:
+     * - `counter` → Counter (incremented by value via inc())
+     * - `histogram` → Histogram (observed via observe())
+     * - `gauge` or `updown_counter` → Gauge (set via set())
+     *
+     * @param descriptor - The metric descriptor being registered
+     * @throws Error if descriptor type is not supported
+     *
+     * @example
+     * ```typescript
+     * exporter.onDescriptorRegistered({
+     *   name: 'http_request_duration_seconds',
+     *   type: 'histogram',
+     *   help: 'Request duration in seconds',
+     *   labelNames: ['method', 'route', 'status_code'],
+     *   buckets: [0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1],
+     * });
+     * ```
+     */
+    onDescriptorRegistered(descriptor: MetricDescriptor): void;
+    /**
+     * Buffer a metric value to be flushed on next getMetrics() call
+     *
+     * Values are buffered rather than immediately recorded into prom-client.
+     * They are applied to the appropriate instrument during the next pull (getMetrics) call.
+     *
+     * Buffering behavior:
+     * - Values are appended to the pending array for the metric
+     * - If the pending array exceeds MAX_PENDING_PER_METRIC (1000), oldest entries are culled
+     * - If the metric descriptor was not registered first, a warning is logged and value is dropped
+     *
+     * @param value - The metric value to buffer
+     *
+     * @example
+     * ```typescript
+     * exporter.onMetricRecorded({
+     *   descriptor: { name: 'http_request_duration_seconds' },
+     *   value: 0.125,
+     *   labels: { method: 'GET', status_code: '200' },
+     *   timestamp: performance.now(),
+     * });
+     * ```
+     */
+    onMetricRecorded(value: MetricValue): void;
+    /**
+     * Retrieve all metrics in Prometheus text format
+     *
+     * Flushes all pending metric values into prom-client instruments, then returns
+     * the complete metrics output in Prometheus text format (version 0.0.4).
+     *
+     * Flush process:
+     * 1. For each metric, atomically swap the pending array with a fresh empty array
+     * 2. Apply all pending values to the corresponding instrument:
+     *    - Counter: increment by value
+     *    - Histogram: observe value
+     *    - Gauge: set to value
+     * 3. Skip any values where the instrument was not pre-created (shouldn't happen)
+     * 4. Return the serialized metrics from the registry
+     *
+     * Includes Node.js default metrics and all custom metrics registered with descriptors.
+     *
+     * @returns Promise resolving to metrics in Prometheus text format (version 0.0.4)
+     * @throws Error if metrics generation fails (logged but re-thrown)
+     *
+     * @example
+     * ```typescript
+     * const prometheusMetrics = await exporter.getMetrics();
+     * // Returns:
+     * // # HELP http_request_duration_seconds Duration of HTTP requests in seconds
+     * // # TYPE http_request_duration_seconds histogram
+     * // http_request_duration_seconds_bucket{le="0.001",...} 0
+     * // http_request_duration_seconds_bucket{le="0.01",...} 5
+     * ```
+     */
+    getMetrics(): Promise<string>;
+    /**
+     * Shutdown the exporter and clean up resources
+     *
+     * Clears the prom-client registry and releases all internal state:
+     * - registry.clear() — removes all instruments
+     * - instruments.clear() — removes cached instrument references
+     * - pending.clear() — discards any buffered but unflushed metric values
+     *
+     * Called by PrometheusModule during application shutdown (onApplicationShutdown).
+     *
+     * @returns Promise that resolves when shutdown is complete
+     *
+     * @example
+     * ```typescript
+     * await exporter.shutdown();
+     * ```
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=prometheus.exporter.d.ts.map

package/build/prometheus.exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prometheus.exporter.d.ts","sourceRoot":"","sources":["../src/prometheus.exporter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBACa,kBAAmB,YAAW,gBAAgB;IAC1D;;;OAGG;IACH,SAAgB,kBAAkB,QAAQ;IAE1C;;OAEG;IACH,SAAgB,YAAY,QAAQ;IAEpC;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IAEpC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmE;IAE/F;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmC;IAE/D;;;;OAIG;IAEH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;IAEtD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IAEnC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAKhC;;;;;OAKG;;IAYH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,sBAAsB,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAgEjE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAiBjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACU,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAqG1C;;;;;;;;;;;;;;;;OAgBG;IAEU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAMtC"}