@zuplo/cli 7.7.7 → 7.7.9

package/node_modules/@posthog/core/dist/traces/index.mjs

@@ -0,0 +1,513 @@
+import { PassThroughSpan, PostHogSpan, applySpanLimits, describeError, inertSpan, monotonicNow, runWithActiveSpan, truncateAttributes } from "./span.mjs";
+import { newSpanId, newTraceId } from "./ids.mjs";
+import { parseTraceparent, sanitizeTracestate, traceparentHeader } from "./traceparent.mjs";
+import { clampEndTime, resolveStartTime, resolveSuppliedTime, sanitizeName, toEpochMs } from "./sanitize.mjs";
+import { assignUserAttributes } from "../utils/json-utils.mjs";
+import { buildOtlpSpan, buildOtlpTracesPayload, buildTracesResourceAttributes } from "./otlp.mjs";
+import { isPromise } from "../utils/index.mjs";
+import { FlushTimer } from "../utils/flush-timer.mjs";
+import { RetryAfterWindow } from "../utils/retry-after.mjs";
+import { MAX_FLUSH_BACKOFF_MS, NO_JITTER, backoffDelayMs, drawJitter } from "../utils/backoff.mjs";
+const MAX_RETRIES_PER_BATCH = 8;
+function clockNow() {
+    return monotonicNow() ?? Date.now();
+}
+function isOwnSpan(value) {
+    try {
+        return value instanceof PostHogSpan;
+    } catch  {
+        return false;
+    }
+}
+function remoteContext(header, tracestate) {
+    const remote = parseTraceparent(header);
+    if (!remote) return;
+    return {
+        traceId: remote.traceId,
+        parentSpanId: remote.spanId,
+        traceState: sanitizeTracestate(tracestate),
+        traceFlags: remote.flags,
+        isRemote: true
+    };
+}
+function looksLikeSpan(value) {
+    try {
+        return 'function' == typeof value.traceparent;
+    } catch  {
+        return false;
+    }
+}
+function isSpanRecordShape(record) {
+    return !!record.attributes && 'object' == typeof record.attributes && !Array.isArray(record.attributes) && Array.isArray(record.events) && void 0 !== record.name && void 0 !== record.kind && void 0 !== record.startTime && void 0 !== record.endTime;
+}
+function restoreField(record, field, value) {
+    if (record[field] !== value) record[field] = value;
+}
+function withRestoredIdentity(hooked, original) {
+    try {
+        const descriptors = Object.getOwnPropertyDescriptors(hooked);
+        for (const field of [
+            'traceId',
+            'spanId',
+            'parentSpanId',
+            'traceState'
+        ])descriptors[field] = {
+            value: original[field],
+            enumerable: true,
+            writable: true,
+            configurable: true
+        };
+        return Object.create(Object.getPrototypeOf(hooked), descriptors);
+    } catch  {
+        return hooked;
+    }
+}
+class PostHogTraces {
+    constructor(_instance, _config, _logger, _getContext, _contextManager, _onSpanQueued){
+        this._instance = _instance;
+        this._config = _config;
+        this._logger = _logger;
+        this._getContext = _getContext;
+        this._contextManager = _contextManager;
+        this._onSpanQueued = _onSpanQueued;
+        this._queue = [];
+        this._flushTimer = new FlushTimer(()=>this._flushInBackground());
+        this._flushPromise = null;
+        this._droppedSinceWarning = 0;
+        this._lastDropWarningAt = 0;
+        this._dropReasons = new Set();
+        this._consecutiveFlushFailures = 0;
+        this._flushJitter = NO_JITTER;
+        this._retryAfter = new RetryAfterWindow();
+        this._headBatchFailures = 0;
+        this._headBatchSize = 0;
+        this._headBatchChargeableAt = 0;
+        this._generation = 0;
+        this._liveSpans = new Map();
+        this._maxExportBatchSize = _config.maxExportBatchSize;
+    }
+    startSpan(name, options) {
+        if (this._instance.isDisabled || this._instance.optedOut) return inertSpan(options, this._contextManager.active());
+        const explicitParent = traceparentHeader(options?.parent);
+        if (explicitParent && 'string' != typeof explicitParent && !isOwnSpan(explicitParent)) {
+            if (looksLikeSpan(explicitParent)) {
+                this._logger.debug('Span parent is not a span from this SDK; returning an inert span');
+                return inertSpan(options, this._contextManager.active());
+            }
+            this._logger.debug('Ignoring an unusable span parent');
+        }
+        const parent = this._resolveParent(explicitParent, options);
+        this._evictAgedSpans();
+        if (this._liveSpans.size >= this._config.maxLiveSpans) {
+            this._recordDrop(1, `the live-span limit (${this._config.maxLiveSpans}) was reached — spans are being started and never ended`);
+            return inertSpan(options, this._contextManager.active());
+        }
+        const now = Date.now();
+        const startTime = resolveStartTime(options?.startTime, now, this._logger);
+        const spanId = newSpanId();
+        this._liveSpans.set(spanId, clockNow());
+        const autoAttributes = this._autoContextAttributes();
+        return new PostHogSpan({
+            traceId: parent?.traceId ?? newTraceId(),
+            spanId,
+            parentSpanId: parent?.parentSpanId,
+            traceState: parent?.traceState,
+            traceFlags: parent?.traceFlags,
+            parentIsRemote: parent?.isRemote,
+            name: sanitizeName(name, 'Span name', this._config.maxAttributeValueLength, this._logger),
+            kind: options?.kind ?? 'internal',
+            attributes: assignUserAttributes({
+                ...autoAttributes
+            }, options?.attributes),
+            autoAttributeKeys: Object.keys(autoAttributes),
+            maxAttributes: this._config.maxAttributesPerSpan,
+            maxEvents: this._config.maxEventsPerSpan,
+            maxAttributesPerEvent: this._config.maxAttributesPerEvent,
+            maxAttributeValueLength: this._config.maxAttributeValueLength,
+            startTime,
+            backdated: startTime !== now
+        }, (record, autoKeys)=>this._onSpanEnd(record, autoKeys), this._logger);
+    }
+    withSpan(name, optionsOrFn, maybeFn) {
+        const options = 'function' == typeof optionsOrFn ? void 0 : optionsOrFn;
+        const fn = 'function' == typeof optionsOrFn ? optionsOrFn : maybeFn;
+        const span = this.startSpan(name, options);
+        try {
+            const result = runWithActiveSpan(this._contextManager, span, fn);
+            if (isPromise(result)) return result.then((value)=>{
+                span.end();
+                return value;
+            }, (error)=>{
+                this._recordCallbackError(span, error);
+                span.end();
+                throw error;
+            });
+            span.end();
+            return result;
+        } catch (error) {
+            this._recordCallbackError(span, error);
+            span.end();
+            throw error;
+        }
+    }
+    getActiveSpan() {
+        return this._contextManager.active() ?? null;
+    }
+    get throttled() {
+        return this._retryAfter.isOpen();
+    }
+    async flush() {
+        for(;;){
+            if (!this._queue.length) return;
+            const inFlight = this._flushPromise;
+            const removed = await (inFlight ?? this._startFlush());
+            if (!removed) return;
+        }
+    }
+    _startFlush() {
+        this._flushTimer.clear();
+        const startedAtGeneration = this._generation;
+        const promise = Promise.resolve().then(()=>startedAtGeneration === this._generation ? this._flushInner() : 0).finally(()=>{
+            if (this._flushPromise === promise) this._flushPromise = null;
+            this._armFlushTimerIfQueuedNoEarlierThan();
+        });
+        this._flushPromise = promise;
+        return promise;
+    }
+    reset() {
+        this._flushTimer.clear();
+        if (this._queue.length) this._logger.critical(`Discarding ${this._queue.length} span(s) that were still queued when tracing was shut down. Raise the shutdown timeout or flush earlier if they matter.`);
+        this._queue = [];
+        this._liveSpans.clear();
+        this._flushPromise = null;
+        this._generation++;
+        this._maxExportBatchSize = this._config.maxExportBatchSize;
+        this._droppedSinceWarning = 0;
+        this._dropReasons.clear();
+        this._lastDropWarningAt = 0;
+        this._consecutiveFlushFailures = 0;
+        this._flushJitter = NO_JITTER;
+        this._retryAfter.reset();
+        this._resetHeadBatchBudget();
+    }
+    _resetHeadBatchBudget() {
+        this._headBatchFailures = 0;
+        this._headBatchChargeableAt = 0;
+    }
+    _resolveParent(explicit, options) {
+        if ('string' == typeof explicit) {
+            const remote = remoteContext(explicit, options?.tracestate);
+            if (!remote) this._logger.debug('Ignoring malformed traceparent; starting a new trace');
+            return remote;
+        }
+        if (isOwnSpan(explicit)) return explicit.childContext();
+        const active = this._contextManager.active();
+        if (isOwnSpan(active)) return active.childContext();
+        if (active instanceof PassThroughSpan) return remoteContext(active.traceparent(), active.tracestate() ?? void 0);
+    }
+    _autoContextAttributes() {
+        let context;
+        try {
+            context = this._getContext();
+        } catch (error) {
+            this._logger.debug('Failed to read tracing context; span will carry no PostHog attributes', error);
+            return {};
+        }
+        const attributes = {};
+        if (context.distinctId) attributes.posthogDistinctId = context.distinctId;
+        if (context.sessionId) attributes.sessionId = context.sessionId;
+        if (context.currentUrl) attributes['url.full'] = context.currentUrl;
+        if (context.screenName) attributes['screen.name'] = context.screenName;
+        if (context.appState) attributes['app.state'] = context.appState;
+        return attributes;
+    }
+    _recordCallbackError(span, error) {
+        if (!(span instanceof PostHogSpan)) return;
+        const { type, message, stack } = describeError(error);
+        span.addEvent('exception', {
+            'exception.type': type,
+            'exception.message': message,
+            ...stack && {
+                'exception.stacktrace': stack
+            }
+        });
+        if (!span.statusIsExplicitlyOk) span.setStatus('error', message);
+    }
+    _evictAgedSpans() {
+        const cutoff = clockNow() - this._config.maxSpanAgeMs;
+        let evicted = 0;
+        for (const [spanId, startedAt] of this._liveSpans){
+            if (startedAt > cutoff) break;
+            this._liveSpans.delete(spanId);
+            evicted++;
+        }
+        if (evicted) this._recordDrop(evicted, `they were still live after ${this._config.maxSpanAgeMs}ms`);
+    }
+    _onSpanEnd(incoming, autoKeys) {
+        if (!this._liveSpans.delete(incoming.spanId)) return;
+        if (this._instance.isDisabled || this._instance.optedOut) return void this._recordDrop(1, 'the user has opted out');
+        const record = this._runBeforeSpanSend(incoming, autoKeys);
+        if (!record) return;
+        this._reportLimitDrops(record);
+        if (this._queue.length >= this._config.maxQueueSize) return void this._recordDrop(1, `the queue is full (${this._config.maxQueueSize}) — raise the flush frequency or reduce span volume`);
+        this._queue.push(record);
+        try {
+            this._onSpanQueued?.();
+        } catch (error) {
+            this._logger.debug('Span queue notification failed', error);
+        }
+        if (!(this._queue.length >= this._maxExportBatchSize) || this._consecutiveFlushFailures || this._retryAfter.isOpen()) this._armFlushTimerIfQueued();
+        else this._flushInBackground();
+    }
+    _reportLimitDrops(record) {
+        const attributes = record.droppedAttributesCount ?? 0;
+        const events = record.droppedEventsCount ?? 0;
+        let eventAttributes = 0;
+        for (const event of record.events)eventAttributes += event.droppedAttributesCount ?? 0;
+        if (attributes || events || eventAttributes) this._logger.debug(`Span limits discarded data from "${record.name}": ${attributes} attributes, ${events} events, ${eventAttributes} event attributes`);
+    }
+    _runBeforeSpanSend(record, autoKeys) {
+        if (!this._config.beforeSpanSend.length) return record;
+        const identity = {
+            traceId: record.traceId,
+            spanId: record.spanId,
+            parentSpanId: record.parentSpanId,
+            traceState: record.traceState
+        };
+        const originalTimes = {
+            startTime: record.startTime,
+            endTime: record.endTime
+        };
+        const originalDropped = {
+            attributes: record.droppedAttributesCount,
+            events: record.droppedEventsCount
+        };
+        const keysBeforeHook = Object.keys(record.attributes);
+        const originalPropagation = {
+            traceFlags: record.traceFlags,
+            parentIsRemote: record.parentIsRemote
+        };
+        const originalStatus = record.status && {
+            ...record.status
+        };
+        let hooked = record;
+        let current = record;
+        try {
+            for (const hook of this._config.beforeSpanSend){
+                const result = hook(hooked);
+                if (!result) {
+                    this._recordDrop(1, 'beforeSpanSend dropped it');
+                    return null;
+                }
+                hooked = this._keepSpanIdentity(result, identity);
+            }
+            const rebuilt = {
+                traceId: identity.traceId,
+                spanId: identity.spanId,
+                parentSpanId: identity.parentSpanId,
+                traceState: identity.traceState,
+                name: hooked.name,
+                kind: hooked.kind,
+                status: hooked.status,
+                attributes: hooked.attributes,
+                events: hooked.events,
+                startTime: hooked.startTime,
+                endTime: hooked.endTime,
+                traceFlags: originalPropagation.traceFlags,
+                parentIsRemote: originalPropagation.parentIsRemote,
+                droppedAttributesCount: originalDropped.attributes,
+                droppedEventsCount: originalDropped.events
+            };
+            current = rebuilt;
+            if (!isSpanRecordShape(current)) {
+                this._logger.debug('beforeSpanSend did not return a span record; dropping the span');
+                this._recordDrop(1, 'beforeSpanSend returned an unusable record');
+                return null;
+            }
+            current.name = sanitizeName(current.name, 'Span name', this._config.maxAttributeValueLength, this._logger);
+            if (current.status && 'ok' !== current.status.code && 'error' !== current.status.code) {
+                this._logger.debug('beforeSpanSend set an unknown span status; keeping the original');
+                current.status = originalStatus;
+            }
+            current.startTime = toEpochMs(current.startTime) ?? originalTimes.startTime;
+            current.endTime = clampEndTime(toEpochMs(current.endTime) ?? originalTimes.endTime, current.startTime);
+            const sanitizedEvents = [];
+            for (const event of current.events)try {
+                sanitizedEvents.push({
+                    ...event,
+                    name: sanitizeName(event.name, 'Span event name', this._config.maxAttributeValueLength, this._logger),
+                    timestamp: resolveSuppliedTime(event.timestamp, current.startTime, 'event timestamp', this._logger)
+                });
+            } catch  {
+                this._logger.debug('beforeSpanSend left an unreadable span event; dropping it');
+            }
+            current.events = sanitizedEvents;
+            applySpanLimits(current, autoKeys, this._config.maxAttributesPerSpan, this._config.maxEventsPerSpan, this._config.maxAttributesPerEvent, this._config.maxAttributeValueLength, keysBeforeHook);
+            return current;
+        } catch (error) {
+            this._logger.debug('beforeSpanSend failed; dropping the span rather than exporting it unscrubbed', error);
+            this._recordDrop(1, 'beforeSpanSend failed');
+            return null;
+        }
+    }
+    _keepSpanIdentity(hooked, original) {
+        if (hooked.traceId !== original.traceId || hooked.spanId !== original.spanId || hooked.parentSpanId !== original.parentSpanId) this._logger.debug('beforeSpanSend changed a span identity field; keeping the original ids');
+        try {
+            restoreField(hooked, 'traceId', original.traceId);
+            restoreField(hooked, 'spanId', original.spanId);
+            restoreField(hooked, 'parentSpanId', original.parentSpanId);
+            restoreField(hooked, 'traceState', original.traceState);
+        } catch  {
+            return withRestoredIdentity(hooked, original);
+        }
+        return hooked;
+    }
+    _recordDrop(count, reason) {
+        this._droppedSinceWarning += count;
+        this._dropReasons.add(reason);
+        if (Date.now() - this._lastDropWarningAt >= this._config.flushIntervalMs) this._warnAboutDrops();
+    }
+    _warnAboutDrops() {
+        if (!this._droppedSinceWarning) return;
+        this._lastDropWarningAt = Date.now();
+        this._logger.warn(`Dropping ${this._droppedSinceWarning} span(s): ${[
+            ...this._dropReasons
+        ].join('; ')}`);
+        this._droppedSinceWarning = 0;
+        this._dropReasons.clear();
+    }
+    _encodeBatch(batch) {
+        const encoded = [];
+        for (const record of batch)try {
+            encoded.push(buildOtlpSpan(record, this._logger));
+        } catch (error) {
+            this._logger.debug('Failed to encode a span; dropping it', error);
+            this._recordDrop(1, 'its attributes could not be encoded');
+        }
+        return encoded;
+    }
+    _discardQueueIfConsentWithdrawn() {
+        if (!this._instance.isDisabled && !this._instance.optedOut) return 0;
+        const discarded = this._queue.length;
+        this._queue = [];
+        this._resetHeadBatchBudget();
+        this._recordDrop(discarded, 'the user has opted out');
+        this._warnAboutDrops();
+        return discarded;
+    }
+    async _flushInner() {
+        if (!this._queue.length) return 0;
+        const discardedBeforeDrain = this._discardQueueIfConsentWithdrawn();
+        if (discardedBeforeDrain) return discardedBeforeDrain;
+        const resourceAttributes = truncateAttributes(buildTracesResourceAttributes(this._config, this._instance.getLibraryId(), this._instance.getLibraryVersion()), this._config.maxAttributeValueLength);
+        const scopeName = this._instance.getLibraryId();
+        const scopeVersion = this._instance.getLibraryVersion();
+        let remaining = this._queue.length;
+        let removed = 0;
+        let localCap = 1 / 0;
+        const generation = this._generation;
+        try {
+            while(remaining > 0 && this._queue.length > 0){
+                const discardedMidDrain = this._discardQueueIfConsentWithdrawn();
+                if (discardedMidDrain) return removed + discardedMidDrain;
+                const cap = this._headBatchFailures > 0 ? Math.min(this._maxExportBatchSize, this._headBatchSize) : this._maxExportBatchSize;
+                const size = Math.max(1, Math.min(cap, localCap, remaining, this._queue.length));
+                const batch = this._queue.slice(0, size);
+                const spans = this._encodeBatch(batch);
+                if (!spans.length) {
+                    this._queue.splice(0, size);
+                    remaining -= size;
+                    removed += size;
+                    this._resetHeadBatchBudget();
+                    continue;
+                }
+                const chargeable = clockNow() >= this._headBatchChargeableAt && !this._retryAfter.isOpen();
+                const outcome = await this._instance._sendTracesBatch(buildOtlpTracesPayload(spans, resourceAttributes, scopeName, scopeVersion, this._logger));
+                if (generation !== this._generation) break;
+                this._retryAfter.record(outcome);
+                if ('ok' === outcome.kind) {
+                    this._consecutiveFlushFailures = 0;
+                    this._flushJitter = NO_JITTER;
+                    this._resetHeadBatchBudget();
+                    this._queue.splice(0, size);
+                    remaining -= size;
+                    removed += size;
+                    if (this._maxExportBatchSize < this._config.maxExportBatchSize) this._maxExportBatchSize++;
+                    continue;
+                }
+                if ('too-large' === outcome.kind) {
+                    if (1 === size) {
+                        this._queue.splice(0, 1);
+                        remaining -= 1;
+                        removed += 1;
+                        this._recordDrop(1, 'it is too large for the ingestion endpoint');
+                        this._consecutiveFlushFailures = 0;
+                        this._flushJitter = NO_JITTER;
+                        this._resetHeadBatchBudget();
+                        continue;
+                    }
+                    const halved = Math.max(1, Math.floor(size / 2));
+                    if (outcome.measuredLocally) localCap = halved;
+                    else this._maxExportBatchSize = halved;
+                    this._resetHeadBatchBudget();
+                    this._logger.debug(`Batch too large; retrying the same spans in batches of ${halved}`);
+                    continue;
+                }
+                if ('retry-later' === outcome.kind) {
+                    this._consecutiveFlushFailures++;
+                    this._flushJitter = drawJitter();
+                    this._headBatchSize = size;
+                    if (chargeable) {
+                        this._headBatchFailures++;
+                        this._headBatchChargeableAt = clockNow() + this._nextFlushDelay();
+                    }
+                    if (this._headBatchFailures < MAX_RETRIES_PER_BATCH) {
+                        this._logger.debug('Span export failed; retrying on the next flush', outcome.error);
+                        return removed;
+                    }
+                    this._queue.splice(0, size);
+                    remaining -= size;
+                    removed += size;
+                    this._consecutiveFlushFailures = 0;
+                    this._flushJitter = NO_JITTER;
+                    this._resetHeadBatchBudget();
+                    this._recordDrop(size, `the ingestion endpoint failed ${MAX_RETRIES_PER_BATCH} times in a row`);
+                    if (this._retryAfter.isOpen()) return removed;
+                    continue;
+                }
+                this._logger.debug('Dropping a span batch the ingestion endpoint rejected', outcome.error);
+                this._queue.splice(0, size);
+                remaining -= size;
+                removed += size;
+                this._consecutiveFlushFailures = 0;
+                this._flushJitter = NO_JITTER;
+                this._resetHeadBatchBudget();
+                this._recordDrop(size, 'the ingestion endpoint rejected the batch');
+            }
+            return removed;
+        } finally{
+            this._warnAboutDrops();
+        }
+    }
+    _flushInBackground() {
+        if (this._backgroundFlush) return;
+        this._backgroundFlush = this.flush().catch((error)=>{
+            this._logger.debug('Background span flush failed', error);
+        }).finally(()=>{
+            this._backgroundFlush = void 0;
+            this._armFlushTimerIfQueuedNoEarlierThan();
+        });
+    }
+    _armFlushTimerIfQueued() {
+        if (this._flushTimer.pending || !this._queue.length) return;
+        this._flushTimer.arm(this._nextFlushDelay());
+    }
+    _armFlushTimerIfQueuedNoEarlierThan() {
+        if (!this._queue.length) return;
+        this._flushTimer.armNoEarlierThan(this._nextFlushDelay());
+    }
+    _nextFlushDelay() {
+        return Math.max(backoffDelayMs(this._config.flushIntervalMs, this._consecutiveFlushFailures, this._flushJitter, MAX_FLUSH_BACKOFF_MS), this._retryAfter.remainingMs());
+    }
+}
+export { PostHogTraces };

