@xapi-js/core 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -1,31 +1,4 @@
-//#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);
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/types.ts
 /**
 * Defines the possible types of rows in an X-API dataset (e.g., "insert", "update", "delete").
@@ -78,7 +51,6 @@ var InvalidXmlError = class extends Error {
 		this.name = "InvalidXmlError";
 	}
 };
-
 //#endregion
 //#region src/xapi-data.ts
 /**
@@ -163,18 +135,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 +274,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.
@@ -344,35 +316,30 @@ var Dataset = class {
 		return this.rows.length;
 	}
 };
-
 //#endregion
 //#region src/utils.ts
 function arrayBufferToString(buffer) {
 	return new TextDecoder().decode(buffer);
 }
 /**
-* Creates an array of entities for parsing XML, including control characters.
-* @returns An array of objects, each with an `entity` (e.g., "&#1;") and its `value` (e.g., "\x01").
+* Pre-defined XML entities for parsing, including control characters.
+* Static array to avoid repeated allocation.
 */
-function makeParseEntities() {
-	const entities$1 = [];
-	for (let i = 1; i <= 32; i++) entities$1.push({
+const PARSE_ENTITIES = (() => {
+	const entities = [];
+	for (let i = 1; i <= 32; i++) entities.push({
 		entity: `&#${i};`,
 		value: String.fromCharCode(i)
 	});
-	return entities$1;
-}
+	return entities;
+})();
 /**
-* Creates an array of entities for writing XML, including control characters.
+* Creates an array of entities for parsing XML, including control characters.
+* @deprecated Use PARSE_ENTITIES directly for better performance
 * @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;
+function makeParseEntities() {
+	return PARSE_ENTITIES.slice();
 }
 /**
 * Converts a Base64 string to a Uint8Array.
@@ -501,10 +468,10 @@ function stringToReadableStream(str) {
 function convertToColumnType(value, type) {
 	switch (type) {
 		case "INT":
-		case "BIGDECIMAL":
 			const intValue = parseInt(value, 10);
 			return isNaN(intValue) ? value : intValue;
 		case "FLOAT":
+		case "BIGDECIMAL":
 			const floatValue = parseFloat(value);
 			return isNaN(floatValue) ? value : floatValue;
 		case "DECIMAL":
@@ -542,19 +509,338 @@ function convertToString(value, type) {
 		default: return String(value);
 	}
 }
-const entities = makeParseEntities();
+/**
+* Pre-compiled regex for control character entities.
+* Created once to avoid repeated compilation.
+*/
+const CONTROL_CHAR_ENTITY_REGEX = new RegExp(PARSE_ENTITIES.map((e) => e.entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+/**
+* Map for fast entity lookup during decoding.
+*/
+const ENTITY_MAP = new Map(PARSE_ENTITIES.map((e) => [e.entity, e.value]));
 function _unescapeXml(str) {
 	if (!str) return str;
-	const regex = new RegExp(entities.map((e) => e.entity).join("|"), "g");
-	return str.replace(regex, (match) => {
-		const entity = entities.find((e) => e.entity === match);
-		return entity ? entity.value : match;
+	if (str.indexOf("&") === -1) return str;
+	let result = str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+	result = result.replace(CONTROL_CHAR_ENTITY_REGEX, (match) => {
+		return ENTITY_MAP.get(match) || 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();
+}
+/**
+* Character codes for fast comparison
+*/
+const CHAR_SPACE = 32;
+const CHAR_TAB = 9;
+const CHAR_LF = 10;
+const CHAR_CR = 13;
+const CHAR_GT = 62;
+const CHAR_SLASH = 47;
+const CHAR_EQUALS = 61;
+const CHAR_QUOTE = 34;
+const CHAR_APOS = 39;
+/**
+* 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.matches("<?xml")) {
+				this.skipUntil("?>");
+				this.pos += 2;
+				continue;
+			}
+			if (this.matches("<!--")) {
+				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,
+			attributes: void 0,
+			children: void 0
+		};
+		const attributes = this.parseAttributes();
+		if (attributes && Object.keys(attributes).length > 0) node.attributes = attributes;
+		this.skipWhitespace();
+		if (this.matches("/>")) {
+			this.pos += 2;
+			return node;
+		}
+		if (this.current() === ">") this.pos++;
+		const children = [];
+		let textContent = "";
+		while (this.pos < this.length) {
+			if (this.matches("<![CDATA[")) {
+				const cdataText = this.parseCDATA();
+				if (cdataText !== null) textContent += cdataText;
+				continue;
+			}
+			if (this.matches("</")) {
+				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() {
+		const start = this.pos;
+		while (this.pos < this.length) {
+			const code = this.currentCharCode();
+			if (this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
+			this.pos++;
+		}
+		return this.xml.substring(start, this.pos);
+	}
+	parseAttributes() {
+		const attrs = {};
+		while (this.pos < this.length) {
+			this.skipWhitespace();
+			const ch = this.current();
+			if (ch === ">" || ch === "/" || this.matches("/>")) 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() {
+		const start = this.pos;
+		while (this.pos < this.length) {
+			const code = this.currentCharCode();
+			if (code === CHAR_EQUALS || this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
+			this.pos++;
+		}
+		return this.xml.substring(start, this.pos);
+	}
+	parseAttributeValue() {
+		const quoteCode = this.currentCharCode();
+		if (quoteCode !== CHAR_QUOTE && quoteCode !== CHAR_APOS) {
+			const start = this.pos;
+			while (this.pos < this.length) {
+				const code = this.currentCharCode();
+				if (this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
+				this.pos++;
+			}
+			return this.xml.substring(start, this.pos);
+		}
+		this.pos++;
+		const start = this.pos;
+		while (this.pos < this.length) {
+			if (this.currentCharCode() === quoteCode) {
+				const value = this.xml.substring(start, this.pos);
+				this.pos++;
+				return value;
+			}
+			this.pos++;
+		}
+		return this.xml.substring(start, this.pos);
+	}
+	parseCDATA() {
+		if (!this.matches("<![CDATA[")) return null;
+		this.pos += 9;
+		const endPos = this.findString("]]>");
+		if (endPos === -1) {
+			const content = this.xml.substring(this.pos);
+			this.pos = this.length;
+			return content;
+		}
+		const content = this.xml.substring(this.pos, endPos);
+		this.pos = endPos + 3;
+		return content;
+	}
+	skipWhitespace() {
+		while (this.pos < this.length) {
+			const code = this.currentCharCode();
+			if (code !== CHAR_SPACE && code !== CHAR_TAB && code !== CHAR_LF && code !== CHAR_CR) break;
+			this.pos++;
+		}
+	}
+	isWhitespace(code) {
+		return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_LF || code === CHAR_CR;
+	}
+	skipUntil(target) {
+		const pos = this.findString(target);
+		if (pos !== -1) this.pos = pos;
+		else this.pos = this.length;
+	}
+	current() {
+		return this.xml[this.pos];
+	}
+	currentCharCode() {
+		return this.xml.charCodeAt(this.pos);
+	}
+	/**
+	* Checks if the string at the given position matches the target string.
+	* This avoids creating substring instances for comparison.
+	* @param str - The target string to match
+	* @param pos - The position to check from (default: current position)
+	*/
+	matches(str, pos = this.pos) {
+		const len = str.length;
+		if (pos + len > this.length) return false;
+		for (let i = 0; i < len; i++) if (this.xml.charCodeAt(pos + i) !== str.charCodeAt(i)) return false;
+		return true;
+	}
+	/**
+	* Finds the position of a target string starting from the given position.
+	* @param str - The string to find
+	* @param startPos - Starting position (default: current position)
+	* @returns The position where the string is found, or -1 if not found
+	*/
+	findString(str, startPos = this.pos) {
+		const maxPos = this.length - str.length;
+		for (let pos = startPos; pos <= maxPos; pos++) if (this.matches(str, pos)) return pos;
+		return -1;
+	}
+};
 //#endregion
 //#region src/handler.ts
 let _options = {
@@ -570,12 +856,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,121 +872,130 @@ 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") {
-			if (!child.attributes || !child.attributes.id) throw new InvalidXmlError("Dataset element must have an 'id' attribute");
-			const datasetId = child.attributes.id;
-			const dataset = new Dataset(datasetId);
-			xapiRoot.addDataset(dataset);
-			const datasetChildren = child.children;
-			let columnInfoElement;
-			let rowsElement;
-			if (datasetChildren) for (let j = 0; j < datasetChildren.length; j++) {
-				const datasetChild = datasetChildren[j];
-				const childTagName = datasetChild.tagName;
-				if (childTagName === "ColumnInfo") columnInfoElement = datasetChild;
-				else if (childTagName === "Rows") rowsElement = datasetChild;
-				if (columnInfoElement && rowsElement) break;
-			}
-			parseColumnInfo(columnInfoElement, dataset);
-			parseRows(rowsElement, dataset);
-		}
+		else if (tagName === "Datasets") {
+			for (const datasetElement of child.children ?? []) if (typeof datasetElement !== "string" && datasetElement.tagName === "Dataset") parseDataset(datasetElement, xapiRoot);
+		} else if (tagName === "Dataset") parseDataset(child, xapiRoot);
 	}
 	return xapiRoot;
 }
+function parseDataset(child, xapiRoot) {
+	if (!child.attributes || !child.attributes.id) throw new InvalidXmlError("Dataset element must have an 'id' attribute");
+	const datasetId = child.attributes.id;
+	const dataset = new Dataset(datasetId);
+	xapiRoot.addDataset(dataset);
+	const datasetChildren = child.children;
+	let columnInfoElement;
+	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;
+		if (columnInfoElement && rowsElement) break;
+	}
+	parseColumnInfo(columnInfoElement, dataset);
+	parseRows(rowsElement, dataset);
+}
 function parseValue(value, type = "STRING") {
 	value = _unescapeXml(value);
 	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";
-			const value = p.children?.[0];
+			const value = p.children?.[0] ?? attrs?.value;
 			xapiRoot.addParameter({
 				id,
 				type,
@@ -710,91 +1005,179 @@ 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
+//#region src/schema.ts
+const defaultSizes = {
+	STRING: 256,
+	INT: 10,
+	FLOAT: 20,
+	DECIMAL: 20,
+	BIGDECIMAL: 30,
+	DATE: 8,
+	DATETIME: 17,
+	TIME: 6,
+	BLOB: 1e3
+};
+function column(type, options = {}) {
+	return {
+		kind: "xapi-column",
+		type,
+		size: options.size ?? defaultSizes[type],
+		optional: options.optional ?? false
+	};
+}
+function defineDataset(columns) {
+	return {
+		kind: "xapi-dataset",
+		columns
+	};
+}
+function defineRoot(definition) {
+	return {
+		kind: "xapi-root",
+		datasets: definition.datasets,
+		parameters: definition.parameters ?? {}
+	};
+}
+function defineOperation(definition) {
+	return {
+		kind: "xapi-operation",
+		...definition
+	};
+}
+const xapi = {
+	string: (options) => column("STRING", options),
+	int: (options) => column("INT", options),
+	float: (options) => column("FLOAT", options),
+	decimal: (options) => column("DECIMAL", options),
+	bigdecimal: (options) => column("BIGDECIMAL", options),
+	date: (options) => column("DATE", options),
+	datetime: (options) => column("DATETIME", options),
+	time: (options) => column("TIME", options),
+	blob: (options) => column("BLOB", options),
+	dataset: defineDataset,
+	root: defineRoot,
+	operation: defineOperation
+};
+function encodeRoot(schema, value) {
+	const root = new XapiRoot();
+	for (const [id, parameterSchema] of Object.entries(schema.parameters)) {
+		const parameterValue = value.parameters[id];
+		if (parameterValue !== void 0 || !parameterSchema.optional) root.addParameter({
+			id,
+			type: parameterSchema.type,
+			value: parameterValue
+		});
+	}
+	for (const [datasetId, datasetSchema] of Object.entries(schema.datasets)) {
+		const dataset = new Dataset(datasetId);
+		for (const [id, columnSchema] of Object.entries(datasetSchema.columns)) dataset.addColumn({
+			id,
+			type: columnSchema.type,
+			size: columnSchema.size
+		});
+		const rows = value.datasets[datasetId];
+		for (const row of rows) {
+			const rowIndex = dataset.newRow();
+			for (const id of Object.keys(datasetSchema.columns)) dataset.setColumn(rowIndex, id, row[id]);
+		}
+		root.addDataset(dataset);
+	}
+	return root;
+}
+function decodeRoot(schema, root) {
+	const parameters = {};
+	for (const id of Object.keys(schema.parameters)) {
+		const value = root.getParameter(id)?.value;
+		if (value !== void 0) parameters[id] = value;
+	}
+	const datasets = {};
+	for (const [datasetId, datasetSchema] of Object.entries(schema.datasets)) {
+		const dataset = root.getDataset(datasetId);
+		if (!dataset) {
+			datasets[datasetId] = [];
+			continue;
+		}
+		const constants = Object.fromEntries(dataset.getConstColumns().map(({ id, value }) => [id, value]));
+		datasets[datasetId] = dataset.getRows().map((row) => {
+			const value = { ...constants };
+			for (const column of row.cols) if (column.id in datasetSchema.columns) value[column.id] = column.value;
+			return value;
+		});
+	}
+	return {
+		parameters,
+		datasets
+	};
 }
-
 //#endregion
 exports.ColumnTypeError = ColumnTypeError;
 exports.Dataset = Dataset;
@@ -802,6 +1185,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,13 +1194,21 @@ exports.columnType = columnType;
 exports.convertToColumnType = convertToColumnType;
 exports.convertToString = convertToString;
 exports.dateToString = dateToString;
+exports.decodeRoot = decodeRoot;
+exports.defineDataset = defineDataset;
+exports.defineOperation = defineOperation;
+exports.defineRoot = defineRoot;
+exports.encodeControlChars = encodeControlChars;
+exports.encodeRoot = encodeRoot;
+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;
 exports.uint8ArrayToBase64 = uint8ArrayToBase64;
-exports.write = write;
+exports.write = write;
+exports.xapi = xapi;