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

package/dist/connection/index.js

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Connection management utilities for East Node IO.
+ *
+ * Provides opaque handle-based connection management for databases,
+ * storage services, and file transfer protocols.
+ *
+ * @packageDocumentation
+ */
+import { randomUUID } from 'node:crypto';
+import { EastError } from "@elaraai/east/internal";
+/**
+ * Internal connection handle storage.
+ * Maps handle UUIDs to connection objects and their cleanup functions.
+ *
+ * @internal
+ */
+const connectionHandles = new Map();
+/**
+ * Creates an opaque handle for a connection object.
+ *
+ * Generates a UUID handle and stores the connection in internal storage.
+ * The handle can be used to retrieve the connection later.
+ *
+ * @param connection - The connection object to store
+ * @param cleanup - Optional cleanup function to call when closing all handles
+ * @returns Opaque handle (UUID string) for the connection
+ *
+ * @example
+ * ```ts
+ * const pool = new pg.Pool(config);
+ * const handle = createHandle(pool, async () => await pool.end());
+ * ```
+ */
+export function createHandle(connection, cleanup) {
+    const handle = randomUUID();
+    const entry = { connection };
+    if (cleanup) {
+        entry.cleanup = cleanup;
+    }
+    connectionHandles.set(handle, entry);
+    return handle;
+}
+/**
+ * Retrieves a connection object by its handle.
+ *
+ * Looks up the connection associated with the given handle.
+ * Throws an error if the handle is invalid or not found.
+ *
+ * @typeParam T - The expected type of the connection object
+ * @param handle - The opaque handle for the connection
+ * @returns The connection object cast to type T
+ *
+ * @throws {EastError} When handle is invalid or not found (location: "connection_handle")
+ *
+ * @example
+ * ```ts
+ * const pool = getConnection<pg.Pool>(handle);
+ * const result = await pool.query(sql, params);
+ * ```
+ */
+export function getConnection(handle) {
+    const entry = connectionHandles.get(handle);
+    if (!entry) {
+        throw new EastError(`Invalid connection handle: ${handle}`, {
+            location: { filename: "connection_handle", line: 0n, column: 0n }
+        });
+    }
+    return entry.connection;
+}
+/**
+ * Closes and removes a connection handle.
+ *
+ * Removes the connection from internal storage. The connection object
+ * itself should be closed by the caller before calling this function.
+ *
+ * @param handle - The opaque handle to close
+ *
+ * @throws {EastError} When handle is invalid or not found (location: "connection_close")
+ *
+ * @example
+ * ```ts
+ * const pool = getConnection<pg.Pool>(handle);
+ * await pool.end();
+ * closeHandle(handle);
+ * ```
+ */
+export function closeHandle(handle) {
+    const entry = connectionHandles.get(handle);
+    if (!entry) {
+        throw new EastError(`Cannot close invalid handle: ${handle}`, {
+            location: { filename: "connection_close", line: 0n, column: 0n }
+        });
+    }
+    connectionHandles.delete(handle);
+}
+/**
+ * Gets the current number of active connection handles.
+ *
+ * Useful for debugging and testing to ensure connections are properly cleaned up.
+ *
+ * @returns Number of active connection handles
+ *
+ * @internal
+ */
+export function getHandleCount() {
+    return connectionHandles.size;
+}
+/**
+ * Closes all active connection handles.
+ *
+ * Useful for test cleanup to ensure all connections are closed even if tests fail.
+ * Calls each connection's registered cleanup function, then clears all handles.
+ *
+ * @internal
+ */
+export async function closeAllHandles() {
+    for (const [handle, entry] of connectionHandles.entries()) {
+        try {
+            if (entry.cleanup) {
+                await entry.cleanup();
+            }
+        }
+        catch (err) {
+            // Ignore errors during cleanup
+            console.error(`Error closing handle ${handle}:`, err);
+        }
+    }
+    connectionHandles.clear();
+}
+//# sourceMappingURL=index.js.map

package/dist/connection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/connection/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAA8D,CAAC;AAEhG;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,YAAY,CAAC,UAAe,EAAE,OAA6B;IACvE,MAAM,MAAM,GAAG,UAAU,EAAE,CAAC;IAC5B,MAAM,KAAK,GAAuD,EAAE,UAAU,EAAE,CAAC;IACjF,IAAI,OAAO,EAAE,CAAC;QACV,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;IAC5B,CAAC;IACD,iBAAiB,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACrC,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,aAAa,CAAI,MAAc;IAC3C,MAAM,KAAK,GAAG,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,IAAI,SAAS,CAAC,8BAA8B,MAAM,EAAE,EAAE;YACxD,QAAQ,EAAE,EAAE,QAAQ,EAAE,mBAAmB,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;SACpE,CAAC,CAAC;IACP,CAAC;IACD,OAAO,KAAK,CAAC,UAAe,CAAC;AACjC,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc;IACtC,MAAM,KAAK,GAAG,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAAC,KAAK,EAAE,CAAC;QACT,MAAM,IAAI,SAAS,CAAC,gCAAgC,MAAM,EAAE,EAAE;YAC1D,QAAQ,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;SACnE,CAAC,CAAC;IACP,CAAC;IACD,iBAAiB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACrC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc;IAC1B,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAClC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACjC,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,iBAAiB,CAAC,OAAO,EAAE,EAAE,CAAC;QACxD,IAAI,CAAC;YACD,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBAChB,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;YAC1B,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,+BAA+B;YAC/B,OAAO,CAAC,KAAK,CAAC,wBAAwB,MAAM,GAAG,EAAE,GAAG,CAAC,CAAC;QAC1D,CAAC;IACL,CAAC;IACD,iBAAiB,CAAC,KAAK,EAAE,CAAC;AAC9B,CAAC"}

