@n1xyz/nord-ts 0.0.1 → 0.0.4

package/dist/websocket/client.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * WebSocket client for real-time data
+ * @module websocket/client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClient = void 0;
+/**
+ * WebSocket client for real-time data
+ */
+class WebSocketClient {
+    /**
+     * Create a new WebSocket client
+     *
+     * @param baseUrl - Base URL for the WebSocket server
+     */
+    constructor(baseUrl) {
+        /**
+         * WebSocket connection
+         */
+        this.ws = null;
+        /**
+         * Map of subscription IDs to callbacks
+         */
+        this.subscriptions = new Map();
+        /**
+         * Whether the WebSocket is connected
+         */
+        this.connected = false;
+        /**
+         * Whether the WebSocket is connecting
+         */
+        this.connecting = false;
+        /**
+         * Queue of messages to send when connected
+         */
+        this.messageQueue = [];
+        // Convert HTTP/HTTPS to WS/WSS
+        this.baseUrl = baseUrl.replace(/^http/, 'ws') + '/ws';
+    }
+    /**
+     * Connect to the WebSocket server
+     *
+     * @returns Promise that resolves when connected
+     */
+    connect() {
+        if (this.connected) {
+            return Promise.resolve();
+        }
+        if (this.connecting) {
+            return new Promise((resolve) => {
+                // Check connection status every 100ms
+                const interval = setInterval(() => {
+                    if (this.connected) {
+                        clearInterval(interval);
+                        resolve();
+                    }
+                }, 100);
+            });
+        }
+        this.connecting = true;
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.baseUrl);
+                this.ws.onopen = () => {
+                    this.connected = true;
+                    this.connecting = false;
+                    // Send queued messages
+                    while (this.messageQueue.length > 0) {
+                        const message = this.messageQueue.shift();
+                        if (message && this.ws) {
+                            this.ws.send(message);
+                        }
+                    }
+                    resolve();
+                };
+                this.ws.onclose = () => {
+                    this.connected = false;
+                    this.ws = null;
+                    // Attempt to reconnect after 5 seconds
+                    setTimeout(() => {
+                        if (!this.connected && !this.connecting) {
+                            this.connect();
+                        }
+                    }, 5000);
+                };
+                this.ws.onerror = (error) => {
+                    if (!this.connected) {
+                        this.connecting = false;
+                        reject(error);
+                    }
+                    console.error('WebSocket error:', error);
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        // Handle subscription updates
+                        if (data.type === 'update' && data.subscriptionId && this.subscriptions.has(data.subscriptionId)) {
+                            const callback = this.subscriptions.get(data.subscriptionId);
+                            if (callback) {
+                                callback(data.data);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error processing WebSocket message:', error);
+                    }
+                };
+            }
+            catch (error) {
+                this.connecting = false;
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.connected = false;
+        }
+    }
+    /**
+     * Send a message to the WebSocket server
+     *
+     * @param message - Message to send
+     */
+    sendMessage(message) {
+        const messageStr = JSON.stringify(message);
+        if (this.connected && this.ws) {
+            this.ws.send(messageStr);
+        }
+        else {
+            // Queue message to send when connected
+            this.messageQueue.push(messageStr);
+            this.connect();
+        }
+    }
+    /**
+     * Generate a unique subscription ID
+     *
+     * @returns Unique subscription ID
+     */
+    generateSubscriptionId() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+    /**
+     * Subscribe to orderbook updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToOrderbook(market, callback) {
+        const subscriptionId = this.generateSubscriptionId();
+        this.subscriptions.set(subscriptionId, callback);
+        this.sendMessage({
+            type: 'subscribe',
+            channel: 'orderbook',
+            market,
+            subscriptionId
+        });
+        return subscriptionId;
+    }
+    /**
+     * Subscribe to trade updates for a specific market
+     *
+     * @param market - Market symbol (e.g., "BTCUSDC")
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToTrades(market, callback) {
+        const subscriptionId = this.generateSubscriptionId();
+        this.subscriptions.set(subscriptionId, callback);
+        this.sendMessage({
+            type: 'subscribe',
+            channel: 'trades',
+            market,
+            subscriptionId
+        });
+        return subscriptionId;
+    }
+    /**
+     * Subscribe to user updates for a specific account
+     *
+     * @param accountId - Account ID
+     * @param callback - Callback function to handle updates
+     * @returns Subscription ID
+     */
+    subscribeToUserUpdates(accountId, callback) {
+        const subscriptionId = this.generateSubscriptionId();
+        this.subscriptions.set(subscriptionId, callback);
+        this.sendMessage({
+            type: 'subscribe',
+            channel: 'user',
+            accountId,
+            subscriptionId
+        });
+        return subscriptionId;
+    }
+    /**
+     * Unsubscribe from a subscription
+     *
+     * @param subscriptionId - Subscription ID to unsubscribe from
+     * @returns Whether the unsubscription was successful
+     */
+    unsubscribe(subscriptionId) {
+        if (!this.subscriptions.has(subscriptionId)) {
+            return false;
+        }
+        this.subscriptions.delete(subscriptionId);
+        this.sendMessage({
+            type: 'unsubscribe',
+            subscriptionId
+        });
+        return true;
+    }
+}
+exports.WebSocketClient = WebSocketClient;

package/dist/websocket/events.d.ts

