@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/Redis.js

@@ -0,0 +1,364 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("redis");
+const Parsing_1 = require("../utils/Parsing");
+const ElasticSearch_1 = __importDefault(require("./ElasticSearch"));
+const Logger_1 = require("../utils/Logger");
+class Redis {
+    constructor(config) {
+        // Prevent concurrent connect / subscriber-connect attempts
+        this.connectPromise = null;
+        this.subscriberConnectPromise = null;
+        // Stored so the subscription can be restored after subscriber recreation
+        this.expiryPattern = null;
+        this.expiryHandler = null;
+        this.config = config;
+        this.prefix = `${config.serverConfig.projectName}-${config.serverConfig.environment}`;
+        this.logger = (0, Logger_1.createLogger)("Redis", config.pipelineConfig.azureAppName);
+        this.client = this.createClient();
+    }
+    static getInstance(config) {
+        if (!this.instance) {
+            this.instance = new Redis(config);
+        }
+        return this.instance;
+    }
+    // -------------------------------------------------------------------------
+    // Client / subscriber creation
+    // -------------------------------------------------------------------------
+    createClient() {
+        let client;
+        if (this.config.serverConfig.environment === "local") {
+            client = (0, redis_1.createClient)();
+        }
+        else {
+            const p = (0, Parsing_1.parseRedisUrl)(this.config.config.redisConnectionstring);
+            client = (0, redis_1.createClient)({
+                pingInterval: 10000,
+                url: `rediss://${p.host}:${p.port}`,
+                password: p.password,
+                socket: {
+                    host: p.host,
+                    port: p.port,
+                    tls: true,
+                    connectTimeout: 10000,
+                    reconnectStrategy: (retries) => {
+                        if (retries > 20)
+                            return new Error("Redis: max reconnect retries reached");
+                        const delay = Math.min(retries * 200, 5000);
+                        this.logger.warn(`Redis: reconnect attempt ${retries}, retrying in ${delay}ms`);
+                        return delay;
+                    },
+                },
+            });
+        }
+        this.attachMainClientListeners(client);
+        return client;
+    }
+    attachMainClientListeners(client) {
+        client.on("error", (err) => {
+            var _a;
+            this.logger.warn("Redis: client error", { data: { error: err === null || err === void 0 ? void 0 : err.message } });
+            ElasticSearch_1.default.getInstance(this.config).index_log("Redis", "client.error", "Error", "Redis client error", { message: (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : "Unexpected error" });
+        });
+        client.on("reconnecting", () => this.logger.warn("Redis: client reconnecting"));
+        client.on("connect", () => this.logger.info("Redis: client connected"));
+        client.on("ready", () => {
+            this.logger.info("Redis: client ready");
+            // Enable TCP keep-alive on the underlying socket
+            const stream = client.socket;
+            if (stream === null || stream === void 0 ? void 0 : stream.setKeepAlive)
+                stream.setKeepAlive(true, 10000);
+        });
+        client.on("end", () => {
+            // Fires when reconnectStrategy gave up (or explicit quit — not used here).
+            // Create a completely fresh client; the old one is dead.
+            this.logger.warn("Redis: client ended — reconnect strategy exhausted, creating fresh client");
+            if (this.connectPromise)
+                return; // already recovering
+            this.client = this.createClient();
+            this.connectPromise = this.connectClient(this.client)
+                .catch((err) => this.logger.error("Redis: fresh client connect failed", { data: { error: err } }))
+                .finally(() => { this.connectPromise = null; });
+        });
+    }
+    attachSubscriberListeners(subscriber) {
+        subscriber.on("error", (err) => this.logger.warn("Redis: subscriber error", { data: { error: err === null || err === void 0 ? void 0 : err.message } }));
+        subscriber.on("reconnecting", () => this.logger.warn("Redis: subscriber reconnecting"));
+        subscriber.on("connect", () => this.logger.info("Redis: subscriber connected"));
+        subscriber.on("ready", () => this.logger.info("Redis: subscriber ready"));
+        subscriber.on("end", () => {
+            // Subscriber's reconnect strategy gave up — rebuild from scratch and restore subscription.
+            this.logger.warn("Redis: subscriber ended — recreating");
+            this.recreateSubscriber();
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Connection management
+    // -------------------------------------------------------------------------
+    connectClient(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info("Redis: connecting main client");
+            yield client.connect();
+            if (this.config.serverConfig.environment === "local") {
+                yield client.configSet("notify-keyspace-events", "Exg");
+            }
+            this.logger.info("Redis: main client ready");
+        });
+    }
+    connectSubscriber() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.isOpen)
+                return;
+            if (this.subscriberConnectPromise)
+                return this.subscriberConnectPromise;
+            this.subscriberConnectPromise = this._doConnectSubscriber()
+                .finally(() => { this.subscriberConnectPromise = null; });
+            return this.subscriberConnectPromise;
+        });
+    }
+    _doConnectSubscriber() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info("Redis: connecting subscriber");
+            // duplicate() copies all connection options, no re-auth needed
+            this.subscriber = this.client.duplicate();
+            this.attachSubscriberListeners(this.subscriber);
+            yield Promise.race([
+                this.subscriber.connect(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Subscriber connect timed out after 10s")), 10000)),
+            ]);
+            this.logger.info("Redis: subscriber ready");
+        });
+    }
+    /**
+     * Called when the subscriber's reconnectStrategy fails
+     * Removes dead subscriber and creates a new one.
+     * Restores expiry subscription using the stored pattern/handler
+     */
+    recreateSubscriber() {
+        this.subscriber = undefined;
+        this.subscriberConnectPromise = null;
+        if (!this.client.isOpen) {
+            // Main client is also down, skip
+            // When the main client recovers, the next initialize() call will
+            // create a fresh subscriber and resubscribe
+            this.logger.warn("Redis: main client not ready, deferring subscriber recreation");
+            return;
+        }
+        this.connectSubscriber()
+            .then(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.expiryPattern && this.expiryHandler && this.subscriber) {
+                yield this.subscriber.pSubscribe(this.expiryPattern, this.expiryHandler);
+                this.logger.info("Redis: subscriber recreated and expiry subscription restored");
+            }
+        }))
+            .catch((err) => this.logger.error("Redis: subscriber recreation failed", { data: { error: err } }));
+    }
+    // -------------------------------------------------------------------------
+    // Public initializer — safe to call multiple times / concurrently
+    // -------------------------------------------------------------------------
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.client.isOpen) {
+                // Main client is up — ensure subscriber is also up
+                if (!((_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.isOpen)) {
+                    yield this.connectSubscriber().catch((err) => this.logger.warn("Redis: subscriber connect failed during initialize", { data: { error: err } }));
+                }
+                return;
+            }
+            // Deduplicate concurrent callers
+            if (this.connectPromise)
+                return this.connectPromise;
+            this.connectPromise = this._doInitialize()
+                .finally(() => { this.connectPromise = null; });
+            return this.connectPromise;
+        });
+    }
+    _doInitialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info("Redis: initializing");
+            yield this.connectClient(this.client);
+            // Subscriber failure is non-fatal for initialization — commands still work.
+            // The subscriber will be retried the first time subscribeToExpiry is called.
+            yield this.connectSubscriber().catch((err) => this.logger.warn("Redis: subscriber connect failed during init — will retry on use", { data: { error: err } }));
+            this.logger.info("Redis: initialization complete");
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Expiry subscription
+    // -------------------------------------------------------------------------
+    subscribeToExpiry(onExpire) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!((_a = this.subscriber) === null || _a === void 0 ? void 0 : _a.isOpen))
+                yield this.connectSubscriber();
+            if (!this.subscriber)
+                throw new Error("Redis: subscriber not available");
+            const db = (_c = (_b = this.client.options) === null || _b === void 0 ? void 0 : _b.database) !== null && _c !== void 0 ? _c : 0;
+            const pattern = `__keyevent@${db}__:expired`;
+            const handler = (expiredKey) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const pref = `${this.prefix}-`;
+                    const normalizedKey = expiredKey.startsWith(pref) ? expiredKey.slice(pref.length) : expiredKey;
+                    this.logger.info(`Redis: key expired: ${normalizedKey}`);
+                    let value = null;
+                    try {
+                        value = yield this.get_object(expiredKey);
+                    }
+                    catch ( /* already gone */_a) { /* already gone */ }
+                    onExpire(normalizedKey, value);
+                }
+                catch (err) {
+                    this.logger.error("Redis: expiry handler error", { data: { error: err } });
+                }
+            });
+            // Persist so recreateSubscriber can restore the subscription automatically.
+            this.expiryPattern = pattern;
+            this.expiryHandler = handler;
+            try {
+                yield Promise.race([
+                    this.subscriber.pSubscribe(pattern, handler),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("pSubscribe timed out after 10s")), 10000)),
+                ]);
+                this.logger.info(`Redis: subscribed to expiry pattern ${pattern}`);
+            }
+            catch (err) {
+                // Non-fatal: handler is stored — subscription is restored automatically
+                // when the subscriber reconnects (see recreateSubscriber / 'end' event).
+                this.logger.warn("Redis: pSubscribe timed out — will retry when subscriber reconnects", { data: { error: err } });
+            }
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Key helpers
+    // -------------------------------------------------------------------------
+    get_key(key, use_prefix = true) {
+        return use_prefix ? `${this.prefix}-${key}` : key;
+    }
+    // -------------------------------------------------------------------------
+    // Core read / write / delete — all guarded by ensureConnected + withTimeout
+    // -------------------------------------------------------------------------
+    ensureConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client.isOpen)
+                yield this.initialize();
+        });
+    }
+    _get(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureConnected();
+            return this.withTimeout(() => this.client.get(final_key));
+        });
+    }
+    _set(final_key, value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureConnected();
+            if (!options) {
+                return this.withTimeout(() => this.client.set(final_key, value));
+            }
+            const { expires_at, ttl, publish } = options;
+            if (!expires_at)
+                throw new Error("expires_at is required");
+            if (!ttl)
+                throw new Error("ttl is required");
+            if (publish) {
+                return this.withTimeout(() => {
+                    const multi = this.client.multi();
+                    multi.set(final_key, value, { EX: ttl });
+                    multi.publish(publish.name, value);
+                    return multi.exec();
+                });
+            }
+            return this.withTimeout(() => this.client.set(final_key, value, { EX: ttl }));
+        });
+    }
+    _delete(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureConnected();
+            return this.withTimeout(() => this.client.del(final_key));
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Public API (interface preserved)
+    // -------------------------------------------------------------------------
+    get(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._get(this.get_key(_key));
+        });
+    }
+    set(_key, value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._set(this.get_key(_key), value, options);
+        });
+    }
+    delete(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._delete(this.get_key(_key));
+        });
+    }
+    set_object(_key, value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._set(this.get_key(_key), JSON.stringify(value), options);
+        });
+    }
+    get_object(_key_1) {
+        return __awaiter(this, arguments, void 0, function* (_key, use_prefix = true) {
+            const key = this.get_key(_key, use_prefix);
+            this.logger.info(`Redis: Getting object with key: ${key}`);
+            const raw = yield this._get(key);
+            return raw ? JSON.parse(raw) : null;
+        });
+    }
+    delete_object(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._delete(this.get_key(_key));
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Command execution with timeout + single retry on dead connection
+    // -------------------------------------------------------------------------
+    withTimeout(fn_1) {
+        return __awaiter(this, arguments, void 0, function* (fn, ms = 5000, retry = true) {
+            let timedOut = false;
+            try {
+                return yield Promise.race([
+                    fn(),
+                    new Promise((_, reject) => setTimeout(() => {
+                        timedOut = true;
+                        reject(new Error(`Redis command timed out after ${ms}ms`));
+                    }, ms)),
+                ]);
+            }
+            catch (err) {
+                if (timedOut && retry) {
+                    this.logger.warn("Redis: command timed out — attempting recovery");
+                    if (!this.client.isOpen) {
+                        // Connection is dead — create a fresh client before retrying.
+                        // This also covers the case where the 'end' event hasn't fired yet.
+                        this.logger.warn("Redis: client closed, creating fresh client before retry");
+                        this.client = this.createClient();
+                        yield this.connectClient(this.client);
+                    }
+                    // fn() references this.client via arrow closure — picks up the new client.
+                    return this.withTimeout(fn, ms, false);
+                }
+                throw err;
+            }
+        });
+    }
+}
+exports.default = Redis;

