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

package/dist/compression/gzip.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gzip compression platform functions for East Node IO.
+ *
+ * Provides gzip compression and decompression operations for East programs,
+ * enabling efficient data compression using the gzip format (RFC 1952).
+ *
+ * @packageDocumentation
+ */
+import { BlobType } from "@elaraai/east";
+import type { PlatformFunction } from "@elaraai/east/internal";
+/**
+ * Compresses data using gzip compression.
+ *
+ * Applies gzip compression (RFC 1952) to binary data, producing a compressed
+ * blob that can be decompressed with {@link gzip_decompress}. The compression
+ * level can be controlled via options (0-9, where 0 is no compression and 9
+ * is maximum compression).
+ *
+ * This is a platform function for the East language, enabling gzip compression
+ * in East programs running on Node.js.
+ *
+ * @param data - Uncompressed data to compress
+ * @param options - Compression options (level)
+ * @returns Compressed data as gzip blob
+ *
+ * @throws {EastError} When compression fails due to:
+ * - Invalid compression level (location: "gzip_compress")
+ * - Memory allocation errors (location: "gzip_compress")
+ * - Internal zlib errors (location: "gzip_compress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for compression
+ * - Default compression level is 6 if not specified
+ * - Level 0 stores data without compression
+ * - Higher levels (7-9) provide better compression but are slower
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export declare const gzip_compress: import("@elaraai/east").AsyncPlatformDefinition<[BlobType, import("@elaraai/east").StructType<{
+    level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+}>], BlobType>;
+/**
+ * Decompresses gzip-compressed data.
+ *
+ * Decompresses data that was compressed using gzip (RFC 1952), restoring the
+ * original uncompressed data. The input must be valid gzip format.
+ *
+ * This is a platform function for the East language, enabling gzip decompression
+ * in East programs running on Node.js.
+ *
+ * @param compressed - Gzip-compressed data
+ * @returns Decompressed original data
+ *
+ * @throws {EastError} When decompression fails due to:
+ * - Invalid gzip format (location: "gzip_decompress")
+ * - Corrupted compressed data (location: "gzip_decompress")
+ * - Memory allocation errors (location: "gzip_decompress")
+ * - Internal zlib errors (location: "gzip_decompress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const text = $.let(decompressed.decodeUtf8());
+ *     return $.return(text);
+ * });
+ *
+ * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled(compressedBlob);  // "Hello, World!"
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for decompression
+ * - Automatically detects gzip header and validates format
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export declare const gzip_decompress: import("@elaraai/east").AsyncPlatformDefinition<[BlobType], BlobType>;
+/**
+ * Node.js implementation of Gzip platform functions.
+ *
+ * Pass this array to {@link East.compileAsync} to enable gzip compression operations.
+ */
+export declare const GzipImpl: PlatformFunction[];
+//# sourceMappingURL=gzip.d.ts.map

package/dist/compression/gzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gzip.d.ts","sourceRoot":"","sources":["../../src/compression/gzip.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAQ,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAU/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,aAAa;;cAA6E,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,eAAe,uEAA8D,CAAC;AAE3F;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,gBAAgB,EA6CtC,CAAC"}

