redux-cluster 1.9.2 → 2.0.0

package/dist/esm/network/server.d.ts

@@ -0,0 +1,39 @@
+import { ServerSettings, ReduxClusterStore, ClusterMessage, ClusterSocket } from "../types";
+export declare class ClusterServer {
+    private store;
+    private settings;
+    readonly uid: string;
+    readonly sockets: Record<string, ClusterSocket>;
+    readonly database: Record<string, string>;
+    readonly ip2ban: Record<string, {
+        time: number;
+        count: number;
+    }>;
+    private readonly ip2banTimeout;
+    private readonly ip2banGC;
+    private server;
+    private unsubscribe?;
+    private shouldAutoRestart;
+    constructor(store: ReduxClusterStore, settings?: ServerSettings);
+    private setupDatabase;
+    private setupBanSystem;
+    private cleanupBannedIPs;
+    private setupServer;
+    private getListenOptions;
+    private startListening;
+    private handleNewConnection;
+    private isIPBanned;
+    private rejectConnection;
+    private setupSocket;
+    private setupSocketPipeline;
+    private handleSocketMessage;
+    private handleAuthentication;
+    private recordFailedLogin;
+    private closeSocket;
+    private setupStoreIntegration;
+    sendtoall(message?: ClusterMessage): void;
+    ip2banGCStop(): void;
+    private cleanup;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/esm/network/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/network/server.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,cAAc,EAEd,aAAa,EACd,MAAM,UAAU,CAAC;AAGlB,qBAAa,aAAa;IAatB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAblB,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAM;IAC5D,SAAgB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IACtD,SAAgB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IAE7E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,iBAAiB,CAAiB;gBAGhC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,GAAE,cAAmB;IAavC,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,WAAW;IA8CnB,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,mBAAmB;IA2D3B,OAAO,CAAC,mBAAmB;IA0C3B,OAAO,CAAC,oBAAoB;IAyD5B,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,qBAAqB;IActB,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAezC,YAAY,IAAI,IAAI;IAI3B,OAAO,CAAC,OAAO;IAQR,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAiD9B"}

package/dist/esm/network/server.js

@@ -0,0 +1,408 @@
+import * as net from "net";
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs";
+import * as zlib from "zlib";
+import * as stream from "stream";
+import * as crypto from "crypto";
+import { MessageType, } from "../types";
+import { hasher } from "../utils/crypto";
+export class ClusterServer {
+    store;
+    settings;
+    uid;
+    sockets = {};
+    database = {};
+    ip2ban = {};
+    ip2banTimeout = 10800000; // 3 hours
+    ip2banGC;
+    server;
+    unsubscribe;
+    shouldAutoRestart = true;
+    constructor(store, settings = {}) {
+        this.store = store;
+        this.settings = settings;
+        this.uid = crypto.randomUUID();
+        this.setupDatabase();
+        this.setupBanSystem();
+        this.setupServer();
+        this.setupStoreIntegration();
+        this.ip2banGC = setInterval(() => {
+            this.cleanupBannedIPs();
+        }, 60000);
+    }
+    setupDatabase() {
+        if (this.settings.logins) {
+            for (const login in this.settings.logins) {
+                const hashedLogin = hasher(`REDUX_CLUSTER${login}`);
+                const hashedPassword = hasher(`REDUX_CLUSTER${this.settings.logins[login]}`);
+                if (hashedLogin && hashedPassword) {
+                    this.database[hashedLogin] = hashedPassword;
+                }
+            }
+        }
+    }
+    setupBanSystem() {
+        // IP ban system is initialized in constructor
+    }
+    cleanupBannedIPs() {
+        const now = Date.now();
+        for (const key in this.ip2ban) {
+            if (this.ip2ban[key].time + this.ip2banTimeout < now) {
+                delete this.ip2ban[key];
+            }
+        }
+    }
+    setupServer() {
+        const listenOptions = this.getListenOptions();
+        this.server = net.createServer((socket) => {
+            this.handleNewConnection(socket);
+        });
+        this.server.on("listening", () => {
+            this.store.connected = true;
+            this.store.sendtoall({
+                _msg: MessageType.CONN_STATUS,
+                _hash: this.store.RCHash,
+                _connected: true,
+            });
+        });
+        this.server.on("close", () => {
+            this.store.connected = false;
+            this.store.sendtoall({
+                _msg: MessageType.CONN_STATUS,
+                _hash: this.store.RCHash,
+                _connected: false,
+            });
+            this.cleanup();
+            // Auto-restart server after 10 seconds
+            if (this.shouldAutoRestart) {
+                setTimeout(() => {
+                    new ClusterServer(this.store, this.settings);
+                }, 10000);
+            }
+        });
+        this.server.on("error", (err) => {
+            this.store.stderr(`ReduxCluster.createServer socket error: ${err.message}`);
+            if (typeof this.server.close === "function") {
+                this.server.close();
+            }
+        });
+        this.startListening(listenOptions);
+    }
+    getListenOptions() {
+        const defaultOptions = { port: 10001 };
+        if (typeof this.settings.path === "string") {
+            switch (os.platform()) {
+                case "win32":
+                    return { path: path.join("\\\\?\\pipe", this.settings.path) };
+                default:
+                    return { path: path.join(this.settings.path) };
+            }
+        }
+        const options = { ...defaultOptions };
+        if (typeof this.settings.host === "string") {
+            options.host = this.settings.host;
+        }
+        if (typeof this.settings.port === "number") {
+            options.port = this.settings.port;
+        }
+        return options;
+    }
+    startListening(options) {
+        if (typeof options.path === "string") {
+            // Remove existing socket file
+            fs.unlink(options.path, (err) => {
+                if (err &&
+                    !err.message.toLowerCase().includes("no such file or directory")) {
+                    this.store.stderr(`ReduxCluster.createServer socket error: ${err.message}`);
+                }
+                this.server.listen(options);
+            });
+        }
+        else {
+            this.server.listen(options);
+        }
+    }
+    handleNewConnection(socket) {
+        // Hash IP address for security using hasher function
+        const clientIP = socket.remoteAddress
+            ? hasher(socket.remoteAddress)
+            : "";
+        const uid = crypto.randomUUID();
+        const clusterSocket = socket;
+        clusterSocket.uid = uid;
+        // Check if IP is banned
+        if (this.isIPBanned(clientIP)) {
+            this.rejectConnection(clusterSocket, true);
+            return;
+        }
+        this.setupSocket(clusterSocket, clientIP);
+    }
+    isIPBanned(ip) {
+        if (!ip || !this.ip2ban[ip])
+            return false;
+        const banInfo = this.ip2ban[ip];
+        const now = Date.now();
+        return banInfo.count >= 5 && banInfo.time + this.ip2banTimeout > now;
+    }
+    rejectConnection(socket, banned = false) {
+        // Create rejection message
+        const rejectionMessage = {
+            _msg: MessageType.SOCKET_AUTH_STATE,
+            _hash: this.store.RCHash,
+            _value: false,
+            ...(banned && { _banned: true }),
+        };
+        // Manually serialize and compress since custom write is not set up yet
+        try {
+            const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(rejectionMessage)));
+            // Use the native write method directly, not the overridden one
+            const originalWrite = socket.writeNEW || socket.write.bind(socket);
+            originalWrite(compressed);
+        }
+        catch (err) {
+            this.store.stderr(`ReduxCluster.rejectConnection error: ${err.message}`);
+        }
+        this.closeSocket(socket);
+    }
+    setupSocket(socket, clientIP) {
+        // Override write method for object mode + compression
+        socket.writeNEW = socket.write;
+        socket.write = (data) => {
+            try {
+                const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(data)));
+                return socket.writeNEW(compressed);
+            }
+            catch (err) {
+                this.store.stderr(`ReduxCluster.createServer write error: ${err.message}`);
+                return false;
+            }
+        };
+        socket.on("error", (err) => {
+            this.store.stderr(`ReduxCluster.createServer client error: ${err.message}`);
+            this.closeSocket(socket);
+        });
+        this.setupSocketPipeline(socket, clientIP);
+    }
+    setupSocketPipeline(socket, clientIP) {
+        // Create processing pipeline
+        const mbstring = new stream.Transform({
+            transform(buffer, encoding, callback) {
+                this.push(buffer);
+                callback();
+            },
+        });
+        mbstring.setEncoding("utf8");
+        const gunzipper = zlib.createGunzip();
+        // For now, we'll create a simple parser instead of using external library
+        const parser = new stream.Transform({
+            transform(chunk, encoding, callback) {
+                try {
+                    const data = JSON.parse(chunk.toString());
+                    this.push(data);
+                }
+                catch {
+                    // Invalid JSON, ignore
+                }
+                callback();
+            },
+            objectMode: true,
+        });
+        const eventHandler = new stream.Writable({
+            write: (data, encoding, callback) => {
+                this.handleSocketMessage(data, socket, clientIP);
+                callback();
+            },
+            objectMode: true,
+        });
+        // Setup error handlers
+        [gunzipper, mbstring, parser, eventHandler].forEach((stream) => {
+            stream.on("error", (err) => {
+                this.store.stderr(`ReduxCluster.createServer stream error: ${err.message}`);
+            });
+        });
+        // Connect pipeline
+        socket.pipe(gunzipper).pipe(mbstring).pipe(parser).pipe(eventHandler);
+    }
+    handleSocketMessage(data, socket, clientIP) {
+        if (data._hash !== this.store.RCHash)
+            return;
+        switch (data._msg) {
+            case MessageType.MSG_TO_MASTER:
+                if (this.sockets[socket.uid]) {
+                    if (data._action.type === MessageType.SYNC) {
+                        throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                    }
+                    // Apply action to server state
+                    // This will automatically trigger sendActionsToNodes via reducer
+                    this.store.dispatch(data._action);
+                }
+                break;
+            case MessageType.START:
+                if (this.sockets[socket.uid]) {
+                    socket.write({
+                        _msg: MessageType.MSG_TO_WORKER,
+                        _hash: this.store.RCHash,
+                        _action: {
+                            type: MessageType.SYNC,
+                            payload: this.store.getState(),
+                        },
+                    });
+                }
+                break;
+            case MessageType.SOCKET_AUTH:
+                this.handleAuthentication(data, socket, clientIP);
+                break;
+            default:
+                // Ignore unknown message types
+                break;
+        }
+    }
+    handleAuthentication(data, socket, clientIP) {
+        const { _login, _password } = data;
+        // If no authentication is configured (empty database), allow all connections
+        if (Object.keys(this.database).length === 0) {
+            // No authentication required
+            this.sockets[socket.uid] = socket;
+            socket.write({
+                _msg: MessageType.SOCKET_AUTH_STATE,
+                _hash: this.store.RCHash,
+                _value: true,
+            });
+            return;
+        }
+        if (typeof _login !== "undefined" &&
+            typeof _password !== "undefined" &&
+            typeof this.database[_login] !== "undefined" &&
+            this.database[_login] === _password) {
+            // Successful authentication
+            this.sockets[socket.uid] = socket;
+            // Clear ban if exists
+            if (clientIP && this.ip2ban[clientIP]) {
+                delete this.ip2ban[clientIP];
+            }
+            // Use the custom write method that should be set up by now
+            socket.write({
+                _msg: MessageType.SOCKET_AUTH_STATE,
+                _hash: this.store.RCHash,
+                _value: true,
+            });
+        }
+        else {
+            // Failed authentication
+            if (clientIP) {
+                this.recordFailedLogin(clientIP);
+            }
+            // Use the custom write method that should be set up by now
+            socket.write({
+                _msg: MessageType.SOCKET_AUTH_STATE,
+                _hash: this.store.RCHash,
+                _value: false,
+            });
+            this.closeSocket(socket);
+        }
+    }
+    recordFailedLogin(ip) {
+        let count = 0;
+        if (this.ip2ban[ip]) {
+            count = this.ip2ban[ip].count;
+            if (count >= 5)
+                count = 0; // Reset on timeout
+        }
+        this.ip2ban[ip] = {
+            time: Date.now(),
+            count: count + 1,
+        };
+    }
+    closeSocket(socket) {
+        if (typeof socket.end === "function") {
+            socket.end();
+        }
+        if (socket.uid && this.sockets[socket.uid]) {
+            delete this.sockets[socket.uid];
+        }
+    }
+    setupStoreIntegration() {
+        // Register with store if in action mode
+        if (this.store.mode === "action") {
+            this.store.allsock[this.uid] = this;
+        }
+        // Subscribe to store changes in snapshot mode
+        this.unsubscribe = this.store.subscribe(() => {
+            if (this.store.mode === "snapshot") {
+                this.sendtoall();
+            }
+        });
+    }
+    sendtoall(message) {
+        const msg = message || {
+            _msg: MessageType.MSG_TO_WORKER,
+            _hash: this.store.RCHash,
+            _action: {
+                type: MessageType.SYNC,
+                payload: this.store.getState(),
+            },
+        };
+        for (const uid in this.sockets) {
+            this.sockets[uid].write(msg);
+        }
+    }
+    ip2banGCStop() {
+        clearInterval(this.ip2banGC);
+    }
+    cleanup() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+        this.ip2banGCStop();
+        delete this.store.allsock[this.uid];
+    }
+    close() {
+        return new Promise((resolve) => {
+            // Prevent the automatic restart handler from creating a new server
+            this.shouldAutoRestart = false;
+            // Close all connected sockets first
+            Object.values(this.sockets).forEach((socket) => {
+                if (socket) {
+                    try {
+                        this.closeSocket(socket);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            });
+            // Clear sockets registry
+            Object.keys(this.sockets).forEach((key) => {
+                delete this.sockets[key];
+            });
+            // Stop IP ban garbage collector
+            if (this.ip2banGC) {
+                clearInterval(this.ip2banGC);
+            }
+            // Unsubscribe from store updates
+            if (this.unsubscribe) {
+                try {
+                    this.unsubscribe();
+                }
+                catch {
+                    // ignore
+                }
+                this.unsubscribe = undefined;
+            }
+            // Finally close the server and resolve when closed
+            if (this.server && typeof this.server.close === "function") {
+                try {
+                    this.server.close(() => resolve());
+                }
+                catch {
+                    // fallback resolve
+                    resolve();
+                }
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/types/index.d.ts

@@ -0,0 +1,125 @@
+import { Store, Action } from "redux";
+export declare enum SerializationMode {
+    JSON = "json",
+    PROTOOBJECT = "protoobject"
+}
+export interface ReduxClusterConfig {
+    serializationMode?: SerializationMode;
+    debug?: boolean;
+    mode?: SyncMode;
+    syncMode?: "ipc" | "tcp";
+    role?: Role[];
+    server?: ServerSettings;
+    client?: ClientSettings;
+    backup?: BackupSettings;
+    stderr?: ErrorHandler;
+    resync?: number;
+}
+export type ProtoObjectState = any;
+export declare enum MessageType {
+    CONN_STATUS = "REDUX_CLUSTER_CONNSTATUS",
+    MSG_TO_WORKER = "REDUX_CLUSTER_MSGTOWORKER",
+    MSG_TO_MASTER = "REDUX_CLUSTER_MSGTOMASTER",
+    SOCKET_AUTH = "REDUX_CLUSTER_SOCKET_AUTH",
+    SOCKET_AUTH_STATE = "REDUX_CLUSTER_SOCKET_AUTHSTATE",
+    START = "REDUX_CLUSTER_START",
+    SYNC = "REDUX_CLUSTER_SYNC"
+}
+export interface BaseMessage {
+    _msg: MessageType;
+    _hash: string;
+}
+export interface ConnectionStatusMessage extends BaseMessage {
+    _msg: MessageType.CONN_STATUS;
+    _connected: boolean;
+}
+export interface ActionToWorkerMessage extends BaseMessage {
+    _msg: MessageType.MSG_TO_WORKER;
+    _action: Action;
+}
+export interface ActionToMasterMessage extends BaseMessage {
+    _msg: MessageType.MSG_TO_MASTER;
+    _action: Action;
+}
+export interface SocketAuthMessage extends BaseMessage {
+    _msg: MessageType.SOCKET_AUTH;
+    _login: string;
+    _password: string;
+}
+export interface SocketAuthStateMessage extends BaseMessage {
+    _msg: MessageType.SOCKET_AUTH_STATE;
+    _value: boolean;
+    _banned?: boolean;
+}
+export interface StartMessage extends BaseMessage {
+    _msg: MessageType.START;
+}
+export type ClusterMessage = ConnectionStatusMessage | ActionToWorkerMessage | ActionToMasterMessage | SocketAuthMessage | SocketAuthStateMessage | StartMessage;
+export type SyncMode = "action" | "snapshot";
+export type Role = "master" | "worker" | "server" | "client";
+export interface ServerSettings {
+    host?: string;
+    port?: number;
+    path?: string;
+    logins?: Record<string, string>;
+}
+export interface ClientSettings {
+    host?: string;
+    port?: number;
+    path?: string;
+    login?: string;
+    password?: string;
+}
+export interface BackupSettings {
+    path: string;
+    key?: string;
+    timeout?: number;
+    count?: number;
+}
+export interface ReduxClusterStore<S = any, A extends Action = Action> extends Store<S, A> {
+    readonly RCHash: string;
+    readonly version: string;
+    readonly homepage: string;
+    readonly role: Role[];
+    connected: boolean;
+    mode: SyncMode;
+    resync: number;
+    stderr: (message: string) => void;
+    readonly config: ReduxClusterConfig;
+    createServer(settings?: ServerSettings): ClusterServer;
+    createClient(settings?: ClientSettings): ClusterClient;
+    backup(settings: BackupSettings): Promise<boolean>;
+    sendtoall(message?: ClusterMessage): void;
+    sendtoallsock(message?: ClusterMessage): void;
+    registerClass?(name: string, classConstructor: any): void;
+    getRegisteredClasses?(): string[];
+}
+export interface ClusterServer {
+    readonly uid: string;
+    readonly sockets: Record<string, any>;
+    readonly database: Record<string, string>;
+    readonly ip2ban: Record<string, {
+        time: number;
+        count: number;
+    }>;
+    sendtoall(message?: ClusterMessage): void;
+    ip2banGCStop(): void;
+}
+export interface ClusterClient {
+    login?: string;
+    password?: string;
+}
+export interface ClusterSocket {
+    uid: string;
+    writeNEW: (data: any) => boolean;
+    write(data: any): boolean;
+    on(event: string, listener: (...args: any[]) => void): any;
+    pipe(...args: any[]): any;
+    end(): void;
+    remoteAddress?: string;
+}
+export type HasherFunction = (data: string, algorithm?: string) => string | undefined;
+export type EncrypterFunction = (data: string, pass: string) => string;
+export type DecrypterFunction = (data: string, pass: string) => string;
+export type ErrorHandler = (message: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/types/index.js

@@ -0,0 +1,17 @@
+// Serialization modes
+export var SerializationMode;
+(function (SerializationMode) {
+    SerializationMode["JSON"] = "json";
+    SerializationMode["PROTOOBJECT"] = "protoobject";
+})(SerializationMode || (SerializationMode = {}));
+// Message types for IPC communication
+export var MessageType;
+(function (MessageType) {
+    MessageType["CONN_STATUS"] = "REDUX_CLUSTER_CONNSTATUS";
+    MessageType["MSG_TO_WORKER"] = "REDUX_CLUSTER_MSGTOWORKER";
+    MessageType["MSG_TO_MASTER"] = "REDUX_CLUSTER_MSGTOMASTER";
+    MessageType["SOCKET_AUTH"] = "REDUX_CLUSTER_SOCKET_AUTH";
+    MessageType["SOCKET_AUTH_STATE"] = "REDUX_CLUSTER_SOCKET_AUTHSTATE";
+    MessageType["START"] = "REDUX_CLUSTER_START";
+    MessageType["SYNC"] = "REDUX_CLUSTER_SYNC";
+})(MessageType || (MessageType = {}));

package/dist/esm/utils/crypto.d.ts

@@ -0,0 +1,22 @@
+import * as crypto from "crypto";
+import { Transform } from "stream";
+import { SerializationMode } from "../types";
+export declare function hasher(input: string): string;
+export declare function createCipher(key: string): crypto.Cipher;
+export declare function createDecipher(key: string, iv: Buffer): crypto.Decipher;
+export declare function encrypter(data: string, password: string): string;
+export declare function decrypter(encryptedData: string, password: string): string;
+export declare function deepClone(obj: any): any;
+export declare function universalClone(obj: any, mode: SerializationMode, _classRegistry?: Map<string, any>): any;
+export declare function protoObjectClone(obj: any): any;
+export declare function universalSerialize(obj: any, mode: SerializationMode, classRegistry?: Map<string, any>): string;
+export declare function universalDeserialize(str: string, mode: SerializationMode, classRegistry?: Map<string, any>): any;
+export declare function serializeProtoObject(obj: any, classRegistry?: Map<string, any>): string;
+export declare function deserializeProtoObject(str: string, classRegistry?: Map<string, any>): any;
+export declare function createClassRegistry(): Map<string, any>;
+export declare function createObjectStreamParser(): Transform | null;
+export declare function createObjectStreamStringifier(): Transform | null;
+export declare function createObjectStream(): Transform | null;
+export declare function createDeserializationStream(mode: SerializationMode, classRegistry?: Map<string, any>): Transform;
+export declare function createSerializationStream(mode: SerializationMode, classRegistry?: Map<string, any>): Transform;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/esm/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAoD7C,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE5C;AAGD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAGvD;AAGD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,QAAQ,CAEvE;AAGD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAShE;AAGD,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWzE;AAGD,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAKvC;AAGD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,iBAAiB,EACvB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,GAAG,CAKL;AAGD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAsC9C;AAGD,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,iBAAiB,EACvB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,MAAM,CAMR;AAGD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,iBAAiB,EACvB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,GAAG,CAML;AAGD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,GAAG,EACR,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,MAAM,CAmCR;AAGD,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,GAAG,CAqCL;AAGD,wBAAgB,mBAAmB,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAEtD;AAKD,wBAAgB,wBAAwB,IAAI,SAAS,GAAG,IAAI,CAK3D;AAGD,wBAAgB,6BAA6B,IAAI,SAAS,GAAG,IAAI,CAKhE;AAGD,wBAAgB,kBAAkB,IAAI,SAAS,GAAG,IAAI,CAErD;AAGD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,iBAAiB,EACvB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,SAAS,CAuBX;AAGD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,iBAAiB,EACvB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,SAAS,CAuBX"}