package/build/services/RedisListQueue.d.ts

@@ -0,0 +1,15 @@
+import { IConfig } from "../interfaces/config";
+declare class RedisListQueue {
+    private redis;
+    private readonly key;
+    private logger;
+    constructor(config: IConfig, name: string);
+    clear(): Promise<void>;
+    push<T>(message: T): Promise<void>;
+    pushMany<T>(messages: T[]): Promise<void>;
+    popBlocking<T>(timeoutSeconds?: number): Promise<T | null>;
+    popMany<T>(count: number, timeoutSeconds?: number): Promise<T[]>;
+    length(): Promise<number>;
+}
+export default RedisListQueue;
+//# sourceMappingURL=RedisListQueue.d.ts.map

package/build/services/RedisListQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisListQueue.d.ts","sourceRoot":"","sources":["../../src/services/RedisListQueue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C,cAAM,cAAc;IAChB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM;IAOnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IASlB,QAAQ,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE;IAkBzB,WAAW,CAAC,CAAC,EAAE,cAAc,SAAI,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAYrD,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,SAAI,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAiB3D,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC;CAIlC;AAED,eAAe,cAAc,CAAC"}

package/build/services/RedisListQueue.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Redis_1 = __importDefault(require("./Redis"));
+const Logger_1 = require("../utils/Logger");
+class RedisListQueue {
+    constructor(config, name) {
+        this.redis = Redis_1.default.getInstance(config);
+        this.key = `${config.serverConfig.projectName}-${config.serverConfig.environment}:queue:${name}`;
+        this.logger = (0, Logger_1.createLogger)(`RedisListQueue`, config.pipelineConfig.azureAppName);
+    }
+    // Clear the queue completely
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.initialize();
+            yield this.redis.client.del(this.key);
+        });
+    }
+    // Push single message
+    push(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.initialize();
+            yield this.redis.client.rPush(this.key, JSON.stringify(message));
+        });
+    }
+    // Push many messages
+    pushMany(messages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!messages.length)
+                return;
+            yield this.redis.initialize();
+            const multi = this.redis.client.multi();
+            for (const m of messages) {
+                multi.rPush(this.key, JSON.stringify(m));
+            }
+            yield multi.exec();
+            const len = yield this.redis.client.lLen(this.key);
+            this.logger.info(`Updated Event Replay Queue ${this.key} length: ${len}`);
+        });
+    }
+    // Blocking pop (consumer side)
+    popBlocking() {
+        return __awaiter(this, arguments, void 0, function* (timeoutSeconds = 0) {
+            yield this.redis.initialize();
+            const result = yield this.redis.client.blPop(this.key, timeoutSeconds);
+            if (!result)
+                return null;
+            return JSON.parse(result.element);
+        });
+    }
+    // Blocking pop many
+    popMany(count_1) {
+        return __awaiter(this, arguments, void 0, function* (count, timeoutSeconds = 0) {
+            yield this.redis.initialize();
+            const results = [];
+            const first = yield this.redis.client.blPop(this.key, timeoutSeconds);
+            if (!first)
+                return results;
+            results.push(JSON.parse(first.element));
+            for (let i = 1; i < count; i++) {
+                const raw = yield this.redis.client.lPop(this.key);
+                if (!raw)
+                    break;
+                results.push(JSON.parse(raw));
+            }
+            return results;
+        });
+    }
+    length() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.initialize();
+            return yield this.redis.client.lLen(this.key);
+        });
+    }
+}
+exports.default = RedisListQueue;

