@xapi-js/core 1.2.0 → 1.3.0

package/dist/index.cjs

@@ -1,30 +1,3 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let stax_xml = require("stax-xml");
-stax_xml = __toESM(stax_xml);
-let txml = require("txml");
-txml = __toESM(txml);
 
 //#region src/types.ts
 /**
@@ -163,18 +136,18 @@ var XapiRoot = class {
 		return this.datasets.length;
 	}
 	/**
-	* Iterates over the parameters.
-	* @returns An IterableIterator for parameters.
+	* Returns all parameters as an array.
+	* @returns An array of parameters.
 	*/
-	*iterParameters() {
-		for (const param of this.parameters.params) yield param;
+	getParameters() {
+		return this.parameters.params;
 	}
 	/**
-	* Iterates over the datasets.
-	* @returns An IterableIterator for datasets.
+	* Returns all datasets as an array.
+	* @returns An array of datasets.
 	*/
-	*iterDatasets() {
-		for (const dataset of this.datasets) yield dataset;
+	getDatasets() {
+		return this.datasets;
 	}
 };
 /**
@@ -302,25 +275,25 @@ var Dataset = class {
 		} else throw new Error(`Row index ${rowIdx} out of bounds in dataset ${this.id}`);
 	}
 	/**
-	* Iterates over the constant column definitions.
-	* @returns An IterableIterator for constant columns.
+	* Returns all constant column definitions as an array.
+	* @returns An array of constant columns.
 	*/
-	*iterConstColumns() {
-		for (const column of this.constColumns) yield column;
+	getConstColumns() {
+		return this.constColumns;
 	}
 	/**
-	* Iterates over the column definitions.
-	* @returns An IterableIterator for columns.
+	* Returns all column definitions as an array.
+	* @returns An array of columns.
 	*/
-	*iterColumns() {
-		for (const column of this.columns) yield column;
+	getColumns() {
+		return this.columns;
 	}
 	/**
-	* Iterates over the rows in the dataset.
-	* @returns An IterableIterator for rows.
+	* Returns all rows in the dataset as an array.
+	* @returns An array of rows.
 	*/
-	*iterRows() {
-		for (const row of this.rows) yield row;
+	getRows() {
+		return this.rows;
 	}
 	/**
 	* Returns the number of column definitions.
@@ -363,18 +336,6 @@ function makeParseEntities() {
 	return entities$1;
 }
 /**
-* Creates an array of entities for writing XML, including control characters.
-* @returns An array of objects, each with an `entity` (e.g., "&#1;") and its `value` (e.g., "\x01").
-*/
-function makeWriterEntities() {
-	const entities$1 = [];
-	for (let i = 1; i <= 32; i++) entities$1.push({
-		entity: `&#${i};`,
-		value: String.fromCharCode(i)
-	});
-	return entities$1;
-}
-/**
 * Converts a Base64 string to a Uint8Array.
 * @param base64String - The Base64 string to convert.
 * @returns A Uint8Array.
@@ -545,15 +506,291 @@ function convertToString(value, type) {
 const entities = makeParseEntities();
 function _unescapeXml(str) {
 	if (!str) return str;
+	let result = str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
 	const regex = new RegExp(entities.map((e) => e.entity).join("|"), "g");
-	return str.replace(regex, (match) => {
+	result = result.replace(regex, (match) => {
 		const entity = entities.find((e) => e.entity === match);
 		return entity ? entity.value : match;
 	});
+	return result;
 }
 function isXapiRoot(value) {
 	return value instanceof XapiRoot;
 }
+/**
+* Escapes XML special characters in a string.
+* @param str - The string to escape.
+* @returns The escaped string.
+*/
+function escapeXml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/**
+* Encodes control characters as XML entities, excluding standard whitespace.
+* Encodes 0x01-0x08, 0x0B-0x0C, 0x0E-0x1F but NOT 0x09 (tab), 0x0A (LF), 0x0D (CR), 0x20 (space).
+* @param str - The string to encode.
+* @returns The encoded string.
+*/
+function encodeControlChars(str) {
+	let result = "";
+	for (let i = 0; i < str.length; i++) {
+		const charCode = str.charCodeAt(i);
+		if (charCode >= 1 && charCode <= 8 || charCode >= 11 && charCode <= 12 || charCode >= 14 && charCode <= 31) result += `&#${charCode};`;
+		else result += str[i];
+	}
+	return result;
+}
+/**
+* A string builder for generating formatted XML.
+*/
+var XmlStringBuilder = class {
+	lines = [];
+	indentLevel = 0;
+	indentString = "  ";
+	/**
+	* Writes the XML declaration.
+	* @param version - The XML version (default: "1.0").
+	* @param encoding - The encoding (default: "UTF-8").
+	*/
+	writeDeclaration(version = "1.0", encoding = "UTF-8") {
+		this.lines.push(`<?xml version="${version}" encoding="${encoding}"?>`);
+	}
+	/**
+	* Writes a start element tag.
+	* @param name - The element name.
+	* @param attributes - Optional attributes object.
+	* @param selfClosing - Whether to create a self-closing tag.
+	*/
+	writeStartElement(name, attributes, selfClosing) {
+		let tag = `${this.indentString.repeat(this.indentLevel)}<${name}`;
+		if (attributes) for (const [key, value] of Object.entries(attributes)) {
+			const encodedValue = encodeControlChars(escapeXml(value));
+			tag += ` ${key}="${encodedValue}"`;
+		}
+		if (selfClosing) {
+			tag += "/>";
+			this.lines.push(tag);
+		} else {
+			tag += ">";
+			this.lines.push(tag);
+			this.indentLevel++;
+		}
+	}
+	/**
+	* Writes an end element tag.
+	* @param name - The element name.
+	*/
+	writeEndElement(name) {
+		this.indentLevel--;
+		const indent = this.indentString.repeat(this.indentLevel);
+		this.lines.push(`${indent}</${name}>`);
+	}
+	/**
+	* Writes an element with text content.
+	* @param name - The element name.
+	* @param attributes - Optional attributes object.
+	* @param text - The text content.
+	*/
+	writeElementWithText(name, attributes, text) {
+		let tag = `${this.indentString.repeat(this.indentLevel)}<${name}`;
+		if (attributes) for (const [key, value] of Object.entries(attributes)) {
+			const encodedValue = encodeControlChars(escapeXml(value));
+			tag += ` ${key}="${encodedValue}"`;
+		}
+		const encodedText = encodeControlChars(escapeXml(text));
+		tag += `>${encodedText}</${name}>`;
+		this.lines.push(tag);
+	}
+	/**
+	* Returns the generated XML string.
+	* @returns The complete XML string with line breaks.
+	*/
+	toString() {
+		return this.lines.join("\n") + "\n";
+	}
+};
+/**
+* Parses XML string into an XML node structure.
+* This is a lightweight parser optimized for X-API XML structure.
+*
+* @param xml - The XML string to parse.
+* @returns An array of parsed XML nodes.
+*/
+function parseXml(xml) {
+	if (!xml || xml.trim() === "") return [];
+	return new XapiXmlParser(xml).parse();
+}
+/**
+* A lightweight XML parser optimized for X-API structure.
+*/
+var XapiXmlParser = class {
+	xml;
+	pos = 0;
+	length;
+	constructor(xml) {
+		this.xml = xml;
+		this.length = xml.length;
+	}
+	parse() {
+		const nodes = [];
+		while (this.pos < this.length) {
+			this.skipWhitespace();
+			if (this.pos >= this.length) break;
+			if (this.peek(5) === "<?xml") {
+				this.skipUntil("?>");
+				this.pos += 2;
+				continue;
+			}
+			if (this.peek(4) === "<!--") {
+				this.skipUntil("-->");
+				this.pos += 3;
+				continue;
+			}
+			if (this.current() === "<") {
+				const node = this.parseElement();
+				if (node) nodes.push(node);
+			} else this.pos++;
+		}
+		return nodes;
+	}
+	parseElement() {
+		if (this.current() !== "<") return null;
+		this.pos++;
+		if (this.current() === "/") return null;
+		const tagName = this.parseTagName();
+		if (!tagName) return null;
+		const node = { tagName };
+		const attributes = this.parseAttributes();
+		if (attributes && Object.keys(attributes).length > 0) node.attributes = attributes;
+		this.skipWhitespace();
+		if (this.peek(2) === "/>") {
+			this.pos += 2;
+			return node;
+		}
+		if (this.current() === ">") this.pos++;
+		const children = [];
+		let textContent = "";
+		while (this.pos < this.length) {
+			if (this.peek(9) === "<![CDATA[") {
+				const cdataText = this.parseCDATA();
+				if (cdataText !== null) textContent += cdataText;
+				continue;
+			}
+			if (this.peek(2) === "</") {
+				if (textContent) children.push(textContent);
+				this.pos += 2;
+				this.skipUntil(">");
+				this.pos++;
+				break;
+			}
+			if (this.current() === "<") {
+				if (textContent.trim()) {
+					children.push(textContent);
+					textContent = "";
+				}
+				const child = this.parseElement();
+				if (child) children.push(child);
+			} else {
+				textContent += this.current();
+				this.pos++;
+			}
+		}
+		if (children.length > 0) node.children = children;
+		return node;
+	}
+	parseTagName() {
+		let name = "";
+		while (this.pos < this.length) {
+			const ch = this.current();
+			if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
+			name += ch;
+			this.pos++;
+		}
+		return name;
+	}
+	parseAttributes() {
+		const attrs = {};
+		while (this.pos < this.length) {
+			this.skipWhitespace();
+			const ch = this.current();
+			if (ch === ">" || ch === "/" || this.peek(2) === "/>") break;
+			const attrName = this.parseAttributeName();
+			if (!attrName) break;
+			this.skipWhitespace();
+			if (this.current() === "=") this.pos++;
+			this.skipWhitespace();
+			attrs[attrName] = this.parseAttributeValue();
+		}
+		return Object.keys(attrs).length > 0 ? attrs : void 0;
+	}
+	parseAttributeName() {
+		let name = "";
+		while (this.pos < this.length) {
+			const ch = this.current();
+			if (ch === "=" || ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
+			name += ch;
+			this.pos++;
+		}
+		return name;
+	}
+	parseAttributeValue() {
+		let value = "";
+		const quote = this.current();
+		if (quote !== "\"" && quote !== "'") {
+			while (this.pos < this.length) {
+				const ch = this.current();
+				if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
+				value += ch;
+				this.pos++;
+			}
+			return value;
+		}
+		this.pos++;
+		while (this.pos < this.length) {
+			const ch = this.current();
+			if (ch === quote) {
+				this.pos++;
+				break;
+			}
+			value += ch;
+			this.pos++;
+		}
+		return value;
+	}
+	parseCDATA() {
+		if (this.peek(9) !== "<![CDATA[") return null;
+		this.pos += 9;
+		let content = "";
+		while (this.pos < this.length) {
+			if (this.peek(3) === "]]>") {
+				this.pos += 3;
+				break;
+			}
+			content += this.current();
+			this.pos++;
+		}
+		return content;
+	}
+	skipWhitespace() {
+		while (this.pos < this.length) {
+			const ch = this.current();
+			if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") break;
+			this.pos++;
+		}
+	}
+	skipUntil(target) {
+		while (this.pos < this.length) {
+			if (this.peek(target.length) === target) break;
+			this.pos++;
+		}
+	}
+	current() {
+		return this.xml[this.pos];
+	}
+	peek(length) {
+		return this.xml.substring(this.pos, this.pos + length);
+	}
+};
 
 //#endregion
 //#region src/handler.ts
@@ -570,12 +807,12 @@ function initXapi(options) {
 	_options = { ...options };
 }
 /**
-* Parses an XML string into an XapiRoot object using txml.
+* Parses an XML string into an XapiRoot object using custom parser.
 * @param xml - The string containing the XML data.
-* @returns A Promise that resolves to an XapiRoot object.
+* @returns An XapiRoot object.
 */
 function parse(xml) {
-	const parsedXml = txml.parse(xml);
+	const parsedXml = parseXml(xml);
 	const xapiRoot = new XapiRoot();
 	let rootElement;
 	for (let i = 0; i < parsedXml.length; i++) if (parsedXml[i].tagName === "Root") {
@@ -586,6 +823,7 @@ function parse(xml) {
 	const rootChildren = rootElement.children;
 	if (rootChildren && rootChildren.length > 0) for (let i = 0; i < rootChildren.length; i++) {
 		const child = rootChildren[i];
+		if (typeof child === "string") continue;
 		const tagName = child.tagName;
 		if (tagName === "Parameters") parseParameters(child, xapiRoot);
 		else if (tagName === "Dataset") {
@@ -598,6 +836,7 @@ function parse(xml) {
 			let rowsElement;
 			if (datasetChildren) for (let j = 0; j < datasetChildren.length; j++) {
 				const datasetChild = datasetChildren[j];
+				if (typeof datasetChild === "string") continue;
 				const childTagName = datasetChild.tagName;
 				if (childTagName === "ColumnInfo") columnInfoElement = datasetChild;
 				else if (childTagName === "Rows") rowsElement = datasetChild;
@@ -614,89 +853,93 @@ function parseValue(value, type = "STRING") {
 	return _options.parseToTypes ? convertToColumnType(value, type) : value;
 }
 function parseColumnInfo(columnInfoElement, dataset) {
-	if (!columnInfoElement) throw new InvalidXmlError("ColumnInfo element is missing in the dataset");
+	if (!columnInfoElement || typeof columnInfoElement === "string") throw new InvalidXmlError("ColumnInfo element is missing in the dataset");
 	const children = columnInfoElement.children;
 	if (!children) return;
 	for (let i = 0; i < children.length; i++) {
 		const colInfo = children[i];
-		const tagName = colInfo.tagName;
-		if (tagName === "ConstColumn") {
-			const attrs = colInfo.attributes;
-			const sizeStr = attrs?.size;
-			dataset.addConstColumn({
-				id: attrs?.id,
-				size: sizeStr ? parseInt(sizeStr, 10) : 0,
-				type: attrs?.type || "STRING",
-				value: parseValue(attrs?.value, attrs?.type)
-			});
-		} else if (tagName === "Column") {
-			const attrs = colInfo.attributes;
-			const sizeStr = attrs?.size;
-			dataset.addColumn({
-				id: attrs?.id,
-				size: sizeStr ? parseInt(sizeStr, 10) : 0,
-				type: attrs?.type || "STRING"
-			});
+		if (typeof colInfo !== "string") {
+			const tagName = colInfo.tagName;
+			if (tagName === "ConstColumn") {
+				const attrs = colInfo.attributes;
+				const sizeStr = attrs?.size;
+				dataset.addConstColumn({
+					id: attrs?.id,
+					size: sizeStr ? parseInt(sizeStr, 10) : 0,
+					type: attrs?.type || "STRING",
+					value: parseValue(attrs?.value, attrs?.type)
+				});
+			} else if (tagName === "Column") {
+				const attrs = colInfo.attributes;
+				const sizeStr = attrs?.size;
+				dataset.addColumn({
+					id: attrs?.id,
+					size: sizeStr ? parseInt(sizeStr, 10) : 0,
+					type: attrs?.type || "STRING"
+				});
+			}
 		}
 	}
 }
 function parseRows(rowsElement, dataset) {
+	if (typeof rowsElement === "string") return;
 	const rows = rowsElement?.children;
 	if (!rows) return;
 	const datasetRows = dataset.rows;
 	for (let i = 0; i < rows.length; i++) {
 		const r = rows[i];
-		const tagName = r.tagName;
-		if (tagName === "Row") {
-			const rowIndex = dataset.newRow();
-			const currentRow = datasetRows[rowIndex];
-			currentRow.type = r.attributes?.type || void 0;
-			const cols = r.children;
-			if (!cols) continue;
-			for (let j = 0; j < cols.length; j++) {
-				const col = cols[j];
-				const colTagName = col.tagName;
-				if (colTagName === "Col") {
-					const colId = col.attributes?.id;
-					const value = col.children?.[0];
-					const columnInfo = dataset.getColumnInfo(colId);
-					if (!columnInfo) throw new InvalidXmlError(`Column with id ${colId} not found in dataset ${dataset.id}`);
-					const castedValue = parseValue(value, columnInfo.type);
-					currentRow.cols.push({
-						id: colId,
-						value: castedValue
-					});
-				} else if (colTagName === "OrgRow") {
-					const orgRow = [];
-					currentRow.orgRow = orgRow;
-					const orgCols = col.children;
-					if (!orgCols) continue;
-					for (let k = 0; k < orgCols.length; k++) {
-						const orgCol = orgCols[k];
-						if (orgCol.tagName === "Col") {
-							const colId = orgCol.attributes?.id;
-							const value = orgCol.children?.[0];
+		if (typeof r !== "string") {
+			const tagName = r.tagName;
+			if (tagName === "Row") {
+				const currentRow = datasetRows[dataset.newRow()];
+				currentRow.type = r.attributes?.type || void 0;
+				const cols = r.children;
+				if (cols) for (let j = 0; j < cols.length; j++) {
+					const col = cols[j];
+					if (typeof col !== "string") {
+						const colTagName = col.tagName;
+						if (colTagName === "Col") {
+							const colId = col.attributes?.id;
+							const value = col.children?.[0];
 							const columnInfo = dataset.getColumnInfo(colId);
+							if (!columnInfo) throw new InvalidXmlError(`Column with id ${colId} not found in dataset ${dataset.id}`);
 							const castedValue = parseValue(value, columnInfo.type);
-							orgRow.push({
+							currentRow.cols.push({
 								id: colId,
 								value: castedValue
 							});
+						} else if (colTagName === "OrgRow") {
+							const orgRow = [];
+							currentRow.orgRow = orgRow;
+							const orgCols = col.children;
+							if (orgCols) for (let k = 0; k < orgCols.length; k++) {
+								const orgCol = orgCols[k];
+								if (typeof orgCol !== "string" && orgCol.tagName === "Col") {
+									const colId = orgCol.attributes?.id;
+									const value = orgCol.children?.[0];
+									const castedValue = parseValue(value, dataset.getColumnInfo(colId).type);
+									orgRow.push({
+										id: colId,
+										value: castedValue
+									});
+								}
+							}
 						}
 					}
 				}
-			}
-		} else if (tagName === "Col") throw new InvalidXmlError("Row must be defined before Col");
-		else if (tagName === "OrgRow") throw new InvalidXmlError("Row must be defined before OrgRow");
+			} else if (tagName === "Col") throw new InvalidXmlError("Row must be defined before Col");
+			else if (tagName === "OrgRow") throw new InvalidXmlError("Row must be defined before OrgRow");
+		}
 	}
 }
 function parseParameters(parametersElement, xapiRoot) {
+	if (typeof parametersElement === "string") return;
 	if (!parametersElement) return;
 	const children = parametersElement.children;
 	if (!children) return;
 	for (let i = 0; i < children.length; i++) {
 		const p = children[i];
-		if (p.tagName === "Parameter") {
+		if (typeof p !== "string" && p.tagName === "Parameter") {
 			const attrs = p.attributes;
 			const id = attrs?.id;
 			const type = attrs?.type || "STRING";
@@ -710,89 +953,73 @@ function parseParameters(parametersElement, xapiRoot) {
 	}
 }
 function write(root) {
-	const writer = new stax_xml.StaxXmlWriterSync({
-		addEntities: makeWriterEntities(),
-		encoding: "UTF-8",
-		indentString: "  ",
-		prettyPrint: true
-	});
-	writer.writeStartDocument("1.0", "UTF-8");
-	writer.writeStartElement("Root", { attributes: {
+	const builder = new XmlStringBuilder();
+	builder.writeDeclaration("1.0", "UTF-8");
+	builder.writeStartElement("Root", {
 		xmlns: _options.xapiVersion?.xmlns || NexaVersion.xmlns,
 		version: _options.xapiVersion?.version || NexaVersion.version
-	} });
-	if (root.parameterSize() > 0) writeParameters(writer, root.iterParameters());
+	});
+	if (root.parameterSize() > 0) writeParameters(builder, root.getParameters());
 	if (root.datasetSize() > 0) {
-		writer.writeStartElement("Datasets");
-		for (const dataset of root.iterDatasets()) writeDataset(writer, dataset);
-		writer.writeEndElement();
+		builder.writeStartElement("Datasets");
+		for (const dataset of root.getDatasets()) writeDataset(builder, dataset);
+		builder.writeEndElement("Datasets");
 	}
-	writer.writeEndElement();
-	return writer.getXmlString();
+	builder.writeEndElement("Root");
+	return builder.toString();
 }
-function writeParameters(writer, iterator) {
-	if (iterator) {
-		writer.writeStartElement("Parameters");
-		for (const parameter of iterator) {
-			writer.writeStartElement("Parameter", { attributes: { id: parameter.id } });
-			if (parameter.type !== void 0) writer.writeAttribute("type", parameter.type);
-			if (parameter.value !== void 0) if (typeof parameter.value === "string") writer.writeAttribute("value", parameter.value);
-			else if (parameter.value instanceof Date) writer.writeAttribute("value", dateToString(parameter.value, parameter.type));
-			else if (parameter.value instanceof Uint8Array) writer.writeAttribute("value", uint8ArrayToBase64(parameter.value));
-			else writer.writeAttribute("value", String(parameter.value));
-			writer.writeEndElement();
+function writeParameters(builder, parameters) {
+	if (parameters) {
+		builder.writeStartElement("Parameters");
+		for (const parameter of parameters) {
+			const attrs = { id: parameter.id };
+			if (parameter.type !== void 0) attrs.type = parameter.type;
+			if (parameter.value !== void 0) if (typeof parameter.value === "string") attrs.value = parameter.value;
+			else if (parameter.value instanceof Date) attrs.value = dateToString(parameter.value, parameter.type);
+			else if (parameter.value instanceof Uint8Array) attrs.value = uint8ArrayToBase64(parameter.value);
+			else attrs.value = String(parameter.value);
+			builder.writeStartElement("Parameter", attrs, true);
 		}
-		writer.writeEndElement();
+		builder.writeEndElement("Parameters");
 	}
 }
-function writeDataset(writer, dataset) {
-	writer.writeStartElement("Dataset", { attributes: { id: dataset.id } });
+function writeDataset(builder, dataset) {
+	builder.writeStartElement("Dataset", { id: dataset.id });
 	if (dataset.constColumnSize() > 0 || dataset.columnSize() > 0) {
-		writer.writeStartElement("ColumnInfo");
-		for (const constCol of dataset.iterConstColumns()) writer.writeStartElement("ConstColumn", {
-			attributes: {
-				id: constCol.id,
-				size: String(constCol.size),
-				type: constCol.type,
-				value: constCol.value !== void 0 ? String(constCol.value) : ""
-			},
-			selfClosing: true
-		});
-		for (const col of dataset.iterColumns()) writer.writeStartElement("Column", {
-			attributes: {
-				id: col.id,
-				size: String(col.size),
-				type: col.type
-			},
-			selfClosing: true
-		});
-		writer.writeEndElement();
+		builder.writeStartElement("ColumnInfo");
+		for (const constCol of dataset.getConstColumns()) builder.writeStartElement("ConstColumn", {
+			id: constCol.id,
+			size: String(constCol.size),
+			type: constCol.type,
+			value: constCol.value !== void 0 ? String(constCol.value) : ""
+		}, true);
+		for (const col of dataset.getColumns()) builder.writeStartElement("Column", {
+			id: col.id,
+			size: String(col.size),
+			type: col.type
+		}, true);
+		builder.writeEndElement("ColumnInfo");
 	}
-	writer.writeStartElement("Rows");
-	for (const row of dataset.iterRows()) {
-		if (row.type) writer.writeStartElement("Row", { attributes: { type: row.type } });
-		else writer.writeStartElement("Row");
-		for (const col of row.cols) writeColumn(writer, dataset, col);
+	builder.writeStartElement("Rows");
+	for (const row of dataset.getRows()) {
+		if (row.type) builder.writeStartElement("Row", { type: row.type });
+		else builder.writeStartElement("Row");
+		for (const col of row.cols) writeColumn(builder, dataset, col);
 		if (row.orgRow && row.orgRow.length > 0) {
-			writer.writeStartElement("OrgRow");
-			for (const orgCol of row.orgRow) writeColumn(writer, dataset, orgCol);
-			writer.writeEndElement();
+			builder.writeStartElement("OrgRow");
+			for (const orgCol of row.orgRow) writeColumn(builder, dataset, orgCol);
+			builder.writeEndElement("OrgRow");
 		}
-		writer.writeEndElement();
+		builder.writeEndElement("Row");
 	}
-	writer.writeEndElement();
-	writer.writeEndElement();
+	builder.writeEndElement("Rows");
+	builder.writeEndElement("Dataset");
 }
-function writeColumn(writer, dataset, col) {
+function writeColumn(builder, dataset, col) {
 	if (col.value !== void 0 && col.value !== null) {
 		const colInfo = dataset.getColumnInfo(col.id);
-		writer.writeStartElement("Col", { attributes: { id: col.id } });
-		writer.writeCharacters(convertToString(col.value, colInfo.type));
-		writer.writeEndElement();
-	} else writer.writeStartElement("Col", {
-		attributes: { id: col.id },
-		selfClosing: true
-	});
+		builder.writeElementWithText("Col", { id: col.id }, convertToString(col.value, colInfo.type));
+	} else builder.writeStartElement("Col", { id: col.id }, true);
 }
 
 //#endregion
@@ -802,6 +1029,7 @@ exports.InvalidXmlError = InvalidXmlError;
 exports.NexaVersion = NexaVersion;
 exports.StringWritableStream = StringWritableStream;
 exports.XapiRoot = XapiRoot;
+exports.XmlStringBuilder = XmlStringBuilder;
 exports.XplatformVersion = XplatformVersion;
 exports._unescapeXml = _unescapeXml;
 exports.arrayBufferToString = arrayBufferToString;
@@ -810,11 +1038,13 @@ exports.columnType = columnType;
 exports.convertToColumnType = convertToColumnType;
 exports.convertToString = convertToString;
 exports.dateToString = dateToString;
+exports.encodeControlChars = encodeControlChars;
+exports.escapeXml = escapeXml;
 exports.initXapi = initXapi;
 exports.isXapiRoot = isXapiRoot;
 exports.makeParseEntities = makeParseEntities;
-exports.makeWriterEntities = makeWriterEntities;
 exports.parse = parse;
+exports.parseXml = parseXml;
 exports.rowType = rowType;
 exports.stringToDate = stringToDate;
 exports.stringToReadableStream = stringToReadableStream;