package/dist/compression/gzip.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gzip compression platform functions for East Node IO.
+ *
+ * Provides gzip compression and decompression operations for East programs,
+ * enabling efficient data compression using the gzip format (RFC 1952).
+ *
+ * @packageDocumentation
+ */
+import { East, BlobType } from "@elaraai/east";
+import { EastError } from "@elaraai/east/internal";
+import { gzip as nodeGzip, gunzip as nodeGunzip } from "node:zlib";
+import { promisify } from "node:util";
+import { GzipOptionsType } from "./types.js";
+// Promisify zlib functions
+const gzipAsync = promisify(nodeGzip);
+const gunzipAsync = promisify(nodeGunzip);
+/**
+ * Compresses data using gzip compression.
+ *
+ * Applies gzip compression (RFC 1952) to binary data, producing a compressed
+ * blob that can be decompressed with {@link gzip_decompress}. The compression
+ * level can be controlled via options (0-9, where 0 is no compression and 9
+ * is maximum compression).
+ *
+ * This is a platform function for the East language, enabling gzip compression
+ * in East programs running on Node.js.
+ *
+ * @param data - Uncompressed data to compress
+ * @param options - Compression options (level)
+ * @returns Compressed data as gzip blob
+ *
+ * @throws {EastError} When compression fails due to:
+ * - Invalid compression level (location: "gzip_compress")
+ * - Memory allocation errors (location: "gzip_compress")
+ * - Internal zlib errors (location: "gzip_compress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for compression
+ * - Default compression level is 6 if not specified
+ * - Level 0 stores data without compression
+ * - Higher levels (7-9) provide better compression but are slower
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export const gzip_compress = East.asyncPlatform("gzip_compress", [BlobType, GzipOptionsType], BlobType);
+/**
+ * Decompresses gzip-compressed data.
+ *
+ * Decompresses data that was compressed using gzip (RFC 1952), restoring the
+ * original uncompressed data. The input must be valid gzip format.
+ *
+ * This is a platform function for the East language, enabling gzip decompression
+ * in East programs running on Node.js.
+ *
+ * @param compressed - Gzip-compressed data
+ * @returns Decompressed original data
+ *
+ * @throws {EastError} When decompression fails due to:
+ * - Invalid gzip format (location: "gzip_decompress")
+ * - Corrupted compressed data (location: "gzip_decompress")
+ * - Memory allocation errors (location: "gzip_decompress")
+ * - Internal zlib errors (location: "gzip_decompress")
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const text = $.let(decompressed.decodeUtf8());
+ *     return $.return(text);
+ * });
+ *
+ * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+ * const result = await compiled(compressedBlob);  // "Hello, World!"
+ * ```
+ *
+ * @remarks
+ * - Uses Node.js built-in zlib for decompression
+ * - Automatically detects gzip header and validates format
+ * - All operations are asynchronous (use East.compileAsync)
+ */
+export const gzip_decompress = East.asyncPlatform("gzip_decompress", [BlobType], BlobType);
+/**
+ * Node.js implementation of Gzip platform functions.
+ *
+ * Pass this array to {@link East.compileAsync} to enable gzip compression operations.
+ */
+export const GzipImpl = [
+    gzip_compress.implement(async (data, options) => {
+        try {
+            // Extract compression level (default to 6)
+            const level = options.level.type === "some"
+                ? Number(options.level.value)
+                : 6;
+            // Validate level
+            if (level < 0 || level > 9) {
+                throw new EastError(`Invalid compression level: ${level}. Must be 0-9.`, {
+                    location: { filename: "gzip_compress", line: 0n, column: 0n }
+                });
+            }
+            // Compress using zlib
+            const compressed = await gzipAsync(data, { level });
+            return new Uint8Array(compressed);
+        }
+        catch (err) {
+            if (err instanceof EastError)
+                throw err;
+            throw new EastError(`Gzip compression failed: ${err.message}`, {
+                location: { filename: "gzip_compress", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+    gzip_decompress.implement(async (compressed) => {
+        try {
+            // Decompress using zlib
+            const decompressed = await gunzipAsync(compressed);
+            return new Uint8Array(decompressed);
+        }
+        catch (err) {
+            if (err instanceof EastError)
+                throw err;
+            throw new EastError(`Gzip decompression failed: ${err.message}`, {
+                location: { filename: "gzip_decompress", line: 0n, column: 0n },
+                cause: err
+            });
+        }
+    }),
+];
+//# sourceMappingURL=gzip.js.map

package/dist/compression/gzip.js.map

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

package/dist/compression/index.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Compression platform functions for East Node IO.
+ *
+ * Provides functions for compressing and decompressing data using various
+ * formats like gzip, zip, and tar.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressText = East.function([StringType], BlobType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     return $.return(compressed);
+ * });
+ *
+ * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+ * await compiled("Hello, World!");  // Compressed gzip blob
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from "./types.js";
+export { gzip_compress, gzip_decompress, GzipImpl } from "./gzip.js";
+export { zip_compress, zip_decompress, ZipImpl } from "./zip.js";
+export { tar_create, tar_extract, TarImpl } from "./tar.js";
+/**
+ * Compression platform functions grouped by compression type.
+ *
+ * Provides organized access to compression-specific operations for compressing
+ * and decompressing data in East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, StringType } from "@elaraai/east";
+ * import { Compression } from "@elaraai/east-node-io";
+ *
+ * const compressAndDecompress = East.function([StringType], StringType, ($, text) => {
+ *     const data = $.let(text.encodeUtf8());
+ *     const options = $.let({
+ *         level: { tag: "some", value: 9n },
+ *     });
+ *
+ *     const compressed = $.let(Compression.Gzip.compress(data, options));
+ *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+ *     const result = $.let(decompressed.decodeUtf8());
+ *     return $.return(result);
+ * });
+ *
+ * const compiled = East.compileAsync(compressAndDecompress.toIR(), Compression.Gzip.Implementation);
+ * await compiled("Hello, World!");  // "Hello, World!"
+ * ```
+ */
+export declare const Compression: {
+    /**
+     * Gzip compression operations.
+     *
+     * Provides functions for compressing and decompressing data using gzip (RFC 1952).
+     */
+    readonly Gzip: {
+        /**
+         * Compresses data using gzip compression.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const compressText = East.function([StringType], BlobType, ($, text) => {
+         *     const data = $.let(text.encodeUtf8());
+         *     const options = $.let({
+         *         level: { tag: "some", value: 9n },
+         *     });
+         *     const compressed = $.let(Compression.Gzip.compress(data, options));
+         *     return $.return(compressed);
+         * });
+         *
+         * const compiled = East.compileAsync(compressText.toIR(), Compression.Gzip.Implementation);
+         * await compiled("Hello, World!");
+         * ```
+         */
+        readonly compress: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Decompresses gzip-compressed data.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const decompressText = East.function([BlobType], StringType, ($, compressed) => {
+         *     const decompressed = $.let(Compression.Gzip.decompress(compressed));
+         *     const text = $.let(decompressed.decodeUtf8());
+         *     return $.return(text);
+         * });
+         *
+         * const compiled = East.compileAsync(decompressText.toIR(), Compression.Gzip.Implementation);
+         * await compiled(compressedBlob);
+         * ```
+         */
+        readonly decompress: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").BlobType>;
+        /**
+         * Node.js implementation of Gzip platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable gzip operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for Gzip operations.
+         */
+        readonly Types: {
+            /**
+             * Compression level (0-9).
+             */
+            readonly Level: import("@elaraai/east").IntegerType;
+            /**
+             * Gzip compression options.
+             */
+            readonly Options: import("@elaraai/east").StructType<{
+                level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+        };
+    };
+    /**
+     * ZIP archive operations.
+     *
+     * Provides functions for creating and extracting ZIP archives with multiple files.
+     */
+    readonly Zip: {
+        /**
+         * Creates a ZIP archive from a list of files.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const createZip = East.function([StringType, StringType], BlobType, ($, file1, file2) => {
+         *     const entries = $.let([
+         *         { name: "file1.txt", data: file1.encodeUtf8() },
+         *         { name: "file2.txt", data: file2.encodeUtf8() },
+         *     ]);
+         *     const options = $.let({
+         *         level: { tag: "some", value: 9n },
+         *     });
+         *     const zipBlob = $.let(Compression.Zip.compress(entries, options));
+         *     return $.return(zipBlob);
+         * });
+         *
+         * const compiled = East.compileAsync(createZip.toIR(), Compression.Zip.Implementation);
+         * await compiled("Hello", "World");
+         * ```
+         */
+        readonly compress: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            name: import("@elaraai/east").StringType;
+            data: import("@elaraai/east").BlobType;
+        }>>, import("@elaraai/east").StructType<{
+            level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Extracts files from a ZIP archive.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, DictType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const extractZip = East.function([BlobType], DictType(StringType, BlobType), ($, zipBlob) => {
+         *     const files = $.let(Compression.Zip.decompress(zipBlob));
+         *     return $.return(files);
+         * });
+         *
+         * const compiled = East.compileAsync(extractZip.toIR(), Compression.Zip.Implementation);
+         * await compiled(zipBlob);
+         * ```
+         */
+        readonly decompress: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>>;
+        /**
+         * Node.js implementation of ZIP platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable ZIP operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for ZIP operations.
+         */
+        readonly Types: {
+            /**
+             * Compression level (0-9).
+             */
+            readonly Level: import("@elaraai/east").IntegerType;
+            /**
+             * ZIP compression options.
+             */
+            readonly Options: import("@elaraai/east").StructType<{
+                level: import("@elaraai/east").OptionType<import("@elaraai/east").IntegerType>;
+            }>;
+            /**
+             * Entry in a ZIP archive.
+             */
+            readonly Entry: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * List of entries for creating a ZIP archive.
+             */
+            readonly Entries: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * Extracted files from a ZIP archive.
+             */
+            readonly Extracted: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>;
+        };
+    };
+    /**
+     * TAR archive operations.
+     *
+     * Provides functions for creating and extracting TAR archives (without compression).
+     */
+    readonly Tar: {
+        /**
+         * Creates a TAR archive from a list of files.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const createTar = East.function([StringType, StringType], BlobType, ($, file1, file2) => {
+         *     const entries = $.let([
+         *         { name: "file1.txt", data: file1.encodeUtf8() },
+         *         { name: "file2.txt", data: file2.encodeUtf8() },
+         *     ]);
+         *     const tarBlob = $.let(Compression.Tar.create(entries));
+         *     return $.return(tarBlob);
+         * });
+         *
+         * const compiled = East.compileAsync(createTar.toIR(), Compression.Tar.Implementation);
+         * await compiled("Hello", "World");
+         * ```
+         */
+        readonly create: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+            name: import("@elaraai/east").StringType;
+            data: import("@elaraai/east").BlobType;
+        }>>], import("@elaraai/east").BlobType>;
+        /**
+         * Extracts files from a TAR archive.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, DictType, StringType } from "@elaraai/east";
+         * import { Compression } from "@elaraai/east-node-io";
+         *
+         * const extractTar = East.function([BlobType], DictType(StringType, BlobType), ($, tarBlob) => {
+         *     const files = $.let(Compression.Tar.extract(tarBlob));
+         *     return $.return(files);
+         * });
+         *
+         * const compiled = East.compileAsync(extractTar.toIR(), Compression.Tar.Implementation);
+         * await compiled(tarBlob);
+         * ```
+         */
+        readonly extract: import("@elaraai/east").AsyncPlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>>;
+        /**
+         * Node.js implementation of TAR platform functions.
+         *
+         * Pass this to {@link East.compileAsync} to enable TAR operations.
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for TAR operations.
+         */
+        readonly Types: {
+            /**
+             * Entry in a TAR archive.
+             */
+            readonly Entry: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * List of entries for creating a TAR archive.
+             */
+            readonly Entries: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                data: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * Extracted files from a TAR archive.
+             */
+            readonly Extracted: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").BlobType>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAmB5D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW;IACpB;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;WAoBG;;;;QAGH;;;;;;;;;;;;;;;;;WAiBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;YAGH;;eAEG;;;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;;;;;;QAGH;;;;;;;;;;;;;;;;WAgBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;IAKX;;;;OAIG;;QAEC;;;;;;;;;;;;;;;;;;;;WAoBG;;;;;QAGH;;;;;;;;;;;;;;;;WAgBG;;QAGH;;;;WAIG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;YAGH;;eAEG;;;;;YAGH;;eAEG;;;;CAIL,CAAC"}