@@ -0,0 +1,19 @@
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketUserUpdate } from '../types';
+/**
+ * Event type definitions for the NordWebSocketClient
+ */
+export interface NordWebSocketEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    trade: (update: WebSocketTradeUpdate) => void;
+    delta: (update: WebSocketDeltaUpdate) => void;
+    user: (update: WebSocketUserUpdate) => void;
+}
+/**
+ * Type declaration for NordWebSocketClient event methods
+ */
+export declare interface NordWebSocketClientEvents {
+    on<E extends keyof NordWebSocketEvents>(event: E, listener: NordWebSocketEvents[E]): this;
+    emit<E extends keyof NordWebSocketEvents>(event: E, ...args: Parameters<NordWebSocketEvents[E]>): boolean;
+}

package/dist/websocket/events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/websocket/index.d.ts

@@ -0,0 +1,2 @@
+export { NordWebSocketClient } from './NordWebSocketClient';
+export { NordWebSocketEvents, NordWebSocketClientEvents } from './events';

package/dist/websocket/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordWebSocketClient = void 0;
+var NordWebSocketClient_1 = require("./NordWebSocketClient");
+Object.defineProperty(exports, "NordWebSocketClient", { enumerable: true, get: function () { return NordWebSocketClient_1.NordWebSocketClient; } });

package/dist/websocket.d.ts

@@ -0,0 +1,55 @@
+import { EventEmitter } from "events";
+import { WebSocketTradeUpdate, WebSocketDeltaUpdate, WebSocketUserUpdate } from "./types";
+export declare class NordWebSocketClient extends EventEmitter {
+    private ws;
+    private url;
+    private subscriptions;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private pingInterval;
+    private pingTimeout;
+    constructor(url: string);
+    /**
+     * Validate stream format
+     * @param stream Stream identifier to validate
+     * @throws Error if stream format is invalid
+     */
+    private validateStream;
+    /**
+     * Setup WebSocket ping/pong heartbeat
+     */
+    private setupHeartbeat;
+    /**
+     * Connect to the Nord WebSocket server
+     */
+    connect(): void;
+    /**
+     * Subscribe to one or more streams
+     * @param streams Array of streams to subscribe to (e.g. ["trades@BTCUSDC", "deltas@BTCUSDC"])
+     */
+    subscribe(streams: string[]): void;
+    /**
+     * Unsubscribe from one or more streams
+     * @param streams Array of streams to unsubscribe from
+     */
+    unsubscribe(streams: string[]): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): void;
+    private handleMessage;
+    private reconnect;
+}
+export interface NordWebSocketEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    trade: (update: WebSocketTradeUpdate) => void;
+    delta: (update: WebSocketDeltaUpdate) => void;
+    user: (update: WebSocketUserUpdate) => void;
+}
+export declare interface NordWebSocketClient {
+    on<E extends keyof NordWebSocketEvents>(event: E, listener: NordWebSocketEvents[E]): this;
+    emit<E extends keyof NordWebSocketEvents>(event: E, ...args: Parameters<NordWebSocketEvents[E]>): boolean;
+}

