redux-cluster 1.9.2 → 2.0.0

package/dist/cjs/utils/crypto.js

@@ -0,0 +1,404 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasher = hasher;
+exports.createCipher = createCipher;
+exports.createDecipher = createDecipher;
+exports.encrypter = encrypter;
+exports.decrypter = decrypter;
+exports.deepClone = deepClone;
+exports.universalClone = universalClone;
+exports.protoObjectClone = protoObjectClone;
+exports.universalSerialize = universalSerialize;
+exports.universalDeserialize = universalDeserialize;
+exports.serializeProtoObject = serializeProtoObject;
+exports.deserializeProtoObject = deserializeProtoObject;
+exports.createClassRegistry = createClassRegistry;
+exports.createObjectStreamParser = createObjectStreamParser;
+exports.createObjectStreamStringifier = createObjectStreamStringifier;
+exports.createObjectStream = createObjectStream;
+exports.createDeserializationStream = createDeserializationStream;
+exports.createSerializationStream = createSerializationStream;
+const crypto = __importStar(require("crypto"));
+const stream_1 = require("stream");
+const types_1 = require("../types");
+// Import ObjectStream components - optional dependency
+let Stringifer = null;
+let Parser = null;
+// Initialize ObjectStream if available
+async function initializeObjectStream() {
+    try {
+        const objectStreamModule = await Promise.resolve().then(() => __importStar(require("@sergdudko/objectstream")));
+        Stringifer = objectStreamModule.Stringifer;
+        Parser = objectStreamModule.Parser;
+    }
+    catch {
+        // ObjectStream is optional
+    }
+}
+// Initialize once
+initializeObjectStream();
+// Import ProtoObject - optional dependency
+let protoObjectConstructor = null;
+// Initialize ProtoObject if available
+async function initializeProtoObject() {
+    try {
+        const protoObjectModule = await Promise.resolve().then(() => __importStar(require("protoobject")));
+        protoObjectConstructor = protoObjectModule.ProtoObject ||
+            protoObjectModule.default ||
+            protoObjectModule;
+    }
+    catch {
+        // ProtoObject is optional
+    }
+}
+// Initialize once
+initializeProtoObject();
+// Check if ProtoObject is available
+function isProtoObjectAvailable() {
+    return protoObjectConstructor !== null;
+}
+// Get ProtoObject class (proper TypeScript way)
+function getProtoObjectClass() {
+    return protoObjectConstructor;
+}
+// Generate hash for reducer names
+function hasher(input) {
+    return crypto.createHash("md5").update(input).digest("hex");
+}
+// Create cipher for encryption
+function createCipher(key) {
+    const iv = crypto.randomBytes(16);
+    return crypto.createCipheriv("aes-256-ctr", Buffer.from(key), iv);
+}
+// Create decipher for decryption
+function createDecipher(key, iv) {
+    return crypto.createDecipheriv("aes-256-ctr", Buffer.from(key), iv);
+}
+// Encryption function for backup
+function encrypter(data, password) {
+    const key = crypto.scryptSync(password, "salt", 32);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-ctr", key, iv);
+    let encrypted = cipher.update(data, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return iv.toString("hex") + ":" + encrypted;
+}
+// Decryption function for backup
+function decrypter(encryptedData, password) {
+    const [ivHex, encrypted] = encryptedData.split(":");
+    const key = crypto.scryptSync(password, "salt", 32);
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = crypto.createDecipheriv("aes-256-ctr", key, iv);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}
+// Utility function for deep cloning objects
+function deepClone(obj) {
+    if (typeof structuredClone === "function") {
+        return structuredClone(obj);
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
+// Universal cloning function based on mode
+function universalClone(obj, mode, _classRegistry) {
+    if (mode === types_1.SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return protoObjectClone(obj);
+    }
+    return deepClone(obj);
+}
+// ProtoObject cloning function that handles nested ProtoObject instances
+function protoObjectClone(obj) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return deepClone(obj);
+    }
+    // If it's not a ProtoObject, use regular deep clone
+    if (!(obj instanceof ProtoObjectClass)) {
+        return deepClone(obj);
+    }
+    // Create a new ProtoObject with all properties
+    const clonedData = {};
+    // Copy all enumerable properties
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (value instanceof ProtoObjectClass) {
+            // Recursively clone nested ProtoObject
+            clonedData[key] = protoObjectClone(value);
+        }
+        else if (Array.isArray(value)) {
+            // Clone arrays with potential ProtoObject elements
+            clonedData[key] = value.map((item) => item instanceof ProtoObjectClass
+                ? protoObjectClone(item)
+                : deepClone(item));
+        }
+        else if (value !== null && typeof value === "object") {
+            // Clone nested objects
+            clonedData[key] = deepClone(value);
+        }
+        else {
+            // Copy primitive values
+            clonedData[key] = value;
+        }
+    }
+    return new ProtoObjectClass(clonedData);
+}
+// Universal serialization function
+function universalSerialize(obj, mode, classRegistry) {
+    if (mode === types_1.SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return serializeProtoObject(obj, classRegistry);
+    }
+    // Default JSON serialization
+    return JSON.stringify(obj);
+}
+// Universal deserialization function
+function universalDeserialize(str, mode, classRegistry) {
+    if (mode === types_1.SerializationMode.PROTOOBJECT && isProtoObjectAvailable()) {
+        return deserializeProtoObject(str, classRegistry);
+    }
+    // Default JSON deserialization
+    return JSON.parse(str);
+}
+// ProtoObject serialization for IPC with class information
+function serializeProtoObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return JSON.stringify(obj);
+    }
+    const serialize = (value) => {
+        if (value instanceof ProtoObjectClass) {
+            const data = {
+                __isProtoObject: true,
+                __className: value.constructor.name,
+            };
+            // Store class information if registry is provided
+            if (classRegistry && value.constructor.name !== "ProtoObject") {
+                classRegistry.set(value.constructor.name, value.constructor);
+            }
+            for (const key of Object.keys(value)) {
+                data[key] = serialize(value[key]);
+            }
+            return data;
+        }
+        else if (Array.isArray(value)) {
+            return value.map(serialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = serialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return JSON.stringify(serialize(obj));
+}
+// ProtoObject deserialization for IPC with class reconstruction
+function deserializeProtoObject(str, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return JSON.parse(str);
+    }
+    const deserialize = (value) => {
+        if (value && typeof value === "object" && value.__isProtoObject) {
+            const className = value.__className;
+            const data = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== "__isProtoObject" && key !== "__className") {
+                    data[key] = deserialize(val);
+                }
+            }
+            // Try to use registered class, fallback to ProtoObject
+            if (className && classRegistry && classRegistry.has(className)) {
+                const ClassConstructor = classRegistry.get(className);
+                return new ClassConstructor(data);
+            }
+            else {
+                return new ProtoObjectClass(data);
+            }
+        }
+        else if (Array.isArray(value)) {
+            return value.map(deserialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = deserialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return deserialize(JSON.parse(str));
+}
+// Helper function to create a shared class registry
+function createClassRegistry() {
+    return new Map();
+}
+// Stream pipeline functions for buffer->json->class->json->buffer processing
+// Create ObjectStream Parser for JSON parsing (Buffer -> Object)
+function createObjectStreamParser() {
+    if (Parser) {
+        return new Parser();
+    }
+    return null;
+}
+// Create ObjectStream Stringifier for JSON serialization (Object -> Buffer)
+function createObjectStreamStringifier() {
+    if (Stringifer) {
+        return new Stringifer();
+    }
+    return null;
+}
+// Legacy function for backward compatibility
+function createObjectStream() {
+    return createObjectStreamParser();
+}
+// Create transform stream that converts JSON objects to ProtoObject instances
+function createDeserializationStream(mode, classRegistry) {
+    return new stream_1.Transform({
+        objectMode: true,
+        transform(chunk, encoding, callback) {
+            try {
+                if (mode === types_1.SerializationMode.PROTOOBJECT &&
+                    isProtoObjectAvailable()) {
+                    const deserialized = deserializeFromObject(chunk, classRegistry);
+                    callback(null, deserialized);
+                }
+                else {
+                    callback(null, chunk);
+                }
+            }
+            catch (error) {
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+}
+// Create transform stream that converts ProtoObject instances to JSON objects
+function createSerializationStream(mode, classRegistry) {
+    return new stream_1.Transform({
+        objectMode: true,
+        transform(chunk, encoding, callback) {
+            try {
+                if (mode === types_1.SerializationMode.PROTOOBJECT &&
+                    isProtoObjectAvailable()) {
+                    const serialized = serializeToObject(chunk, classRegistry);
+                    callback(null, serialized);
+                }
+                else {
+                    callback(null, chunk);
+                }
+            }
+            catch (error) {
+                callback(error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+    });
+}
+// Helper functions for object-level serialization/deserialization (without JSON.stringify)
+function serializeToObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return obj;
+    }
+    const serialize = (value) => {
+        if (value instanceof ProtoObjectClass) {
+            const data = {
+                __isProtoObject: true,
+                __className: value.constructor.name,
+            };
+            // Store class information if registry is provided
+            if (classRegistry && value.constructor.name !== "ProtoObject") {
+                classRegistry.set(value.constructor.name, value.constructor);
+            }
+            for (const key of Object.keys(value)) {
+                data[key] = serialize(value[key]);
+            }
+            return data;
+        }
+        else if (Array.isArray(value)) {
+            return value.map(serialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = serialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return serialize(obj);
+}
+function deserializeFromObject(obj, classRegistry) {
+    const ProtoObjectClass = getProtoObjectClass();
+    if (!ProtoObjectClass) {
+        return obj;
+    }
+    const deserialize = (value) => {
+        if (value && typeof value === "object" && value.__isProtoObject) {
+            const className = value.__className;
+            const data = {};
+            for (const [key, val] of Object.entries(value)) {
+                if (key !== "__isProtoObject" && key !== "__className") {
+                    data[key] = deserialize(val);
+                }
+            }
+            // Try to use registered class, fallback to ProtoObject
+            if (className && classRegistry && classRegistry.has(className)) {
+                const ClassConstructor = classRegistry.get(className);
+                return new ClassConstructor(data);
+            }
+            else {
+                return new ProtoObjectClass(data);
+            }
+        }
+        else if (Array.isArray(value)) {
+            return value.map(deserialize);
+        }
+        else if (value !== null && typeof value === "object") {
+            const result = {};
+            for (const [key, val] of Object.entries(value)) {
+                result[key] = deserialize(val);
+            }
+            return result;
+        }
+        return value;
+    };
+    return deserialize(obj);
+}

package/dist/esm/core/backup.d.ts

@@ -0,0 +1,10 @@
+import { BackupSettings, ReduxClusterStore } from "../types";
+export declare class BackupManager<S = any> {
+    private store;
+    private settings;
+    private createBackupInstance?;
+    constructor(store: ReduxClusterStore<S>, settings: BackupSettings);
+    initialize(): Promise<boolean>;
+    private loadBackup;
+}
+//# sourceMappingURL=backup.d.ts.map

package/dist/esm/core/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/core/backup.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAe,MAAM,UAAU,CAAC;AAG1E,qBAAa,aAAa,CAAC,CAAC,GAAG,GAAG;IAI9B,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAJlB,OAAO,CAAC,oBAAoB,CAAC,CAAoB;gBAGvC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,cAAc;IAGrB,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;YAiB7B,UAAU;CA+CzB"}

package/dist/esm/core/backup.js

@@ -0,0 +1,134 @@
+import * as fs from "fs";
+import { MessageType } from "../types";
+import { encrypter, decrypter } from "../utils/crypto";
+export class BackupManager {
+    store;
+    settings;
+    createBackupInstance;
+    constructor(store, settings) {
+        this.store = store;
+        this.settings = settings;
+    }
+    async initialize() {
+        try {
+            await this.loadBackup();
+            this.createBackupInstance = new BackupInstance(this.store, this.settings);
+            return true;
+        }
+        catch (err) {
+            if (err.message.toLowerCase().includes("no such file or directory")) {
+                this.createBackupInstance = new BackupInstance(this.store, this.settings);
+                return true;
+            }
+            throw err;
+        }
+    }
+    async loadBackup() {
+        return new Promise((resolve, reject) => {
+            fs.readFile(this.settings.path, (err, data) => {
+                if (err) {
+                    reject(new Error(`ReduxCluster.backup load error: ${err.message}`));
+                    return;
+                }
+                try {
+                    let content = data.toString();
+                    // Decrypt if key is provided
+                    if (this.settings.key) {
+                        content = decrypter(content, this.settings.key);
+                    }
+                    const state = JSON.parse(content);
+                    // Restore state using internal method
+                    if ("_internalSync" in this.store &&
+                        typeof this.store._internalSync === "function") {
+                        this.store._internalSync(state);
+                    }
+                    else {
+                        // Fallback: use dispatchNEW if available, otherwise skip restore
+                        if ("dispatchNEW" in this.store &&
+                            typeof this.store.dispatchNEW === "function") {
+                            this.store.dispatchNEW({
+                                type: MessageType.SYNC,
+                                payload: state,
+                                _internal: true,
+                            });
+                        }
+                    }
+                    setTimeout(() => resolve(), 500);
+                }
+                catch (parseErr) {
+                    reject(new Error(`ReduxCluster.backup decoding error: ${parseErr.message}`));
+                }
+            });
+        });
+    }
+}
+class BackupInstance {
+    store;
+    settings;
+    count = 0;
+    allowed = true;
+    unsubscribe = null;
+    constructor(store, settings) {
+        this.store = store;
+        this.settings = settings;
+        this.unsubscribe = this.store.subscribe(() => {
+            this.handleStateChange();
+        });
+    }
+    handleStateChange() {
+        if (typeof this.settings.timeout === "number") {
+            // Priority setting - timeout based backup
+            if (this.allowed) {
+                this.allowed = false;
+                setTimeout(() => {
+                    this.write(true);
+                }, this.settings.timeout * 1000);
+            }
+        }
+        else if (typeof this.settings.count === "number") {
+            // Count based backup
+            this.count++;
+            if (this.count >= this.settings.count) {
+                this.count = 0;
+                this.write();
+            }
+        }
+    }
+    write(restart = false, callback) {
+        if (this.allowed || restart) {
+            try {
+                let content = JSON.stringify(this.store.getState());
+                // Encrypt if key is provided
+                if (this.settings.key) {
+                    content = encrypter(content, this.settings.key);
+                }
+                this.writeToFile(content, callback);
+            }
+            catch (err) {
+                this.store.stderr(`ReduxCluster.backup write error: ${err.message}`);
+                this.allowed = false;
+                setTimeout(() => this.write(true, callback), 1000);
+            }
+        }
+    }
+    writeToFile(content, callback) {
+        try {
+            fs.writeFileSync(this.settings.path, content);
+            this.allowed = true;
+            if (callback) {
+                callback(true);
+            }
+        }
+        catch (err) {
+            this.store.stderr(`ReduxCluster.backup write error: ${err.message}`);
+            this.allowed = false;
+            setTimeout(() => this.write(true, callback), 1000);
+        }
+    }
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+}

package/dist/esm/core/redux-cluster.d.ts

@@ -0,0 +1,47 @@
+import { Store, Reducer, Action } from "redux";
+import { ReduxClusterStore, SyncMode, Role, ClusterMessage, ServerSettings, ClientSettings, BackupSettings, ErrorHandler, ReduxClusterConfig } from "../types";
+import { ClusterServer } from "../network/server";
+import { ClusterClient } from "../network/client";
+export declare class ReduxCluster<S = any, A extends Action = Action> implements ReduxClusterStore<S, A> {
+    readonly dispatch: Store<S, A>["dispatch"];
+    readonly getState: Store<S, A>["getState"];
+    readonly subscribe: Store<S, A>["subscribe"];
+    readonly replaceReducer: Store<S, A>["replaceReducer"];
+    readonly [Symbol.observable]: Store<S, A>[typeof Symbol.observable];
+    readonly RCHash: string;
+    readonly version: string;
+    readonly homepage: string;
+    readonly role: Role[];
+    connected: boolean;
+    mode: SyncMode;
+    resync: number;
+    stderr: ErrorHandler;
+    readonly config: ReduxClusterConfig;
+    private readonly altReducer;
+    private readonly defaultState;
+    private readonly store;
+    private readonly allsock;
+    private counter?;
+    private dispatchNEW?;
+    private unsubscribe?;
+    private classRegistry;
+    constructor(reducer: Reducer<S, A>, config?: ReduxClusterConfig);
+    private internalSync;
+    _internalSync(payload: S): void;
+    private createNewReducer;
+    private updateCounter;
+    private sendActionsToNodes;
+    private initializeClusterRole;
+    private initializeMaster;
+    private initializeWorker;
+    private handleMasterMessage;
+    private handleWorkerMessage;
+    sendtoall(message?: ClusterMessage): void;
+    sendtoallsock(message?: ClusterMessage): void;
+    createServer(settings?: ServerSettings): ClusterServer;
+    createClient(settings?: ClientSettings): ClusterClient;
+    backup(settings: BackupSettings): Promise<boolean>;
+    registerClass(name: string, classConstructor: any): void;
+    getRegisteredClasses(): string[];
+}
+//# sourceMappingURL=redux-cluster.d.ts.map

package/dist/esm/core/redux-cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux-cluster.d.ts","sourceRoot":"","sources":["../../../src/core/redux-cluster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAW5D,OAAO,EACL,iBAAiB,EACjB,QAAQ,EACR,IAAI,EACJ,cAAc,EAEd,cAAc,EACd,cAAc,EACd,cAAc,EACd,YAAY,EACZ,kBAAkB,EAEnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAMlD,qBAAa,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAC1D,YAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAGlC,SAAgB,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClD,SAAgB,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClD,SAAgB,SAAS,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACpD,SAAgB,cAAc,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC9D,SAAgB,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC;IAG3E,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,IAAI,EAAE,CAAM;IAC3B,SAAS,UAAS;IAClB,IAAI,EAAE,QAAQ,CAAY;IAC1B,MAAM,SAAQ;IACd,MAAM,EAAE,YAAY,CAAiB;IAC5C,SAAgB,MAAM,EAAE,kBAAkB,CAAC;IAE3C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAI;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,WAAW,CAAC,CAA0B;IAC9C,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,aAAa,CAAyB;gBAElC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAE,kBAAuB;IA4EnE,OAAO,CAAC,YAAY;IASb,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAItC,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,mBAAmB;IAwD3B,OAAO,CAAC,mBAAmB;IAoCpB,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IA6BzC,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAW7C,YAAY,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa;IAetD,YAAY,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa;IAetD,MAAM,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAKlD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAG,IAAI;IASxD,oBAAoB,IAAI,MAAM,EAAE;CAMxC"}