@elaraai/east-node-io 0.0.1-beta.1 → 0.0.1-beta.11

package/dist/index.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * East Node IO - I/O platform functions for the East language on Node.js
+ *
+ * Provides type-safe I/O operations for East programs including:
+ * - SQL databases (SQLite, PostgreSQL, MySQL)
+ * - Cloud storage (S3)
+ * - File transfer (FTP, SFTP)
+ * - NoSQL databases (Redis, MongoDB)
+ * - File formats (XLSX/Excel, CSV, XML)
+ * - Compression (gzip, zip, tar)
+ *
+ * @packageDocumentation
+ */
+// Export SQL modules
+export * from "./sql/index.js";
+// Export Storage modules
+export * from "./storage/index.js";
+// Export Transfer modules
+export * from "./transfer/index.js";
+// Export NoSQL modules
+export * from "./nosql/index.js";
+// Export Format modules
+export * from "./format/index.js";
+// Export Compression modules
+export * from "./compression/index.js";
+// Re-export all exports as a nested EastNodeIO namespace (matching East.East pattern)
+export * as EastNodeIO from './index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,qBAAqB;AACrB,cAAc,gBAAgB,CAAC;AAE/B,yBAAyB;AACzB,cAAc,oBAAoB,CAAC;AAEnC,0BAA0B;AAC1B,cAAc,qBAAqB,CAAC;AAEpC,uBAAuB;AACvB,cAAc,kBAAkB,CAAC;AAEjC,wBAAwB;AACxB,cAAc,mBAAmB,CAAC;AAElC,6BAA6B;AAC7B,cAAc,wBAAwB,CAAC;AAEvC,sFAAsF;AACtF,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC"}

package/dist/nosql/index.d.ts