package/dist/websocket.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordWebSocketClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+const events_1 = require("events");
+const types_1 = require("./types");
+const VALID_STREAM_TYPES = ["trades", "deltas", "user"];
+class NordWebSocketClient extends events_1.EventEmitter {
+    constructor(url) {
+        super();
+        this.ws = null;
+        this.subscriptions = new Set();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectDelay = 1000;
+        this.pingInterval = null;
+        this.pingTimeout = null;
+        this.url = url;
+    }
+    /**
+     * Validate stream format
+     * @param stream Stream identifier to validate
+     * @throws Error if stream format is invalid
+     */
+    validateStream(stream) {
+        const [type, params] = stream.split("@");
+        if (!type || !params) {
+            throw new Error(`Invalid stream format: ${stream}. Expected format: <type>@<params>`);
+        }
+        if (!VALID_STREAM_TYPES.includes(type)) {
+            throw new Error(`Invalid stream type: ${type}. Valid types are: ${VALID_STREAM_TYPES.join(", ")}`);
+        }
+        if (type === "user" && !/^\d+$/.test(params)) {
+            throw new Error(`Invalid user ID in stream: ${params}. Expected numeric ID`);
+        }
+    }
+    /**
+     * Setup WebSocket ping/pong heartbeat
+     */
+    setupHeartbeat() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        if (this.pingTimeout) {
+            clearTimeout(this.pingTimeout);
+        }
+        this.pingInterval = setInterval(() => {
+            if (this.ws?.readyState === ws_1.default.OPEN) {
+                this.ws.ping();
+                // Set timeout for pong response
+                this.pingTimeout = setTimeout(() => {
+                    this.emit("error", new Error("WebSocket ping timeout"));
+                    this.close();
+                    this.reconnect();
+                }, 5000); // 5 second timeout
+            }
+        }, 30000); // Send ping every 30 seconds
+    }
+    /**
+     * Connect to the Nord WebSocket server
+     */
+    connect() {
+        if (this.ws) {
+            return;
+        }
+        this.ws = new ws_1.default(this.url);
+        this.ws.on("open", () => {
+            this.emit("connected");
+            this.reconnectAttempts = 0;
+            this.reconnectDelay = 1000;
+            this.setupHeartbeat();
+            // Resubscribe to previous subscriptions
+            if (this.subscriptions.size > 0) {
+                this.subscribe([...this.subscriptions]);
+            }
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                this.handleMessage(message);
+            }
+            catch (error) {
+                this.emit("error", new Error(`Failed to parse message: ${error}`));
+            }
+        });
+        this.ws.on("close", () => {
+            this.emit("disconnected");
+            if (this.pingInterval) {
+                clearInterval(this.pingInterval);
+            }
+            if (this.pingTimeout) {
+                clearTimeout(this.pingTimeout);
+            }
+            this.reconnect();
+        });
+        this.ws.on("error", (error) => {
+            this.emit("error", error);
+        });
+        this.ws.on("pong", () => {
+            if (this.pingTimeout) {
+                clearTimeout(this.pingTimeout);
+            }
+        });
+    }
+    /**
+     * Subscribe to one or more streams
+     * @param streams Array of streams to subscribe to (e.g. ["trades@BTCUSDC", "deltas@BTCUSDC"])
+     */
+    subscribe(streams) {
+        // Validate all streams first
+        try {
+            streams.forEach(stream => this.validateStream(stream));
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            streams.forEach(stream => this.subscriptions.add(stream));
+            return;
+        }
+        const message = {
+            type: types_1.WebSocketMessageType.Subscribe,
+            streams,
+        };
+        try {
+            this.ws.send(JSON.stringify(message));
+            streams.forEach(stream => this.subscriptions.add(stream));
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Unsubscribe from one or more streams
+     * @param streams Array of streams to unsubscribe from
+     */
+    unsubscribe(streams) {
+        // Validate all streams first
+        try {
+            streams.forEach(stream => this.validateStream(stream));
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            streams.forEach(stream => this.subscriptions.delete(stream));
+            return;
+        }
+        const message = {
+            type: types_1.WebSocketMessageType.Unsubscribe,
+            streams,
+        };
+        try {
+            this.ws.send(JSON.stringify(message));
+            streams.forEach(stream => this.subscriptions.delete(stream));
+        }
+        catch (error) {
+            this.emit("error", error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Close the WebSocket connection
+     */
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        if (this.pingTimeout) {
+            clearTimeout(this.pingTimeout);
+            this.pingTimeout = null;
+        }
+        this.subscriptions.clear();
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case types_1.WebSocketMessageType.TradeUpdate:
+                this.emit("trade", message);
+                break;
+            case types_1.WebSocketMessageType.DeltaUpdate:
+                this.emit("delta", message);
+                break;
+            case types_1.WebSocketMessageType.UserUpdate:
+                this.emit("user", message);
+                break;
+            default:
+                this.emit("error", new Error(`Unknown message type: ${message.type}`));
+        }
+    }
+    reconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit("error", new Error("Max reconnection attempts reached"));
+            return;
+        }
+        setTimeout(() => {
+            this.reconnectAttempts++;
+            this.reconnectDelay *= 2; // Exponential backoff
+            this.connect();
+        }, this.reconnectDelay);
+    }
+}
+exports.NordWebSocketClient = NordWebSocketClient;

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "data:application/octet-stream;base64,H4sIAAAAAAAAE5WYWXPaPhTFvwvPnaZN03R5M2BnmMSGeiH/ZToeYV+IByN5ZNEm0+l3r7AJ3qQr91XnnB+6krXx/6+JgGcx+Tpxsjx3WQqTN5OCiCfZAvR4KK9e298+iUMuxX1G08nXz7/fXJL38BK+FIPguVmfWwHZh0W5Ap6xNKKZ6BMGBj0ryIY9P7XpEx7jaZNIclKWUF6dWruZ99f9VFQCVydPCpYOjpsy4dlGlW80jGAlCTvS1khlVADfkkQSzlo3fv3xthMXGaMLumUawqtshnw7An9BKJVuxvhQFoyWgJBeLWZYaT8LoCmkhgo7vhFYU63lyGLLEdWWo8rd7TjsiAAXBM+SUs3rmTDgNGfJXl9mIxshaIkdhxEVHA8HgvXobBgLMnetZ8TAc8gFsX+AZjE2Mgax/dn1u5DtQb8muxYMpkWYgi7he1CXUUvmcCCIUH+FLd2MKSsfOk8qIwY+7cszRrfZTolrZAyy5Gl7z27lK8UY1U7NRTUiNoztDd24WEbB0FEeuDCkPKAL02fQ82A4n+X5gdB6OzTu6Fr36J8Yh/4rJDq2SudoNL461NYRcPPerTJi4OZCgyy/vgkDVpugklIpaJSTVF1VpRij2k/kohoR6mVRS+ZwdfauCCcHjNNymZHoZHct6AGb7RZUrEl+bJGEvPjLI7WReoR3Xz69/3jdPk3taXQX39v/Bg3kB+EZ2eSnw/SidjkfugjHih7C2Im8+cK7iy13GXmhhqe0ovB1PFt6oW/Nwtiaz3070JCHPgM2XN7bXrzwnKWW2LIYYJH/oINICQlX14zYmi5U8YuIAdZujPSgJSMQOS0zO4xX/mJthTY20Gongnatf+Jp5Di2Hz/YngrZdSAob+nP4zs7DG0/iB3r1A/NwKmdJrRvuasR3K4NgQZyZBZLLw5D5dS0ZATyaE8D21/LwUFmeWBCgP/Z/lLaZgvXUrLaOoI5vZ556/K6PdL68LuqlW709qYV3VT7U8hWnAkWyYe2ijIwIcDkCZL96ri5h5cHoDtJUgAHJhMQUgdEomeddQzDQT4DH2ETyLNb3sDqQ7c4MZRUvR35kRQSlkJdknz9ZIdMQKrCK40IGOhIsNKIgLfnv7bOkzv8B6xBa6wonKb9h1Wb96oaEL1LT5eguPd0AAeyh0eS53IOsx11lJy+B8GxQtjPBSTKii4iDnBJoUlLBY9G9CfXpmsRARSEZokqXAlIsJTDUt+nVelGRRCCBQnJIdXtMW19DOb2BqXc3gwg3/8AbpPhh+kVAAA="
+window.navigationData = "data:application/octet-stream;base64,H4sIAAAAAAAAE5WYWXObMBSF/4ufM03iJm6bN2yLDBMDLovTZTqMDLLDGAsGRJpMp/+9Mnhhka7oq845H1xJXAQ//4wYeWOjh5EeJ4mZRmR0Ncowe+EjhJb74vo0/uGF7RMu7mIajR4+/706J5/Iu/ee9YLHYXluSfDOy4olyeM08mnMuoSeQc5y4/6dH8bkCSvNo0siTHBRkOL6MNrO3I67Kb8guTh5UKC0FoZpSRt1xpSRfINDnj9q7fj4ftKKszilBt2kEsJJVkO+liR/ByiVrsY4pMhSWhCAdLKoYQV6Y4RGJFJU2PINwKpqLQYWWwyothhU7nabky1mxCQsj8NCzOuYIOA0ScOdvMyLrISAJbYcSpRb7vcYuqOjYShIfWsdIwSek4Rh9EokD+NFhiDImY1vvHRH5M9k2wLBpAhV0MT5jojLqCV12GWYiXdhQ1djisoHrpPICIEPXXWW0k28FeIuMgSx86jZsRv5SlFGpUtzViEEf31lqmnueCCckybJHtO63Sg7ptQ9+BLD0P+FBHeI0DkYDe8+sXUAXN0bRUYI7JbrIszjNcmB7d01QcCqyQgplQJGcxyJq6oUZVS8p2sJ7O7x1qBshZOycXXGz4y8n1+kDuHmy6fb+3GzlaOp/xg8oe/uBfKK8xivk0MnP6ttzsc2Qtf8hRfovjU3rMdAM23f8iQ8oRWEr4KZbXmONvMCbT53kCsh930KrGc/ISswLN2WEhsWBcx3FjIIl4Bw9Y4LtKkhip9FCLAyA+AOGjIA4csyQ16wdIyV5iFoosVOAG1q34Kpr+vICRbIEiHbDgBl2c48eESehxw30LXDfUgmTuxUoR3NXA7gtm0A1OUzY9hW4HnCpWnIAOQZTV3krPjkAKvcMwHAH8ixuW1mmJqQ1dQBzOHDLW+cnDYlrd8M17XSjk7uGtF11Z+8dJmnLPX5V56I0jMBwPCFhLtlueZfzQtCt5wkAPZMKiCJdMJCOeuoA5iIhPzjv74aPxXH+5iRSMQTGgEwoQPBQiMA3hx/WBznvf9f44KWWEE4jboH7ibvpCoQnZd1myB4X7cAe7wjzzhJ+GEx3lJdyOl6AFyaMfSWkVBY0VmEASbOJGmuwFGf/s6l6VoEABmmcSgKVwIQLPi01OdAUfqiAgiWuiFOSCR7/Jv6EMzkDqRM7nqQX/8AH8q1Qb8TAAA="

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "data:application/octet-stream;base64,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";
+window.searchData = "data:application/octet-stream;base64,H4sIAAAAAAAAE7VdXXPbuJL9L/arNyOA3/PmJM7d1ORrbWfu3k1NsSgJtlWWRA1JOcmdmv++BEiJjWY3CdG+LzNW2OgGcBqNxgEI/nVW5N/Ls1+//XX2uNouz34N/YuzbbZRZ7+e3a3W64/5Ut3mX4q8yt+1P88uzvbFWj/fbxfVKt+WvzCSrx6qzboWX6yzslS1lbOzvy8OhuKjnS8qe7zdlV9UscqXX7er6mhBbfeb8pfe80G9Ijwq/u98XzjpOm8lgcKLs11WqG1F1o+09jb76WasEXyWrX8q9ehmrJV8lrWP+bZ6cDN3EH2WvX+pzBG3VvJ0azLozH3Ki+WbfHu3uj8aXW0rVdxlC1X+0j0ddruZ7EaOetp8LdYO2s6PknQTQNUYU9/V/EYVT6pwNIjkp5pd1DgX2aK6XC4LVZYulvtFphqv8ke1fb+9y53sWtInmIQucnX9Rs5uD4ooq7aEu6tkfAcSKs+zkc5DFWWM7gq1WJV16HY1Cws8x3CDxdLVbCf+HKPmf44WW9kTzUFX+VwsVUGZMw/cHSPX4nRXdZrOOym6yk1tGBOr8kO+JYMesHAUmmCgXP2b7HmgvhWZoHxXrBZj2g8yE9RvsuJRVaMAADE3I13e85v6eftz1zWhmenaf3XNca6WMghEMqDkvBOha3ioB6n/Ri12tXs/iiELUGiCjdfrUsjUiwdtQCFXG11f36yWuKP1P7n28mWJ061j6fPmGV0lY5Zu82rJamyeOWnsWthLzxutTrk4qNeH1aaXgFs6zg8SdP2O1SC1f8nL6vN2jRNl2wAQmmLj/WajlqusUp+LN9l2odaDxijpKVb108/Fb/V/B81ZYs524Pxys5+Xi2I1VwWfs2IZ91mnrAqVbb5ef3BWew6LMD6Lq8yG3B+v93d3qvigyMyEto9KnVwF2LkfTTSnbDdPTujIn5t5TmbkQNP5UYqudVsdxsQ8K9Utn1BBO7boFGN/7vPK1RqSnWLOTNxv66Rzk63J5Bjaw8JTDOo8xNUeknU0B/3MdA5lxjx4CS/rFI05WVMXbiVbPej12oiFTmqCieVArwMby7EOHzQysPAANsbWG9gEhJRbGJ62HGzSSbIvukVKJ0RXc3QFNqL/KOOkHnbCW7WusqsnLUdY6J66d0gtUKX73bKeodMViR/Set4rQbcCVJUxfZLVlzDY4JrygxobxQWmGs7KR9IlsL1WbqqZ+WrpZKaVO8GMFVuLbEmuC82DE2LrakzNeSvCBAtTj1MXr0D78OJ1UD238LbqPrDwHlRuOAdmWAADQMzNSA9EekowT14ygACNrsGjrd6UwAGtPdfQaMCAxtyCxbDBygWW86OUo4kefcbNpceH7vDTINiKzgcA6OrDGCjUcr9QaQ5XtbwlW3qiSb0AT4fpL9A2KDzR4CCP15ka5/KGjGSLRb7fVsywQaYsYXeD0NMuGxWUsfbRSwYZqNI1yhxqOCXMWPaebWoYG8uWAzIjxvRuMhljLDsHqUkmdmutcNTGUWySkYXhk8atdHKTzMyztVYwbgcIuhqC4+X1Ol88/s9eFWSc6566j5q5LpNu95s5vWOCdJ4jeboRoJoD7bhW5S7flmRUswReuDWW2hMadKwvO0DNSQxHu530aSZ73Xiz39Rpxc/R3kRyp3Zq2RQ/Sf05LjrQVNwMbsLQvcaOAPD4hO1fU4iNq7bGcyjNDeGujkOtGELMlni5AUDodRsBqMqDXelq+Ch9osl+V5YjHlGe6BImORhoB9B3fpQdakU57g7luD+UpzvEQFCidI6GJVzX8cA0FjFeOLpDrScE90NluXyoyDfpYKDoG++VmW6+yk81jkqcZLrvm9xisHv6ouEWrjHcou3womY4KGFrzzClfqhFWq02qqyyzc7FZK/ECaaJGHL1o1LbpVoOA2aJvfTk0ld+ygxjt2C6CxG1cPWlE6owwf5E4xbW9/eFuq9Xkx9VVawWdHBHMieiXKZVXmUkn0VqPkelmCbiinPh7sep5kGJ55veuffo+VH+JcymO5U9nmr7UOh5FSjUn/s6BqXrWnS7+JlmT6rI7ulchKwMr+DkikFfv87X6022HV0wUnIvF9lY7W6hjWzE6QkbX4uxrG2kAkSHjy9RSMEX7/LJCxa6HcMTym5+Yk1guReoxnj6MFAXx0xirEKsLwyuT2jJF1mmDKh29Xu3RYslzCVQPaEXSnxpvQ45S7/Wz/bxnnlX/35easzUYYpfDyRPltxYuswK/4fi3MTUmW/Ts11xSho9tToOrslWx9VFHdLr5tRYeVNl1WDMo+Re5JQRq3j01BFZ9aFWGkm+DubxqW1i3AprPIfSQ81p6sjtw9Zg/uA3YntGbfnJZp/y9X6jUuk/OFm1xCcbfVjdPzibBMKTDa7z7872OtnJ5naq2KWlq0eeW+KnGIXD4EutZGQoIJHThgPvmpTac6sI3SZcY46x3G+Xq+19WtRLLGfzqNCzKrBVP6r0oFDP3861oEo+qyr5TtUTlrZaJxHO1cClTq0CeI17l21Xi6Ph7qVt8++DDgWU6KdFRWhpHriqyXfV1Y+dWlCajs9OUPZ1+73IdrSy5tkJyj5ymj66q1k8qMWjWr5T1eKBUAYfu6osV/dt/kAo7B66qttkj+qf2Xpd+0xd9h2lFIsMqw4CrwtpaVrBV9pGdJ73/vVYnnb4nnyvNWSb56v799uqvZ3gq5AxUcGejGuHqu0iX6oPantfPbxVa33eSi0JA6Scq5GlcjNCyp3kvF/289/Uz0YD58FQxlX5Xf0P6PUaeIHE4eEp6uy3KGxt4y9SeLJ7p+rq5ub950/p7W333tNTVqyy+Vq/dtQ9dVX4f1fXn9O3V2/ef7ykNMLHrio/Xv5v+vrru3dX1+mHq0+EUltgUK2cJZEIOt2vje//nq333dDV47D8BTxxRabKbxbZWi2/hj6BDXh6skJ64MLHrp1p3uROL1+/J/rx+MxV2afP12/T68uPX9J3l2+ubhm1hNRJBv5xdXt7dX0zbqMnOJw0yu4VUn0NwtcSUAVtiV8ODwY1BaKr8aIGpir2iyofUXZuS9JR/1gvLturn4+YaUWm6cd3NNAmxq5mGLPynZqUaVNI1Nne4Fw9bqqdnf/LH7X56js9J9uniuveqkewU4ux7H+yyZatQ5vleJvtOrqe1qTrMHpW82WaejAzlncdSx3rNfRuyFjjjkL/yaY1Rg7w8bcGHEu1tRo+Af1+ORoGoOC0SNA60vuxoAblplna7efr1aLO5UYsQblplvRJtduxvjsKTbfxKd8uxlwDyjlbkjO/mykX63w7ZuUgM83CvXJqChCbZqd5NeDy4LQj5vrS06ze6QWwtfFB24Ny0yyVqvri6ORIdGLL9tvlVfXQrEnHWodkn2GxWMiZu01LeprVQt3V2c7DTROCRoz2hKfafKpXda4mbdlpFpdql5ersT7tpJ5l5XK3K/IndfvDzRwUf5ZdfdeKq9Gj7LMsXgFqYdDc1cBlgmO2vq+qh2WRfR9LcDuxaXbMS0L2rV/MJAoFJ8475lUhF2O25DRrVZFtyztV3Ob4XTnaJiU/sZ2F6uaZsZYiWffcAS19STsjPAqo82q7qobVnAMRvpZD+t+qJwcTndTpVrLBINSmuE6RZyI1cBotwG7NbnbroV5qHp+uF93s2dfscKEnSwBQV3n2LTjf4MnZ4e7uJFFwvrKTf32gd1ln35DjHZ2u5xn6BsYOL4y2YLT2zrpxmn/bO5fUt4DEJtlpton4RcXRki14ui2TtGsBNsEHyT2QO93SBhw5GQf/ZnC7fsjOn/oFKnOAdcCKJTTRxge9MjU6htpDiE60d60WtaSbQSQ70SLayWRsHaWe1a5LdLBzsGGd8IRJk3spgpg7+6KTRvObfaEFb3dDxrDcJEvtNdrDZjqhSTY+6jsYtx+a4/vDlrDotJir39e41ekqPvxLx15C/HS78+Ob6e2pwAGjlOxEi+07dqcYpotMGBfd28jjlknhqTbLk4xi6YlR50uRb1T1oPajIceSdLIGtgPfXr3++o/0t6t/3RzNdFuA3UPX3cW3V7+n8MJPqMs8cd5U/f1jyisDT10V/vPq9c3V9e9X1wNqezKnNPvN50+315dvbtPLt2+vr27o/uyLnWLi9vNvV5/S95/efea0AwlXxe8uv+q93S/X73+/vL0aqD0t6F7/uvyH2/Td109v33/6R3r58fPXT7d0O0jJ6QeH3FSfj2xbcQ34+4+L5vDu2a9/ndUrKcMR/nomX3mv9DXZdyu1Xta6vjWVq7Xnm43W+Ef77HelF6ZaohH5ZXZ28W12EYhXMy/544+Lb4cS5oH5ByMm6l+CEhOWmKx/SUpMWmJe/cujxDxLzK9/+ZSYb4kF9a+AEgsssbD+FVJioSUW1b8iSiyyxOL6V3zhB68ST1hisSVWg/ItocQSu3t1b4sZJSgQEAYJQUraWAjd54JEQ9hwCN3twiN12ogI3fOCxETYoAjd+SIgddq4CN3/gkRG2NAIDYEgwRE2OkKjIGJS0gZI3y7/TSSkpI2R1EDIGiP5KghD27ttjKQGQpIYSTRezIChR4yNkdRASHLQSBsjqYGQJEbSxkhqICQ5dKSNkdRASBIjaWMkNRAyIttuY6SPRH2TJEbSxkhqICSJkbQx8jQQHhnPPBsjTwPhkSHNszHyNBAeiZGHwpqJa3RgszHyNBAeiZFnY+RpIDwSI8/GyNNAeCRGno2Rp4HwyHHk2Rh5GgiPxMizMfI0EB4Z6jwbI18D4ZMY+TZGvgbCJzHybYx8DYRPYuTbGPkaCJ/EyEezj5l+6PnHxsgP2Lb7Nka+BsIn0fRtjHwNhE+i6dsY+TEbaX0bI18D4ZO4+zZGgcEopmJdYGMUGIzItgc2RoEGIiBxD2yMAg1EIEjrNkaBBiKQpCRKEkyWQM5xgY1RoIEISNwDG6NAAxHQqYeNUaCBCEg0AxujIGHjZ2BjFM7YWSa0MQoFO3OFNkahwYj0kNDGKDQYkRlQaGMU+iyaoY1RGLBohiiXC1k0QxujMOLraWMUGozIWSa0MQo1ECHpyaGNUaSBCMkIFtkYRRqIkIxgkY1RJFk0IxujSAMRkr0U2RhFGoiQ9PnIxigKWDQjG6MoZNGMUMod8fW0MYo0ECE54iIbo8hgRI64yMYoNhiRPh/bGMUGIzrrtzGKNRAh6UuxjVGsgYhmF573Kkw8W9LGKNZARKQvxTZGccDrtDGKNRBRjdHs1SxAkjZGsVkXkfNmjFZGGoiI9KXYxijWQEQkmrGNUaKBiMILL341821fSmyMEg1ERKKZ2Bglku2lxMYoMRiRs2FiY5QYjEjcExujRAMRkzEksTFKNBAxiXtiY5RELJqJjVFilq9ktEnQAjbhewmvYTUSMekizTMoq7GI6YXkDK1jZxqNmHST5hmU9VhHaZ5BWZ+FtXkGZQ1cIS2L1rMzAxi9TJ2hFe0sYru3eQZl44G2oVXtLBloG8LNMAwxGdZEj30wuNHLZcw/GJYhIV1cYAbC8AwJzTBhDsIwDQlNbGAWwnANCe2TmIcwbENC+yRmIsQAbpiLMIwDPSwFZiMM55DQvo74CGFYB6YOiJEQhndIaP+VmDeSvK8jVkIY7iGhfR3xEsKwD0w/IGZCGP4hoQkcxE0Iw0Aw4wKxE8JwEFw/INwMC8H1A8LN8BAJPS4QRyG8AdwQSyEMF8G0DfEUwrARTNs8zPgZym9GD05EVghDSdCrQYHoCmFIiTqE04oRcoaXqGM4LYygM9REHcRpYYSdYSfqKE4LI/AMQVGHcVoYoec3VC3NVyICQxiaog7ktDDCzzAVdSSnhRGAfgMg7XE+Zm0NbStotBGZIQxlUQdzWhghaFgLwbDMiNIQhriowzktjBBsaA2Oa0YIGvqiDui0MELQMBiCYZwRvSGChm+nEUQMhzA8hmB4Z0RyCENlCIZ6RjyHMGxGHdVpYUy9GwSluPDCV16EBixiO4ThNATNQQtEeAhDawiahhaI8xCG2RA0Ey0Q7SEMuSFoMlog5kMYfkPQfLRA5IcwFEcd3GlhhGDYbJrQCCIKRBiiQ9DEtEAsiDBch6C5aYGIEGHoDkHT0yLE+ycGQZqhFogOEYb0EDRJLRAjIgzvIWieWiBSRBjqQ9BUtUC8iDDsh6DZaoGoEWEIEEET1gKxI8JwIHWIJ9NZRJCIqNn5IulLgTgSETUI0rIIQMOFCJrlFogoEVE4MF4jvAdmAKRZcYHoEhHFQ5oRgA1lwnQcwi+eDShGtIkw5Iig6XmBmBMRyyHNCD9DkQiazheIPxFxs3lJezOiUETcAEh7M2JRhOFKBM3WC0SkiLgBkPZmxKUIw5jU0x0tjAA0pEk93dHCCEHDmwiajxeIVBGGOqmnO1oYIWjYE31JAymMEDQESj3d0cIIQcOhCJqbF4hgEUmzA00jiDgWYZgUQTP0AtEswpApgqbJBWJaRNJsz9AIIrJFGEpF0CS0QHyLNJyKoHloiQgXaUgVQVPREjEu0rAqgmajJaJcpKFV6umOFkZ704ZXETTTLBHpIg2xImi6VyLWRc5CPpRLRLtIQ60Imh6WiHeRhlsRNEMsEfEiDblSz420MEKwOfZBz1USUS+yOflBk8oScS/S8CuMXoRfQ73Qogi95vgHeUxFIuZFNgdAmEMQCDvDrtALTImYF2nYFXrDUSLmRTbHQCJ6hCDqRTYnQWiCXeKzIIZfqdMJUhgfBzEEi6DJc9k7EWLGHs2fS3woxFAsgqbQJT4XYjiWOp+ghRF8hmQRNJEu8ekQw7LU+QQtjAA0NAtNN0p8REQ2ANI+j0+JGJ5F0Jy6RCSMNESLoGl1iVgYaZgWQfPlEtEw0lAtgubBJeJhZMPD0ES4RDyMNFyLoJlwiYgY2RAxMY02ImJkQ8TQnLVERIxsiJiYRhsRMbIhYmjGWCIiRjZEDE0ZS0TEyIaIoTljiYgY2RAxNGksEREjGyKGZo0lImJkQ8TQtLFERIxsiBia35WIiJH+wDJetkSMOQ76pIpK381rjoV++3Y8kfrXWdqeFdVajFZ9bFRTAL/+9ffFmV5btH/E7R916t7+IZs/tKH6j7+7o6T6l65KdnhvtTPTXX3111m9IhosZ26wBUU9UNRrbNermUEV5mPLoJE+0KGzf65w84ZOVzCKu3JJa1vvALV/JIOKUDuiEOg6dObsqPTQz/LQ83X0GNSub2jutCdAu+btW2XRQZkcVLYyb6t12upI0mmbDZf9s/lUGGgoKBwPd5EpWxzeUQCAwQroADakpDjeKQ3qEIHOHu5Iy1MiCereIpEcOlEcMRquUKnaS7F73RrBbg2HlfT7NQFtGqkB37Eh7Fh+BBstVM/GIF4kbBMOL9cCy3AIHryeDwWHV8o2h1fKQA3AoNTbkE00kmxIaN7srn5YtQmBEskP5PIRlpKwUMyXsaobgNAXsB1WNnfRghoKUE7T2nTB7lItEDFBNeNDKIi4Ns6zUpm3fe1w5c86Jf6MK2uXkcBDJWsPBecADPWAA3G+ul9tqyrf6ZtM92aTDc5hEs5hXB83Op6aGyGhY8IZMOSGhP3hADAqQT/FrV/H7TSatFNlkhyi/DGUHP6Qh5nAY/vY/uYnsAwcJGb9Q5fuhZIQABVz4b0rSgYSDwaSQR1kgAadHnNRwP4IFogACYwAXHhvSvf7LQbekgz2W1uY7wMf9gGXVkBVZFeAnozZAbAuhUw9zYmC8QaDOef2za0peXNrCoyAEMAZV/njh5yB84BZLOa8tr0V+q65NBqGNRi9A85vTPHdfv6ofq7ba3vheIfpScAFmvayMpgGQtvskLHu6YBxApaODlmwYHugvWiCmgtnMA84KOJGQXMZDJFUawIMQMhFrmVmuT+AnQN9qeb7+7Tue7vWcOLVyzmu8GK1yWyX8YGj+gMF86Vq4F5290FD3OGUGHD4LdVdtl93N95nG91xdlMS2HM+1/N1LapMPSm72wOAHuvAx/uzgNEApn8J3w2mJJ22BNAH2eDVqlBo2IQz6C6c37aF8+36JzYOw27CDbulekoPvp9Szp9I2Pdc9NZqTFqSrpo7VKAGGLp8HoKnVL95abkwzFA8rv/UUgaBJvZAqIWhnvOX5jr0QQ+GWTCb7Sh9mV2azVd2/IHeH7J112WbfA6tPgTMkrhOq31GY2YNXjBWfG6WUU+blOrwBPqcx/lMXRoVhCnsIUCydUZftAJa4Kp4diA3pDz8wXViHUAWqtIfDnmqQy/txZZDcJHUzH89IAKYcbLLU1N2W0/cvfJwlSolN5DvVnXGUvujFfwBHGzGeSjYptuUHqBmSEtePNb/tSoAuo1d1+uidsoBXDBiQauFN+1t/NDroQ+EfG23y6q5ex+WhRE7ZIFCH6YG/geHOxtx9URlhu339v5K6Cpw0LOrfqOheqDKwxokrJta36mB2RrMVNh58l5VTfO3zQVL0FWBq+u9ElbBornUxXz8FZaHAZsdr3X5jblDZX24QwXGfFgF1ulrFf3a+3DGY7msuqj+ZiyuegxDH7scrguToUvAhaUUAy03y6PKuskF1gLGCpZT7L5uBbNUmGazsfsh31vTBbTHFEEEL2hoyFnRc+nhQ06gKDAWcW1bbYxvVCovmtWMFY9gOswNj+ZqPZhJQa9kF6Ar+G002K8WFcYlATjq+yAW+Ww3bVdVPQ1vzVWJsMKgsJxxzqRL94vCReaMrW1Zr7bu7RkSRh6mWL3GwDsS0iIWmHL6uuvUitVwtCXcUsgUay58RpEaTslBS+OELdEfDakjggacNNgFvS6LFiVwlSRiLtMyaaXlwqDq7AA/fk4O+iG0x3J8+nNEzcSiP8x0hyZIOD8E3PwAv8IG7UMPYVOo/pQOF+JsDg++hghNwhzY47q4LVv+3Mxza+DD2fSwVxYOa0EMqZW5DRa0F9CgycGRMmz9U5+EGNTUftQPTi5wkEnOaWBxirnSrwmA7hxGsF+JGUyD2b2ITfYjne/v7lSRrlF6BrNZEfLe96Mpj4p7YJyyUXhTr2StUQPZaqaMeW6FUFhNrlD/I30wD4NdxW689mK3B0fYYfNUsjtPunyqMwpVlKn+kl/VX4TCtkRczDCKijqj4bTAzIKd87WWRb69W1nzCkCNA00X3JeI74RwCzZZQB8phBDA0MGug/NdpdqvAcKysL3s5F2X3WR2EihgpQO+0tW+/WogLAuhCjio+sSw1U9DpfAUCgqGXGwzBVFQtljZwXIoJYKEFEuI5O2XWeBEC6GMuV5tPzIJexQmbiyP2a4FdnV98+V+i0hAoIEt332HFUZLiAtLm+nCbLyFHc3SZuZKd2K7AM5c7JEAU9heugMvZPcgd3lpCEcrPAOD7P7SrlCLVYlObdg7p2xJlI5Ia6Xazu3cqDGlSaYb1JrvYvNJjkdlr1MhzyZiLsabzaj+SRUBTzzoY3gDpefNhb6wMCSz2LzEFDY577y9MReqgIw6m7cbFTtwUyQMA7AFbG7WbMaZ622p5S48sSPZPTGghGoKXPGwZO+f+7wiN86BH7HDtFDL/UKl2OdDUJadXNsvj5SH74BAtge6ELsKKlTd/noh1JIlafakiuzeGgyQYdevQ3OK9AdJyIrAuYc9JtLuqTY4codmEpjDsDSKpaqnAgY+dmxYKqh0F24aCXZJa6kh0+YERnJ2qLR62B10SEALNq0s1WIng/DR3jeGY5XrjhbWtKps7gMeghHsPN+WRjO9D+vMbvu3ZYnlJhxbgj0EWKqKjrABnPcTtuorm+uGJPDhQB276awrTURniwwJOMjL1b9ty9aGXTsltVNTxFf/3/TMBIY0u9guq0JleC8G5vxsXC7383JRrOaq6KfsMN1n13n91TZcvXjtERp27VPlDAUPXW7GxeMe9Q89leW9iehvZfotQ8Ae3jpu09nzD3TyFm3JxuDDhxpA1UG3Bcfy3GCp8tJ8arZ3qAoyo/r9z5Hi+kVVWBoONZYiqYrMHmtw3mA3+E0p+wwZiEnhgb1jq9x+0qfKyTMVMBWascj/6J9Kgludgt2s1CXtjYLEwpsbmU25VC8urMKwn9lkl6Y8QdGgpZLC1mUjDrFG0/GYte36sAMSLn15ytf7jeqTkXCcsqweS0TC44qCJWy/q3lpvjND71XDFQDLhx51oOLwdO5h0HFgflfKQhEGG67I8Zte0Flhjdng9lNl1loOjDEO5n+rIk/bWcSe/eFEFpLt++PibLfaqfVqW0t9++Pvv/8fFrOHLpG/AAA=";