hot-updater 1.0.2 → 1.0.4

package/dist/{fingerprint-D0Q1Sl5G.mjs → fingerprint-DyKBEn51.mjs}

@@ -67,12 +67,12 @@ const criticalProperties = [
 ];
 //#endregion
 //#region ../../node_modules/.pnpm/fast-xml-parser@5.7.2/node_modules/fast-xml-parser/src/validator.js
-const defaultOptions$2 = {
+const defaultOptions$1 = {
 	allowBooleanAttributes: false,
 	unpairedTags: []
 };
 function validate(xmlData, options) {
-	options = Object.assign({}, defaultOptions$2, options);
+	options = Object.assign({}, defaultOptions$1, options);
 	const tags = [];
 	let tagFound = false;
 	let reachedRoot = false;
@@ -1839,7 +1839,7 @@ const defaultOnDangerousProperty = (name) => {
 	if (DANGEROUS_PROPERTY_NAMES.includes(name)) return "__" + name;
 	return name;
 };
-const defaultOptions$1 = {
+const defaultOptions = {
 	preserveOrder: false,
 	attributeNamePrefix: "@_",
 	attributesGroupName: false,
@@ -1926,7 +1926,7 @@ function normalizeProcessEntities(value, htmlEntities) {
 	return normalizeProcessEntities(true);
 }
 const buildOptions = function(options) {
-	const built = Object.assign({}, defaultOptions$1, options);
+	const built = Object.assign({}, defaultOptions, options);
 	const propertyNameOptions = [
 		{
 			value: built.attributeNamePrefix,
@@ -2509,7 +2509,7 @@ function handleInfinity(str, num, options) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/fast-xml-parser@5.7.2/node_modules/fast-xml-parser/src/ignoreAttributes.js
-function getIgnoreAttributesFn$1(ignoreAttributes) {
+function getIgnoreAttributesFn(ignoreAttributes) {
 	if (typeof ignoreAttributes === "function") return ignoreAttributes;
 	if (Array.isArray(ignoreAttributes)) return (attrName) => {
 		for (const pattern of ignoreAttributes) {
@@ -3321,11 +3321,11 @@ var OrderedObjParser = class {
 		this.resolveNameSpace = resolveNameSpace;
 		this.buildAttributesMap = buildAttributesMap;
 		this.isItStopNode = isItStopNode;
-		this.replaceEntitiesValue = replaceEntitiesValue$1;
+		this.replaceEntitiesValue = replaceEntitiesValue;
 		this.readStopNodeData = readStopNodeData;
 		this.saveTextToParentTag = saveTextToParentTag;
 		this.addChild = addChild;
-		this.ignoreAttributesFn = getIgnoreAttributesFn$1(this.options.ignoreAttributes);
+		this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
 		this.entityExpansionCount = 0;
 		this.currentExpandedLength = 0;
 		let namedEntities = { ...XML };
@@ -3624,7 +3624,7 @@ function addChild(currentNode, childNode, matcher, startIndex) {
 * @param {string} tagName - Tag name
 * @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath
 */
-function replaceEntitiesValue$1(val, tagName, jPath) {
+function replaceEntitiesValue(val, tagName, jPath) {
 	const entityConfig = this.options.processEntities;
 	if (!entityConfig || !entityConfig.enabled) return val;
 	if (entityConfig.allowedTags) {
@@ -3832,7 +3832,7 @@ function compress(arr, options, matcher, readonlyMatcher) {
 	const compressedObj = {};
 	for (let i = 0; i < arr.length; i++) {
 		const tagObj = arr[i];
-		const property = propName$1(tagObj);
+		const property = propName(tagObj);
 		if (property !== void 0 && property !== options.textNodeName) {
 			const rawAttrs = stripAttributePrefix(tagObj[":@"] || {}, options.attributeNamePrefix);
 			matcher.push(property, rawAttrs);
@@ -3867,7 +3867,7 @@ function compress(arr, options, matcher, readonlyMatcher) {
 	} else if (text !== void 0) compressedObj[options.textNodeName] = text;
 	return compressedObj;
 }
-function propName$1(obj) {
+function propName(obj) {
 	const keys = Object.keys(obj);
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
@@ -3945,667 +3945,290 @@ var XMLParser = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/fast-xml-builder@1.2.0/node_modules/fast-xml-builder/src/util.js
-function safeComment(val) {
-	return String(val).replace(/--/g, "- -").replace(/--/g, "- -").replace(/-$/, "- ");
-}
-function safeCdata(val) {
-	return String(val).replace(/\]\]>/g, "]]]]><![CDATA[>");
-}
-function escapeAttribute(val) {
-	return String(val).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-//#endregion
-//#region ../../node_modules/.pnpm/xml-naming@0.1.0/node_modules/xml-naming/src/index.js
-/**
-* xml-naming
-* Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.
-* Covers: Name, NCName, QName, NMToken, NMTokens
-*
-* XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name
-* XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar
-* XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName
-*/
-const nameStartChar10 = ":A-Za-z_À-ÖØ-öø-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�";
-const nameChar10 = nameStartChar10 + "\\-\\.\\d" + "·" + "̀-ͯ" + "‿-⁀";
-const nameStartChar11 = ":A-Za-z_À-˿Ͱ-ͽͿ-҆҈-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�𐀀-󯿿";
-const nameChar11 = nameStartChar11 + "\\-\\.\\d" + "·" + "̀-ͯ" + "҇" + "‿-⁀";
-const buildRegexes = (startChar, char, flags = "") => {
-	const ncNamePat = `[${startChar.replace(":", "")}][${char.replace(":", "")}]*`;
-	return {
-		name: new RegExp(`^[${startChar}][${char}]*$`, flags),
-		ncName: new RegExp(`^${ncNamePat}$`, flags),
-		qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),
-		nmToken: new RegExp(`^[${char}]+$`, flags),
-		nmTokens: new RegExp(`^[${char}]+(?:\\s+[${char}]+)*$`, flags)
-	};
+//#region src/utils/configParser/androidManifestEdit.ts
+const NAME = /[^\s/>=]+/y;
+const WHITESPACE = /\s*/y;
+const matchAt = (pattern, text, index) => {
+	pattern.lastIndex = index;
+	return pattern.exec(text);
+};
+const skipTo = (xml, terminator, from) => {
+	const index = xml.indexOf(terminator, from);
+	if (index === -1) throw new Error(`unterminated markup, expected "${terminator}"`);
+	return index + terminator.length;
 };
-const regexes10 = buildRegexes(nameStartChar10, nameChar10);
-const regexes11 = buildRegexes(nameStartChar11, nameChar11, "u");
-const getRegexes = (xmlVersion = "1.0") => xmlVersion === "1.1" ? regexes11 : regexes10;
-/**
-* Returns true if the string is a valid QName (Qualified Name).
-* Allows exactly one colon as a prefix separator: prefix:localName.
-* Used for: element and attribute names in namespace-aware XML/SVG.
-*/
-const qName = (str, { xmlVersion = "1.0" } = {}) => getRegexes(xmlVersion).qName.test(str);
-//#endregion
-//#region ../../node_modules/.pnpm/fast-xml-builder@1.2.0/node_modules/fast-xml-builder/src/orderedJs2Xml.js
-const EOL = "\n";
-/**
-* Detect XML version from the first element of the ordered array input.
-* The first element must be a ?xml processing instruction with a version attribute.
-* Returns '1.0' if not found.
-*
-* @param {array}  jArray
-* @param {object} options
-*/
-function detectXmlVersionFromArray(jArray, options) {
-	if (!Array.isArray(jArray) || jArray.length === 0) return "1.0";
-	const first = jArray[0];
-	if (propName(first) === "?xml") {
-		const attrs = first[":@"];
-		if (attrs) {
-			const versionKey = options.attributeNamePrefix + "version";
-			if (attrs[versionKey]) return attrs[versionKey];
-		}
-	}
-	return "1.0";
-}
-/**
-* Resolve a tag or attribute name through sanitizeName if configured.
-* Validation via xml-naming's qName is performed first; the sanitizeName
-* callback is invoked only when the name is invalid. If sanitizeName is
-* false (default), no validation occurs and the name is used as-is.
-*
-* @param {string}  name        - raw name from the JS object
-* @param {boolean} isAttribute - true when resolving an attribute name
-* @param {object}  options
-* @param {Matcher} matcher     - current matcher state (readonly from callback perspective)
-* @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming
-*/
-function resolveTagName$1(name, isAttribute, options, matcher, xmlVersion) {
-	if (!options.sanitizeName) return name;
-	if (qName(name, { xmlVersion })) return name;
-	return options.sanitizeName(name, {
-		isAttribute,
-		matcher: matcher.readOnly()
-	});
-}
 /**
-* @param {array} jArray
-* @param {any} options
-* @returns
+* Element tags of an XML document in document order. Comments, CDATA,
+* processing instructions and the doctype are skipped, so markup inside them
+* is never mistaken for an element.
 */
-function toXml(jArray, options) {
-	let indentation = "";
-	if (options.format) indentation = EOL;
-	const stopNodeExpressions = [];
-	if (options.stopNodes && Array.isArray(options.stopNodes)) for (let i = 0; i < options.stopNodes.length; i++) {
-		const node = options.stopNodes[i];
-		if (typeof node === "string") stopNodeExpressions.push(new Expression(node));
-		else if (node instanceof Expression) stopNodeExpressions.push(node);
-	}
-	const xmlVersion = detectXmlVersionFromArray(jArray, options);
-	const matcher = new Matcher();
-	return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions, xmlVersion);
-}
-function arrToStr(arr, options, indentation, matcher, stopNodeExpressions, xmlVersion) {
-	let xmlStr = "";
-	let isPreviousElementTag = false;
-	if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
-	if (!Array.isArray(arr)) {
-		if (arr !== void 0 && arr !== null) {
-			let text = arr.toString();
-			text = replaceEntitiesValue(text, options);
-			return text;
-		}
-		return "";
-	}
-	for (let i = 0; i < arr.length; i++) {
-		const tagObj = arr[i];
-		const rawTagName = propName(tagObj);
-		if (rawTagName === void 0) continue;
-		const tagName = rawTagName === options.textNodeName || rawTagName === options.cdataPropName || rawTagName === options.commentPropName || rawTagName[0] === "?" ? rawTagName : resolveTagName$1(rawTagName, false, options, matcher, xmlVersion);
-		const attrValues = extractAttributeValues(tagObj[":@"], options);
-		matcher.push(tagName, attrValues);
-		const isStopNode = checkStopNode(matcher, stopNodeExpressions);
-		if (tagName === options.textNodeName) {
-			let tagText = tagObj[rawTagName];
-			if (!isStopNode) {
-				tagText = options.tagValueProcessor(tagName, tagText);
-				tagText = replaceEntitiesValue(tagText, options);
-			}
-			if (isPreviousElementTag) xmlStr += indentation;
-			xmlStr += tagText;
-			isPreviousElementTag = false;
-			matcher.pop();
-			continue;
-		} else if (tagName === options.cdataPropName) {
-			if (isPreviousElementTag) xmlStr += indentation;
-			const val = tagObj[rawTagName][0][options.textNodeName];
-			const safeVal = safeCdata(val);
-			xmlStr += `<![CDATA[${safeVal}]]>`;
-			isPreviousElementTag = false;
-			matcher.pop();
+const scanTags = (xml) => {
+	const tags = [];
+	let index = 0;
+	while (index < xml.length) {
+		const start = xml.indexOf("<", index);
+		if (start === -1) break;
+		if (xml.startsWith("<!--", start)) {
+			index = skipTo(xml, "-->", start + 4);
 			continue;
-		} else if (tagName === options.commentPropName) {
-			const val = tagObj[rawTagName][0][options.textNodeName];
-			const safeVal = safeComment(val);
-			xmlStr += indentation + `<!--${safeVal}-->`;
-			isPreviousElementTag = true;
-			matcher.pop();
+		}
+		if (xml.startsWith("<![CDATA[", start)) {
+			index = skipTo(xml, "]]>", start + 9);
 			continue;
-		} else if (tagName[0] === "?") {
-			const attStr = attr_to_str(tagObj[":@"], options, isStopNode, matcher, xmlVersion);
-			xmlStr += (tagName === "?xml" ? "" : indentation) + `<${tagName}${attStr}?>`;
-			isPreviousElementTag = true;
-			matcher.pop();
+		}
+		if (xml.startsWith("<?", start)) {
+			index = skipTo(xml, "?>", start + 2);
 			continue;
 		}
-		let newIdentation = indentation;
-		if (newIdentation !== "") newIdentation += options.indentBy;
-		const tagStart = indentation + `<${tagName}${attr_to_str(tagObj[":@"], options, isStopNode, matcher, xmlVersion)}`;
-		let tagValue;
-		if (isStopNode) tagValue = getRawContent(tagObj[rawTagName], options);
-		else tagValue = arrToStr(tagObj[rawTagName], options, newIdentation, matcher, stopNodeExpressions, xmlVersion);
-		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}>`;
+		if (xml.startsWith("<!", start)) {
+			index = skipTo(xml, ">", start + 2);
+			continue;
 		}
-		isPreviousElementTag = true;
-		matcher.pop();
-	}
-	return xmlStr;
-}
-/**
-* Extract attribute values from the ":@" object and return as plain object
-* for passing to matcher.push()
-*/
-function extractAttributeValues(attrMap, options) {
-	if (!attrMap || options.ignoreAttributes) return null;
-	const attrValues = {};
-	let hasAttrs = false;
-	for (let attr in attrMap) {
-		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
-		const cleanAttrName = attr.startsWith(options.attributeNamePrefix) ? attr.substr(options.attributeNamePrefix.length) : attr;
-		attrValues[cleanAttrName] = escapeAttribute(attrMap[attr]);
-		hasAttrs = true;
-	}
-	return hasAttrs ? attrValues : null;
-}
-/**
-* Extract raw content from a stopNode without any processing
-* This preserves the content exactly as-is, including special characters
-*/
-function getRawContent(arr, options) {
-	if (!Array.isArray(arr)) {
-		if (arr !== void 0 && arr !== null) return arr.toString();
-		return "";
-	}
-	let content = "";
-	for (let i = 0; i < arr.length; i++) {
-		const item = arr[i];
-		const tagName = propName(item);
-		if (tagName === options.textNodeName) content += item[tagName];
-		else if (tagName === options.cdataPropName) content += item[tagName][0][options.textNodeName];
-		else if (tagName === options.commentPropName) content += item[tagName][0][options.textNodeName];
-		else if (tagName && tagName[0] === "?") continue;
-		else if (tagName) {
-			const attStr = attr_to_str_raw(item[":@"], options);
-			const nestedContent = getRawContent(item[tagName], options);
-			if (!nestedContent || nestedContent.length === 0) content += `<${tagName}${attStr}/>`;
-			else content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;
-		}
-	}
-	return content;
-}
-/**
-* Build attribute string for stopNodes - NO entity replacement
-*/
-function attr_to_str_raw(attrMap, options) {
-	let attrStr = "";
-	if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
-		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
-		let attrVal = attrMap[attr];
-		if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
-		else attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${escapeAttribute(attrVal)}"`;
-	}
-	return attrStr;
-}
-function propName(obj) {
-	const keys = Object.keys(obj);
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-		if (key !== ":@") return key;
-	}
-}
-/**
-* Build attribute string, resolving attribute names through sanitizeName when configured.
-* Accepts matcher so the callback has path context.
-*/
-function attr_to_str(attrMap, options, isStopNode, matcher, xmlVersion) {
-	let attrStr = "";
-	if (attrMap && !options.ignoreAttributes) for (let attr in attrMap) {
-		if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;
-		const cleanAttrName = attr.substr(options.attributeNamePrefix.length);
-		const resolvedAttrName = isStopNode ? cleanAttrName : resolveTagName$1(cleanAttrName, true, options, matcher, xmlVersion);
-		let attrVal;
-		if (isStopNode) attrVal = attrMap[attr];
-		else {
-			attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
-			attrVal = replaceEntitiesValue(attrVal, options);
+		let cursor = start + 1;
+		const closing = xml[cursor] === "/";
+		if (closing) cursor += 1;
+		const name = matchAt(NAME, xml, cursor)?.[0];
+		if (!name) throw new Error(`invalid tag at offset ${start}`);
+		cursor += name.length;
+		const attributes = [];
+		let selfClosing = false;
+		for (;;) {
+			cursor += matchAt(WHITESPACE, xml, cursor)?.[0].length ?? 0;
+			if (cursor >= xml.length) throw new Error(`unterminated tag <${name}> at offset ${start}`);
+			if (xml.startsWith("/>", cursor)) {
+				selfClosing = true;
+				cursor += 2;
+				break;
+			}
+			if (xml[cursor] === ">") {
+				cursor += 1;
+				break;
+			}
+			const attributeStart = cursor;
+			const attributeName = matchAt(NAME, xml, cursor)?.[0];
+			if (!attributeName) throw new Error(`invalid attribute in <${name}> at offset ${cursor}`);
+			cursor += attributeName.length;
+			cursor += matchAt(WHITESPACE, xml, cursor)?.[0].length ?? 0;
+			if (xml[cursor] !== "=") throw new Error(`attribute ${attributeName} in <${name}> has no value`);
+			cursor += 1;
+			cursor += matchAt(WHITESPACE, xml, cursor)?.[0].length ?? 0;
+			const quote = xml[cursor];
+			if (quote !== "\"" && quote !== "'") throw new Error(`attribute ${attributeName} in <${name}> is not quoted`);
+			const valueEnd = xml.indexOf(quote, cursor + 1);
+			if (valueEnd === -1) throw new Error(`unterminated value of ${attributeName} in <${name}>`);
+			attributes.push({
+				name: attributeName,
+				rawValue: xml.slice(cursor + 1, valueEnd),
+				start: attributeStart,
+				end: valueEnd + 1
+			});
+			cursor = valueEnd + 1;
 		}
-		if (attrVal === true && options.suppressBooleanAttributes) attrStr += ` ${resolvedAttrName}`;
-		else attrStr += ` ${resolvedAttrName}="${escapeAttribute(attrVal)}"`;
+		tags.push({
+			name,
+			start,
+			end: cursor,
+			closing,
+			selfClosing,
+			attributes
+		});
+		index = cursor;
 	}
-	return attrStr;
-}
-function checkStopNode(matcher, stopNodeExpressions) {
-	if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;
-	for (let i = 0; i < stopNodeExpressions.length; i++) if (matcher.matches(stopNodeExpressions[i])) 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 tags;
+};
+const decodeEntities = (value) => value.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);/g, (_, entity) => {
+	switch (entity) {
+		case "amp": return "&";
+		case "lt": return "<";
+		case "gt": return ">";
+		case "quot": return "\"";
+		case "apos": return "'";
+		default: return String.fromCodePoint(entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10));
 	}
-	return textValue;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/fast-xml-builder@1.2.0/node_modules/fast-xml-builder/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;
+});
+const escapeAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+const attributeValue = (tag, name) => {
+	const attribute = tag.attributes.find((item) => item.name === name);
+	return attribute === void 0 ? void 0 : decodeEntities(attribute.rawValue);
+};
+/** The first `<application>` directly under `<manifest>`, with its children. */
+const findApplication = (xml) => {
+	const tags = scanTags(xml);
+	const stack = [];
+	for (let index = 0; index < tags.length; index += 1) {
+		const tag = tags[index];
+		if (tag.closing) {
+			stack.pop();
+			continue;
 		}
-	};
-	return () => false;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/fast-xml-builder@1.2.0/node_modules/fast-xml-builder/src/fxb.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: /* @__PURE__ */ new RegExp("&", "g"),
-			val: "&amp;"
-		},
-		{
-			regex: /* @__PURE__ */ new RegExp(">", "g"),
-			val: "&gt;"
-		},
-		{
-			regex: /* @__PURE__ */ new RegExp("<", "g"),
-			val: "&lt;"
-		},
-		{
-			regex: /* @__PURE__ */ new RegExp("'", "g"),
-			val: "&apos;"
-		},
-		{
-			regex: /* @__PURE__ */ new RegExp("\"", "g"),
-			val: "&quot;"
+		if (!(tag.name === "application" && stack.length === 1 && stack[0] === "manifest")) {
+			if (!tag.selfClosing) stack.push(tag.name);
+			continue;
 		}
-	],
-	processEntities: true,
-	stopNodes: [],
-	oneListGroup: false,
-	maxNestedTags: 100,
-	jPath: true,
-	sanitizeName: false
-};
-function Builder(options) {
-	this.options = Object.assign({}, defaultOptions, options);
-	if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) this.options.stopNodes = this.options.stopNodes.map((node) => {
-		if (typeof node === "string" && node.startsWith("*.")) return ".." + node.substring(2);
-		return node;
-	});
-	this.stopNodeExpressions = [];
-	if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) for (let i = 0; i < this.options.stopNodes.length; i++) {
-		const node = this.options.stopNodes[i];
-		if (typeof node === "string") this.stopNodeExpressions.push(new Expression(node));
-		else if (node instanceof Expression) this.stopNodeExpressions.push(node);
-	}
-	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.processTextOrObjNode = processTextOrObjNode;
-	if (this.options.format) {
-		this.indentate = indentate;
-		this.tagEndChar = ">\n";
-		this.newLine = "\n";
-	} else {
-		this.indentate = function() {
-			return "";
+		if (tag.selfClosing) return {
+			openTag: tag,
+			closeTag: null,
+			children: []
 		};
-		this.tagEndChar = ">";
-		this.newLine = "";
-	}
-}
-/**
-* Detect XML version from the ?xml declaration at the root of a plain-object input.
-* Checks both attributesGroupName and flat attribute forms.
-* Returns '1.0' if no declaration is found.
-*/
-function detectXmlVersionFromObj(jObj, options) {
-	const decl = jObj["?xml"];
-	if (decl && typeof decl === "object") {
-		if (options.attributesGroupName && decl[options.attributesGroupName]) {
-			const v = decl[options.attributesGroupName][options.attributeNamePrefix + "version"];
-			if (v) return v;
+		const children = [];
+		let depth = 0;
+		let open = null;
+		for (let inner = index + 1; inner < tags.length; inner += 1) {
+			const child = tags[inner];
+			if (child.closing) {
+				if (depth === 0) return {
+					openTag: tag,
+					closeTag: child,
+					children
+				};
+				depth -= 1;
+				if (depth === 0 && open) {
+					children.push({
+						openTag: open,
+						start: open.start,
+						end: child.end
+					});
+					open = null;
+				}
+				continue;
+			}
+			if (child.selfClosing) {
+				if (depth === 0) children.push({
+					openTag: child,
+					start: child.start,
+					end: child.end
+				});
+				continue;
+			}
+			if (depth === 0) open = child;
+			depth += 1;
 		}
-		const v = decl[options.attributeNamePrefix + "version"];
-		if (v) return v;
-	}
-	return "1.0";
-}
-/**
-* Resolve a tag or attribute name through sanitizeName if configured.
-* Validation via xml-naming's qName is performed first; the sanitizeName
-* callback is invoked only when the name is invalid. If sanitizeName is
-* false (default), no validation occurs and the name is used as-is.
-*
-* @param {string}  name        - raw name from the JS object
-* @param {boolean} isAttribute - true when resolving an attribute name
-* @param {object}  options
-* @param {Matcher} matcher     - current matcher state (readonly from callback perspective)
-* @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming
-*/
-function resolveTagName(name, isAttribute, options, matcher, xmlVersion) {
-	if (!options.sanitizeName) return name;
-	if (qName(name, { xmlVersion })) return name;
-	return options.sanitizeName(name, {
-		isAttribute,
-		matcher: matcher.readOnly()
-	});
-}
-Builder.prototype.build = function(jObj) {
-	if (this.options.preserveOrder) return toXml(jObj, this.options);
-	else {
-		if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) jObj = { [this.options.arrayNodeName]: jObj };
-		const matcher = new Matcher();
-		const xmlVersion = detectXmlVersionFromObj(jObj, this.options);
-		return this.j2x(jObj, 0, matcher, xmlVersion).val;
-	}
-};
-Builder.prototype.j2x = function(jObj, level, matcher, xmlVersion) {
-	let attrStr = "";
-	let val = "";
-	if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) throw new Error("Maximum nested tags exceeded");
-	const jPath = this.options.jPath ? matcher.toString() : matcher;
-	const isCurrentStopNode = this.checkStopNode(matcher);
-	for (let key in jObj) {
-		if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
-		const resolvedKey = key === this.options.textNodeName || key === this.options.cdataPropName || key === this.options.commentPropName || this.options.attributesGroupName && key === this.options.attributesGroupName || this.isAttribute(key) || key[0] === "?" ? key : resolveTagName(key, false, this.options, matcher, xmlVersion);
-		if (typeof jObj[key] === "undefined") {
-			if (this.isAttribute(key)) val += "";
-		} else if (jObj[key] === null) {
-			if (this.isAttribute(key)) val += "";
-			else if (resolvedKey === this.options.cdataPropName || resolvedKey === this.options.commentPropName) val += "";
-			else if (resolvedKey[0] === "?") val += this.indentate(level) + "<" + resolvedKey + "?" + this.tagEndChar;
-			else val += this.indentate(level) + "<" + resolvedKey + "/" + this.tagEndChar;
-		} else if (jObj[key] instanceof Date) val += this.buildTextValNode(jObj[key], resolvedKey, "", level, matcher);
-		else if (typeof jObj[key] !== "object") {
-			const attr = this.isAttribute(key);
-			if (attr && !this.ignoreAttributesFn(attr, jPath)) {
-				const resolvedAttr = resolveTagName(attr, true, this.options, matcher, xmlVersion);
-				attrStr += this.buildAttrPairStr(resolvedAttr, "" + jObj[key], isCurrentStopNode);
-			} else if (!attr) {
-				if (key === this.options.textNodeName) {
-					let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
-					val += this.replaceEntitiesValue(newval);
-				} else {
-					matcher.push(resolvedKey);
-					const isStopNode = this.checkStopNode(matcher);
-					matcher.pop();
-					if (isStopNode) {
-						const textValue = "" + jObj[key];
-						if (textValue === "") val += this.indentate(level) + "<" + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
-						else val += this.indentate(level) + "<" + resolvedKey + ">" + textValue + "</" + resolvedKey + this.tagEndChar;
-					} else val += this.buildTextValNode(jObj[key], resolvedKey, "", level, matcher);
-				}
-			}
-		} else if (Array.isArray(jObj[key])) {
-			const arrLen = jObj[key].length;
-			let listTagVal = "";
-			let listTagAttr = "";
-			for (let j = 0; j < arrLen; j++) {
-				const item = jObj[key][j];
-				if (typeof item === "undefined") {} else if (item === null) {
-					if (resolvedKey[0] === "?") val += this.indentate(level) + "<" + resolvedKey + "?" + this.tagEndChar;
-					else val += this.indentate(level) + "<" + resolvedKey + "/" + this.tagEndChar;
-				} else if (typeof item === "object") {
-					if (this.options.oneListGroup) {
-						matcher.push(resolvedKey);
-						const result = this.j2x(item, level + 1, matcher, xmlVersion);
-						matcher.pop();
-						listTagVal += result.val;
-						if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) listTagAttr += result.attrStr;
-					} else listTagVal += this.processTextOrObjNode(item, resolvedKey, level, matcher, xmlVersion);
-				} else if (this.options.oneListGroup) {
-					let textValue = this.options.tagValueProcessor(resolvedKey, item);
-					textValue = this.replaceEntitiesValue(textValue);
-					listTagVal += textValue;
-				} else {
-					matcher.push(resolvedKey);
-					const isStopNode = this.checkStopNode(matcher);
-					matcher.pop();
-					if (isStopNode) {
-						const textValue = "" + item;
-						if (textValue === "") listTagVal += this.indentate(level) + "<" + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;
-						else listTagVal += this.indentate(level) + "<" + resolvedKey + ">" + textValue + "</" + resolvedKey + this.tagEndChar;
-					} else listTagVal += this.buildTextValNode(item, resolvedKey, "", level, matcher);
-				}
-			}
-			if (this.options.oneListGroup) listTagVal = this.buildObjectNode(listTagVal, resolvedKey, listTagAttr, level);
-			val += listTagVal;
-		} else if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
-			const Ks = Object.keys(jObj[key]);
-			const L = Ks.length;
-			for (let j = 0; j < L; j++) {
-				const resolvedAttr = resolveTagName(Ks[j], true, this.options, matcher, xmlVersion);
-				attrStr += this.buildAttrPairStr(resolvedAttr, "" + jObj[key][Ks[j]], isCurrentStopNode);
-			}
-		} else val += this.processTextOrObjNode(jObj[key], resolvedKey, level, matcher, xmlVersion);
+		throw new Error("<application> is not closed");
 	}
-	return {
-		attrStr,
-		val
-	};
+	return null;
 };
-Builder.prototype.buildAttrPairStr = function(attrName, val, isStopNode) {
-	if (!isStopNode) {
-		val = this.options.attributeValueProcessor(attrName, "" + val);
-		val = this.replaceEntitiesValue(val);
-	}
-	if (this.options.suppressBooleanAttributes && val === "true") return " " + attrName;
-	else return " " + attrName + "=\"" + escapeAttribute(val) + "\"";
+const metaDataElements = (application, key) => application.children.filter((child) => child.openTag.name === "meta-data" && attributeValue(child.openTag, "android:name") === key);
+/** Leading whitespace of the line that contains `offset`. */
+const lineIndent = (xml, offset) => {
+	const lineStart = xml.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*/.exec(xml.slice(lineStart, offset))?.[0] ?? "";
 };
-function processTextOrObjNode(object, key, level, matcher, xmlVersion) {
-	const attrValues = this.extractAttributes(object);
-	matcher.push(key, attrValues);
-	if (this.checkStopNode(matcher)) {
-		const rawContent = this.buildRawContent(object);
-		const attrStr = this.buildAttributesForStopNode(object);
-		matcher.pop();
-		return this.buildObjectNode(rawContent, key, attrStr, level);
-	}
-	const result = this.j2x(object, level + 1, matcher, xmlVersion);
-	matcher.pop();
-	if (key[0] === "?") return this.buildTextValNode("", key, result.attrStr, level, matcher);
-	else if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);
-	else return this.buildObjectNode(result.val, key, result.attrStr, level);
-}
-Builder.prototype.extractAttributes = function(obj) {
-	if (!obj || typeof obj !== "object") return null;
-	const attrValues = {};
-	let hasAttrs = false;
-	if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {
-		const attrGroup = obj[this.options.attributesGroupName];
-		for (let attrKey in attrGroup) {
-			if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;
-			const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix) ? attrKey.substring(this.options.attributeNamePrefix.length) : attrKey;
-			attrValues[cleanKey] = escapeAttribute(attrGroup[attrKey]);
-			hasAttrs = true;
-		}
-	} else for (let key in obj) {
-		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-		const attr = this.isAttribute(key);
-		if (attr) {
-			attrValues[attr] = escapeAttribute(obj[key]);
-			hasAttrs = true;
-		}
-	}
-	return hasAttrs ? attrValues : null;
+/** Whether only whitespace sits between the start of the line and `offset`. */
+const startsLine = (xml, offset) => {
+	const lineStart = xml.lastIndexOf("\n", offset - 1) + 1;
+	return /^[ \t]*$/.test(xml.slice(lineStart, offset));
 };
-Builder.prototype.buildRawContent = function(obj) {
-	if (typeof obj === "string") return obj;
-	if (typeof obj !== "object" || obj === null) return String(obj);
-	if (obj[this.options.textNodeName] !== void 0) return obj[this.options.textNodeName];
-	let content = "";
-	for (let key in obj) {
-		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-		if (this.isAttribute(key)) continue;
-		if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;
-		const value = obj[key];
-		if (key === this.options.textNodeName) content += value;
-		else if (Array.isArray(value)) {
-			for (let item of value) if (typeof item === "string" || typeof item === "number") content += `<${key}>${item}</${key}>`;
-			else if (typeof item === "object" && item !== null) {
-				const nestedContent = this.buildRawContent(item);
-				const nestedAttrs = this.buildAttributesForStopNode(item);
-				if (nestedContent === "") content += `<${key}${nestedAttrs}/>`;
-				else content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;
-			}
-		} else if (typeof value === "object" && value !== null) {
-			const nestedContent = this.buildRawContent(value);
-			const nestedAttrs = this.buildAttributesForStopNode(value);
-			if (nestedContent === "") content += `<${key}${nestedAttrs}/>`;
-			else content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;
-		} else content += `<${key}>${value}</${key}>`;
-	}
-	return content;
+const lineEnding = (xml) => xml.includes("\r\n") ? "\r\n" : "\n";
+/** `" />"` or `"/>"`, whichever the file already uses more. */
+const selfClosingStyle = (xml) => {
+	return (xml.match(/\s\/>/g)?.length ?? 0) >= (xml.match(/[^\s]\/>/g)?.length ?? 0) ? " />" : "/>";
 };
-Builder.prototype.buildAttributesForStopNode = function(obj) {
-	if (!obj || typeof obj !== "object") return "";
-	let attrStr = "";
-	if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {
-		const attrGroup = obj[this.options.attributesGroupName];
-		for (let attrKey in attrGroup) {
-			if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;
-			const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix) ? attrKey.substring(this.options.attributeNamePrefix.length) : attrKey;
-			const val = attrGroup[attrKey];
-			if (val === true && this.options.suppressBooleanAttributes) attrStr += " " + cleanKey;
-			else attrStr += " " + cleanKey + "=\"" + val + "\"";
-		}
-	} else for (let key in obj) {
-		if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-		const attr = this.isAttribute(key);
-		if (attr) {
-			const val = obj[key];
-			if (val === true && this.options.suppressBooleanAttributes) attrStr += " " + attr;
-			else attrStr += " " + attr + "=\"" + val + "\"";
-		}
-	}
-	return attrStr;
+const indentUnit = (xml, application) => {
+	const applicationIndent = lineIndent(xml, application.openTag.start);
+	if (applicationIndent.includes("	")) return "	";
+	const manifest = /<manifest\b/.exec(xml);
+	const manifestIndent = manifest ? lineIndent(xml, manifest.index) : "";
+	const unit = applicationIndent.slice(manifestIndent.length);
+	return unit.length > 0 ? unit : "    ";
 };
-Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
-	if (val === "") {
-		if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-		else return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
-	} else if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-	else {
-		let tagEndExp = "</" + key + this.tagEndChar;
-		let piClosingChar = "";
-		if (key[0] === "?") {
-			piClosingChar = "?";
-			tagEndExp = "";
+const applyEdits = (xml, edits) => [...edits].sort((a, b) => b.start - a.start).reduce((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), xml);
+/**
+* Sets `<meta-data android:name={key} android:value={value}>` under
+* `<application>`, changing nothing else in the file. An existing element
+* gets its `android:value` replaced in place; otherwise a new element is
+* added as the last child, indented like its siblings.
+*
+* @returns the edited manifest, or null when it has no `<application>`.
+*/
+const setManifestMetaData = (xml, key, value) => {
+	const application = findApplication(xml);
+	if (!application) return null;
+	const valueAttribute = `android:value="${escapeAttribute(value)}"`;
+	const existing = metaDataElements(application, key);
+	if (existing.length > 0) return applyEdits(xml, existing.flatMap(({ openTag }) => {
+		const attribute = (name) => openTag.attributes.find((item) => item.name === name);
+		const current = attribute("android:value");
+		const resource = attribute("android:resource");
+		if (!current && resource) return [{
+			start: resource.start,
+			end: resource.end,
+			text: valueAttribute
+		}];
+		const edits = current ? [{
+			start: current.start,
+			end: current.end,
+			text: valueAttribute
+		}] : [{
+			start: attribute("android:name").end,
+			end: attribute("android:name").end,
+			text: ` ${valueAttribute}`
+		}];
+		if (resource) {
+			let start = resource.start;
+			while (start > openTag.start && /\s/.test(xml[start - 1])) start -= 1;
+			edits.push({
+				start,
+				end: resource.end,
+				text: ""
+			});
 		}
-		if ((attrStr || attrStr === "") && val.indexOf("<") === -1) return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
-		else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) return this.indentate(level) + `<!--${val}-->` + this.newLine;
-		else return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
-	}
+		return edits;
+	}));
+	const eol = lineEnding(xml);
+	const element = `<meta-data android:name="${escapeAttribute(key)}" ${valueAttribute}${selfClosingStyle(xml)}`;
+	const applicationIndent = lineIndent(xml, application.openTag.start);
+	const lastChild = application.children.at(-1);
+	const childIndent = lastChild && startsLine(xml, lastChild.start) ? lineIndent(xml, lastChild.start) : applicationIndent + indentUnit(xml, application);
+	if (application.closeTag === null) {
+		const { openTag } = application;
+		const head = xml.slice(openTag.start, openTag.end).replace(/\s*\/>$/, ">");
+		return applyEdits(xml, [{
+			start: openTag.start,
+			end: openTag.end,
+			text: `${head}${eol}${childIndent}${element}${eol}${applicationIndent}</application>`
+		}]);
+	}
+	const closeStart = application.closeTag.start;
+	if (startsLine(xml, closeStart)) {
+		const lineStart = xml.lastIndexOf("\n", closeStart - 1) + 1;
+		return applyEdits(xml, [{
+			start: lineStart,
+			end: lineStart,
+			text: `${childIndent}${element}${eol}`
+		}]);
+	}
+	return applyEdits(xml, [{
+		start: closeStart,
+		end: closeStart,
+		text: element
+	}]);
 };
-Builder.prototype.closeTag = function(key) {
-	let closeTag = "";
-	if (this.options.unpairedTags.indexOf(key) !== -1) {
-		if (!this.options.suppressUnpairedNode) closeTag = "/";
-	} else if (this.options.suppressEmptyNode) closeTag = "/";
-	else closeTag = `></${key}`;
-	return closeTag;
-};
-Builder.prototype.checkStopNode = function(matcher) {
-	if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;
-	for (let i = 0; i < this.stopNodeExpressions.length; i++) if (matcher.matches(this.stopNodeExpressions[i])) return true;
-	return false;
-};
-Builder.prototype.buildTextValNode = function(val, key, attrStr, level, matcher) {
-	if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
-		const safeVal = safeCdata(val);
-		return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;
-	} else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
-		const safeVal = safeComment(val);
-		return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;
-	} else if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
-	else {
-		let textValue = this.options.tagValueProcessor(key, val);
-		textValue = this.replaceEntitiesValue(textValue);
-		if (textValue === "") return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
-		else return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
-	}
-};
-Builder.prototype.replaceEntitiesValue = function(textValue) {
-	if (textValue && textValue.length > 0 && this.options.processEntities) for (let i = 0; i < this.options.entities.length; i++) {
-		const entity = this.options.entities[i];
-		textValue = textValue.replace(entity.regex, entity.val);
-	}
-	return textValue;
+/**
+* Removes every `<meta-data android:name={key}>` under `<application>`. An
+* element alone on its line takes the line with it.
+*
+* @returns the edited manifest, or null when there was nothing to remove.
+*/
+const removeManifestMetaData = (xml, key) => {
+	const application = findApplication(xml);
+	if (!application) return null;
+	const existing = metaDataElements(application, key);
+	if (existing.length === 0) return null;
+	return applyEdits(xml, existing.map(({ start, end }) => {
+		const lineStart = xml.lastIndexOf("\n", start - 1) + 1;
+		const newline = xml.indexOf("\n", end);
+		const lineEnd = newline === -1 ? xml.length : newline + 1;
+		return /^[ \t]*$/.test(xml.slice(lineStart, start)) && /^[ \t]*\r?\n?$/.test(xml.slice(end, lineEnd)) ? {
+			start: lineStart,
+			end: lineEnd,
+			text: ""
+		} : {
+			start,
+			end,
+			text: ""
+		};
+	}));
 };
-function indentate(level) {
-	return this.options.indentBy.repeat(level);
-}
-function isAttribute(name) {
-	if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) return name.substr(this.attrPrefixLen);
-	else return false;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/fast-xml-parser@5.7.2/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
-var json2xml_default = Builder;
 //#endregion
 //#region src/utils/configParser/androidParser.ts
 /** The AndroidManifest meta-data names the native SDK reads. */
@@ -4617,7 +4240,6 @@ const MANIFEST_KEYS = /* @__PURE__ */ new Set([
 var AndroidConfigParser = class {
 	androidManifestPaths;
 	parser;
-	builder;
 	constructor(androidManifestPaths) {
 		this.androidManifestPaths = (androidManifestPaths || []).map((p) => path.isAbsolute(p) ? p : path.join(getCwd(), p));
 		const options = {
@@ -4629,13 +4251,6 @@ var AndroidConfigParser = class {
 			suppressEmptyNode: true
 		};
 		this.parser = new XMLParser(options);
-		this.builder = new json2xml_default({
-			...options,
-			format: true,
-			indentBy: "    ",
-			suppressBooleanAttributes: false,
-			processEntities: true
-		});
 	}
 	async exists() {
 		return this.getExistingManifestPaths().length > 0;
@@ -4688,14 +4303,8 @@ var AndroidConfigParser = class {
 		const updatedPaths = [];
 		for (const androidManifestPath of existingManifestPaths) try {
 			const content = await fs.promises.readFile(androidManifestPath, "utf-8");
-			const result = this.parser.parse(content);
-			const application = this.getApplication(result);
-			if (!application?.["meta-data"]) continue;
-			const metaData = Array.isArray(application["meta-data"]) ? application["meta-data"] : [application["meta-data"]];
-			const filtered = metaData.filter((item) => item["@_android:name"] !== manifestKey);
-			if (filtered.length === metaData.length) continue;
-			application["meta-data"] = filtered.length === 0 ? void 0 : filtered.length === 1 ? filtered[0] : filtered;
-			const newContent = this.builder.build(result);
+			const newContent = removeManifestMetaData(content, manifestKey);
+			if (newContent === null) continue;
 			await fs.promises.writeFile(androidManifestPath, newContent, "utf-8");
 			updatedPaths.push(path.relative(getCwd(), androidManifestPath));
 		} catch (error) {
@@ -4717,21 +4326,9 @@ var AndroidConfigParser = class {
 		const updatedPaths = [];
 		for (const androidManifestPath of existingPaths) try {
 			const content = await fs.promises.readFile(androidManifestPath, "utf-8");
-			const result = this.parser.parse(content);
-			const application = this.getApplication(result);
-			if (!application) continue;
-			if (!application["meta-data"]) application["meta-data"] = [];
-			const metaData = Array.isArray(application["meta-data"]) ? application["meta-data"] : [application["meta-data"]];
-			const existingIndex = metaData.findIndex((item) => item["@_android:name"] === key);
-			const metaDataElement = {
-				"@_android:name": key,
-				"@_android:value": value
-			};
-			if (existingIndex !== -1) metaData[existingIndex] = metaDataElement;
-			else metaData.push(metaDataElement);
-			application["meta-data"] = metaData.length === 1 ? metaData[0] : metaData;
-			const newContent = this.builder.build(result);
-			await fs.promises.writeFile(androidManifestPath, newContent, "utf-8");
+			const newContent = setManifestMetaData(content, key, value);
+			if (newContent === null) continue;
+			if (newContent !== content) await fs.promises.writeFile(androidManifestPath, newContent, "utf-8");
 			updatedPaths.push(path.relative(getCwd(), androidManifestPath));
 		} catch (error) {
 			throw new Error(`Failed to parse or update AndroidManifest.xml: ${error}`);
@@ -15021,7 +14618,7 @@ var require_build = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 //#endregion
-//#region src/utils/configParser/bplistParser.ts
+//#region src/utils/configParser/plistFormat.ts
 var import_plist = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
 	/**
 	* Parser functions.
@@ -15038,6 +14635,61 @@ var import_plist = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((expo
 		exports[k] = builderFunctions[k];
 	});
 })))(), 1);
+/** Elements whose text can span several lines in a pretty-printed plist. */
+const TEXT_ELEMENT = /<(key|string|data|date|integer|real)>/;
+const closingTag = (name) => `</${name}>`;
+/**
+* Lays out `plist.build` output the way Xcode writes an Info.plist, so that
+* writing one key does not shift every other line of the file.
+*
+* `plist.build` indents everything under `<plist>` one level, while Xcode
+* puts the root `<dict>` at column 0. When the previous file had its root at
+* column 0 (or there is no previous file), every element line under `<plist>`
+* loses one leading tab. A file whose root is already indented under
+* `<plist>` (the layout `plist.build` itself writes) is left indented. Text of a multi-line value is left as it is: a text line
+* never starts with a raw `<`, and lines between an opening and a closing text
+* tag are skipped. The file keeps the trailing newline it had.
+*/
+function formatPlistLikeXcode(built, previous) {
+	const lines = built.split("\n");
+	const formatted = [];
+	let insidePlist = false;
+	let openText = null;
+	const dedent = previous === void 0 || rootIsAtColumnZero(previous);
+	for (const line of lines) {
+		if (openText !== null) {
+			formatted.push(line);
+			if (line.includes(closingTag(openText))) openText = null;
+			continue;
+		}
+		if (line.startsWith("</plist>")) insidePlist = false;
+		formatted.push(dedent && insidePlist && /^\t+</.test(line) ? line.slice(1) : line);
+		if (/^<plist\b/.test(line)) insidePlist = true;
+		const opened = TEXT_ELEMENT.exec(line);
+		if (opened) {
+			if (!line.slice(opened.index + opened[0].length).includes(closingTag(opened[1]))) openText = opened[1];
+		}
+	}
+	let result = formatted.join("\n");
+	if (previous?.endsWith("\n") && !result.endsWith("\n")) result += "\n";
+	return result;
+}
+/**
+* Whether the root element under `<plist>` in `xml` starts at column 0.
+* Blank lines and XML comments before the root are skipped.
+*/
+function rootIsAtColumnZero(xml) {
+	const open = /<plist\b[^>]*>/.exec(xml);
+	if (!open) return true;
+	const rest = xml.slice(open.index + open[0].length).replace(/<!--[\s\S]*?-->/g, (comment) => comment.replace(/[^\n]/g, " "));
+	for (const line of rest.split("\n").slice(1)) {
+		const indent = /^[^\S\n]*(?=<)/.exec(line);
+		if (indent) return indent[0] === "";
+	}
+	return true;
+}
+//#endregion
+//#region src/utils/configParser/bplistParser.ts
 const MAX_OBJECT_SIZE = 1e8;
 const MAX_OBJECT_COUNT = 32768;
 const EPOCH = 9783072e5;
@@ -15329,13 +14981,14 @@ var IosConfigParser = class {
 		for (const plistFile of plistPaths) {
 			const relativePath = path.relative(getCwd(), plistFile);
 			try {
-				const plistObject = parsePlist(await fs.promises.readFile(plistFile));
+				const plistBuffer = await fs.promises.readFile(plistFile);
+				const plistObject = parsePlist(plistBuffer);
 				if (!(key in plistObject)) continue;
 				delete plistObject[key];
-				const newPlistXml = import_plist.default.build(plistObject, {
+				const newPlistXml = formatPlistLikeXcode(import_plist.default.build(plistObject, {
 					indent: "	",
 					pretty: true
-				});
+				}), plistBuffer.toString("utf-8"));
 				await fs.promises.writeFile(plistFile, newPlistXml);
 				updatedPaths.push(relativePath);
 			} catch (error) {
@@ -15354,13 +15007,14 @@ var IosConfigParser = class {
 		for (const plistFile of plistPaths) {
 			const relativePath = path.relative(getCwd(), plistFile);
 			try {
-				const plistObject = parsePlist(await fs.promises.readFile(plistFile));
+				const plistBuffer = await fs.promises.readFile(plistFile);
+				const plistObject = parsePlist(plistBuffer);
 				if (plistObject[key] === value) continue;
 				plistObject[key] = value;
-				const newPlistXml = import_plist.default.build(plistObject, {
+				const newPlistXml = formatPlistLikeXcode(import_plist.default.build(plistObject, {
 					indent: "	",
 					pretty: true
-				});
+				}), plistBuffer.toString("utf-8"));
 				await fs.promises.writeFile(plistFile, newPlistXml);
 				updatedPaths.push(relativePath);
 			} catch (error) {