astro-loader-goodreads/dist/index.js

Load data from Goodreads in Astro

"use strict";
//#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
const astro_zod = __toESM(require("astro/zod"));

//#region src/schema.ts
const BookSchema = astro_zod.z.object({
	id: astro_zod.z.coerce.string(),
	title: astro_zod.z.coerce.string(),
	guid: astro_zod.z.string(),
	pubDate: astro_zod.z.string(),
	link: astro_zod.z.string(),
	book_id: astro_zod.z.coerce.string(),
	book_image_url: astro_zod.z.string(),
	book_small_image_url: astro_zod.z.string(),
	book_medium_image_url: astro_zod.z.string(),
	book_large_image_url: astro_zod.z.string(),
	book_description: astro_zod.z.string(),
	num_pages: astro_zod.z.string().optional(),
	author_name: astro_zod.z.string(),
	isbn: astro_zod.z.coerce.string(),
	user_name: astro_zod.z.string(),
	user_rating: astro_zod.z.number(),
	user_read_at: astro_zod.z.string(),
	user_date_added: astro_zod.z.string(),
	user_date_created: astro_zod.z.string(),
	user_shelves: astro_zod.z.string().optional(),
	user_review: astro_zod.z.string().optional(),
	average_rating: astro_zod.z.number(),
	book_published: astro_zod.z.coerce.string()
});
const AuthorBlogSchema = astro_zod.z.object({
	id: astro_zod.z.string(),
	title: astro_zod.z.string(),
	link: astro_zod.z.string(),
	description: astro_zod.z.string(),
	pubDate: astro_zod.z.string(),
	author: astro_zod.z.string().optional(),
	content: astro_zod.z.string().optional()
});
/**
* Discriminated union for different types of user updates.
*/
const ItemDataSchema = astro_zod.z.discriminatedUnion("type", [
	astro_zod.z.object({
		type: astro_zod.z.literal("AuthorFollowing"),
		followId: astro_zod.z.string(),
		userUrl: astro_zod.z.string(),
		authorId: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("UserStatus"),
		userUrl: astro_zod.z.string(),
		percentRead: astro_zod.z.string(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string(),
		bookAuthor: astro_zod.z.string(),
		bookImgUrl: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("ReadStatus"),
		userUrl: astro_zod.z.string(),
		readingStatus: astro_zod.z.string(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string(),
		bookAuthor: astro_zod.z.string(),
		bookImgUrl: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("Review"),
		userUrl: astro_zod.z.string(),
		rating: astro_zod.z.number(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string(),
		bookAuthor: astro_zod.z.string(),
		bookImgUrl: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("LikeReview"),
		userUrl: astro_zod.z.string(),
		reviewUrl: astro_zod.z.string(),
		reviewUser: astro_zod.z.string(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string(),
		bookImgUrl: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("LikeReadStatus"),
		userUrl: astro_zod.z.string(),
		readStatusUser: astro_zod.z.string(),
		readStatusUserImgUrl: astro_zod.z.string(),
		readStatus: astro_zod.z.string(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("CommentStatus"),
		userUrl: astro_zod.z.string(),
		statusUrl: astro_zod.z.string(),
		statusUser: astro_zod.z.string(),
		comment: astro_zod.z.string()
	}),
	astro_zod.z.object({
		type: astro_zod.z.literal("CommentReview"),
		userUrl: astro_zod.z.string(),
		reviewUrl: astro_zod.z.string(),
		reviewUser: astro_zod.z.string(),
		bookUrl: astro_zod.z.string(),
		bookTitle: astro_zod.z.string(),
		bookAuthor: astro_zod.z.string(),
		comment: astro_zod.z.string()
	})
]);
const UserUpdateSchema = astro_zod.z.object({
	id: astro_zod.z.string(),
	title: astro_zod.z.string(),
	link: astro_zod.z.string().optional(),
	description: astro_zod.z.string().optional(),
	pubDate: astro_zod.z.string(),
	itemType: astro_zod.z.string().optional(),
	itemData: ItemDataSchema.optional()
});

//#endregion
//#region node_modules/fast-xml-parser/src/util.js
const nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
const nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
const nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
const regexName = new RegExp("^" + nameRegexp + "$");
function getAllMatches(string, regex) {
	const matches = [];
	let match = regex.exec(string);
	while (match) {
		const allmatches = [];
		allmatches.startIndex = regex.lastIndex - match[0].length;
		const len = match.length;
		for (let index = 0; index < len; index++) allmatches.push(match[index]);
		matches.push(allmatches);
		match = regex.exec(string);
	}
	return matches;
}
const isName = function(string) {
	const match = regexName.exec(string);
	return !(match === null || typeof match === "undefined");
};
function isExist(v) {
	return typeof v !== "undefined";
}

//#endregion
//#region node_modules/fast-xml-parser/src/validator.js
const defaultOptions$2 = {
	allowBooleanAttributes: false,
	unpairedTags: []
};
function validate(xmlData, options) {
	options = Object.assign({}, defaultOptions$2, options);
	const tags = [];
	let tagFound = false;
	let reachedRoot = false;
	if (xmlData[0] === "") xmlData = xmlData.substr(1);
	for (let i = 0; i < xmlData.length; i++) if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
		i += 2;
		i = readPI(xmlData, i);
		if (i.err) return i;
	} else if (xmlData[i] === "<") {
		let tagStartPos = i;
		i++;
		if (xmlData[i] === "!") {
			i = readCommentAndCDATA(xmlData, i);
			continue;
		} else {
			let closingTag = false;
			if (xmlData[i] === "/") {
				closingTag = true;
				i++;
			}
			let tagName = "";
			for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) tagName += xmlData[i];
			tagName = tagName.trim();
			if (tagName[tagName.length - 1] === "/") {
				tagName = tagName.substring(0, tagName.length - 1);
				i--;
			}
			if (!validateTagName(tagName)) {
				let msg;
				if (tagName.trim().length === 0) msg = "Invalid space after '<'.";
				else msg = "Tag '" + tagName + "' is an invalid name.";
				return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
			}
			const result = readAttributeStr(xmlData, i);
			if (result === false) return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
			let attrStr = result.value;
			i = result.index;
			if (attrStr[attrStr.length - 1] === "/") {
				const attrStrStart = i - attrStr.length;
				attrStr = attrStr.substring(0, attrStr.length - 1);
				const isValid = validateAttributeString(attrStr, options);
				if (isValid === true) tagFound = true;
				else return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
			} else if (closingTag) if (!result.tagClosed) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
			else if (attrStr.trim().length > 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
			else if (tags.length === 0) return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
			else {
				const otg = tags.pop();
				if (tagName !== otg.tagName) {
					let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
					return getErrorObject("InvalidTag", "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", getLineNumberForPosition(xmlData, tagStartPos));
				}
				if (tags.length == 0) reachedRoot = true;
			}
			else {
				const isValid = validateAttributeString(attrStr, options);
				if (isValid !== true) return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
				if (reachedRoot === true) return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
				else if (options.unpairedTags.indexOf(tagName) !== -1) {} else tags.push({
					tagName,
					tagStartPos
				});
				tagFound = true;
			}
			for (i++; i < xmlData.length; i++) if (xmlData[i] === "<") if (xmlData[i + 1] === "!") {
				i++;
				i = readCommentAndCDATA(xmlData, i);
				continue;
			} else if (xmlData[i + 1] === "?") {
				i = readPI(xmlData, ++i);
				if (i.err) return i;
			} else break;
			else if (xmlData[i] === "&") {
				const afterAmp = validateAmpersand(xmlData, i);
				if (afterAmp == -1) return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
				i = afterAmp;
			} else if (reachedRoot === true && !isWhiteSpace(xmlData[i])) return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
			if (xmlData[i] === "<") i--;
		}
	} else {
		if (isWhiteSpace(xmlData[i])) continue;
		return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
	}
	if (!tagFound) return getErrorObject("InvalidXml", "Start tag expected.", 1);
	else if (tags.length == 1) return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
	else if (tags.length > 0) return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", {
		line: 1,
		col: 1
	});
	return true;
}
function isWhiteSpace(char) {
	return char === " " || char === "	" || char === "\n" || char === "\r";
}
/**
* Read Processing insstructions and skip
* @param {*} xmlData
* @param {*} i
*/
function readPI(xmlData, i) {
	const start = i;
	for (; i < xmlData.length; i++) if (xmlData[i] == "?" || xmlData[i] == " ") {
		const tagname = xmlData.substr(start, i - start);
		if (i > 5 && tagname === "xml") return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
		else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
			i++;
			break;
		} else continue;
	}
	return i;
}
function readCommentAndCDATA(xmlData, i) {
	if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
		for (i += 3; i < xmlData.length; i++) if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
			i += 2;
			break;
		}
	} else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
		let angleBracketsCount = 1;
		for (i += 8; i < xmlData.length; i++) if (xmlData[i] === "<") angleBracketsCount++;
		else if (xmlData[i] === ">") {
			angleBracketsCount--;
			if (angleBracketsCount === 0) break;
		}
	} else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
		for (i += 8; i < xmlData.length; i++) if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
			i += 2;
			break;
		}
	}
	return i;
}
const doubleQuote = "\"";
const singleQuote = "'";
/**
* Keep reading xmlData until '<' is found outside the attribute value.
* @param {string} xmlData
* @param {number} i
*/
function readAttributeStr(xmlData, i) {
	let attrStr = "";
	let startChar = "";
	let tagClosed = false;
	for (; i < xmlData.length; i++) {
		if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) if (startChar === "") startChar = xmlData[i];
		else if (startChar !== xmlData[i]) {} else startChar = "";
		else if (xmlData[i] === ">") {
			if (startChar === "") {
				tagClosed = true;
				break;
			}
		}
		attrStr += xmlData[i];
	}
	if (startChar !== "") return false;
	return {
		value: attrStr,
		index: i,
		tagClosed
	};
}
/**
* Select all the attributes whether valid or invalid.
*/
const validAttrStrRegxp = new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?", "g");
function validateAttributeString(attrStr, options) {
	const matches = getAllMatches(attrStr, validAttrStrRegxp);
	const attrNames = {};
	for (let i = 0; i < matches.length; i++) {
		if (matches[i][1].length === 0) return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
		else if (matches[i][3] !== undefined && matches[i][4] === undefined) return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
		else if (matches[i][3] === undefined && !options.allowBooleanAttributes) return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
		const attrName = matches[i][2];
		if (!validateAttrName(attrName)) return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
		if (!attrNames.hasOwnProperty(attrName)) attrNames[attrName] = 1;
		else return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
	}
	return true;
}
function validateNumberAmpersand(xmlData, i) {
	let re = /\d/;
	if (xmlData[i] === "x") {
		i++;
		re = /[\da-fA-F]/;
	}
	for (; i < xmlData.length; i++) {
		if (xmlData[i] === ";") return i;
		if (!xmlData[i].match(re)) break;
	}
	return -1;
}
function validateAmpersand(xmlData, i) {
	i++;
	if (xmlData[i] === ";") return -1;
	if (xmlData[i] === "#") {
		i++;
		return validateNumberAmpersand(xmlData, i);
	}
	let count = 0;
	for (; i < xmlData.length; i++, count++) {
		if (xmlData[i].match(/\w/) && count < 20) continue;
		if (xmlData[i] === ";") break;
		return -1;
	}
	return i;
}
function getErrorObject(code, message, lineNumber) {
	return { err: {
		code,
		msg: message,
		line: lineNumber.line || lineNumber,
		col: lineNumber.col
	} };
}
function validateAttrName(attrName) {
	return isName(attrName);
}
function validateTagName(tagname) {
	return isName(tagname);
}
function getLineNumberForPosition(xmlData, index) {
	const lines = xmlData.substring(0, index).split(/\r?\n/);
	return {
		line: lines.length,
		col: lines[lines.length - 1].length + 1
	};
}
function getPositionFromMatch(match) {
	return match.startIndex + match[1].length;
}

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
const defaultOptions$1 = {
	preserveOrder: false,
	attributeNamePrefix: "@_",
	attributesGroupName: false,
	textNodeName: "#text",
	ignoreAttributes: true,
	removeNSPrefix: false,
	allowBooleanAttributes: false,
	parseTagValue: true,
	parseAttributeValue: false,
	trimValues: true,
	cdataPropName: false,
	numberParseOptions: {
		hex: true,
		leadingZeros: true,
		eNotation: true
	},
	tagValueProcessor: function(tagName, val) {
		return val;
	},
	attributeValueProcessor: function(attrName, val) {
		return val;
	},
	stopNodes: [],
	alwaysCreateTextNode: false,
	isArray: () => false,
	commentPropName: false,
	unpairedTags: [],
	processEntities: true,
	htmlEntities: false,
	ignoreDeclaration: false,
	ignorePiTags: false,
	transformTagName: false,
	transformAttributeName: false,
	updateTag: function(tagName, jPath, attrs) {
		return tagName;
	}
};
const buildOptions = function(options) {
	return Object.assign({}, defaultOptions$1, options);
};

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
var XmlNode = class {
	constructor(tagname) {
		this.tagname = tagname;
		this.child = [];
		this[":@"] = {};
	}
	add(key, val) {
		if (key === "__proto__") key = "#__proto__";
		this.child.push({ [key]: val });
	}
	addChild(node) {
		if (node.tagname === "__proto__") node.tagname = "#__proto__";
		if (node[":@"] && Object.keys(node[":@"]).length > 0) this.child.push({
			[node.tagname]: node.child,
			[":@"]: node[":@"]
		});
		else this.child.push({ [node.tagname]: node.child });
	}
};

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
function readDocType(xmlData, i) {
	const entities = {};
	if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
		i = i + 9;
		let angleBracketsCount = 1;
		let hasBody = false, comment = false;
		let exp = "";
		for (; i < xmlData.length; i++) if (xmlData[i] === "<" && !comment) {
			if (hasBody && isEntity(xmlData, i)) {
				i += 7;
				let entityName, val;
				[entityName, val, i] = readEntityExp(xmlData, i + 1);
				if (val.indexOf("&") === -1) entities[validateEntityName(entityName)] = {
					regx: RegExp(`&${entityName};`, "g"),
					val
				};
			} else if (hasBody && isElement(xmlData, i)) i += 8;
			else if (hasBody && isAttlist(xmlData, i)) i += 8;
			else if (hasBody && isNotation(xmlData, i)) i += 9;
			else if (isComment) comment = true;
			else throw new Error("Invalid DOCTYPE");
			angleBracketsCount++;
			exp = "";
		} else if (xmlData[i] === ">") {
			if (comment) {
				if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
					comment = false;
					angleBracketsCount--;
				}
			} else angleBracketsCount--;
			if (angleBracketsCount === 0) break;
		} else if (xmlData[i] === "[") hasBody = true;
		else exp += xmlData[i];
		if (angleBracketsCount !== 0) throw new Error(`Unclosed DOCTYPE`);
	} else throw new Error(`Invalid Tag instead of DOCTYPE`);
	return {
		entities,
		i
	};
}
function readEntityExp(xmlData, i) {
	let entityName = "";
	for (; i < xmlData.length && xmlData[i] !== "'" && xmlData[i] !== "\""; i++) entityName += xmlData[i];
	entityName = entityName.trim();
	if (entityName.indexOf(" ") !== -1) throw new Error("External entites are not supported");
	const startChar = xmlData[i++];
	let val = "";
	for (; i < xmlData.length && xmlData[i] !== startChar; i++) val += xmlData[i];
	return [
		entityName,
		val,
		i
	];
}
function isComment(xmlData, i) {
	if (xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-") return true;
	return false;
}
function isEntity(xmlData, i) {
	if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y") return true;
	return false;
}
function isElement(xmlData, i) {
	if (xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T") return true;
	return false;
}
function isAttlist(xmlData, i) {
	if (xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T") return true;
	return false;
}
function isNotation(xmlData, i) {
	if (xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N") return true;
	return false;
}
function validateEntityName(name) {
	if (isName(name)) return name;
	else throw new Error(`Invalid entity name ${name}`);
}

//#endregion
//#region node_modules/strnum/strnum.js
const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
const consider = {
	hex: true,
	leadingZeros: true,
	decimalPoint: ".",
	eNotation: true
};
function toNumber(str, options = {}) {
	options = Object.assign({}, consider, options);
	if (!str || typeof str !== "string") return str;
	else if (str === "0") return 0;
	let trimmedStr = str.trim();
	if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
	else if (options.hex && hexRegex.test(trimmedStr)) return parse_int(trimmedStr, 16);
	else if (trimmedStr.search(/[eE]/) !== -1) {
		const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
		if (notation) {
			if (options.leadingZeros) trimmedStr = (notation[1] || "") + notation[3];
			else if (notation[2] === "0" && notation[3][0] === ".") {} else return str;
			return options.eNotation ? Number(trimmedStr) : str;
		} else return str;
	} else {
		const match = numRegex.exec(trimmedStr);
		if (match) {
			const sign = match[1];
			const leadingZeros = match[2];
			let numTrimmedByZeros = trimZeros(match[3]);
			if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str;
			else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str;
			else if (options.leadingZeros && leadingZeros === str) return 0;
			else {
				const num = Number(trimmedStr);
				const numStr = "" + num;
				if (numStr.search(/[eE]/) !== -1) if (options.eNotation) return num;
				else return str;
				else if (trimmedStr.indexOf(".") !== -1) if (numStr === "0" && numTrimmedByZeros === "") return num;
				else if (numStr === numTrimmedByZeros) return num;
				else if (sign && numStr === "-" + numTrimmedByZeros) return num;
				else return str;
				if (leadingZeros) return numTrimmedByZeros === numStr || sign + numTrimmedByZeros === numStr ? num : str;
				else return trimmedStr === numStr || trimmedStr === sign + numStr ? num : str;
			}
		} else return str;
	}
}
/**
* 
* @param {string} numStr without leading zeros
* @returns 
*/
function trimZeros(numStr) {
	if (numStr && numStr.indexOf(".") !== -1) {
		numStr = numStr.replace(/0+$/, "");
		if (numStr === ".") numStr = "0";
		else if (numStr[0] === ".") numStr = "0" + numStr;
		else if (numStr[numStr.length - 1] === ".") numStr = numStr.substr(0, numStr.length - 1);
		return numStr;
	}
	return numStr;
}
function parse_int(numStr, base) {
	if (parseInt) return parseInt(numStr, base);
	else if (Number.parseInt) return Number.parseInt(numStr, base);
	else if (window && window.parseInt) return window.parseInt(numStr, base);
	else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
}

//#endregion
//#region node_modules/fast-xml-parser/src/ignoreAttributes.js
function getIgnoreAttributesFn(ignoreAttributes) {
	if (typeof ignoreAttributes === "function") return ignoreAttributes;
	if (Array.isArray(ignoreAttributes)) return (attrName) => {
		for (const pattern of ignoreAttributes) {
			if (typeof pattern === "string" && attrName === pattern) return true;
			if (pattern instanceof RegExp && pattern.test(attrName)) return true;
		}
	};
	return () => false;
}

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
var OrderedObjParser = class {
	constructor(options) {
		this.options = options;
		this.currentNode = null;
		this.tagsNodeStack = [];
		this.docTypeEntities = {};
		this.lastEntities = {
			"apos": {
				regex: /&(apos|#39|#x27);/g,
				val: "'"
			},
			"gt": {
				regex: /&(gt|#62|#x3E);/g,
				val: ">"
			},
			"lt": {
				regex: /&(lt|#60|#x3C);/g,
				val: "<"
			},
			"quot": {
				regex: /&(quot|#34|#x22);/g,
				val: "\""
			}
		};
		this.ampEntity = {
			regex: /&(amp|#38|#x26);/g,
			val: "&"
		};
		this.htmlEntities = {
			"space": {
				regex: /&(nbsp|#160);/g,
				val: " "
			},
			"cent": {
				regex: /&(cent|#162);/g,
				val: "¢"
			},
			"pound": {
				regex: /&(pound|#163);/g,
				val: "£"
			},
			"yen": {
				regex: /&(yen|#165);/g,
				val: "¥"
			},
			"euro": {
				regex: /&(euro|#8364);/g,
				val: "€"
			},
			"copyright": {
				regex: /&(copy|#169);/g,
				val: "©"
			},
			"reg": {
				regex: /&(reg|#174);/g,
				val: "®"
			},
			"inr": {
				regex: /&(inr|#8377);/g,
				val: "₹"
			},
			"num_dec": {
				regex: /&#([0-9]{1,7});/g,
				val: (_, str) => String.fromCharCode(Number.parseInt(str, 10))
			},
			"num_hex": {
				regex: /&#x([0-9a-fA-F]{1,6});/g,
				val: (_, str) => String.fromCharCode(Number.parseInt(str, 16))
			}
		};
		this.addExternalEntities = addExternalEntities;
		this.parseXml = parseXml;
		this.parseTextData = parseTextData;
		this.resolveNameSpace = resolveNameSpace;
		this.buildAttributesMap = buildAttributesMap;
		this.isItStopNode = isItStopNode;
		this.replaceEntitiesValue = replaceEntitiesValue$1;
		this.readStopNodeData = readStopNodeData;
		this.saveTextToParentTag = saveTextToParentTag;
		this.addChild = addChild;
		this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
	}
};
function addExternalEntities(externalEntities) {
	const entKeys = Object.keys(externalEntities);
	for (let i = 0; i < entKeys.length; i++) {
		const ent = entKeys[i];
		this.lastEntities[ent] = {
			regex: new RegExp("&" + ent + ";", "g"),
			val: externalEntities[ent]
		};
	}
}
/**
* @param {string} val
* @param {string} tagName
* @param {string} jPath
* @param {boolean} dontTrim
* @param {boolean} hasAttributes
* @param {boolean} isLeafNode
* @param {boolean} escapeEntities
*/
function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
	if (val !== undefined) {
		if (this.options.trimValues && !dontTrim) val = val.trim();
		if (val.length > 0) {
			if (!escapeEntities) val = this.replaceEntitiesValue(val);
			const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
			if (newval === null || newval === undefined) return val;
			else if (typeof newval != typeof val || newval !== val) return newval;
			else if (this.options.trimValues) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
			else {
				const trimmedVal = val.trim();
				if (trimmedVal === val) return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
				else return val;
			}
		}
	}
}
function resolveNameSpace(tagname) {
	if (this.options.removeNSPrefix) {
		const tags = tagname.split(":");
		const prefix = tagname.charAt(0) === "/" ? "/" : "";
		if (tags[0] === "xmlns") return "";
		if (tags.length === 2) tagname = prefix + tags[1];
	}
	return tagname;
}
const attrsRegx = new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?", "gm");
function buildAttributesMap(attrStr, jPath, tagName) {
	if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
		const matches = getAllMatches(attrStr, attrsRegx);
		const len = matches.length;
		const attrs = {};
		for (let i = 0; i < len; i++) {
			const attrName = this.resolveNameSpace(matches[i][1]);
			if (this.ignoreAttributesFn(attrName, jPath)) continue;
			let oldVal = matches[i][4];
			let aName = this.options.attributeNamePrefix + attrName;
			if (attrName.length) {
				if (this.options.transformAttributeName) aName = this.options.transformAttributeName(aName);
				if (aName === "__proto__") aName = "#__proto__";
				if (oldVal !== undefined) {
					if (this.options.trimValues) oldVal = oldVal.trim();
					oldVal = this.replaceEntitiesValue(oldVal);
					const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
					if (newVal === null || newVal === undefined) attrs[aName] = oldVal;
					else if (typeof newVal != typeof oldVal || newVal !== oldVal) attrs[aName] = newVal;
					else attrs[aName] = parseValue(oldVal, this.options.parseAttributeValue, this.options.numberParseOptions);
				} else if (this.options.allowBooleanAttributes) attrs[aName] = true;
			}
		}
		if (!Object.keys(attrs).length) return;
		if (this.options.attributesGroupName) {
			const attrCollection = {};
			attrCollection[this.options.attributesGroupName] = attrs;
			return attrCollection;
		}
		return attrs;
	}
}
const parseXml = function(xmlData) {
	xmlData = xmlData.replace(/\r\n?/g, "\n");
	const xmlObj = new XmlNode("!xml");
	let currentNode = xmlObj;
	let textData = "";
	let jPath = "";
	for (let i = 0; i < xmlData.length; i++) {
		const ch = xmlData[i];
		if (ch === "<") if (xmlData[i + 1] === "/") {
			const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
			let tagName = xmlData.substring(i + 2, closeIndex).trim();
			if (this.options.removeNSPrefix) {
				const colonIndex = tagName.indexOf(":");
				if (colonIndex !== -1) tagName = tagName.substr(colonIndex + 1);
			}
			if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
			if (currentNode) textData = this.saveTextToParentTag(textData, currentNode, jPath);
			const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
			if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
			let propIndex = 0;
			if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
				propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
				this.tagsNodeStack.pop();
			} else propIndex = jPath.lastIndexOf(".");
			jPath = jPath.substring(0, propIndex);
			currentNode = this.tagsNodeStack.pop();
			textData = "";
			i = closeIndex;
		} else if (xmlData[i + 1] === "?") {
			let tagData = readTagExp(xmlData, i, false, "?>");
			if (!tagData) throw new Error("Pi Tag is not closed.");
			textData = this.saveTextToParentTag(textData, currentNode, jPath);
			if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {} else {
				const childNode = new XmlNode(tagData.tagName);
				childNode.add(this.options.textNodeName, "");
				if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
				this.addChild(currentNode, childNode, jPath);
			}
			i = tagData.closeIndex + 1;
		} else if (xmlData.substr(i + 1, 3) === "!--") {
			const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
			if (this.options.commentPropName) {
				const comment = xmlData.substring(i + 4, endIndex - 2);
				textData = this.saveTextToParentTag(textData, currentNode, jPath);
				currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
			}
			i = endIndex;
		} else if (xmlData.substr(i + 1, 2) === "!D") {
			const result = readDocType(xmlData, i);
			this.docTypeEntities = result.entities;
			i = result.i;
		} else if (xmlData.substr(i + 1, 2) === "![") {
			const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
			const tagExp = xmlData.substring(i + 9, closeIndex);
			textData = this.saveTextToParentTag(textData, currentNode, jPath);
			let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
			if (val == undefined) val = "";
			if (this.options.cdataPropName) currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
			else currentNode.add(this.options.textNodeName, val);
			i = closeIndex + 2;
		} else {
			let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
			let tagName = result.tagName;
			const rawTagName = result.rawTagName;
			let tagExp = result.tagExp;
			let attrExpPresent = result.attrExpPresent;
			let closeIndex = result.closeIndex;
			if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
			if (currentNode && textData) {
				if (currentNode.tagname !== "!xml") textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
			}
			const lastTag = currentNode;
			if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
				currentNode = this.tagsNodeStack.pop();
				jPath = jPath.substring(0, jPath.lastIndexOf("."));
			}
			if (tagName !== xmlObj.tagname) jPath += jPath ? "." + tagName : tagName;
			if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
				let tagContent = "";
				if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
					if (tagName[tagName.length - 1] === "/") {
						tagName = tagName.substr(0, tagName.length - 1);
						jPath = jPath.substr(0, jPath.length - 1);
						tagExp = tagName;
					} else tagExp = tagExp.substr(0, tagExp.length - 1);
					i = result.closeIndex;
				} else if (this.options.unpairedTags.indexOf(tagName) !== -1) i = result.closeIndex;
				else {
					const result$1 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
					if (!result$1) throw new Error(`Unexpected end of ${rawTagName}`);
					i = result$1.i;
					tagContent = result$1.tagContent;
				}
				const childNode = new XmlNode(tagName);
				if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
				if (tagContent) tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
				jPath = jPath.substr(0, jPath.lastIndexOf("."));
				childNode.add(this.options.textNodeName, tagContent);
				this.addChild(currentNode, childNode, jPath);
			} else {
				if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
					if (tagName[tagName.length - 1] === "/") {
						tagName = tagName.substr(0, tagName.length - 1);
						jPath = jPath.substr(0, jPath.length - 1);
						tagExp = tagName;
					} else tagExp = tagExp.substr(0, tagExp.length - 1);
					if (this.options.transformTagName) tagName = this.options.transformTagName(tagName);
					const childNode = new XmlNode(tagName);
					if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
					this.addChild(currentNode, childNode, jPath);
					jPath = jPath.substr(0, jPath.lastIndexOf("."));
				} else {
					const childNode = new XmlNode(tagName);
					this.tagsNodeStack.push(currentNode);
					if (tagName !== tagExp && attrExpPresent) childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
					this.addChild(currentNode, childNode, jPath);
					currentNode = childNode;
				}
				textData = "";
				i = closeIndex;
			}
		}
		else textData += xmlData[i];
	}
	return xmlObj.child;
};
function addChild(currentNode, childNode, jPath) {
	const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
	if (result === false) {} else if (typeof result === "string") {
		childNode.tagname = result;
		currentNode.addChild(childNode);
	} else currentNode.addChild(childNode);
}
const replaceEntitiesValue$1 = function(val) {
	if (this.options.processEntities) {
		for (let entityName in this.docTypeEntities) {
			const entity = this.docTypeEntities[entityName];
			val = val.replace(entity.regx, entity.val);
		}
		for (let entityName in this.lastEntities) {
			const entity = this.lastEntities[entityName];
			val = val.replace(entity.regex, entity.val);
		}
		if (this.options.htmlEntities) for (let entityName in this.htmlEntities) {
			const entity = this.htmlEntities[entityName];
			val = val.replace(entity.regex, entity.val);
		}
		val = val.replace(this.ampEntity.regex, this.ampEntity.val);
	}
	return val;
};
function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
	if (textData) {
		if (isLeafNode === undefined) isLeafNode = currentNode.child.length === 0;
		textData = this.parseTextData(textData, currentNode.tagname, jPath, false, currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false, isLeafNode);
		if (textData !== undefined && textData !== "") currentNode.add(this.options.textNodeName, textData);
		textData = "";
	}
	return textData;
}
/**
* 
* @param {string[]} stopNodes 
* @param {string} jPath
* @param {string} currentTagName 
*/
function isItStopNode(stopNodes, jPath, currentTagName) {
	const allNodesExp = "*." + currentTagName;
	for (const stopNodePath in stopNodes) {
		const stopNodeExp = stopNodes[stopNodePath];
		if (allNodesExp === stopNodeExp || jPath === stopNodeExp) return true;
	}
	return false;
}
/**
* Returns the tag Expression and where it is ending handling single-double quotes situation
* @param {string} xmlData 
* @param {number} i starting index
* @returns 
*/
function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
	let attrBoundary;
	let tagExp = "";
	for (let index = i; index < xmlData.length; index++) {
		let ch = xmlData[index];
		if (attrBoundary) {
			if (ch === attrBoundary) attrBoundary = "";
		} else if (ch === "\"" || ch === "'") attrBoundary = ch;
		else if (ch === closingChar[0]) if (closingChar[1]) {
			if (xmlData[index + 1] === closingChar[1]) return {
				data: tagExp,
				index
			};
		} else return {
			data: tagExp,
			index
		};
		else if (ch === "	") ch = " ";
		tagExp += ch;
	}
}
function findClosingIndex(xmlData, str, i, errMsg) {
	const closingIndex = xmlData.indexOf(str, i);
	if (closingIndex === -1) throw new Error(errMsg);
	else return closingIndex + str.length - 1;
}
function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
	const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
	if (!result) return;
	let tagExp = result.data;
	const closeIndex = result.index;
	const separatorIndex = tagExp.search(/\s/);
	let tagName = tagExp;
	let attrExpPresent = true;
	if (separatorIndex !== -1) {
		tagName = tagExp.substring(0, separatorIndex);
		tagExp = tagExp.substring(separatorIndex + 1).trimStart();
	}
	const rawTagName = tagName;
	if (removeNSPrefix) {
		const colonIndex = tagName.indexOf(":");
		if (colonIndex !== -1) {
			tagName = tagName.substr(colonIndex + 1);
			attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
		}
	}
	return {
		tagName,
		tagExp,
		closeIndex,
		attrExpPresent,
		rawTagName
	};
}
/**
* find paired tag for a stop node
* @param {string} xmlData 
* @param {string} tagName 
* @param {number} i 
*/
function readStopNodeData(xmlData, tagName, i) {
	const startIndex = i;
	let openTagCount = 1;
	for (; i < xmlData.length; i++) if (xmlData[i] === "<") if (xmlData[i + 1] === "/") {
		const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
		let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
		if (closeTagName === tagName) {
			openTagCount--;
			if (openTagCount === 0) return {
				tagContent: xmlData.substring(startIndex, i),
				i: closeIndex
			};
		}
		i = closeIndex;
	} else if (xmlData[i + 1] === "?") {
		const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
		i = closeIndex;
	} else if (xmlData.substr(i + 1, 3) === "!--") {
		const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
		i = closeIndex;
	} else if (xmlData.substr(i + 1, 2) === "![") {
		const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
		i = closeIndex;
	} else {
		const tagData = readTagExp(xmlData, i, ">");
		if (tagData) {
			const openTagName = tagData && tagData.tagName;
			if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") openTagCount++;
			i = tagData.closeIndex;
		}
	}
}
function parseValue(val, shouldParse, options) {
	if (shouldParse && typeof val === "string") {
		const newval = val.trim();
		if (newval === "true") return true;
		else if (newval === "false") return false;
		else return toNumber(val, options);
	} else if (isExist(val)) return val;
	else return "";
}

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/node2json.js
function prettify(node, options) {
	return compress(node, options);
}
/**
* 
* @param {array} arr 
* @param {object} options 
* @param {string} jPath 
* @returns object
*/
function compress(arr, options, jPath) {
	let text;
	const compressedObj = {};
	for (let i = 0; i < arr.length; i++) {
		const tagObj = arr[i];
		const property = propName$1(tagObj);
		let newJpath = "";
		if (jPath === undefined) newJpath = property;
		else newJpath = jPath + "." + property;
		if (property === options.textNodeName) if (text === undefined) text = tagObj[property];
		else text += "" + tagObj[property];
		else if (property === undefined) continue;
		else if (tagObj[property]) {
			let val = compress(tagObj[property], options, newJpath);
			const isLeaf = isLeafTag(val, options);
			if (tagObj[":@"]) assignAttributes(val, tagObj[":@"], newJpath, options);
			else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) val = val[options.textNodeName];
			else if (Object.keys(val).length === 0) if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
			else val = "";
			if (compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
				if (!Array.isArray(compressedObj[property])) compressedObj[property] = [compressedObj[property]];
				compressedObj[property].push(val);
			} else if (options.isArray(property, newJpath, isLeaf)) compressedObj[property] = [val];
			else compressedObj[property] = val;
		}
	}
	if (typeof text === "string") {
		if (text.length > 0) compressedObj[options.textNodeName] = text;
	} else if (text !== undefined) compressedObj[options.textNodeName] = text;
	return compressedObj;
}
function propName$1(obj) {
	const keys = Object.keys(obj);
	for (let i = 0; i < keys.length; i++) {
		const key = keys[i];
		if (key !== ":@") return key;
	}
}
function assignAttributes(obj, attrMap, jpath, options) {
	if (attrMap) {
		const keys = Object.keys(attrMap);
		const len = keys.length;
		for (let i = 0; i < len; i++) {
			const atrrName = keys[i];
			if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) obj[atrrName] = [attrMap[atrrName]];
			else obj[atrrName] = attrMap[atrrName];
		}
	}
}
function isLeafTag(obj, options) {
	const { textNodeName } = options;
	const propCount = Object.keys(obj).length;
	if (propCount === 0) return true;
	if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) return true;
	return false;
}

//#endregion
//#region node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
var XMLParser = class {
	constructor(options) {
		this.externalEntities = {};
		this.options = buildOptions(options);
	}
	/**
	* Parse XML dats to JS object 
	* @param {string|Buffer} xmlData 
	* @param {boolean|Object} validationOption 
	*/
	parse(xmlData, validationOption) {
		if (typeof xmlData === "string") {} else if (xmlData.toString) xmlData = xmlData.toString();
		else throw new Error("XML data is accepted in String or Bytes[] form.");
		if (validationOption) {
			if (validationOption === true) validationOption = {};
			const result = validate(xmlData, validationOption);
			if (result !== true) throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
		}
		const orderedObjParser = new OrderedObjParser(this.options);
		orderedObjParser.addExternalEntities(this.externalEntities);
		const orderedResult = orderedObjParser.parseXml(xmlData);
		if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;
		else return prettify(orderedResult, this.options);
	}
	/**
	* Add Entity which is not by default supported by this library
	* @param {string} key 
	* @param {string} value 
	*/
	addEntity(key, value) {
		if (value.indexOf("&") !== -1) throw new Error("Entity value can't have '&'");
		else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
		else if (value === "&") throw new Error("An entity with value '&' is not permitted");
		else this.externalEntities[key] = value;
	}
};

//#endregion
//#region node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js
const EOL = "\n";
function toXml(jArray, options) {
	let indentation = "";
	if (options.format && options.indentBy.length > 0) indentation = EOL;
	return arrToStr(jArray, options, "", indentation);
}
function arrToStr(arr, options, jPath, indentation) {
	let xmlStr = "";
	let isPreviousElementTag = false;
	for (let i = 0; i < arr.length; i++) {
		const tagObj = arr[i];
		const tagName = propName(tagObj);
		if (tagName === undefined) continue;
		let newJPath = "";
		if (jPath.length === 0) newJPath = tagName;
		else newJPath = `${jPath}.${tagName}`;
		if (tagName === options.textNodeName) {
			let tagText = tagObj[tagName];
			if (!isStopNode(newJPath, options)) {
				tagText = options.tagValueProcessor(tagName, tagText);
				tagText = replaceEntitiesValue(tagText, options);
			}
			if (isPreviousElementTag) xmlStr += indentation;
			xmlStr += tagText;
			isPreviousElementTag = false;
			continue;
		} else if (tagName === options.cdataPropName) {
			if (isPreviousElementTag) xmlStr += indentation;
			xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
			isPreviousElementTag = false;
			continue;
		} else if (tagName === options.commentPropName) {
			xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
			isPreviousElementTag = true;
			continue;
		} else if (tagName[0] === "?") {
			const attStr$1 = attr_to_str(tagObj[":@"], options);
			const tempInd = tagName === "?xml" ? "" : indentation;
			let piTextNodeName = tagObj[tagName][0][options.textNodeName];
			piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
			xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr$1}?>`;
			isPreviousElementTag = true;
			continue;
		}
		let newIdentation = indentation;
		if (newIdentation !== "") newIdentation += options.indentBy;
		const attStr = attr_to_str(tagObj[":@"], options);
		const tagStart = indentation + `<${tagName}${attStr}`;
		const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
		if (options.unpairedTags.indexOf(tagName) !== -1) if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
		else xmlStr += tagStart + "/>";
		else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) xmlStr += tagStart + "/>";
		else if (tagValue && tagValue.endsWith(">")) xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
		else {
			xmlStr += tagStart + ">";
			if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) xmlStr += indentation + options.indentBy + tagValue + indentation;
			else xmlStr += tagValue;
			xmlStr += `</${tagName}>`;
		}
		isPreviousElementTag = true;
	}
	return xmlStr;
}
function propName(obj) {
	const keys = Object.keys(obj);
	for (let i = 0; i < keys.length; i++) {
		const key = keys[i];
		if (!obj.hasOwnProperty(key)) continue;
		if (key !== ":@") return key;
	}
}
function attr_to_str(attrMap, options) {
	let attrStr = "";
	if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
		if (!attrMap.hasOwnProperty(attr)) continue;
		let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
		attrVal = replaceEntitiesValue(attrVal, options);
		if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
		else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
	}
	return attrStr;
}
function isStopNode(jPath, options) {
	jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
	let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
	for (let index in options.stopNodes) if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) return true;
	return false;
}
function replaceEntitiesValue(textValue, options) {
	if (textValue && textValue.length > 0 && options.processEntities) for (let i = 0; i < options.entities.length; i++) {
		const entity = options.entities[i];
		textValue = textValue.replace(entity.regex, entity.val);
	}
	return textValue;
}

//#endregion
//#region node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
const defaultOptions = {
	attributeNamePrefix: "@_",
	attributesGroupName: false,
	textNodeName: "#text",
	ignoreAttributes: true,
	cdataPropName: false,
	format: false,
	indentBy: "  ",
	suppressEmptyNode: false,
	suppressUnpairedNode: true,
	suppressBooleanAttributes: true,
	tagValueProcessor: function(key, a) {
		return a;
	},
	attributeValueProcessor: function(attrName, a) {
		return a;
	},
	preserveOrder: false,
	commentPropName: false,
	unpairedTags: [],
	entities: [
		{
			regex: new RegExp("&", "g"),
			val: "&amp;"
		},
		{
			regex: new RegExp(">", "g"),
			val: "&gt;"
		},
		{
			regex: new RegExp("<", "g"),
			val: "&lt;"
		},
		{
			regex: new RegExp("'", "g"),
			val: "&apos;"
		},
		{
			regex: new RegExp("\"", "g"),
			val: "&quot;"
		}
	],
	processEntities: true,
	stopNodes: [],
	oneListGroup: false
};
function Builder(options) {
	this.options = Object.assign({}, defaultOptions, options);
	if (this.options.ignoreAttributes === true || this.options.attributesGroupName) this.isAttribute = function() {
		return false;
	};
	else {
		this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
		this.attrPrefixLen = this.options.attributeNamePrefix.length;
		this.isAttribute = isAttribute;
	}
	this.proc