@@ -0,0 +1,503 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * NoSQL database platform functions.
+ *
+ * Provides Redis and MongoDB operations for East programs,
+ * supporting caching and document storage use cases.
+ *
+ * @packageDocumentation
+ */
+export * from "./redis.js";
+export * from "./mongodb.js";
+export { RedisConfigType, MongoConfigType, BsonValueType, MongoFindOptionsType } from "./types.js";
+/**
+ * NoSQL database platform functions.
+ *
+ * Provides Redis and MongoDB operations for East programs with type-safe
+ * caching and document storage capabilities.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType, OptionType, variant } from "@elaraai/east";
+ * import { NoSQL } from "@elaraai/east-node-io";
+ *
+ * const cacheExample = East.function([StringType], OptionType(StringType), ($, key) => {
+ *     const config = $.let({
+ *         host: "localhost",
+ *         port: 6379n,
+ *         password: variant('none', null),
+ *         db: variant('none', null),
+ *         keyPrefix: variant('none', null),
+ *     });
+ *
+ *     const conn = $.let(NoSQL.Redis.connect(config));
+ *     const value = $.let(NoSQL.Redis.get(conn, key));
+ *     $(NoSQL.Redis.close(conn));
+ *
+ *     $.return(value);
+ * });
+ *
+ * // All NoSQL operations are async
+ * const compiled = East.compileAsync(cacheExample.toIR(), NoSQL.Redis.Implementation);
+ * await compiled("user:42");
+ * ```
+ */
+export declare const NoSQL: {
+    /**
+     * Redis key-value store operations.
+     *
+     * Provides platform functions for Redis caching and data storage,
+     * supporting get, set, delete, and expiration operations.
+     */
+    readonly Redis: {
+        /**
+         * Connects to a Redis server.
+         *
+         * Creates a connection to a Redis server and returns an
+         * opaque handle for use in key-value operations.
+         *
+         * @example
+         * ```ts
+         * const getValue = East.function([StringType], OptionType(StringType), ($, key) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     const value = $.let(NoSQL.Redis.get(conn, key));
+         *     $(NoSQL.Redis.close(conn));
+         *     $.return(value);
+         * });
+         *
+         * const compiled = East.compileAsync(getValue.toIR(), NoSQL.Redis.Implementation);
+         * await compiled("user:42");  // Some("Alice") or None
+         * ```
+         */
+        readonly connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            host: import("@elaraai/east").StringType;
+            port: import("@elaraai/east").IntegerType;
+            password: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            db: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            keyPrefix: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+        }>], import("@elaraai/east").StringType>;
+        /**
+         * Gets a value by key from Redis.
+         *
+         * Retrieves the string value associated with the given key.
+         * Returns None if the key doesn't exist.
+         *
+         * @example
+         * ```ts
+         * const getValue = East.function([StringType], OptionType(StringType), ($, key) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     const value = $.let(NoSQL.Redis.get(conn, key));
+         *     $(NoSQL.Redis.close(conn));
+         *     $.return(value);
+         * });
+         *
+         * const compiled = East.compileAsync(getValue.toIR(), NoSQL.Redis.Implementation);
+         * await compiled("user:42");  // variant('some', "Alice") or variant('none', null)
+         * ```
+         */
+        readonly get: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], import("@elaraai/east").OptionType<import("@elaraai/east").StringType>>;
+        /**
+         * Sets a key-value pair in Redis.
+         *
+         * Stores a string value associated with the given key.
+         * Overwrites existing values.
+         *
+         * @example
+         * ```ts
+         * const setValue = East.function([StringType, StringType], NullType, ($, key, value) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     $(NoSQL.Redis.set(conn, key, value));
+         *     $(NoSQL.Redis.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(setValue.toIR(), NoSQL.Redis.Implementation);
+         * await compiled("user:42", "Alice");
+         * ```
+         */
+        readonly set: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Sets a key-value pair with expiration in Redis.
+         *
+         * Stores a string value with a TTL (time-to-live) in seconds.
+         * The key will automatically expire after the specified duration.
+         *
+         * @example
+         * ```ts
+         * const setSession = East.function([StringType, StringType], NullType, ($, sessionId, data) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     $(NoSQL.Redis.setex(conn, sessionId, data, 3600n)); // 1 hour TTL
+         *     $(NoSQL.Redis.close(conn));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(setSession.toIR(), NoSQL.Redis.Implementation);
+         * await compiled("session:xyz", "user_data");
+         * ```
+         */
+        readonly setex: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").StringType, import("@elaraai/east").IntegerType], import("@elaraai/east").NullType>;
+        /**
+         * Deletes a key from Redis.
+         *
+         * Removes the key and its associated value from Redis.
+         * Returns the number of keys deleted (0 or 1).
+         *
+         * @example
+         * ```ts
+         * const deleteKey = East.function([StringType], IntegerType, ($, key) => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     const deleted = $.let(NoSQL.Redis.delete(conn, key));
+         *     $(NoSQL.Redis.close(conn));
+         *     $.return(deleted);
+         * });
+         *
+         * const compiled = East.compileAsync(deleteKey.toIR(), NoSQL.Redis.Implementation);
+         * await compiled("user:42");  // 1n (deleted) or 0n (not found)
+         * ```
+         */
+        readonly delete: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").StringType], import("@elaraai/east").IntegerType>;
+        /**
+         * Closes the Redis connection.
+         *
+         * Closes the connection and releases all resources.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         host: "localhost",
+         *         port: 6379n,
+         *         password: variant('none', null),
+         *         db: variant('none', null),
+         *         keyPrefix: variant('none', null),
+         *     });
+         *     const conn = $.let(NoSQL.Redis.connect(config));
+         *     // ... do work ...
+         *     $(NoSQL.Redis.close(conn));
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), NoSQL.Redis.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Closes all Redis connections.
+         *
+         * Closes all active Redis connections and releases all resources.
+         * Useful for test cleanup to ensure all connections are closed.
+         *
+         * @returns Null on success
+         *
+         * @example
+         * ```ts
+         * const cleanupAll = East.function([], NullType, $ => {
+         *     // ... test code that may have left connections open ...
+         *     $(NoSQL.Redis.closeAll());
+         *     return $.return(null);
+         * });
+         *
+         * const compiled = East.compileAsync(cleanupAll.toIR(), NoSQL.Redis.Implementation);
+         * await compiled();
+         * ```
+         *
+         * @internal
+         */
+        readonly closeAll: import("@elaraai/east").AsyncPlatformDefinition<[], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of Redis platform functions.
+         *
+         * Pass this to East.compileAsync() to enable Redis operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for Redis operations.
+         */
+        readonly Types: {
+            /**
+             * Redis connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                host: import("@elaraai/east").StringType;
+                port: import("@elaraai/east").IntegerType;
+                password: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                db: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                keyPrefix: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            }>;
+        };
+    };
+    /**
+     * MongoDB document database operations.
+     *
+     * Provides platform functions for MongoDB document storage,
+     * supporting find, insert, update, and delete operations.
+     */
+    readonly MongoDB: {
+        /**
+         * Connects to a MongoDB server.
+         *
+         * Creates a connection to a MongoDB database and returns an
+         * opaque handle for use in document operations.
+         *
+         * @example
+         * ```ts
+         * const findUser = East.function([StringType], OptionType(BsonDocumentType), ($, username) => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const query = $.let(new Map([["username", variant('String', username)]]), BsonDocumentType);
+         *     const result = $.let(NoSQL.MongoDB.findOne(conn, query));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(result);
+         * });
+         *
+         * const compiled = East.compileAsync(findUser.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled("alice");  // variant('some', document) or variant('none', null)
+         * ```
+         */
+        readonly connect: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StructType<{
+            uri: import("@elaraai/east").StringType;
+            database: import("@elaraai/east").StringType;
+            collection: import("@elaraai/east").StringType;
+        }>], import("@elaraai/east").StringType>;
+        /**
+         * Finds a single document in MongoDB.
+         *
+         * Searches for a document matching the query object.
+         * Returns None if no document is found.
+         *
+         * @example
+         * ```ts
+         * const findUser = East.function([StringType], OptionType(BsonDocumentType), ($, username) => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const query = $.let(new Map([["username", variant('String', username)]]), BsonDocumentType);
+         *     const result = $.let(NoSQL.MongoDB.findOne(conn, query));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(result);
+         * });
+         *
+         * const compiled = East.compileAsync(findUser.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled("alice");  // variant('some', document) or variant('none', null)
+         * ```
+         */
+        readonly findOne: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>], import("@elaraai/east").OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>>>;
+        /**
+         * Finds multiple documents in MongoDB.
+         *
+         * Searches for documents matching the query object with optional
+         * limit and skip for pagination.
+         *
+         * @example
+         * ```ts
+         * const findUsers = East.function([], ArrayType(BsonDocumentType), $ => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const query = $.let(new Map(), BsonDocumentType);
+         *     const options = $.let({ limit: variant('some',10n), skip: variant('none', null) });
+         *     const result = $.let(NoSQL.MongoDB.findMany(conn, query, options));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(result);
+         * });
+         *
+         * const compiled = East.compileAsync(findUsers.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled();  // [doc1, doc2, ...]
+         * ```
+         */
+        readonly findMany: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>, import("@elaraai/east").StructType<{
+            limit: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            skip: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>>>;
+        /**
+         * Inserts a document into MongoDB.
+         *
+         * Inserts a new document into the collection.
+         * Returns the inserted document's _id as a string.
+         *
+         * @example
+         * ```ts
+         * const createUser = East.function([StringType, StringType], StringType, ($, username, email) => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const doc = $.let(new Map([
+         *         ["username", variant('String', username)],
+         *         ["email", variant('String', email)],
+         *     ]), BsonDocumentType);
+         *     const id = $.let(NoSQL.MongoDB.insertOne(conn, doc));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(id);
+         * });
+         *
+         * const compiled = East.compileAsync(createUser.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled("alice", "alice@example.com");  // "507f1f77bcf86cd799439011"
+         * ```
+         */
+        readonly insertOne: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>], import("@elaraai/east").StringType>;
+        /**
+         * Updates a document in MongoDB.
+         *
+         * Updates a single document matching the query with the update operations.
+         * Returns the number of documents modified (0 or 1).
+         *
+         * @example
+         * ```ts
+         * const updateUser = East.function([StringType, StringType], IntegerType, ($, username, newEmail) => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const query = $.let(new Map([["username", variant('String', username)]]), BsonDocumentType);
+         *     const update = $.let(new Map([["email", variant('String', newEmail)]]), BsonDocumentType);
+         *     const modified = $.let(NoSQL.MongoDB.updateOne(conn, query, update));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(modified);
+         * });
+         *
+         * const compiled = East.compileAsync(updateUser.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled("alice", "newemail@example.com");  // 1n (updated) or 0n (not found)
+         * ```
+         */
+        readonly updateOne: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>], import("@elaraai/east").IntegerType>;
+        /**
+         * Deletes a document from MongoDB.
+         *
+         * Deletes a single document matching the query object.
+         * Returns the number of documents deleted (0 or 1).
+         *
+         * @example
+         * ```ts
+         * const deleteUser = East.function([StringType], IntegerType, ($, username) => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     const query = $.let(new Map([["username", variant('String', username)]]), BsonDocumentType);
+         *     const deleted = $.let(NoSQL.MongoDB.deleteOne(conn, query));
+         *     $(NoSQL.MongoDB.close(conn));
+         *     $.return(deleted);
+         * });
+         *
+         * const compiled = East.compileAsync(deleteUser.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled("alice");  // 1n (deleted) or 0n (not found)
+         * ```
+         */
+        readonly deleteOne: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType, import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>], import("@elaraai/east").IntegerType>;
+        /**
+         * Closes the MongoDB connection.
+         *
+         * Closes the connection and releases all resources.
+         *
+         * @example
+         * ```ts
+         * const cleanup = East.function([], NullType, $ => {
+         *     const config = $.let({
+         *         uri: "mongodb://localhost:27017",
+         *         database: "myapp",
+         *         collection: "users",
+         *     });
+         *     const conn = $.let(NoSQL.MongoDB.connect(config));
+         *     // ... do work ...
+         *     $(NoSQL.MongoDB.close(conn));
+         * });
+         *
+         * const compiled = East.compileAsync(cleanup.toIR(), NoSQL.MongoDB.Implementation);
+         * await compiled();
+         * ```
+         */
+        readonly close: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").StringType], import("@elaraai/east").NullType>;
+        /**
+         * Node.js implementation of MongoDB platform functions.
+         *
+         * Pass this to East.compileAsync() to enable MongoDB operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for MongoDB operations.
+         */
+        readonly Types: {
+            /**
+             * MongoDB connection configuration type.
+             */
+            readonly Config: import("@elaraai/east").StructType<{
+                uri: import("@elaraai/east").StringType;
+                database: import("@elaraai/east").StringType;
+                collection: import("@elaraai/east").StringType;
+            }>;
+            /**
+             * BSON value type (recursive type for MongoDB values).
+             */
+            readonly BsonValue: import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>;
+            /**
+             * BSON document type (dictionary of string keys to BSON values).
+             */
+            readonly BsonDocument: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").RecursiveType<import("@elaraai/east").EastType>>;
+            /**
+             * MongoDB find operation options type.
+             */
+            readonly FindOptions: import("@elaraai/east").StructType<{
+                limit: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+                skip: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/nosql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nosql/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAGH,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAG7B,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0BnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,KAAK;IACd;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;IAKX;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2BG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;;QAGH;;;;;;;;;;;;;;;;;;;;;WAqBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;YAGH;;eAEG;;YAGH;;eAEG;;YAGH;;eAEG;;;;;;;CAIL,CAAC"}