package/dist/format/index.d.ts

@@ -0,0 +1,421 @@
+/**
+ * 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), XML, 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 * from "./types.js";
+export { xlsx_read, xlsx_write, xlsx_info, XlsxImpl } from "./xlsx.js";
+export { xml_parse, xml_serialize, XmlImpl, XmlParseConfig, XmlSerializeConfig, XmlNode } from "./xml.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 declare 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).
+     */
+    readonly 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
+         * ```
+         */
+        readonly read: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+        }>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>>;
+        /**
+         * 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();
+         * ```
+         */
+        readonly write: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>, import("@elaraai/east").StructType<{
+            sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * 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
+         * ```
+         */
+        readonly info: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").StructType<{
+            sheets: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                rowCount: import("@elaraai/east").IntegerType;
+                columnCount: import("@elaraai/east").IntegerType;
+            }>>;
+        }>>;
+        /**
+         * 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);
+         * ```
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for XLSX operations.
+         */
+        readonly Types: {
+            /**
+             * A single cell value in a spreadsheet (LiteralValueType).
+             */
+            readonly Cell: import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * A row of cells in a spreadsheet.
+             */
+            readonly Row: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * A 2D array representing a complete worksheet.
+             */
+            readonly Sheet: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>>;
+            /**
+             * XLSX read options configuration.
+             */
+            readonly ReadOptions: import("@elaraai/east").StructType<{
+                sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            }>;
+            /**
+             * XLSX write options configuration.
+             */
+            readonly WriteOptions: import("@elaraai/east").StructType<{
+                sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            }>;
+            /**
+             * Information about a single sheet in an XLSX file.
+             */
+            readonly SheetInfo: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                rowCount: import("@elaraai/east").IntegerType;
+                columnCount: import("@elaraai/east").IntegerType;
+            }>;
+            /**
+             * XLSX file metadata with sheet listing.
+             */
+            readonly Info: import("@elaraai/east").StructType<{
+                sheets: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    name: import("@elaraai/east").StringType;
+                    rowCount: import("@elaraai/east").IntegerType;
+                    columnCount: import("@elaraai/east").IntegerType;
+                }>>;
+            }>;
+        };
+    };
+    /**
+     * 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.
+     */
+    readonly 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
+         * ```
+         */
+        readonly parse: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            preserveWhitespace: import("@elaraai/east").BooleanType;
+            decodeEntities: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+            tag: import("@elaraai/east").StringType;
+            attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+            children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                TEXT: import("@elaraai/east").StringType;
+                ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>>>;
+        /**
+         * 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
+         * ```
+         */
+        readonly serialize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+            tag: import("@elaraai/east").StringType;
+            attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+            children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                TEXT: import("@elaraai/east").StringType;
+                ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>>, import("@elaraai/east").StructType<{
+            indent: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            includeXmlDeclaration: import("@elaraai/east").BooleanType;
+            encodeEntities: import("@elaraai/east").BooleanType;
+            selfClosingTags: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * 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);
+         * ```
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for XML operations.
+         */
+        readonly Types: {
+            /**
+             * XML parsing configuration type.
+             */
+            readonly ParseConfig: import("@elaraai/east").StructType<{
+                preserveWhitespace: import("@elaraai/east").BooleanType;
+                decodeEntities: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * XML serialization configuration type.
+             */
+            readonly SerializeConfig: import("@elaraai/east").StructType<{
+                indent: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                includeXmlDeclaration: import("@elaraai/east").BooleanType;
+                encodeEntities: import("@elaraai/east").BooleanType;
+                selfClosingTags: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * XML node recursive type (element with tag, attributes, and children).
+             */
+            readonly Node: import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+                tag: import("@elaraai/east").StringType;
+                attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+                children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                    TEXT: import("@elaraai/east").StringType;
+                    ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAe1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,MAAM;IACf;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2BG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;WAmBG;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;WAsBG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;;;YAGH;;eAEG;;;;;;;;;;IAKX;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;YAGH;;eAEG;;;;;;;YAGH;;eAEG;;;;;;;;;;;CAIL,CAAC"}