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

package/dist/format/index.js

@@ -0,0 +1,463 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * File format platform functions for East Node IO.
+ *
+ * Provides functions for reading and writing structured file formats like
+ * Excel (XLSX), CSV, and more.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, IntegerType } from "@elaraai/east";
+ * import { Format } from "@elaraai/east-node-io";
+ *
+ * const countRows = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+ *     const options = $.let({
+ *         sheetName: { tag: "none", value: {} },
+ *     });
+ *
+ *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+ *     return $.return(sheet.size());
+ * });
+ *
+ * const compiled = East.compile(countRows.toIR(), Format.XLSX.Implementation);
+ * const xlsxBlob = new Uint8Array([]);  // XLSX file bytes
+ * compiled(xlsxBlob);  // 100n
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Export types
+export * from "./types.js";
+// Export platform functions and implementation
+export { xlsx_read, xlsx_write, xlsx_info, XlsxImpl } from "./xlsx.js";
+export { csv_parse, csv_serialize, CsvImpl, CsvParseConfig, CsvSerializeConfig, CsvRowType, CsvDataType } from "./csv.js";
+export { xml_parse, xml_serialize, XmlImpl, XmlParseConfig, XmlSerializeConfig, XmlNode } from "./xml.js";
+// Import for grouped exports
+import { xlsx_read, xlsx_write, xlsx_info, XlsxImpl } from "./xlsx.js";
+import { csv_parse, csv_serialize, CsvImpl, CsvParseConfig, CsvSerializeConfig, CsvRowType, CsvDataType } from "./csv.js";
+import { xml_parse, xml_serialize, XmlImpl, XmlParseConfig, XmlSerializeConfig, XmlNode } from "./xml.js";
+import { XlsxCellType, XlsxRowType, XlsxSheetType, XlsxReadOptionsType, XlsxWriteOptionsType, XlsxSheetInfoType, XlsxInfoType, } from "./types.js";
+/**
+ * File format platform functions grouped by format type.
+ *
+ * Provides organized access to format-specific operations for reading and
+ * writing structured data files in East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType } from "@elaraai/east";
+ * import { Format } from "@elaraai/east-node-io";
+ *
+ * const createExcel = East.function([], BlobType, $ => {
+ *     const data = $.let([
+ *         [East.variant('String', "Name"), East.variant('String', "Age")],
+ *         [East.variant('String', "Alice"), East.variant('Float', 30)],
+ *         [East.variant('String', "Bob"), East.variant('Float', 25)],
+ *     ]);
+ *
+ *     const options = $.let({
+ *         sheetName: { tag: "some", value: "People" },
+ *     });
+ *
+ *     const blob = $.let(Format.XLSX.write(data, options));
+ *     return $.return(blob);
+ * });
+ *
+ * const compiled = East.compile(createExcel.toIR(), Format.XLSX.Implementation);
+ * const xlsxBlob = compiled();  // Uint8Array with XLSX file bytes
+ * ```
+ */
+export const Format = {
+    /**
+     * XLSX (Excel) file format operations.
+     *
+     * Provides functions for reading and writing Excel files as 2D arrays
+     * of literal values (strings, numbers, booleans, null).
+     */
+    XLSX: {
+        /**
+         * Reads an XLSX file and returns a 2D array of cell values.
+         *
+         * Parses an Excel file from a blob and extracts data as ArrayType<ArrayType<LiteralValueType>>.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, IntegerType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const countRows = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+         *     const options = $.let({
+         *         sheetName: variant('none', null),
+         *     });
+         *
+         *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+         *     $.return(sheet.size());
+         * });
+         *
+         * const compiled = East.compile(countRows.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);  // 100n
+         * ```
+         */
+        read: xlsx_read,
+        /**
+         * Writes a 2D array of cell values to an XLSX file.
+         *
+         * Creates an Excel file from a 2D array of literal values.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const createExcel = East.function([], BlobType, $ => {
+         *     const data = $.let([
+         *         [variant('String', "Name"), variant('String', "Age")],
+         *         [variant('String', "Alice"), variant('Float', 30)],
+         *     ], Format.XLSX.Types.Sheet);
+         *
+         *     const options = $.let({
+         *         sheetName: variant('some', "People"),
+         *     });
+         *
+         *     const blob = $.let(Format.XLSX.write(data, options));
+         *     $.return(blob);
+         * });
+         *
+         * const compiled = East.compile(createExcel.toIR(), Format.XLSX.Implementation);
+         * const xlsxBlob = compiled();
+         * ```
+         */
+        write: xlsx_write,
+        /**
+         * Gets metadata about an XLSX file.
+         *
+         * Returns sheet names and approximate sizes without reading all data.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, IntegerType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const countSheets = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+         *     const info = $.let(Format.XLSX.info(xlsxBlob));
+         *     $.return(info.sheets.size());
+         * });
+         *
+         * const compiled = East.compile(countSheets.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);  // 3n
+         * ```
+         */
+        info: xlsx_info,
+        /**
+         * Node.js implementation of XLSX platform functions.
+         *
+         * Pass this to {@link East.compile} to enable XLSX operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, NullType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], NullType, ($, xlsxBlob) => {
+         *     const options = $.let({
+         *         sheetName: variant('none', null),
+         *     });
+         *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);
+         * ```
+         */
+        Implementation: XlsxImpl,
+        /**
+         * Type definitions for XLSX operations.
+         */
+        Types: {
+            /**
+             * A single cell value in a spreadsheet (LiteralValueType).
+             */
+            Cell: XlsxCellType,
+            /**
+             * A row of cells in a spreadsheet.
+             */
+            Row: XlsxRowType,
+            /**
+             * A 2D array representing a complete worksheet.
+             */
+            Sheet: XlsxSheetType,
+            /**
+             * XLSX read options configuration.
+             */
+            ReadOptions: XlsxReadOptionsType,
+            /**
+             * XLSX write options configuration.
+             */
+            WriteOptions: XlsxWriteOptionsType,
+            /**
+             * Information about a single sheet in an XLSX file.
+             */
+            SheetInfo: XlsxSheetInfoType,
+            /**
+             * XLSX file metadata with sheet listing.
+             */
+            Info: XlsxInfoType,
+        },
+    },
+    /**
+     * CSV (Comma-Separated Values) file format operations.
+     *
+     * Provides functions for parsing and serializing CSV files as arrays of dictionaries,
+     * where each row is a dictionary mapping column names to optional string values.
+     */
+    CSV: {
+        /**
+         * Parses CSV data from a binary blob into structured row data.
+         *
+         * Converts CSV-formatted binary data into an array of row dictionaries,
+         * where each dictionary maps column names to optional string values.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const parseCSV = East.function([BlobType], Format.CSV.Types.Data, ($, csvBlob) => {
+         *     const config = $.let({
+         *         delimiter: variant('none', null),
+         *         quoteChar: variant('none', null),
+         *         escapeChar: variant('none', null),
+         *         newline: variant('none', null),
+         *         hasHeader: true,
+         *         nullString: variant('some', ""),
+         *         skipEmptyLines: true,
+         *         trimFields: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.parse(csvBlob, config));
+         * });
+         *
+         * const compiled = East.compile(parseCSV.toIR(), Format.CSV.Implementation);
+         * const csvBlob = new TextEncoder().encode("name,age\nAlice,30\nBob,25");
+         * compiled(csvBlob);  // Returns parsed CSV data
+         * ```
+         */
+        parse: csv_parse,
+        /**
+         * Serializes structured row data into CSV-formatted binary data.
+         *
+         * Converts an array of row dictionaries into CSV-formatted binary data
+         * with configurable formatting options.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const serializeCSV = East.function([Format.CSV.Types.Data], BlobType, ($, data) => {
+         *     const config = $.let({
+         *         delimiter: ",",
+         *         quoteChar: '"',
+         *         escapeChar: '"',
+         *         newline: "\n",
+         *         includeHeader: true,
+         *         nullString: "",
+         *         alwaysQuote: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.serialize(data, config));
+         * });
+         *
+         * const compiled = East.compile(serializeCSV.toIR(), Format.CSV.Implementation);
+         * const data = [new Map([["name", variant("some", "Alice")], ["age", variant("some", "30")]])];
+         * compiled(data);  // Returns CSV blob
+         * ```
+         */
+        serialize: csv_serialize,
+        /**
+         * Node.js implementation of CSV platform functions.
+         *
+         * Pass this to {@link East.compile} to enable CSV operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], BlobType, ($, csvBlob) => {
+         *     const parseConfig = $.let({
+         *         delimiter: variant('none', null),
+         *         quoteChar: variant('none', null),
+         *         escapeChar: variant('none', null),
+         *         newline: variant('none', null),
+         *         hasHeader: true,
+         *         nullString: variant('none', null),
+         *         skipEmptyLines: true,
+         *         trimFields: false,
+         *     });
+         *
+         *     const data = $.let(Format.CSV.parse(csvBlob, parseConfig));
+         *
+         *     const serializeConfig = $.let({
+         *         delimiter: ",",
+         *         quoteChar: '"',
+         *         escapeChar: '"',
+         *         newline: "\n",
+         *         includeHeader: true,
+         *         nullString: "",
+         *         alwaysQuote: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.serialize(data, serializeConfig));
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.CSV.Implementation);
+         * const csvBlob = new TextEncoder().encode("name,age\nAlice,30");
+         * compiled(csvBlob);
+         * ```
+         */
+        Implementation: CsvImpl,
+        /**
+         * Type definitions for CSV operations.
+         */
+        Types: {
+            /**
+             * CSV parse configuration options.
+             */
+            ParseConfig: CsvParseConfig,
+            /**
+             * CSV serialize configuration options.
+             */
+            SerializeConfig: CsvSerializeConfig,
+            /**
+             * A row in a CSV file (dictionary mapping column names to optional string values).
+             */
+            Row: CsvRowType,
+            /**
+             * CSV data as an array of rows.
+             */
+            Data: CsvDataType,
+        },
+    },
+    /**
+     * XML (Extensible Markup Language) file format operations.
+     *
+     * Provides functions for parsing and serializing XML files as recursive tree structures,
+     * where each node contains a tag name, attributes dictionary, and children array.
+     */
+    XML: {
+        /**
+         * Parses XML data from a binary blob into a recursive tree structure.
+         *
+         * Converts XML-formatted binary data into an XmlNode recursive structure.
+         * Supports XML declarations, namespaces, CDATA, entity decoding, and comments.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const parseXML = East.function([BlobType], Format.XML.Types.Node, ($, xmlBlob) => {
+         *     const config = $.let({
+         *         preserveWhitespace: false,
+         *         decodeEntities: true,
+         *     });
+         *
+         *     return $.return(Format.XML.parse(xmlBlob, config));
+         * });
+         *
+         * const compiled = East.compile(parseXML.toIR(), Format.XML.Implementation);
+         * const xmlBlob = new TextEncoder().encode("<book id='123'><title>East Guide</title></book>");
+         * compiled(xmlBlob);  // Returns parsed XML tree
+         * ```
+         */
+        parse: xml_parse,
+        /**
+         * Serializes a recursive XML tree structure into XML-formatted binary data.
+         *
+         * Converts an XmlNode recursive structure into XML-formatted binary data.
+         * Supports indentation, XML declarations, entity encoding, and self-closing tags.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const serializeXML = East.function([Format.XML.Types.Node], BlobType, ($, doc) => {
+         *     const config = $.let({
+         *         indent: variant('some', "  "),
+         *         includeXmlDeclaration: true,
+         *         encodeEntities: true,
+         *         selfClosingTags: true,
+         *     });
+         *
+         *     return $.return(Format.XML.serialize(doc, config));
+         * });
+         *
+         * const compiled = East.compile(serializeXML.toIR(), Format.XML.Implementation);
+         * const xmlNode = { tag: "book", attributes: new Map([["id", "123"]]), children: [] };
+         * compiled(xmlNode);  // Returns XML blob
+         * ```
+         */
+        serialize: xml_serialize,
+        /**
+         * Node.js implementation of XML platform functions.
+         *
+         * Pass this to {@link East.compile} to enable XML operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], BlobType, ($, xmlBlob) => {
+         *     const parseConfig = $.let({
+         *         preserveWhitespace: false,
+         *         decodeEntities: true,
+         *     });
+         *
+         *     const doc = $.let(Format.XML.parse(xmlBlob, parseConfig));
+         *
+         *     const serializeConfig = $.let({
+         *         indent: variant('some', "  "),
+         *         includeXmlDeclaration: true,
+         *         encodeEntities: true,
+         *         selfClosingTags: true,
+         *     });
+         *
+         *     return $.return(Format.XML.serialize(doc, serializeConfig));
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.XML.Implementation);
+         * const xmlBlob = new TextEncoder().encode("<book><title>East</title></book>");
+         * compiled(xmlBlob);
+         * ```
+         */
+        Implementation: XmlImpl,
+        /**
+         * Type definitions for XML operations.
+         */
+        Types: {
+            /**
+             * XML parsing configuration type.
+             */
+            ParseConfig: XmlParseConfig,
+            /**
+             * XML serialization configuration type.
+             */
+            SerializeConfig: XmlSerializeConfig,
+            /**
+             * XML node recursive type (element with tag, attributes, and children).
+             */
+            Node: XmlNode,
+        },
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/format/index.js.map

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

package/dist/format/types.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * XLSX type definitions for East Node IO.
+ *
+ * Provides East type definitions for reading and writing Excel (XLSX) files,
+ * representing spreadsheets as 2D arrays of literal values.
+ *
+ * @packageDocumentation
+ */
+import { StructType, OptionType, ArrayType, DictType, StringType, IntegerType } from "@elaraai/east";
+/**
+ * A single cell value in a spreadsheet.
+ *
+ * Can be a string, number, boolean, or null. Matches the LiteralValueType
+ * which supports all primitive JavaScript values that can appear in Excel cells.
+ */
+export declare const XlsxCellType: import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>;
+/**
+ * A row of cells in a spreadsheet.
+ *
+ * Represents a single row as an array of cell values.
+ */
+export declare const XlsxRowType: ArrayType<import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>>;
+/**
+ * A 2D array representing a complete worksheet.
+ *
+ * Array of rows, where each row is an array of cell values.
+ * This is the main data structure for reading/writing XLSX files.
+ */
+export declare const XlsxSheetType: ArrayType<ArrayType<import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>>>;
+/**
+ * XLSX read options configuration.
+ *
+ * Controls how Excel files are parsed when reading.
+ */
+export declare const XlsxReadOptionsType: StructType<{
+    /**
+     * Name of the sheet to read.
+     * If not specified, reads the first sheet.
+     */
+    sheetName: OptionType<StringType>;
+}>;
+/**
+ * XLSX write options configuration.
+ *
+ * Controls how data is written to Excel files.
+ */
+export declare const XlsxWriteOptionsType: StructType<{
+    /**
+     * Name of the sheet to create.
+     * Defaults to "Sheet1" if not specified.
+     */
+    sheetName: OptionType<StringType>;
+}>;
+/**
+ * Information about sheets in an XLSX file.
+ */
+export declare const XlsxSheetInfoType: StructType<{
+    /** Sheet name */
+    name: StringType;
+    /** Number of rows (approximate) */
+    rowCount: IntegerType;
+    /** Number of columns (approximate) */
+    columnCount: IntegerType;
+}>;
+/**
+ * XLSX file metadata and sheet listing.
+ */
+export declare const XlsxInfoType: StructType<{
+    /** List of sheets in the workbook */
+    sheets: ArrayType<StructType<{
+        /** Sheet name */
+        name: StringType;
+        /** Number of rows (approximate) */
+        rowCount: IntegerType;
+        /** Number of columns (approximate) */
+        columnCount: IntegerType;
+    }>>;
+}>;
+/**
+ * A single cell value in a CSV file.
+ *
+ * Can be a string, number, boolean, or null. Matches the LiteralValueType
+ * which supports all primitive JavaScript values that can appear in CSV cells.
+ */
+export declare const CsvCellType: import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>;
+/**
+ * A row of cells in a CSV file represented as a dictionary.
+ *
+ * Maps column names (from the header row) to cell values.
+ * This allows accessing cells by name rather than index.
+ */
+export declare const CsvRowType: DictType<StringType, import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>>;
+/**
+ * CSV data as an array of rows.
+ *
+ * Each row is a dictionary mapping column names to values.
+ * The first row of the CSV file is used as column headers.
+ */
+export declare const CsvDataType: ArrayType<DictType<StringType, import("@elaraai/east").VariantType<{
+    Null: import("@elaraai/east").NullType;
+    Boolean: import("@elaraai/east").BooleanType;
+    Integer: IntegerType;
+    Float: import("@elaraai/east").FloatType;
+    String: StringType;
+    DateTime: import("@elaraai/east").DateTimeType;
+    Blob: import("@elaraai/east").BlobType;
+}>>>;
+/**
+ * CSV read options configuration.
+ *
+ * Controls how CSV files are parsed when reading.
+ */
+export declare const CsvReadOptionsType: StructType<{
+    /**
+     * Delimiter character.
+     * Defaults to "," if not specified.
+     */
+    delimiter: OptionType<StringType>;
+}>;
+/**
+ * CSV write options configuration.
+ *
+ * Controls how data is written to CSV files.
+ */
+export declare const CsvWriteOptionsType: StructType<{
+    /**
+     * Delimiter character.
+     * Defaults to "," if not specified.
+     */
+    delimiter: OptionType<StringType>;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/format/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/format/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EACH,UAAU,EACV,UAAU,EACV,SAAS,EACT,QAAQ,EACR,UAAU,EACV,WAAW,EACd,MAAM,eAAe,CAAC;AAGvB;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;;;;EAAmB,CAAC;AAE7C;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;GAA0B,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;IAAyB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC5B;;;OAGG;;EAEL,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;IAC7B;;;OAGG;;EAEL,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC1B,iBAAiB;;IAGjB,mCAAmC;;IAGnC,sCAAsC;;EAExC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;IACrB,qCAAqC;;QAdrC,iBAAiB;;QAGjB,mCAAmC;;QAGnC,sCAAsC;;;EAUxC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;EAAmB,CAAC;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;GAAoC,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;IAAwB,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;IAC3B;;;OAGG;;EAEL,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;IAC5B;;;OAGG;;EAEL,CAAC"}