package/build/services/RedisPubSub.d.ts

@@ -0,0 +1,41 @@
+import { RedisClientType } from "@redis/client";
+import { IConfig } from "../interfaces/config";
+import { RedisPatternEventNames, RedisPublishNames } from "./types/RedisPubSub";
+interface SetOptions {
+    expires_at?: number;
+    ttl: number;
+}
+declare class RedisPubSub {
+    private config;
+    client: RedisClientType;
+    prefix: string;
+    subscriber?: RedisClientType;
+    initialized: boolean;
+    private logger;
+    constructor(config: IConfig, prefix: string);
+    private create_redis_client;
+    private reinitialize;
+    initialize(): Promise<void>;
+    psubscribe(events: {
+        onEvent: (key: string, eventName: RedisPatternEventNames, value?: any) => void;
+        eventName: RedisPatternEventNames;
+    }[]): Promise<void>;
+    subscribe(events: {
+        onEvent: (data: any) => void;
+        eventName: RedisPublishNames;
+    }[]): Promise<void>;
+    get_key(key: string, _prefix?: string): string;
+    private _get;
+    private _set;
+    private _delete;
+    get(_key: string): Promise<string | null>;
+    set(_key: string, _value: string, options?: SetOptions): Promise<string | null>;
+    delete(_key: string): Promise<number>;
+    set_object(_key: string, _value: any, options?: SetOptions): Promise<string | null>;
+    get_object(_key: string): Promise<any>;
+    delete_object(_key: string): Promise<number>;
+    private handle_redis_error;
+    private handle_redis_action;
+}
+export default RedisPubSub;
+//# sourceMappingURL=RedisPubSub.d.ts.map

