kassza 0.12.0 → 0.14.0

package/dist/serialize-CquIsxA-.cjs

@@ -0,0 +1,290 @@
+//#region src/core/xml/parse.ts
+var XmlParseError = class extends Error {
+	name = "XmlParseError";
+};
+const NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+const MAX_CODE_POINT = 1114111;
+const MIN_SURROGATE = 55296;
+const MAX_SURROGATE = 57343;
+function codePointToString(codePoint, fallback) {
+	return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= MAX_CODE_POINT && (codePoint < MIN_SURROGATE || codePoint > MAX_SURROGATE) ? String.fromCodePoint(codePoint) : fallback;
+}
+function decodeEntities(value) {
+	return value.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (match, entity) => {
+		if (entity.startsWith("#x")) return codePointToString(Number.parseInt(entity.slice(2), 16), match);
+		if (entity.startsWith("#")) return codePointToString(Number.parseInt(entity.slice(1), 10), match);
+		return NAMED_ENTITIES[entity] ?? match;
+	});
+}
+function localName(qualifiedName) {
+	const colon = qualifiedName.indexOf(":");
+	return colon === -1 ? qualifiedName : qualifiedName.slice(colon + 1);
+}
+const ATTRIBUTE_PATTERN = /([^\s=/>]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseAttributes(source) {
+	const attributes = {};
+	for (const match of source.matchAll(ATTRIBUTE_PATTERN)) {
+		const [, name, , doubleQuoted, singleQuoted] = match;
+		if (name === void 0) continue;
+		attributes[name] = decodeEntities(doubleQuoted ?? singleQuoted ?? "");
+	}
+	return attributes;
+}
+function findTagEnd(xml, from) {
+	let quote;
+	for (let index = from; index < xml.length; index++) {
+		const char = xml[index];
+		if (quote !== void 0) {
+			if (char === quote) quote = void 0;
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === ">") return index;
+	}
+	return -1;
+}
+function skipUntil(xml, from, terminator) {
+	const end = xml.indexOf(terminator, from);
+	if (end === -1) throw new XmlParseError(`Lezáratlan szerkezet, hiányzik: ${terminator}`);
+	return end + terminator.length;
+}
+function parseXml(xml) {
+	const stack = [];
+	let root;
+	let position = xml.charCodeAt(0) === 65279 ? 1 : 0;
+	const appendText = (value) => {
+		const current = stack.at(-1);
+		if (current) current.text += value;
+	};
+	while (position < xml.length) {
+		const tagStart = xml.indexOf("<", position);
+		if (tagStart === -1) {
+			appendText(decodeEntities(xml.slice(position)));
+			break;
+		}
+		if (tagStart > position) appendText(decodeEntities(xml.slice(position, tagStart)));
+		if (xml.startsWith("<!--", tagStart)) {
+			position = skipUntil(xml, tagStart + 4, "-->");
+			continue;
+		}
+		if (xml.startsWith("<![CDATA[", tagStart)) {
+			const end = xml.indexOf("]]>", tagStart + 9);
+			if (end === -1) throw new XmlParseError("Lezáratlan CDATA szakasz");
+			appendText(xml.slice(tagStart + 9, end));
+			position = end + 3;
+			continue;
+		}
+		if (xml.startsWith("<?", tagStart)) {
+			position = skipUntil(xml, tagStart + 2, "?>");
+			continue;
+		}
+		if (xml.startsWith("<!", tagStart)) {
+			position = skipUntil(xml, tagStart + 2, ">");
+			continue;
+		}
+		const tagEnd = findTagEnd(xml, tagStart + 1);
+		if (tagEnd === -1) throw new XmlParseError("Lezáratlan XML tag");
+		const rawTag = xml.slice(tagStart + 1, tagEnd);
+		position = tagEnd + 1;
+		if (rawTag.startsWith("/")) {
+			const closingName = localName(rawTag.slice(1).trim());
+			const current = stack.pop();
+			if (!current || current.name !== closingName) throw new XmlParseError(`Váratlan záró tag: ${closingName}`);
+			continue;
+		}
+		const selfClosing = rawTag.endsWith("/");
+		const tagBody = selfClosing ? rawTag.slice(0, -1) : rawTag;
+		const nameMatch = /^\s*([^\s/>]+)/.exec(tagBody);
+		if (!nameMatch?.[1]) throw new XmlParseError("Érvénytelen XML tag");
+		const element = {
+			name: localName(nameMatch[1]),
+			attributes: parseAttributes(tagBody.slice(nameMatch[0].length)),
+			children: [],
+			text: ""
+		};
+		const parent = stack.at(-1);
+		if (parent) parent.children.push(element);
+		else if (root) throw new XmlParseError("Az XML-nek csak egy gyökéreleme lehet");
+		else root = element;
+		if (!selfClosing) {
+			if (stack.length >= 256) throw new XmlParseError(`Az XML túl mélyen ágyazott (legfeljebb 256 szint).`);
+			stack.push(element);
+		}
+	}
+	if (stack.length > 0) throw new XmlParseError(`Lezáratlan elem: ${stack.at(-1)?.name}`);
+	if (!root) throw new XmlParseError("Üres XML dokumentum");
+	return root;
+}
+function findChild(element, name) {
+	return element?.children.find((child) => child.name === name);
+}
+function findChildren(element, name) {
+	return element?.children.filter((child) => child.name === name) ?? [];
+}
+function childText(element, name) {
+	const child = findChild(element, name);
+	if (!child) return void 0;
+	const value = child.text.trim();
+	return value === "" ? void 0 : value;
+}
+function childNumber(element, name) {
+	const value = childText(element, name);
+	if (value === void 0) return void 0;
+	const parsed = Number(value.replace(",", "."));
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function childBoolean(element, name) {
+	const value = childText(element, name)?.toLowerCase();
+	if (value === "true" || value === "1") return true;
+	if (value === "false" || value === "0") return false;
+}
+//#endregion
+//#region src/core/xml/serialize.ts
+function el(name, content, attributes) {
+	return attributes === void 0 ? {
+		name,
+		content
+	} : {
+		name,
+		content,
+		attributes
+	};
+}
+function optionalEl(name, content) {
+	if (content === void 0 || content === null) return void 0;
+	if (Array.isArray(content) && !content.some(Boolean)) return void 0;
+	return {
+		name,
+		content
+	};
+}
+function isAllowedXmlChar(codePoint) {
+	if (codePoint === 9 || codePoint === 10 || codePoint === 13) return true;
+	if (codePoint < 32) return false;
+	if (codePoint >= 55296 && codePoint <= 57343) return false;
+	return codePoint !== 65534 && codePoint !== 65535;
+}
+function stripInvalidXmlChars(value) {
+	let result = "";
+	for (const char of value) if (isAllowedXmlChar(char.codePointAt(0) ?? 0)) result += char;
+	return result;
+}
+function escapeXml(value) {
+	return stripInvalidXmlChars(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatXmlNumber(value) {
+	if (!Number.isFinite(value)) throw new RangeError(`Az XML-be csak véges szám írható, kapott: ${value}`);
+	if (Math.abs(value) > Number.MAX_SAFE_INTEGER) throw new RangeError(`Az XML-be írható szám abszolút értéke legfeljebb 2^53 - 1 lehet, kapott: ${value}`);
+	if (Number.isInteger(value)) return value.toString();
+	const fixed = value.toFixed(10).replace(/0+$/, "").replace(/\.$/, "");
+	return fixed === "-0" ? "0" : fixed;
+}
+function formatScalar(value) {
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return formatXmlNumber(value);
+	return escapeXml(value);
+}
+function isPresent(child) {
+	return Boolean(child);
+}
+function renderAttributes(attributes) {
+	if (attributes === void 0) return "";
+	return Object.entries(attributes).map(([key, value]) => ` ${key}="${escapeXml(value)}"`).join("");
+}
+function renderNode(node, depth) {
+	const indent = "  ".repeat(depth);
+	const { name, content } = node;
+	const open = `${name}${renderAttributes(node.attributes)}`;
+	if (content === void 0 || content === null) return `${indent}<${open}></${name}>`;
+	if (!Array.isArray(content)) return `${indent}<${open}>${formatScalar(content)}</${name}>`;
+	const children = content.filter(isPresent);
+	if (children.length === 0) return `${indent}<${open}></${name}>`;
+	return `${indent}<${open}>\n${children.map((child) => renderNode(child, depth + 1)).join("\n")}\n${indent}</${name}>`;
+}
+const XSI_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
+function buildXmlDocument(options) {
+	const declarations = /* @__PURE__ */ new Map([["xmlns", options.namespace]]);
+	for (const [prefix, uri] of Object.entries(options.namespaces ?? {})) declarations.set(`xmlns:${prefix}`, uri);
+	if (options.schemaLocation !== void 0) declarations.set("xmlns:xsi", XSI_NAMESPACE);
+	const attributes = [...declarations].map(([name, value]) => `${name}="${escapeXml(value)}"`);
+	if (options.schemaLocation !== void 0) attributes.push(`xsi:schemaLocation="${options.namespace} ${options.schemaLocation}"`);
+	const body = options.children.filter(isPresent).map((child) => renderNode(child, 1)).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<${options.root} ${attributes.join(" ")}>\n${body}\n</${options.root}>\n`;
+}
+//#endregion
+Object.defineProperty(exports, "XSI_NAMESPACE", {
+	enumerable: true,
+	get: function() {
+		return XSI_NAMESPACE;
+	}
+});
+Object.defineProperty(exports, "XmlParseError", {
+	enumerable: true,
+	get: function() {
+		return XmlParseError;
+	}
+});
+Object.defineProperty(exports, "buildXmlDocument", {
+	enumerable: true,
+	get: function() {
+		return buildXmlDocument;
+	}
+});
+Object.defineProperty(exports, "childBoolean", {
+	enumerable: true,
+	get: function() {
+		return childBoolean;
+	}
+});
+Object.defineProperty(exports, "childNumber", {
+	enumerable: true,
+	get: function() {
+		return childNumber;
+	}
+});
+Object.defineProperty(exports, "childText", {
+	enumerable: true,
+	get: function() {
+		return childText;
+	}
+});
+Object.defineProperty(exports, "el", {
+	enumerable: true,
+	get: function() {
+		return el;
+	}
+});
+Object.defineProperty(exports, "findChild", {
+	enumerable: true,
+	get: function() {
+		return findChild;
+	}
+});
+Object.defineProperty(exports, "findChildren", {
+	enumerable: true,
+	get: function() {
+		return findChildren;
+	}
+});
+Object.defineProperty(exports, "formatXmlNumber", {
+	enumerable: true,
+	get: function() {
+		return formatXmlNumber;
+	}
+});
+Object.defineProperty(exports, "optionalEl", {
+	enumerable: true,
+	get: function() {
+		return optionalEl;
+	}
+});
+Object.defineProperty(exports, "parseXml", {
+	enumerable: true,
+	get: function() {
+		return parseXml;
+	}
+});