package/node_modules/@posthog/core/dist/traces/otlp.d.ts

@@ -0,0 +1,24 @@
+import type { OtlpSpan, OtlpTracesPayload, SpanAttributes, SpanKind } from '@posthog/types';
+import type { Logger } from '../types';
+import type { ResolvedTracesConfig, SpanRecord } from './types';
+export declare function spanKindToOtlp(kind: SpanKind | undefined): number;
+/**
+ * Converts a millisecond epoch to the unix-nanosecond string OTLP expects.
+ * Concatenation rather than multiplication: `Date.now() * 1e6` exceeds
+ * `Number.MAX_SAFE_INTEGER`.
+ */
+export declare function msToUnixNanoString(ms: number): string;
+export declare function buildOtlpSpan(record: SpanRecord, logger?: Logger): OtlpSpan;
+/**
+ * OTLP resource attributes for every batch. User `resourceAttributes` are spread
+ * first, then SDK-controlled identity keys on top so a stray key can't clobber
+ * them. `service.name` is always emitted: the server reads `service_name` only
+ * from that attribute, and spans are unattributable without it.
+ */
+export declare function buildTracesResourceAttributes(config: ResolvedTracesConfig, sdkName: string, sdkVersion: string): SpanAttributes;
+/**
+ * Wraps spans in the OTLP `resourceSpans` envelope: one resource, one scope, N
+ * spans per batch. The server flattens the scope to `{name}@{version}`.
+ */
+export declare function buildOtlpTracesPayload(spans: OtlpSpan[], resourceAttributes: SpanAttributes, scopeName: string, scopeVersion: string, logger?: Logger): OtlpTracesPayload;
+//# sourceMappingURL=otlp.d.ts.map

package/node_modules/@posthog/core/dist/traces/otlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otlp.d.ts","sourceRoot":"","sources":["../../src/traces/otlp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAGR,iBAAiB,EACjB,cAAc,EACd,QAAQ,EAET,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAsD/D,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAOjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYrD;AAoBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,CAwC3E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,oBAAoB,EAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,cAAc,CAEhB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,EAAE,EACjB,kBAAkB,EAAE,cAAc,EAClC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,MAAM,CAAC,EAAE,MAAM,GACd,iBAAiB,CAcnB"}