package/build/services/RedisPubSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisPubSub.d.ts","sourceRoot":"","sources":["../../src/services/RedisPubSub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAIhF,UAAU,UAAU;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;CACf;AAID,cAAM,WAAW;IACb,OAAO,CAAC,MAAM,CAAU;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,MAAM,CAAS;gBACX,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM;IAU3C,OAAO,CAAC,mBAAmB,CAyB1B;YAEa,YAAY;IAWb,UAAU;IAoCV,UAAU,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,sBAAsB,EAAE,KAAK,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;QAAC,SAAS,EAAE,sBAAsB,CAAA;KAAE,EAAE;IAsB1I,SAAS,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;QAAC,SAAS,EAAE,iBAAiB,CAAA;KAAE,EAAE;IAqBxF,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;YAI9B,IAAI;YAOJ,IAAI;YA2BJ,OAAO;IAMR,GAAG,CAAC,IAAI,EAAE,MAAM;IAQhB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU;IAKtD,MAAM,CAAC,IAAI,EAAE,MAAM;IAKnB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,UAAU;IAK1D,UAAU,CAAC,IAAI,EAAE,MAAM;IAMvB,aAAa,CAAC,IAAI,EAAE,MAAM;YAMzB,kBAAkB;YAMlB,mBAAmB;CASpC;AAED,eAAe,WAAW,CAAC"}