@ai-sdk-tool/rxml 0.1.0 → 0.1.2-canary.0

package/dist/index.cjs

@@ -27,16 +27,19 @@ __export(index_exports, {
   RXMLStringifyError: () => RXMLStringifyError,
   XMLTokenizer: () => XMLTokenizer,
   XMLTransformStream: () => XMLTransformStream,
+  coerceBySchema: () => coerceBySchema,
   coerceDomBySchema: () => coerceDomBySchema,
   countTagOccurrences: () => countTagOccurrences,
   createXMLStream: () => createXMLStream,
   domToObject: () => domToObject,
   extractRawInner: () => extractRawInner,
   filter: () => filter,
+  findAllTopLevelRanges: () => findAllTopLevelRanges,
   findElementByIdStream: () => findElementByIdStream,
   findElementsByClassStream: () => findElementsByClassStream,
   findFirstTopLevelRange: () => findFirstTopLevelRange,
   getPropertySchema: () => getPropertySchema,
+  getSchemaType: () => getSchemaType,
   getStringTypedProperties: () => getStringTypedProperties,
   parse: () => parse,
   parseFromStream: () => parseFromStream,
@@ -49,7 +52,9 @@ __export(index_exports, {
   stringify: () => stringify,
   stringifyNode: () => stringifyNode,
   stringifyNodes: () => stringifyNodes,
-  toContentString: () => toContentString
+  toContentString: () => toContentString,
+  unescapeXml: () => unescapeXml,
+  unwrapJsonSchema: () => unwrapJsonSchema
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -57,10 +62,10 @@ module.exports = __toCommonJS(index_exports);
 var RXMLParseError = class extends Error {
   constructor(message, cause, line, column) {
     super(message);
+    this.name = "RXMLParseError";
     this.cause = cause;
     this.line = line;
     this.column = column;
-    this.name = "RXMLParseError";
   }
 };
 var RXMLDuplicateStringTagError = class extends Error {
@@ -72,384 +77,25 @@ var RXMLDuplicateStringTagError = class extends Error {
 var RXMLCoercionError = class extends Error {
   constructor(message, cause) {
     super(message);
-    this.cause = cause;
     this.name = "RXMLCoercionError";
+    this.cause = cause;
   }
 };
 var RXMLStringifyError = class extends Error {
   constructor(message, cause) {
     super(message);
-    this.cause = cause;
     this.name = "RXMLStringifyError";
+    this.cause = cause;
   }
 };
 var RXMLStreamError = class extends Error {
   constructor(message, cause) {
     super(message);
-    this.cause = cause;
     this.name = "RXMLStreamError";
+    this.cause = cause;
   }
 };
 
-// src/schema/base-coercion.ts
-function unwrapJsonSchema(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-  const s = schema;
-  if (s.jsonSchema && typeof s.jsonSchema === "object") {
-    return unwrapJsonSchema(s.jsonSchema);
-  }
-  return schema;
-}
-function getSchemaType(schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") return void 0;
-  const t = unwrapped.type;
-  if (typeof t === "string") return t;
-  if (Array.isArray(t)) {
-    const preferred = [
-      "object",
-      "array",
-      "boolean",
-      "number",
-      "integer",
-      "string"
-    ];
-    for (const p of preferred) if (t.includes(p)) return p;
-  }
-  const s = unwrapped;
-  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
-    return "object";
-  }
-  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
-    return "array";
-  }
-  return void 0;
-}
-function coerceBySchema(value, schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    if (typeof value === "string") {
-      const s = value.trim();
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-        const num = Number(s);
-        if (Number.isFinite(num)) return num;
-      }
-      if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
-        try {
-          const parsed = JSON.parse(s);
-          return coerceBySchema(parsed, void 0);
-        } catch (e) {
-        }
-      }
-    }
-    return value;
-  }
-  const schemaType = getSchemaType(unwrapped);
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "object") {
-      try {
-        let normalized = s.replace(/'/g, '"');
-        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
-        const obj = JSON.parse(normalized);
-        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-          const props = unwrapped.properties;
-          const out = {};
-          for (const [k, v] of Object.entries(obj)) {
-            const propSchema = props ? props[k] : void 0;
-            out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-          }
-          return out;
-        }
-      } catch (e) {
-      }
-    }
-    if (schemaType === "array") {
-      try {
-        const normalized = s.replace(/'/g, '"');
-        const arr = JSON.parse(normalized);
-        if (Array.isArray(arr)) {
-          const u = unwrapped;
-          const prefixItems = Array.isArray(
-            u.prefixItems
-          ) ? u.prefixItems : void 0;
-          const itemsSchema = u.items;
-          if (prefixItems && arr.length === prefixItems.length) {
-            return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-          }
-          return arr.map((v) => coerceBySchema(v, itemsSchema));
-        }
-      } catch (e) {
-        const csv = s.includes("\n") ? s.split(/\n+/) : s.split(/,\s*/);
-        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
-        const u = unwrapped;
-        const prefixItems = Array.isArray(
-          u.prefixItems
-        ) ? u.prefixItems : void 0;
-        const itemsSchema = u.items;
-        if (prefixItems && trimmed.length === prefixItems.length) {
-          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
-        }
-        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
-      }
-    }
-  }
-  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
-    const out = {};
-    const props = unwrapped.properties;
-    for (const [k, v] of Object.entries(value)) {
-      const propSchema = props ? props[k] : void 0;
-      out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-    }
-    return out;
-  }
-  if (schemaType === "array") {
-    const u = unwrapped;
-    const itemsSchema = u.items;
-    const prefixItems = Array.isArray(
-      u.prefixItems
-    ) ? u.prefixItems : void 0;
-    if (Array.isArray(value)) {
-      if (prefixItems && value.length === prefixItems.length) {
-        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
-      }
-      return value.map((v) => coerceBySchema(v, itemsSchema));
-    }
-    if (value && typeof value === "object") {
-      const maybe = value;
-      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
-        const items = maybe.item;
-        const arr = Array.isArray(items) ? items : [items];
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      const keys = Object.keys(maybe);
-      if (keys.length === 1) {
-        const singleKey = keys[0];
-        const singleValue = maybe[singleKey];
-        if (Array.isArray(singleValue)) {
-          const coercedArray = singleValue.map(
-            (v) => coerceBySchema(v, itemsSchema)
-          );
-          return coercedArray;
-        }
-      }
-      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
-        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
-        if (prefixItems && arr.length === prefixItems.length) {
-          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-        }
-        return arr.map((v) => coerceBySchema(v, itemsSchema));
-      }
-    }
-    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      if (prefixItems && prefixItems.length > 0) {
-        return [coerceBySchema(value, prefixItems[0])];
-      }
-      return [coerceBySchema(value, itemsSchema)];
-    }
-  }
-  if (typeof value === "string") {
-    const s = value.trim();
-    if (schemaType === "boolean") {
-      const lower = s.toLowerCase();
-      if (lower === "true") return true;
-      if (lower === "false") return false;
-    }
-    if (schemaType === "number" || schemaType === "integer") {
-      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
-        const num = Number(s);
-        if (Number.isFinite(num)) return num;
-      }
-    }
-  }
-  return value;
-}
-
-// src/schema/coercion.ts
-function getPropertySchema(toolSchema, key) {
-  const unwrapped = unwrapJsonSchema(toolSchema);
-  if (!unwrapped || typeof unwrapped !== "object") return void 0;
-  const u = unwrapped;
-  const props = u.properties;
-  if (props && Object.prototype.hasOwnProperty.call(props, key)) {
-    return props[key];
-  }
-  return void 0;
-}
-function domToObject(nodes, schema, textNodeName = "#text") {
-  const result = {};
-  for (const node of nodes) {
-    if (typeof node === "string") {
-      continue;
-    }
-    const { tagName, children, attributes } = node;
-    let value;
-    if (children.length === 0) {
-      value = "";
-    } else if (children.length === 1 && typeof children[0] === "string") {
-      value = children[0];
-    } else {
-      value = processComplexContent(
-        children,
-        getPropertySchema(schema, tagName),
-        textNodeName
-      );
-    }
-    if (Object.keys(attributes).length > 0) {
-      if (typeof value === "string") {
-        const result2 = { [textNodeName]: value };
-        for (const [attrName, attrValue] of Object.entries(attributes)) {
-          result2[`@_${attrName}`] = attrValue;
-        }
-        value = result2;
-      } else if (value && typeof value === "object" && !Array.isArray(value)) {
-        for (const [attrName, attrValue] of Object.entries(attributes)) {
-          value[`@_${attrName}`] = attrValue;
-        }
-      }
-    }
-    if (result[tagName]) {
-      if (!Array.isArray(result[tagName])) {
-        result[tagName] = [result[tagName]];
-      }
-      result[tagName].push(value);
-    } else {
-      result[tagName] = value;
-    }
-  }
-  return result;
-}
-function processComplexContent(children, schema, textNodeName) {
-  const textContent = [];
-  const elements = {};
-  for (const child of children) {
-    if (typeof child === "string") {
-      textContent.push(child);
-    } else {
-      let childValue;
-      if (child.children.length === 0) {
-        childValue = "";
-      } else if (child.children.length === 1 && typeof child.children[0] === "string") {
-        childValue = child.children[0];
-      } else {
-        childValue = processComplexContent(
-          child.children,
-          getPropertySchema(schema, child.tagName),
-          textNodeName
-        );
-      }
-      if (Object.keys(child.attributes).length > 0) {
-        if (typeof childValue === "string") {
-          const result = {
-            [textNodeName]: childValue
-          };
-          for (const [attrName, attrValue] of Object.entries(
-            child.attributes
-          )) {
-            result[`@_${attrName}`] = attrValue;
-          }
-          childValue = result;
-        } else if (childValue && typeof childValue === "object" && !Array.isArray(childValue)) {
-          for (const [attrName, attrValue] of Object.entries(
-            child.attributes
-          )) {
-            childValue[`@_${attrName}`] = attrValue;
-          }
-        }
-      }
-      if (elements[child.tagName]) {
-        if (!Array.isArray(elements[child.tagName])) {
-          elements[child.tagName] = [elements[child.tagName]];
-        }
-        elements[child.tagName].push(childValue);
-      } else {
-        elements[child.tagName] = childValue;
-      }
-    }
-  }
-  if (textContent.length > 0 && Object.keys(elements).length > 0) {
-    return {
-      [textNodeName]: textContent.join("").trim(),
-      ...elements
-    };
-  }
-  if (textContent.length > 0 && Object.keys(elements).length === 0) {
-    return textContent.join("").trim();
-  }
-  if (Object.keys(elements).length > 0) {
-    return elements;
-  }
-  return "";
-}
-function coerceDomBySchema(domObject, schema) {
-  try {
-    return coerceBySchema(domObject, schema);
-  } catch (error) {
-    throw new RXMLCoercionError("Failed to coerce DOM object by schema", error);
-  }
-}
-function getStringTypedProperties(schema) {
-  const set = /* @__PURE__ */ new Set();
-  const unwrapped = unwrapJsonSchema(schema);
-  if (unwrapped && typeof unwrapped === "object") {
-    const u = unwrapped;
-    const props = u.properties;
-    if (props && typeof props === "object") {
-      for (const key of Object.keys(props)) {
-        const propSchema = props[key];
-        const propType = getSchemaType(propSchema);
-        if (propType === "string") {
-          set.add(key);
-        }
-      }
-    }
-  }
-  return set;
-}
-function processArrayContent(value, schema, textNodeName) {
-  if (!Array.isArray(value)) return value;
-  const schemaType = getSchemaType(schema);
-  if (schemaType === "string") {
-    return value.map((item) => {
-      if (typeof item === "string") return item.trim();
-      if (item && typeof item === "object" && textNodeName in item) {
-        const textVal = item[textNodeName];
-        return typeof textVal === "string" ? textVal.trim() : String(textVal);
-      }
-      return String(item);
-    });
-  }
-  return value.map((item) => {
-    if (typeof item === "string") return item.trim();
-    if (item && typeof item === "object" && textNodeName in item) {
-      const textVal = item[textNodeName];
-      return typeof textVal === "string" ? textVal.trim() : textVal;
-    }
-    return item;
-  });
-}
-function processIndexedTuple(obj, textNodeName) {
-  const keys = Object.keys(obj);
-  const indices = keys.map((k) => parseInt(k, 10)).sort((a, b) => a - b);
-  const isValidTuple = indices[0] === 0 && indices.every((val, idx) => val === idx);
-  if (!isValidTuple) return [obj];
-  const sortedKeys = keys.sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
-  return sortedKeys.map((key) => {
-    const item = obj[key];
-    if (item && typeof item === "object" && textNodeName in item) {
-      const textVal = item[textNodeName];
-      return typeof textVal === "string" ? textVal.trim() : textVal;
-    }
-    return typeof item === "string" ? item.trim() : item;
-  });
-}
-
 // src/core/types.ts
 var CharCodes = {
   OPEN_BRACKET: "<".charCodeAt(0),
@@ -486,32 +132,37 @@ var DEFAULT_NO_CHILD_NODES = [
 var NAME_SPACER = "\r\n	>/= ";
 
 // src/utils/helpers.ts
+var NAME_START_CHAR_REGEX = /[A-Za-z_:]/;
+var NAME_CHAR_REGEX = /[A-Za-z0-9_.:-]/;
 function isNameStartChar(ch) {
-  return /[A-Za-z_:]/.test(ch);
+  return NAME_START_CHAR_REGEX.test(ch);
 }
 function isNameChar(ch) {
-  return /[A-Za-z0-9_.:-]/.test(ch);
+  return NAME_CHAR_REGEX.test(ch);
 }
 function skipQuoted(s, i) {
   const quote = s[i];
-  i++;
-  while (i < s.length) {
-    const ch = s[i];
+  let pos = i + 1;
+  while (pos < s.length) {
+    const ch = s[pos];
     if (ch === "\\") {
-      i += 2;
+      pos += 2;
       continue;
     }
-    if (ch === quote) return i + 1;
-    i++;
+    if (ch === quote) {
+      return pos + 1;
+    }
+    pos += 1;
   }
-  return i;
+  return pos;
 }
 function parseName(s, pos) {
   const start = pos;
-  while (NAME_SPACER.indexOf(s[pos]) === -1 && s[pos]) {
-    pos++;
+  let currentPos = pos;
+  while (NAME_SPACER.indexOf(s[currentPos]) === -1 && s[currentPos]) {
+    currentPos += 1;
   }
-  return { name: s.slice(start, pos), newPos: pos };
+  return { name: s.slice(start, currentPos), newPos: currentPos };
 }
 function parseString(s, pos) {
   const startChar = s[pos];
@@ -529,12 +180,12 @@ function parseString(s, pos) {
 function getLineColumn(s, pos) {
   let line = 1;
   let column = 1;
-  for (let i = 0; i < pos && i < s.length; i++) {
+  for (let i = 0; i < pos && i < s.length; i += 1) {
     if (s[i] === "\n") {
-      line++;
+      line += 1;
       column = 1;
     } else {
-      column++;
+      column += 1;
     }
   }
   return { line, column };
@@ -554,383 +205,1361 @@ function escapeXmlMinimalAttr(value, wrapper = '"') {
   }
   return escaped;
 }
+function unescapeXml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
 
-// src/schema/extraction.ts
-function extractRawInner(xmlContent, tagName) {
-  const len = xmlContent.length;
-  const target = tagName;
-  let bestStart = -1;
-  let bestEnd = -1;
-  let bestDepth = Number.POSITIVE_INFINITY;
-  let i = 0;
-  let depth = 0;
-  while (i < len) {
-    const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) return void 0;
-    i = lt + 1;
-    if (i >= len) return void 0;
-    const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
-      continue;
-    } else if (ch === "/") {
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      depth = Math.max(0, depth - 1);
-      continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      let isSelfClosing = false;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") break;
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          isSelfClosing = true;
-          k++;
-          break;
-        }
-        k++;
-      }
-      const tagEnd = k;
-      if (name === target) {
-        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-        if (isSelfClosing) {
-          if (depth < bestDepth) {
-            bestStart = contentStart;
-            bestEnd = contentStart;
-            bestDepth = depth;
-          }
-        } else {
-          let pos = contentStart;
-          let sameDepth = 1;
-          while (pos < len) {
-            const nextLt = xmlContent.indexOf("<", pos);
-            if (nextLt === -1) break;
-            const nx = nextLt + 1;
-            if (nx >= len) break;
-            const h = xmlContent[nx];
-            if (h === "!") {
-              if (xmlContent.startsWith("!--", nx + 1)) {
-                const close = xmlContent.indexOf("-->", nx + 4);
-                pos = close === -1 ? len : close + 3;
-                continue;
-              }
-              if (xmlContent.startsWith("![CDATA[", nx + 1)) {
-                const close = xmlContent.indexOf("]]>", nx + 9);
-                pos = close === -1 ? len : close + 3;
-                continue;
-              }
-              const gt2 = xmlContent.indexOf(">", nx + 1);
-              pos = gt2 === -1 ? len : gt2 + 1;
-              continue;
-            } else if (h === "?") {
-              const close = xmlContent.indexOf("?>", nx + 1);
-              pos = close === -1 ? len : close + 2;
-              continue;
-            } else if (h === "/") {
-              let t = nx + 1;
-              if (t < len && isNameStartChar(xmlContent[t])) {
-                t++;
-                while (t < len && isNameChar(xmlContent[t])) t++;
-              }
-              const endName = xmlContent.slice(nx + 1, t);
-              const gt2 = xmlContent.indexOf(">", t);
-              if (endName === target) {
-                sameDepth--;
-                if (sameDepth === 0) {
-                  if (depth < bestDepth) {
-                    bestStart = contentStart;
-                    bestEnd = nextLt;
-                    bestDepth = depth;
-                  }
-                  break;
-                }
-              }
-              pos = gt2 === -1 ? len : gt2 + 1;
-              continue;
-            } else {
-              let t = nx;
-              if (t < len && isNameStartChar(xmlContent[t])) {
-                t++;
-                while (t < len && isNameChar(xmlContent[t])) t++;
-              }
-              let u = t;
-              let isSelfClosingNested = false;
-              while (u < len) {
-                const cu = xmlContent[u];
-                if (cu === '"' || cu === "'") {
-                  u = skipQuoted(xmlContent, u);
-                  continue;
-                }
-                if (cu === ">") break;
-                if (cu === "/" && xmlContent[u + 1] === ">") {
-                  isSelfClosingNested = true;
-                  u++;
-                  break;
-                }
-                u++;
-              }
-              const startName = xmlContent.slice(nx, t);
-              if (startName === target && !isSelfClosingNested) {
-                sameDepth++;
-              }
-              pos = xmlContent[u] === ">" ? u + 1 : u + 1;
-              continue;
-            }
-          }
-        }
-      }
-      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-      depth += isSelfClosing ? 0 : 1;
-      continue;
+// src/builders/stringify.ts
+function stringify(rootTag, obj, options = {}) {
+  var _a, _b, _c, _d;
+  try {
+    const format = (_a = options.format) != null ? _a : true;
+    const minimalEscaping = (_b = options.minimalEscaping) != null ? _b : false;
+    const suppressEmptyNode = (_c = options.suppressEmptyNode) != null ? _c : false;
+    const strictBooleanAttributes = (_d = options.strictBooleanAttributes) != null ? _d : false;
+    let result = "";
+    if (format) {
+      result += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    }
+    result += stringifyValue(rootTag, obj, {
+      depth: 0,
+      format,
+      suppressEmptyNode,
+      minimalEscaping,
+      strictBooleanAttributes
+    });
+    return result;
+  } catch (error) {
+    throw new RXMLStringifyError("Failed to stringify XML", error);
+  }
+}
+function escapeContent(content, minimalEscaping) {
+  return minimalEscaping ? escapeXmlMinimalText(content) : escapeXml(content);
+}
+function createSelfClosingTag(tagName, indent, newline) {
+  return `${indent}<${tagName}/>${newline}`;
+}
+function createTextElement(tagName, content, indent, newline) {
+  return `${indent}<${tagName}>${content}</${tagName}>${newline}`;
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function stringifyPrimitive(tagName, value, context, format) {
+  const { minimalEscaping, suppressEmptyNode } = context;
+  const content = escapeContent(String(value), minimalEscaping);
+  if (content === "" && suppressEmptyNode) {
+    return "";
+  }
+  return createTextElement(tagName, content, format.indent, format.newline);
+}
+function stringifyArray(tagName, value, context) {
+  let result = "";
+  for (const item of value) {
+    result += stringifyValue(tagName, item, context);
+  }
+  return result;
+}
+function stringifyValue(tagName, value, context) {
+  const { format, suppressEmptyNode, minimalEscaping } = context;
+  const indent = format ? "  ".repeat(context.depth) : "";
+  const newline = format ? "\n" : "";
+  if (value === null || value === void 0) {
+    if (suppressEmptyNode) {
+      return "";
+    }
+    return createSelfClosingTag(tagName, indent, newline);
+  }
+  if (isPrimitive(value)) {
+    return stringifyPrimitive(tagName, value, context, { indent, newline });
+  }
+  if (Array.isArray(value)) {
+    return stringifyArray(tagName, value, context);
+  }
+  if (typeof value === "object") {
+    return stringifyObject(tagName, value, context);
+  }
+  const content = escapeContent(String(value), minimalEscaping);
+  if (content === "" && suppressEmptyNode) {
+    return "";
+  }
+  return createTextElement(tagName, content, indent, newline);
+}
+function extractObjectParts(obj) {
+  const attributes = {};
+  const elements = {};
+  let textContent;
+  for (const [key, value] of Object.entries(obj)) {
+    if (key.startsWith("@")) {
+      attributes[key.substring(1)] = value;
+    } else if (key === "#text" || key === "_text") {
+      textContent = String(value);
+    } else if (key === "_attributes") {
+      if (typeof value === "object" && value !== null) {
+        Object.assign(attributes, value);
+      }
+    } else {
+      elements[key] = value;
+    }
+  }
+  return { attributes, elements, textContent };
+}
+function formatAttribute(attrName, attrValue, minimalEscaping, strictBooleanAttributes) {
+  if (attrValue === null) {
+    return strictBooleanAttributes ? ` ${attrName}="${attrName}"` : ` ${attrName}`;
+  }
+  const valueStr = String(attrValue);
+  if (valueStr.indexOf('"') === -1) {
+    const escaped2 = minimalEscaping ? escapeXmlMinimalAttr(valueStr, '"') : escapeXml(valueStr);
+    return ` ${attrName}="${escaped2}"`;
+  }
+  const escaped = minimalEscaping ? escapeXmlMinimalAttr(valueStr, "'") : escapeXml(valueStr);
+  return ` ${attrName}='${escaped}'`;
+}
+function buildOpeningTag(tagName, attributes, context) {
+  let openTag = `<${tagName}`;
+  const { minimalEscaping, strictBooleanAttributes } = context;
+  for (const [attrName, attrValue] of Object.entries(attributes)) {
+    openTag += formatAttribute(
+      attrName,
+      attrValue,
+      minimalEscaping,
+      strictBooleanAttributes
+    );
+  }
+  return openTag;
+}
+function stringifyTextOnlyContent(options) {
+  const { tagName, textContent, openTag, format, minimalEscaping } = options;
+  const content = escapeContent(textContent, minimalEscaping);
+  return `${format.indent}${openTag}${content}</${tagName}>${format.newline}`;
+}
+function stringifyComplexContent(tagName, parts, context, options) {
+  const { format, minimalEscaping, depth } = context;
+  const { textContent, elements } = parts;
+  const hasElements = Object.keys(elements).length > 0;
+  let result = `${options.indent}${options.openTag}`;
+  if (textContent) {
+    const content = escapeContent(textContent, minimalEscaping);
+    result += format ? `${options.newline}${options.childIndent}${content}` : content;
+  }
+  if (hasElements) {
+    if (format) {
+      result += options.newline;
+    }
+    for (const [elementName, elementValue] of Object.entries(elements)) {
+      result += stringifyValue(elementName, elementValue, {
+        ...context,
+        depth: depth + 1
+      });
+    }
+    if (format) {
+      result += options.indent;
+    }
+  }
+  result += `</${tagName}>${options.newline}`;
+  return result;
+}
+function stringifyObject(tagName, obj, context) {
+  const { depth, format, suppressEmptyNode } = context;
+  const indent = format ? "  ".repeat(depth) : "";
+  const newline = format ? "\n" : "";
+  const childIndent = format ? "  ".repeat(depth + 1) : "";
+  const parts = extractObjectParts(obj);
+  const openTag = buildOpeningTag(tagName, parts.attributes, context);
+  const hasElements = Object.keys(parts.elements).length > 0;
+  const hasTextContent = parts.textContent !== void 0 && parts.textContent !== "";
+  if (!(hasElements || hasTextContent)) {
+    if (suppressEmptyNode) {
+      return "";
+    }
+    return `${indent}${openTag}/>${newline}`;
+  }
+  const fullOpenTag = `${openTag}>`;
+  if (!hasElements && hasTextContent && parts.textContent) {
+    return stringifyTextOnlyContent({
+      tagName,
+      textContent: parts.textContent,
+      openTag: fullOpenTag,
+      format: { indent, newline },
+      minimalEscaping: context.minimalEscaping
+    });
+  }
+  return stringifyComplexContent(tagName, parts, context, {
+    indent,
+    newline,
+    childIndent,
+    openTag: fullOpenTag
+  });
+}
+function stringifyNodes(nodes, format = true, options = {}) {
+  let result = "";
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      result += node;
+    } else {
+      result += stringifyNode(node, 0, format, options);
+    }
+  }
+  return result;
+}
+function formatNodeAttribute(attrName, attrValue, minimalEscaping, strictBooleanAttributes) {
+  if (attrValue === null) {
+    if (strictBooleanAttributes) {
+      return ` ${attrName}="${attrName}"`;
+    }
+    return ` ${attrName}`;
+  }
+  if (attrValue.indexOf('"') === -1) {
+    const escaped2 = minimalEscaping ? escapeXmlMinimalAttr(attrValue, '"') : escapeXml(attrValue);
+    return ` ${attrName}="${escaped2}"`;
+  }
+  const escaped = minimalEscaping ? escapeXmlMinimalAttr(attrValue, "'") : escapeXml(attrValue);
+  return ` ${attrName}='${escaped}'`;
+}
+function buildNodeOpeningTag(node, opts) {
+  let result = `${opts.indent}<${node.tagName}`;
+  for (const [attrName, attrValue] of Object.entries(node.attributes)) {
+    result += formatNodeAttribute(
+      attrName,
+      attrValue,
+      opts.minimalEscaping,
+      opts.strictBooleanAttributes
+    );
+  }
+  return result;
+}
+function stringifyNodeChildren(options) {
+  const {
+    children,
+    depth,
+    format,
+    stringifyOptions,
+    minimalEscaping,
+    newline
+  } = options;
+  let content = "";
+  let hasElementChildren = false;
+  for (const child of children) {
+    if (typeof child === "string") {
+      content += minimalEscaping ? escapeXmlMinimalText(child) : escapeXml(child);
+    } else {
+      if (!hasElementChildren && format) {
+        content += newline;
+        hasElementChildren = true;
+      }
+      content += stringifyNode(child, depth + 1, format, stringifyOptions);
+    }
+  }
+  return { content, hasElementChildren };
+}
+function stringifyNode(node, depth = 0, format = true, options = {}) {
+  var _a, _b;
+  const indent = format ? "  ".repeat(depth) : "";
+  const newline = format ? "\n" : "";
+  const minimalEscaping = (_a = options.minimalEscaping) != null ? _a : false;
+  const strictBooleanAttributes = (_b = options.strictBooleanAttributes) != null ? _b : false;
+  const opts = {
+    minimalEscaping,
+    strictBooleanAttributes,
+    indent,
+    newline
+  };
+  let result = buildNodeOpeningTag(node, opts);
+  if (node.tagName[0] === "?") {
+    return `${result}?>${newline}`;
+  }
+  if (node.children.length === 0) {
+    return `${result}/>${newline}`;
+  }
+  result += ">";
+  const { content, hasElementChildren } = stringifyNodeChildren({
+    children: node.children,
+    depth,
+    format,
+    stringifyOptions: options,
+    minimalEscaping,
+    newline
+  });
+  result += content;
+  if (hasElementChildren && format) {
+    result += indent;
+  }
+  result += `</${node.tagName}>`;
+  if (format) {
+    result += newline;
+  }
+  return result;
+}
+function toContentString(nodes) {
+  let result = "";
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      result += ` ${node}`;
+    } else {
+      result += ` ${toContentString(node.children)}`;
+    }
+    result = result.trim();
+  }
+  return result;
+}
+
+// src/schema/base-coercion.ts
+var NUMERIC_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
+var NEWLINE_SPLIT_REGEX = /\n+/;
+var COMMA_SPLIT_REGEX = /,\s*/;
+var DIGIT_KEY_REGEX = /^\d+$/;
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return;
+  }
+  const t = unwrapped.type;
+  if (typeof t === "string") {
+    return t;
+  }
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) {
+      if (t.includes(p)) {
+        return p;
+      }
+    }
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  return;
+}
+function coerceStringWithoutSchema(value) {
+  const s = value.trim();
+  const lower = s.toLowerCase();
+  if (lower === "true") {
+    return true;
+  }
+  if (lower === "false") {
+    return false;
+  }
+  if (NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(s);
+      return coerceBySchema(parsed, void 0);
+    } catch (e) {
+    }
+  }
+  return value;
+}
+function coerceStringToObject(s, unwrapped) {
+  try {
+    let normalized = s.replace(/'/g, '"');
+    normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
+    const obj = JSON.parse(normalized);
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      const props = unwrapped.properties;
+      const out = {};
+      for (const [k, v] of Object.entries(obj)) {
+        const propSchema = props ? props[k] : void 0;
+        out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+      }
+      return out;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function coerceStringToArray(s, unwrapped) {
+  const prefixItems = Array.isArray(unwrapped.prefixItems) ? unwrapped.prefixItems : void 0;
+  const itemsSchema = unwrapped.items;
+  try {
+    const normalized = s.replace(/'/g, '"');
+    const arr = JSON.parse(normalized);
+    if (Array.isArray(arr)) {
+      if (prefixItems && arr.length === prefixItems.length) {
+        return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return arr.map((v) => coerceBySchema(v, itemsSchema));
+    }
+  } catch (e) {
+    const csv = s.includes("\n") ? s.split(NEWLINE_SPLIT_REGEX) : s.split(COMMA_SPLIT_REGEX);
+    const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+    if (prefixItems && trimmed.length === prefixItems.length) {
+      return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
+    }
+    return trimmed.map((x) => coerceBySchema(x, itemsSchema));
+  }
+  return null;
+}
+function coerceObjectToObject(value, unwrapped) {
+  const out = {};
+  const props = unwrapped.properties;
+  for (const [k, v] of Object.entries(value)) {
+    const propSchema = props ? props[k] : void 0;
+    out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+  }
+  return out;
+}
+function coerceArrayToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && value.length === prefixItems.length) {
+    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+  }
+  return value.map((v) => coerceBySchema(v, itemsSchema));
+}
+function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (Object.hasOwn(maybe, "item")) {
+    const items = maybe.item;
+    const arr = Array.isArray(items) ? items : [items];
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+  }
+  const keys = Object.keys(maybe);
+  if (keys.length === 1) {
+    const singleValue = maybe[keys[0]];
+    if (Array.isArray(singleValue)) {
+      return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+    }
+  }
+  if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
+    const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
+    return coerceArrayToArray(arr, prefixItems, itemsSchema);
+  }
+  return null;
+}
+function coercePrimitiveToArray(value, prefixItems, itemsSchema) {
+  if (prefixItems && prefixItems.length > 0) {
+    return [coerceBySchema(value, prefixItems[0])];
+  }
+  return [coerceBySchema(value, itemsSchema)];
+}
+function coerceStringToPrimitive(s, schemaType) {
+  if (schemaType === "boolean") {
+    const lower = s.toLowerCase();
+    if (lower === "true") {
+      return true;
+    }
+    if (lower === "false") {
+      return false;
+    }
+  }
+  if ((schemaType === "number" || schemaType === "integer") && NUMERIC_REGEX.test(s)) {
+    const num = Number(s);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return null;
+}
+function coerceStringValue(value, schemaType, u) {
+  const s = value.trim();
+  if (schemaType === "object") {
+    const result = coerceStringToObject(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  if (schemaType === "array") {
+    const result = coerceStringToArray(s, u);
+    if (result !== null) {
+      return result;
+    }
+  }
+  const primitiveResult = coerceStringToPrimitive(s, schemaType);
+  if (primitiveResult !== null) {
+    return primitiveResult;
+  }
+  return value;
+}
+function coerceArrayValue(value, prefixItems, itemsSchema) {
+  if (Array.isArray(value)) {
+    return coerceArrayToArray(value, prefixItems, itemsSchema);
+  }
+  if (value && typeof value === "object") {
+    const result = coerceObjectToArray(
+      value,
+      prefixItems,
+      itemsSchema
+    );
+    if (result !== null) {
+      return result;
+    }
+  }
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return coercePrimitiveToArray(value, prefixItems, itemsSchema);
+  }
+  return value;
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      return coerceStringWithoutSchema(value);
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  const u = unwrapped;
+  if (typeof value === "string") {
+    return coerceStringValue(value, schemaType, u);
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    return coerceObjectToObject(value, u);
+  }
+  if (schemaType === "array") {
+    const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
+    const itemsSchema = u.items;
+    return coerceArrayValue(value, prefixItems, itemsSchema);
+  }
+  return value;
+}
+
+// src/schema/coercion.ts
+function getPropertySchema(toolSchema, key) {
+  const unwrapped = unwrapJsonSchema(toolSchema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return;
+  }
+  const u = unwrapped;
+  const props = u.properties;
+  if (props && Object.hasOwn(props, key)) {
+    return props[key];
+  }
+  return;
+}
+function getNodeValue(children, schema, tagName, textNodeName) {
+  if (children.length === 0) {
+    return "";
+  }
+  if (children.length === 1 && typeof children[0] === "string") {
+    return children[0];
+  }
+  return processComplexContent(
+    children,
+    getPropertySchema(schema, tagName),
+    textNodeName
+  );
+}
+function addAttributesToValue(value, attributes, textNodeName) {
+  if (Object.keys(attributes).length === 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const valueResult = { [textNodeName]: value };
+    for (const [attrName, attrValue] of Object.entries(attributes)) {
+      valueResult[`@_${attrName}`] = attrValue;
+    }
+    return valueResult;
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    for (const [attrName, attrValue] of Object.entries(attributes)) {
+      value[`@_${attrName}`] = attrValue;
+    }
+  }
+  return value;
+}
+function addToResult(result, tagName, value) {
+  if (result[tagName]) {
+    if (!Array.isArray(result[tagName])) {
+      result[tagName] = [result[tagName]];
+    }
+    result[tagName].push(value);
+  } else {
+    result[tagName] = value;
+  }
+}
+function domToObject(nodes, schema, textNodeName = "#text") {
+  const result = {};
+  for (const node of nodes) {
+    if (typeof node === "string") {
+      continue;
+    }
+    const { tagName, children, attributes } = node;
+    let value = getNodeValue(children, schema, tagName, textNodeName);
+    value = addAttributesToValue(value, attributes, textNodeName);
+    addToResult(result, tagName, value);
+  }
+  return result;
+}
+function processChildElement(child, schema, textNodeName) {
+  let childValue;
+  if (child.children.length === 0) {
+    childValue = "";
+  } else if (child.children.length === 1 && typeof child.children[0] === "string") {
+    childValue = child.children[0];
+  } else {
+    childValue = processComplexContent(
+      child.children,
+      getPropertySchema(schema, child.tagName),
+      textNodeName
+    );
+  }
+  return addAttributesToValue(childValue, child.attributes, textNodeName);
+}
+function combineContent(textContent, elements, textNodeName) {
+  const hasText = textContent.length > 0;
+  const hasElements = Object.keys(elements).length > 0;
+  if (hasText && hasElements) {
+    return {
+      [textNodeName]: textContent.join("").trim(),
+      ...elements
+    };
+  }
+  if (hasText) {
+    return textContent.join("").trim();
+  }
+  if (hasElements) {
+    return elements;
+  }
+  return "";
+}
+function processComplexContent(children, schema, textNodeName) {
+  const textContent = [];
+  const elements = {};
+  for (const child of children) {
+    if (typeof child === "string") {
+      textContent.push(child);
+    } else {
+      const childValue = processChildElement(child, schema, textNodeName);
+      addToResult(elements, child.tagName, childValue);
+    }
+  }
+  return combineContent(textContent, elements, textNodeName);
+}
+function coerceDomBySchema(domObject, schema) {
+  try {
+    return coerceBySchema(domObject, schema);
+  } catch (error) {
+    throw new RXMLCoercionError("Failed to coerce DOM object by schema", error);
+  }
+}
+function visitObjectProperties(props, collected, visit) {
+  for (const [key, propSchema] of Object.entries(props)) {
+    const t = getSchemaType(propSchema);
+    if (t === "string") {
+      collected.add(key);
+    } else if (t === "object" || t === "array") {
+      visit(propSchema);
+    }
+  }
+}
+function visitArrayItems(u, visit) {
+  const items = u.items;
+  if (items) {
+    visit(items);
+  }
+  const prefix = u.prefixItems;
+  if (Array.isArray(prefix)) {
+    for (const item of prefix) {
+      visit(item);
+    }
+  }
+}
+function getStringTypedProperties(schema) {
+  const collected = /* @__PURE__ */ new Set();
+  const visit = (s) => {
+    const unwrapped = unwrapJsonSchema(s);
+    if (!unwrapped || typeof unwrapped !== "object") {
+      return;
+    }
+    const u = unwrapped;
+    const type = getSchemaType(unwrapped);
+    if (type === "object") {
+      const props = u.properties;
+      if (props && typeof props === "object") {
+        visitObjectProperties(props, collected, visit);
+      }
+    } else if (type === "array") {
+      visitArrayItems(u, visit);
+    }
+  };
+  visit(schema);
+  return collected;
+}
+function processArrayContent(value, schema, textNodeName) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  const schemaType = getSchemaType(schema);
+  if (schemaType === "string") {
+    return value.map((item) => {
+      if (typeof item === "string") {
+        return item.trim();
+      }
+      if (item && typeof item === "object" && textNodeName in item) {
+        const textVal = item[textNodeName];
+        return typeof textVal === "string" ? textVal.trim() : String(textVal);
+      }
+      return String(item);
+    });
+  }
+  return value.map((item) => {
+    if (typeof item === "string") {
+      return item.trim();
+    }
+    if (item && typeof item === "object" && textNodeName in item) {
+      const textVal = item[textNodeName];
+      return typeof textVal === "string" ? textVal.trim() : textVal;
+    }
+    return item;
+  });
+}
+function processIndexedTuple(obj, textNodeName) {
+  const keys = Object.keys(obj);
+  const indices = keys.map((k) => Number.parseInt(k, 10)).sort((a, b) => a - b);
+  const isValidTuple = indices[0] === 0 && indices.every((val, idx) => val === idx);
+  if (!isValidTuple) {
+    return [obj];
+  }
+  const sortedKeys = keys.sort(
+    (a, b) => Number.parseInt(a, 10) - Number.parseInt(b, 10)
+  );
+  return sortedKeys.map((key) => {
+    const item = obj[key];
+    if (item && typeof item === "object" && textNodeName in item) {
+      const textVal = item[textNodeName];
+      return typeof textVal === "string" ? textVal.trim() : textVal;
+    }
+    return typeof item === "string" ? item.trim() : item;
+  });
+}
+
+// src/schema/extraction.ts
+function skipDoctype(xmlContent, i, len) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return gt === -1 ? len : gt + 1;
+}
+function skipComment(xmlContent, i, len) {
+  const close = xmlContent.indexOf("-->", i + 4);
+  return close === -1 ? len : close + 3;
+}
+function skipCdata(xmlContent, i, len) {
+  const close = xmlContent.indexOf("]]>", i + 9);
+  return close === -1 ? len : close + 3;
+}
+function skipProcessingInstruction(xmlContent, i, len) {
+  const close = xmlContent.indexOf("?>", i + 1);
+  return close === -1 ? len : close + 2;
+}
+function skipSpecialConstruct(xmlContent, i, len) {
+  const ch = xmlContent[i];
+  if (ch === "!") {
+    if (xmlContent.startsWith("!DOCTYPE", i + 1)) {
+      return skipDoctype(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("!--", i + 1)) {
+      return skipComment(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("![CDATA[", i + 1)) {
+      return skipCdata(xmlContent, i, len);
+    }
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  if (ch === "?") {
+    return skipProcessingInstruction(xmlContent, i, len);
+  }
+  return -1;
+}
+function parseTagName(xmlContent, i, len) {
+  let j = i;
+  if (j < len && isNameStartChar(xmlContent[j])) {
+    j += 1;
+    while (j < len && isNameChar(xmlContent[j])) {
+      j += 1;
+    }
+  }
+  return { name: xmlContent.slice(i, j), pos: j };
+}
+function skipToTagEnd(xmlContent, start, len) {
+  let k = start;
+  let isSelfClosing = false;
+  while (k < len) {
+    const c = xmlContent[k];
+    if (c === '"' || c === "'") {
+      k = skipQuoted(xmlContent, k);
+      continue;
+    }
+    if (c === ">") {
+      break;
+    }
+    if (c === "/" && xmlContent[k + 1] === ">") {
+      isSelfClosing = true;
+      k += 1;
+      break;
+    }
+    k += 1;
+  }
+  return { pos: k, isSelfClosing };
+}
+function processClosingTagMatch(options) {
+  const { xmlContent, nx, len, tagName, depth, nextLt } = options;
+  const tagInfo = parseTagName(xmlContent, nx + 1, len);
+  const gt = xmlContent.indexOf(">", tagInfo.pos);
+  if (tagInfo.name === tagName) {
+    const newDepth = depth - 1;
+    if (newDepth === 0) {
+      return { newPos: nextLt, newDepth, found: true };
+    }
+    return { newPos: gt === -1 ? len : gt + 1, newDepth, found: false };
+  }
+  return { newPos: gt === -1 ? len : gt + 1, newDepth: depth, found: false };
+}
+function processOpeningTagMatch(options) {
+  const { xmlContent, nx, len, tagName, depth } = options;
+  const tagInfo = parseTagName(xmlContent, nx, len);
+  const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+  const newDepth = tagInfo.name === tagName && !tagEndInfo.isSelfClosing ? depth + 1 : depth;
+  const newPos = xmlContent[tagEndInfo.pos] === ">" ? tagEndInfo.pos + 1 : tagEndInfo.pos + 1;
+  return { newPos, newDepth };
+}
+function findMatchingCloseTag(xmlContent, startPos, tagName, len) {
+  let pos = startPos;
+  let depth = 1;
+  while (pos < len) {
+    const nextLt = xmlContent.indexOf("<", pos);
+    if (nextLt === -1 || nextLt + 1 >= len) {
+      break;
+    }
+    const nx = nextLt + 1;
+    const h = xmlContent[nx];
+    const specialPos = skipSpecialConstruct(xmlContent, nx, len);
+    if (specialPos !== -1) {
+      pos = specialPos;
+      continue;
+    }
+    if (h === "/") {
+      const result = processClosingTagMatch({
+        xmlContent,
+        nx,
+        len,
+        tagName,
+        depth,
+        nextLt
+      });
+      if (result.found) {
+        return result.newPos;
+      }
+      pos = result.newPos;
+      depth = result.newDepth;
+    } else {
+      const result = processOpeningTagMatch({
+        xmlContent,
+        nx,
+        len,
+        tagName,
+        depth
+      });
+      pos = result.newPos;
+      depth = result.newDepth;
+    }
+  }
+  return -1;
+}
+function updateBestMatch(depth, bestDepth, contentStart, contentEnd) {
+  if (depth < bestDepth) {
+    return { start: contentStart, end: contentEnd, depth };
+  }
+  return null;
+}
+function processTargetTag(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len, depth, bestDepth } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    return updateBestMatch(depth, bestDepth, contentStart, contentStart);
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    return updateBestMatch(depth, bestDepth, contentStart, closePos);
+  }
+  return null;
+}
+function handleClosingTagInExtract(xmlContent, i, len, depth) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return {
+    newPos: gt === -1 ? len : gt + 1,
+    newDepth: Math.max(0, depth - 1)
+  };
+}
+function processOpeningTagInExtract(options) {
+  const { xmlContent, i, len, target, depth, bestDepth } = options;
+  const tagInfo = parseTagName(xmlContent, i, len);
+  const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+  const tagEnd = tagEndInfo.pos;
+  const isSelfClosing = tagEndInfo.isSelfClosing;
+  let bestMatch = null;
+  if (tagInfo.name === target) {
+    bestMatch = processTargetTag({
+      xmlContent,
+      tagEnd,
+      isSelfClosing,
+      target,
+      len,
+      depth,
+      bestDepth
+    });
+  }
+  return {
+    newPos: xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1,
+    newDepth: depth + (isSelfClosing ? 0 : 1),
+    bestMatch
+  };
+}
+function extractRawInner(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let bestStart = -1;
+  let bestEnd = -1;
+  let bestDepth = Number.POSITIVE_INFINITY;
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      return;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      const result2 = handleClosingTagInExtract(xmlContent, i, len, depth);
+      i = result2.newPos;
+      depth = result2.newDepth;
+      continue;
+    }
+    const result = processOpeningTagInExtract({
+      xmlContent,
+      i,
+      len,
+      target,
+      depth,
+      bestDepth
+    });
+    if (result.bestMatch) {
+      bestStart = result.bestMatch.start;
+      bestEnd = result.bestMatch.end;
+      bestDepth = result.bestMatch.depth;
+    }
+    i = result.newPos;
+    depth = result.newDepth;
+  }
+  if (bestStart !== -1) {
+    return xmlContent.slice(bestStart, bestEnd);
+  }
+  return;
+}
+function processOpeningTag(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len, ranges } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    ranges.push({ start: contentStart, end: contentStart });
+    return contentStart;
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    ranges.push({ start: contentStart, end: closePos });
+    const gt = xmlContent.indexOf(">", closePos);
+    return gt === -1 ? len : gt + 1;
+  }
+  return -1;
+}
+function handleClosingTagInFindAll(xmlContent, i, len) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return gt === -1 ? len : gt + 1;
+}
+function findAllInnerRanges(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  const ranges = [];
+  let i = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      break;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      i = handleClosingTagInFindAll(xmlContent, i, len);
+      continue;
+    }
+    const tagInfo = parseTagName(xmlContent, i, len);
+    const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+    const tagEnd = tagEndInfo.pos;
+    const isSelfClosing = tagEndInfo.isSelfClosing;
+    if (tagInfo.name !== target) {
+      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+      continue;
+    }
+    const nextPos = processOpeningTag({
+      xmlContent,
+      tagEnd,
+      isSelfClosing,
+      target,
+      len,
+      ranges
+    });
+    if (nextPos === -1) {
+      break;
+    }
+    i = nextPos;
+  }
+  return ranges;
+}
+function findTopLevelTargetRange(options) {
+  const { xmlContent, tagEnd, isSelfClosing, target, len } = options;
+  const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+  if (isSelfClosing) {
+    return { start: contentStart, end: contentStart };
+  }
+  const closePos = findMatchingCloseTag(xmlContent, contentStart, target, len);
+  if (closePos !== -1) {
+    return { start: contentStart, end: closePos };
+  }
+  return;
+}
+function handleClosingTagInFindFirst(xmlContent, i, len, depth) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return {
+    newPos: gt === -1 ? len : gt + 1,
+    newDepth: Math.max(0, depth - 1)
+  };
+}
+function findFirstTopLevelRange(xmlContent, tagName) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let i = 0;
+  let depth = 0;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1 || lt + 1 >= len) {
+      return;
+    }
+    i = lt + 1;
+    const ch = xmlContent[i];
+    const specialPos = skipSpecialConstruct(xmlContent, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
+      continue;
+    }
+    if (ch === "/") {
+      const result = handleClosingTagInFindFirst(xmlContent, i, len, depth);
+      i = result.newPos;
+      depth = result.newDepth;
+      continue;
+    }
+    const tagInfo = parseTagName(xmlContent, i, len);
+    const tagEndInfo = skipToTagEnd(xmlContent, tagInfo.pos, len);
+    const tagEnd = tagEndInfo.pos;
+    const isSelfClosing = tagEndInfo.isSelfClosing;
+    if (depth === 0 && tagInfo.name === target) {
+      return findTopLevelTargetRange({
+        xmlContent,
+        tagEnd,
+        isSelfClosing,
+        target,
+        len
+      });
+    }
+    i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+    depth += isSelfClosing ? 0 : 1;
+  }
+  return;
+}
+function isPositionExcluded(pos, excludeRanges) {
+  if (!excludeRanges || excludeRanges.length === 0) {
+    return false;
+  }
+  for (const r of excludeRanges) {
+    if (pos >= r.start && pos < r.end) {
+      return true;
+    }
+  }
+  return false;
+}
+function skipCommentInCounting(xmlContent, i, len) {
+  const close = xmlContent.indexOf("-->", i + 4);
+  return close === -1 ? len : close + 3;
+}
+function skipCdataInCounting(xmlContent, i, len) {
+  const close = xmlContent.indexOf("]]>", i + 9);
+  return close === -1 ? len : close + 3;
+}
+function skipSpecialInCounting(xmlContent, ch, i, len) {
+  if (ch === "!") {
+    if (xmlContent.startsWith("!--", i + 1)) {
+      return skipCommentInCounting(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("![CDATA[", i + 1)) {
+      return skipCdataInCounting(xmlContent, i, len);
+    }
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  if (ch === "?") {
+    const close = xmlContent.indexOf("?>", i + 1);
+    return close === -1 ? len : close + 2;
+  }
+  if (ch === "/") {
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  return -1;
+}
+function parseAndCountTag(options) {
+  const { xmlContent, i, len, target, lt, excludeRanges } = options;
+  let j = i;
+  if (j < len && isNameStartChar(xmlContent[j])) {
+    j += 1;
+    while (j < len && isNameChar(xmlContent[j])) {
+      j += 1;
+    }
+  }
+  const name = xmlContent.slice(i, j);
+  let k = j;
+  while (k < len) {
+    const c = xmlContent[k];
+    if (c === '"' || c === "'") {
+      k = skipQuoted(xmlContent, k);
+      continue;
+    }
+    if (c === ">") {
+      break;
     }
+    if (c === "/" && xmlContent[k + 1] === ">") {
+      k += 1;
+      break;
+    }
+    k += 1;
   }
-  if (bestStart !== -1) {
-    return xmlContent.slice(bestStart, bestEnd);
-  }
-  return void 0;
+  const shouldCount = name === target && !isPositionExcluded(lt, excludeRanges);
+  return { nextPos: k + 1, shouldCount };
 }
-function findFirstTopLevelRange(xmlContent, tagName) {
+function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst = true) {
   const len = xmlContent.length;
   const target = tagName;
   let i = 0;
-  let depth = 0;
+  let count = 0;
+  let skipFirstLocal = shouldSkipFirst;
   while (i < len) {
     const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) return void 0;
+    if (lt === -1) {
+      break;
+    }
     i = lt + 1;
-    if (i >= len) return void 0;
+    if (i >= len) {
+      break;
+    }
     const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
-      continue;
-    } else if (ch === "/") {
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      depth = Math.max(0, depth - 1);
+    const skipPos = skipSpecialInCounting(xmlContent, ch, i, len);
+    if (skipPos !== -1) {
+      i = skipPos;
       continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      let isSelfClosing = false;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") break;
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          isSelfClosing = true;
-          k++;
-          break;
-        }
-        k++;
-      }
-      const tagEnd = k;
-      if (depth === 0 && name === target) {
-        const contentStart = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-        if (isSelfClosing) return { start: contentStart, end: contentStart };
-        let pos = contentStart;
-        let sameDepth = 1;
-        while (pos < len) {
-          const nextLt = xmlContent.indexOf("<", pos);
-          if (nextLt === -1) break;
-          const nx = nextLt + 1;
-          if (nx >= len) break;
-          const h = xmlContent[nx];
-          if (h === "!") {
-            if (xmlContent.startsWith("!--", nx + 1)) {
-              const close = xmlContent.indexOf("-->", nx + 4);
-              pos = close === -1 ? len : close + 3;
-              continue;
-            }
-            if (xmlContent.startsWith("![CDATA[", nx + 1)) {
-              const close = xmlContent.indexOf("]]>", nx + 9);
-              pos = close === -1 ? len : close + 3;
-              continue;
-            }
-            const gt2 = xmlContent.indexOf(">", nx + 1);
-            pos = gt2 === -1 ? len : gt2 + 1;
-            continue;
-          } else if (h === "?") {
-            const close = xmlContent.indexOf("?>", nx + 1);
-            pos = close === -1 ? len : close + 2;
-            continue;
-          } else if (h === "/") {
-            let t = nx + 1;
-            if (t < len && isNameStartChar(xmlContent[t])) {
-              t++;
-              while (t < len && isNameChar(xmlContent[t])) t++;
-            }
-            const endName = xmlContent.slice(nx + 1, t);
-            const gt2 = xmlContent.indexOf(">", t);
-            if (endName === target) {
-              sameDepth--;
-              if (sameDepth === 0) {
-                return { start: contentStart, end: nextLt };
-              }
-            }
-            pos = gt2 === -1 ? len : gt2 + 1;
-            continue;
-          } else {
-            let t = nx;
-            if (t < len && isNameStartChar(xmlContent[t])) {
-              t++;
-              while (t < len && isNameChar(xmlContent[t])) t++;
-            }
-            const startName = xmlContent.slice(nx, t);
-            let u = t;
-            let isSelfClosingNested = false;
-            while (u < len) {
-              const cu = xmlContent[u];
-              if (cu === '"' || cu === "'") {
-                u = skipQuoted(xmlContent, u);
-                continue;
-              }
-              if (cu === ">") break;
-              if (cu === "/" && xmlContent[u + 1] === ">") {
-                isSelfClosingNested = true;
-                u++;
-                break;
-              }
-              u++;
-            }
-            if (startName === target && !isSelfClosingNested) {
-              sameDepth++;
-            }
-            pos = xmlContent[u] === ">" ? u + 1 : u + 1;
-            continue;
-          }
-        }
-        return void 0;
+    }
+    const result = parseAndCountTag({
+      xmlContent,
+      i,
+      len,
+      target,
+      lt,
+      excludeRanges
+    });
+    if (result.shouldCount) {
+      if (skipFirstLocal) {
+        skipFirstLocal = false;
+      } else {
+        count += 1;
       }
-      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
-      depth += isSelfClosing ? 0 : 1;
+    }
+    i = result.nextPos;
+  }
+  return count;
+}
+function skipAttributes(xmlContent, i, len) {
+  let k = i;
+  while (k < len && xmlContent[k] !== ">") {
+    const c = xmlContent[k];
+    if (c === '"' || c === "'") {
+      k = skipQuoted(xmlContent, k);
       continue;
     }
+    if (c === "/" && xmlContent[k + 1] === ">") {
+      k += 1;
+      break;
+    }
+    k += 1;
   }
-  return void 0;
+  return k;
 }
-function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst = true) {
+function updateDepthForClosingTag(xmlContent, nextLt, target, closeDepth) {
+  const { name: closeName } = parseName(xmlContent, nextLt + 2);
+  return closeName === target ? closeDepth - 1 : closeDepth;
+}
+function updateDepthForOpeningTag(xmlContent, nextLt, target, closeDepth) {
+  const { name: openName } = parseName(xmlContent, nextLt + 1);
+  return openName === target ? closeDepth + 1 : closeDepth;
+}
+function findClosingTagForRange(xmlContent, k, len, target) {
+  let closeDepth = 1;
+  let j = k + 1;
+  while (j < len && closeDepth > 0) {
+    const nextLt = xmlContent.indexOf("<", j);
+    if (nextLt === -1) {
+      break;
+    }
+    if (xmlContent[nextLt + 1] === "/") {
+      closeDepth = updateDepthForClosingTag(
+        xmlContent,
+        nextLt,
+        target,
+        closeDepth
+      );
+    } else if (xmlContent[nextLt + 1] !== "!" && xmlContent[nextLt + 1] !== "?") {
+      closeDepth = updateDepthForOpeningTag(
+        xmlContent,
+        nextLt,
+        target,
+        closeDepth
+      );
+    }
+    j = xmlContent.indexOf(">", nextLt + 1);
+    if (j === -1) {
+      break;
+    }
+    j += 1;
+  }
+  return closeDepth === 0 ? j : -1;
+}
+function processTopLevelTarget(options) {
+  const { xmlContent, tagStart, k, len, target, ranges } = options;
+  const isSelfClosing = xmlContent[k] === "/" || xmlContent.startsWith("/>", k);
+  if (isSelfClosing) {
+    ranges.push({
+      start: tagStart,
+      end: k + (xmlContent[k] === "/" ? 2 : 1)
+    });
+    return { newDepth: 0 };
+  }
+  const endPos = findClosingTagForRange(xmlContent, k, len, target);
+  if (endPos !== -1) {
+    ranges.push({ start: tagStart, end: endPos });
+  }
+  return { newDepth: 0 };
+}
+function skipDoctypeInSpecial(xmlContent, i, len) {
+  const gt = xmlContent.indexOf(">", i + 1);
+  return gt === -1 ? len : gt + 1;
+}
+function handleSpecialConstructs(xmlContent, ch, i, len) {
+  if (ch === "!") {
+    if (xmlContent.startsWith("!DOCTYPE", i + 1)) {
+      return skipDoctypeInSpecial(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("!--", i + 1)) {
+      return skipCommentInCounting(xmlContent, i, len);
+    }
+    if (xmlContent.startsWith("![CDATA[", i + 1)) {
+      return skipCdataInCounting(xmlContent, i, len);
+    }
+    const gt = xmlContent.indexOf(">", i + 1);
+    return gt === -1 ? len : gt + 1;
+  }
+  if (ch === "?") {
+    const close = xmlContent.indexOf("?>", i + 1);
+    return close === -1 ? len : close + 2;
+  }
+  return -1;
+}
+function handleClosingTagInFindAllTop(xmlContent, i, target, depth) {
+  const { name: closingName, newPos: closingPos } = parseName(
+    xmlContent,
+    i + 1
+  );
+  const newDepth = closingName === target ? depth - 1 : depth;
+  const gt = xmlContent.indexOf(">", closingPos);
+  return {
+    newPos: gt === -1 ? -1 : gt + 1,
+    newDepth
+  };
+}
+function findAllTopLevelRanges(xmlContent, tagName) {
+  const ranges = [];
   const len = xmlContent.length;
   const target = tagName;
   let i = 0;
-  let count = 0;
-  let skipFirstLocal = shouldSkipFirst;
-  const isExcluded = (pos) => {
-    if (!excludeRanges || excludeRanges.length === 0) return false;
-    for (const r of excludeRanges) {
-      if (pos >= r.start && pos < r.end) return true;
-    }
-    return false;
-  };
+  let depth = 0;
   while (i < len) {
     const lt = xmlContent.indexOf("<", i);
-    if (lt === -1) break;
+    if (lt === -1 || lt + 1 >= len) {
+      break;
+    }
     i = lt + 1;
-    if (i >= len) break;
     const ch = xmlContent[i];
-    if (ch === "!") {
-      if (xmlContent.startsWith("!--", i + 1)) {
-        const close = xmlContent.indexOf("-->", i + 4);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      if (xmlContent.startsWith("![CDATA[", i + 1)) {
-        const close = xmlContent.indexOf("]]>", i + 9);
-        i = close === -1 ? len : close + 3;
-        continue;
-      }
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else if (ch === "?") {
-      const close = xmlContent.indexOf("?>", i + 1);
-      i = close === -1 ? len : close + 2;
+    const specialPos = handleSpecialConstructs(xmlContent, ch, i, len);
+    if (specialPos !== -1) {
+      i = specialPos;
       continue;
-    } else if (ch === "/") {
-      const gt = xmlContent.indexOf(">", i + 1);
-      i = gt === -1 ? len : gt + 1;
-      continue;
-    } else {
-      let j = i;
-      if (j < len && isNameStartChar(xmlContent[j])) {
-        j++;
-        while (j < len && isNameChar(xmlContent[j])) j++;
-      }
-      const name = xmlContent.slice(i, j);
-      let k = j;
-      while (k < len) {
-        const c = xmlContent[k];
-        if (c === '"' || c === "'") {
-          k = skipQuoted(xmlContent, k);
-          continue;
-        }
-        if (c === ">") break;
-        if (c === "/" && xmlContent[k + 1] === ">") {
-          k++;
-          break;
-        }
-        k++;
-      }
-      if (name === target && !isExcluded(lt)) {
-        if (skipFirstLocal) {
-          skipFirstLocal = false;
-        } else {
-          count++;
-        }
+    }
+    if (ch === "/") {
+      const result = handleClosingTagInFindAllTop(xmlContent, i, target, depth);
+      if (result.newPos === -1) {
+        break;
       }
-      i = k + 1;
+      i = result.newPos;
+      depth = result.newDepth;
       continue;
     }
-  }
-  return count;
+    const { name, newPos } = parseName(xmlContent, i);
+    i = newPos;
+    const k = skipAttributes(xmlContent, i, len);
+    if (name === target && depth === 0) {
+      depth += 1;
+      const result = processTopLevelTarget({
+        xmlContent,
+        tagStart: lt,
+        k,
+        len,
+        target,
+        ranges
+      });
+      depth += result.newDepth;
+    }
+    i = k + 1;
+  }
+  return ranges;
 }
 
 // src/core/tokenizer.ts
@@ -949,57 +1578,30 @@ var XMLTokenizer = class {
     this.pos = options.pos || 0;
   }
   /**
-   * Parse XML children recursively
+   * Handle closing tag parsing
    */
-  parseChildren(tagName) {
-    const children = [];
-    let consumedToEnd = false;
-    while (this.xmlString[this.pos]) {
-      if (this.xmlString.charCodeAt(this.pos) === CharCodes.OPEN_BRACKET) {
-        if (this.xmlString.charCodeAt(this.pos + 1) === CharCodes.SLASH) {
-          const closeStart = this.pos + 2;
-          this.pos = this.xmlString.indexOf(">", this.pos);
-          const closeTag = this.xmlString.substring(closeStart, this.pos);
-          if (tagName && closeTag.trim() !== tagName) {
-            const { line, column } = getLineColumn(this.xmlString, this.pos);
-            throw new RXMLParseError(
-              `Unexpected close tag at line ${line}, column ${column}. Expected </${tagName}>, found </${closeTag}>`,
-              void 0,
-              line,
-              column
-            );
-          }
-          if (this.pos !== -1) this.pos += 1;
-          return children;
-        } else if (this.xmlString.charCodeAt(this.pos + 1) === CharCodes.EXCLAMATION) {
-          const prevPos = this.pos;
-          this.handleSpecialContent(children);
-          if (this.pos >= this.xmlString.length && prevPos < this.xmlString.length) {
-            consumedToEnd = true;
-          }
-        } else {
-          const node = this.parseNode();
-          children.push(node);
-          if (node.tagName[0] === "?") {
-            children.push(...node.children);
-            node.children = [];
-          }
-        }
-      } else {
-        const text = this.parseText();
-        if (this.options.keepWhitespace) {
-          if (text.length > 0) {
-            children.push(text);
-          }
-        } else {
-          const trimmed = text.trim();
-          if (trimmed.length > 0) {
-            children.push(trimmed);
-          }
-        }
-        this.pos++;
-      }
+  handleClosingTag(tagName, children) {
+    const closeStart = this.pos + 2;
+    this.pos = this.xmlString.indexOf(">", this.pos);
+    const closeTag = this.xmlString.substring(closeStart, this.pos);
+    if (tagName && closeTag.trim() !== tagName) {
+      const { line, column } = getLineColumn(this.xmlString, this.pos);
+      throw new RXMLParseError(
+        `Unexpected close tag at line ${line}, column ${column}. Expected </${tagName}>, found </${closeTag}>`,
+        void 0,
+        line,
+        column
+      );
     }
+    if (this.pos !== -1) {
+      this.pos += 1;
+    }
+    return children;
+  }
+  /**
+   * Check if we're at end of string and should throw unclosed tag error
+   */
+  checkUnclosedTag(tagName, consumedToEnd) {
     if (tagName && this.pos >= this.xmlString.length && !consumedToEnd) {
       const { line, column } = getLineColumn(this.xmlString, this.pos - 1);
       throw new RXMLParseError(
@@ -1009,93 +1611,205 @@ var XMLTokenizer = class {
         column
       );
     }
+  }
+  /**
+   * Process special content (comments, CDATA, DOCTYPE) and track if we consumed to end
+   */
+  processSpecialContent(children) {
+    const prevPos = this.pos;
+    this.handleSpecialContent(children);
+    return this.pos >= this.xmlString.length && prevPos < this.xmlString.length;
+  }
+  /**
+   * Handle text content parsing
+   */
+  handleTextContent(children) {
+    const text = this.parseText();
+    if (this.options.keepWhitespace) {
+      if (text.length > 0) {
+        children.push(text);
+      }
+    } else {
+      const trimmed = text.trim();
+      if (trimmed.length > 0) {
+        children.push(trimmed);
+      }
+    }
+    this.pos += 1;
+  }
+  /**
+   * Handle regular element parsing
+   */
+  handleRegularElement(children) {
+    const node = this.parseNode();
+    children.push(node);
+    if (node.tagName[0] === "?") {
+      children.push(...node.children);
+      node.children = [];
+    }
+  }
+  /**
+   * Process a single child element based on the current character
+   */
+  processSingleChild(children, tagName) {
+    if (this.xmlString.charCodeAt(this.pos) !== CharCodes.OPEN_BRACKET) {
+      this.handleTextContent(children);
+      return { shouldReturn: false, consumedToEnd: false };
+    }
+    const nextChar = this.xmlString.charCodeAt(this.pos + 1);
+    if (nextChar === CharCodes.SLASH) {
+      const result = this.handleClosingTag(tagName, children);
+      if (result !== null) {
+        return { shouldReturn: true, consumedToEnd: false };
+      }
+      return { shouldReturn: false, consumedToEnd: false };
+    }
+    if (nextChar === CharCodes.EXCLAMATION) {
+      const wasConsumedToEnd = this.processSpecialContent(children);
+      return { shouldReturn: false, consumedToEnd: wasConsumedToEnd };
+    }
+    this.handleRegularElement(children);
+    return { shouldReturn: false, consumedToEnd: false };
+  }
+  /**
+   * Parse XML children recursively
+   */
+  parseChildren(tagName) {
+    const children = [];
+    let consumedToEnd = false;
+    while (this.xmlString[this.pos]) {
+      const result = this.processSingleChild(children, tagName);
+      if (result.shouldReturn) {
+        return children;
+      }
+      if (result.consumedToEnd) {
+        consumedToEnd = true;
+      }
+    }
+    this.checkUnclosedTag(tagName, consumedToEnd);
     return children;
   }
   /**
-   * Parse a single XML node
+   * Check if character is whitespace
    */
-  parseNode() {
-    var _a;
-    this.pos++;
-    const { name: tagName, newPos } = parseName(this.xmlString, this.pos);
-    this.pos = newPos;
+  isWhitespace(code) {
+    return code === CharCodes.SPACE || code === CharCodes.TAB || code === CharCodes.NEWLINE || code === CharCodes.CARRIAGE_RETURN;
+  }
+  /**
+   * Skip whitespace characters
+   */
+  skipWhitespace() {
+    while (this.pos < this.xmlString.length && this.isWhitespace(this.xmlString.charCodeAt(this.pos))) {
+      this.pos += 1;
+    }
+  }
+  /**
+   * Parse attribute value
+   */
+  parseAttributeValue() {
+    if (this.pos >= this.xmlString.length || this.xmlString[this.pos] !== "=") {
+      return null;
+    }
+    this.pos += 1;
+    this.skipWhitespace();
+    const code = this.xmlString.charCodeAt(this.pos);
+    if (code === CharCodes.SINGLE_QUOTE || code === CharCodes.DOUBLE_QUOTE) {
+      const { value: parsedValue, newPos: valueEnd } = parseString(
+        this.xmlString,
+        this.pos
+      );
+      this.pos = valueEnd;
+      return parsedValue;
+    }
+    return null;
+  }
+  /**
+   * Parse single attribute
+   */
+  parseAttribute(attributes) {
+    const { name: attrName, newPos: nameEnd } = parseName(
+      this.xmlString,
+      this.pos
+    );
+    this.pos = nameEnd;
+    this.skipWhitespace();
+    const value = this.parseAttributeValue();
+    attributes[attrName] = value;
+  }
+  /**
+   * Parse all attributes
+   */
+  parseAttributes() {
     const attributes = {};
-    let children = [];
     while (this.xmlString.charCodeAt(this.pos) !== CharCodes.CLOSE_BRACKET && this.xmlString[this.pos]) {
       const c = this.xmlString.charCodeAt(this.pos);
-      if (c === CharCodes.SPACE || c === CharCodes.TAB || c === CharCodes.NEWLINE || c === CharCodes.CARRIAGE_RETURN) {
-        this.pos++;
+      if (this.isWhitespace(c)) {
+        this.pos += 1;
         continue;
       }
       if (c > 64 && c < 91 || c > 96 && c < 123) {
-        const { name: attrName, newPos: nameEnd } = parseName(
-          this.xmlString,
-          this.pos
-        );
-        this.pos = nameEnd;
-        while (this.pos < this.xmlString.length && (this.xmlString.charCodeAt(this.pos) === CharCodes.SPACE || this.xmlString.charCodeAt(this.pos) === CharCodes.TAB || this.xmlString.charCodeAt(this.pos) === CharCodes.NEWLINE || this.xmlString.charCodeAt(this.pos) === CharCodes.CARRIAGE_RETURN)) {
-          this.pos++;
-        }
-        let value = null;
-        if (this.pos < this.xmlString.length && this.xmlString[this.pos] === "=") {
-          this.pos++;
-          while (this.pos < this.xmlString.length && (this.xmlString.charCodeAt(this.pos) === CharCodes.SPACE || this.xmlString.charCodeAt(this.pos) === CharCodes.TAB || this.xmlString.charCodeAt(this.pos) === CharCodes.NEWLINE || this.xmlString.charCodeAt(this.pos) === CharCodes.CARRIAGE_RETURN)) {
-            this.pos++;
-          }
-          const code = this.xmlString.charCodeAt(this.pos);
-          if (code === CharCodes.SINGLE_QUOTE || code === CharCodes.DOUBLE_QUOTE) {
-            const { value: parsedValue, newPos: valueEnd } = parseString(
-              this.xmlString,
-              this.pos
-            );
-            value = parsedValue;
-            this.pos = valueEnd;
-          }
-        }
-        attributes[attrName] = value;
+        this.parseAttribute(attributes);
       } else {
-        this.pos++;
+        this.pos += 1;
       }
     }
-    const isSelfClosing = this.xmlString.charCodeAt(this.pos - 1) === CharCodes.SLASH || tagName[0] === "?" && this.xmlString.charCodeAt(this.pos - 1) === CharCodes.QUESTION;
-    if (!isSelfClosing) {
-      if (tagName === "script") {
-        const start = this.pos + 1;
-        this.pos = this.xmlString.indexOf("</script>", this.pos);
-        if (this.pos === -1) {
-          children = [this.xmlString.slice(start)];
-          this.pos = this.xmlString.length;
-        } else {
-          children = [this.xmlString.slice(start, this.pos)];
-          this.pos += 9;
-        }
-      } else if (tagName === "style") {
-        const start = this.pos + 1;
-        this.pos = this.xmlString.indexOf("</style>", this.pos);
-        if (this.pos === -1) {
-          children = [this.xmlString.slice(start)];
-          this.pos = this.xmlString.length;
-        } else {
-          children = [this.xmlString.slice(start, this.pos)];
-          this.pos += 8;
-        }
-      } else if (((_a = this.options.noChildNodes) == null ? void 0 : _a.indexOf(tagName)) === -1) {
-        this.pos++;
-        children = this.parseChildren(tagName);
-      } else {
-        this.pos++;
-        if (DEFAULT_NO_CHILD_NODES.includes(tagName)) {
-        } else {
-          const closingTag = `</${tagName}>`;
-          const closingPos = this.xmlString.indexOf(closingTag, this.pos);
-          if (closingPos !== -1) {
-            this.pos = closingPos + closingTag.length;
-          }
-        }
-      }
-    } else {
-      this.pos++;
+    return attributes;
+  }
+  /**
+   * Parse special tag content (script, style)
+   */
+  parseSpecialTagContent(_tagName, closingTag) {
+    const start = this.pos + 1;
+    this.pos = this.xmlString.indexOf(closingTag, this.pos);
+    if (this.pos === -1) {
+      const children2 = [this.xmlString.slice(start)];
+      this.pos = this.xmlString.length;
+      return children2;
+    }
+    const children = [this.xmlString.slice(start, this.pos)];
+    this.pos += closingTag.length;
+    return children;
+  }
+  /**
+   * Parse node children based on tag type
+   */
+  parseNodeChildren(tagName, isSelfClosing) {
+    var _a;
+    if (isSelfClosing) {
+      this.pos += 1;
+      return [];
+    }
+    if (tagName === "script") {
+      return this.parseSpecialTagContent(tagName, "</script>");
+    }
+    if (tagName === "style") {
+      return this.parseSpecialTagContent(tagName, "</style>");
+    }
+    if (((_a = this.options.noChildNodes) == null ? void 0 : _a.indexOf(tagName)) === -1) {
+      this.pos += 1;
+      return this.parseChildren(tagName);
+    }
+    this.pos += 1;
+    if (DEFAULT_NO_CHILD_NODES.includes(tagName)) {
+      return [];
     }
+    const closingTag = `</${tagName}>`;
+    const closingPos = this.xmlString.indexOf(closingTag, this.pos);
+    if (closingPos !== -1) {
+      this.pos = closingPos + closingTag.length;
+    }
+    return [];
+  }
+  /**
+   * Parse a single XML node
+   */
+  parseNode() {
+    this.pos += 1;
+    const { name: tagName, newPos } = parseName(this.xmlString, this.pos);
+    this.pos = newPos;
+    const attributes = this.parseAttributes();
+    const isSelfClosing = this.xmlString.charCodeAt(this.pos - 1) === CharCodes.SLASH || tagName[0] === "?" && this.xmlString.charCodeAt(this.pos - 1) === CharCodes.QUESTION;
+    const children = this.parseNodeChildren(tagName, isSelfClosing);
     return { tagName, attributes, children };
   }
   /**
@@ -1135,7 +1849,7 @@ var XMLTokenizer = class {
     if (this.options.keepComments) {
       children.push(this.xmlString.substring(startCommentPos, this.pos + 1));
     }
-    this.pos++;
+    this.pos += 1;
   }
   /**
    * Handle CDATA sections
@@ -1163,10 +1877,10 @@ var XMLTokenizer = class {
       } else if (encapsulated && this.xmlString.charCodeAt(this.pos) === CharCodes.CLOSE_CORNER_BRACKET) {
         encapsulated = false;
       }
-      this.pos++;
+      this.pos += 1;
     }
     children.push(this.xmlString.substring(startDoctype, this.pos));
-    this.pos++;
+    this.pos += 1;
   }
   /**
    * Get current position
@@ -1183,6 +1897,146 @@ var XMLTokenizer = class {
 };
 
 // src/core/parser.ts
+var WHITESPACE_REGEX = /\s/;
+var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var DIGIT_KEY_REGEX2 = /^\d+$/;
+function getTopLevelStringProps(s) {
+  const set = /* @__PURE__ */ new Set();
+  const unwrapped = unwrapJsonSchema(s);
+  if (unwrapped && typeof unwrapped === "object") {
+    const props = unwrapped.properties;
+    if (props && typeof props === "object") {
+      for (const [k, v] of Object.entries(props)) {
+        if (getSchemaType(v) === "string") {
+          set.add(k);
+        }
+      }
+    }
+  }
+  return set;
+}
+function restorePlaceholderString(val, placeholderMap) {
+  if (val.startsWith("__RXML_PLACEHOLDER_")) {
+    const orig = placeholderMap.get(val);
+    return orig !== void 0 ? orig : val;
+  }
+  return val;
+}
+function restorePlaceholdersInObject(obj, _placeholderMap, textNodeName, restorer) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const restored = restorer(v);
+    if (k === textNodeName && typeof restored === "string") {
+      out[k] = restored.trim();
+    } else {
+      out[k] = restored;
+    }
+  }
+  return out;
+}
+function createPlaceholderRestorer(placeholderMap, textNodeName) {
+  const restorer = (val) => {
+    if (val == null) {
+      return val;
+    }
+    if (typeof val === "string") {
+      return restorePlaceholderString(val, placeholderMap);
+    }
+    if (Array.isArray(val)) {
+      return val.map(restorer);
+    }
+    if (typeof val === "object") {
+      return restorePlaceholdersInObject(
+        val,
+        placeholderMap,
+        textNodeName,
+        restorer
+      );
+    }
+    return val;
+  };
+  return restorer;
+}
+function tryConvertToNumber(val) {
+  if (typeof val !== "string") {
+    return val;
+  }
+  const trimmed = val.trim();
+  if (NUMERIC_STRING_REGEX.test(trimmed)) {
+    const num = Number(trimmed);
+    if (Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return trimmed;
+}
+function processItemValue(item, textNodeName) {
+  let currentVal = item;
+  if (item && typeof item === "object" && Object.hasOwn(item, textNodeName)) {
+    currentVal = item[textNodeName];
+  }
+  const trimmed = typeof currentVal === "string" ? currentVal.trim() : currentVal;
+  return tryConvertToNumber(trimmed);
+}
+function processItemWrapper(itemValue, textNodeName) {
+  if (Array.isArray(itemValue)) {
+    return itemValue.map((item) => processItemValue(item, textNodeName));
+  }
+  const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+  return tryConvertToNumber(trimmed);
+}
+function shouldRethrowParseError(error, xmlString) {
+  if (!(error instanceof RXMLParseError)) {
+    return false;
+  }
+  const isSimple = xmlString.split("<").length < 6;
+  return error.message.includes("Unexpected close tag") && isSimple || error.message.includes("Unclosed tag") && isSimple;
+}
+function extractPartialXmlResults(xmlString, options) {
+  const partialResults = [];
+  const xmlPattern = /<([a-zA-Z_][\w.-]*)[^>]*>.*?<\/\1>/gs;
+  let match = null;
+  match = xmlPattern.exec(xmlString);
+  while (match !== null) {
+    try {
+      const elementXml = match[0];
+      const tokenizer = new XMLTokenizer(elementXml, options);
+      const parsed = tokenizer.parseChildren();
+      partialResults.push(...parsed);
+    } catch (e) {
+    }
+    match = xmlPattern.exec(xmlString);
+  }
+  return partialResults;
+}
+function deepDecodeStringsBySchema(input, schema) {
+  var _a;
+  if (input == null || schema == null) {
+    return input;
+  }
+  const type = getSchemaType(schema);
+  if (type === "string" && typeof input === "string") {
+    return unescapeXml(input);
+  }
+  if (type === "array" && Array.isArray(input)) {
+    const unwrapped = unwrapJsonSchema(schema);
+    const itemSchema = (_a = unwrapped == null ? void 0 : unwrapped.items) != null ? _a : {};
+    return input.map((item) => deepDecodeStringsBySchema(item, itemSchema));
+  }
+  if (type === "object" && input && typeof input === "object") {
+    const obj = input;
+    const out = {};
+    for (const key of Object.keys(obj)) {
+      const childSchema = getPropertySchema(schema, key);
+      out[key] = deepDecodeStringsBySchema(obj[key], childSchema);
+    }
+    return out;
+  }
+  if (typeof input === "string") {
+    return unescapeXml(input);
+  }
+  return input;
+}
 function parse(xmlInner, schema, options = {}) {
   var _a, _b, _c;
   const textNodeName = (_a = options.textNodeName) != null ? _a : "#text";
@@ -1195,7 +2049,9 @@ function parse(xmlInner, schema, options = {}) {
     let rootName = "";
     while (i < s.length) {
       const lt = s.indexOf("<", i);
-      if (lt === -1) break;
+      if (lt === -1) {
+        break;
+      }
       const next = s[lt + 1];
       if (next === "?") {
         const end = s.indexOf("?>", lt + 2);
@@ -1222,7 +2078,7 @@ function parse(xmlInner, schema, options = {}) {
       }
       let j = lt + 1;
       while (j < s.length && s[j] !== " " && s[j] !== "\n" && s[j] !== "\r" && s[j] !== "	" && s[j] !== "/" && s[j] !== ">") {
-        j++;
+        j += 1;
       }
       rootStart = lt;
       rootName = s.slice(lt + 1, j);
@@ -1235,27 +2091,36 @@ function parse(xmlInner, schema, options = {}) {
         const closeHead = s.indexOf(`</${rootName}`, range.end);
         if (closeHead === range.end) {
           let p = closeHead + 2 + rootName.length;
-          while (p < s.length && /\s/.test(s[p])) p++;
-          if (s[p] === ">") fullEnd = p + 1;
+          while (p < s.length && WHITESPACE_REGEX.test(s[p])) {
+            p += 1;
+          }
+          if (s[p] === ">") {
+            fullEnd = p + 1;
+          }
         }
         if (fullEnd === s.length) {
           const unwrapped = unwrapJsonSchema(schema);
           const schemaProps = unwrapped && typeof unwrapped === "object" ? unwrapped.properties : void 0;
-          if (schemaProps && !Object.prototype.hasOwnProperty.call(schemaProps, rootName)) {
+          if (schemaProps && !Object.hasOwn(schemaProps, rootName)) {
             actualXmlInner = s.slice(range.start, range.end);
           }
         }
       }
     }
   }
-  const stringTypedProps = getStringTypedProperties(schema);
+  const topLevelStringProps = getTopLevelStringProps(schema);
+  const deepStringTypedProps = getStringTypedProperties(schema);
   const duplicateKeys = /* @__PURE__ */ new Set();
-  for (const key of stringTypedProps) {
+  for (const key of topLevelStringProps) {
     const excludeRanges = [];
-    for (const other of stringTypedProps) {
-      if (other === key) continue;
+    for (const other of topLevelStringProps) {
+      if (other === key) {
+        continue;
+      }
       const range = findFirstTopLevelRange(actualXmlInner, other);
-      if (range) excludeRanges.push(range);
+      if (range) {
+        excludeRanges.push(range);
+      }
     }
     const occurrences = countTagOccurrences(
       actualXmlInner,
@@ -1282,37 +2147,35 @@ function parse(xmlInner, schema, options = {}) {
   const originalContentMap = /* @__PURE__ */ new Map();
   try {
     const ranges = [];
-    for (const key of stringTypedProps) {
-      const r = findFirstTopLevelRange(actualXmlInner, key);
-      if (r && r.end > r.start) ranges.push({ ...r, key });
+    for (const key of deepStringTypedProps) {
+      const innerRanges = findAllInnerRanges(actualXmlInner, key);
+      for (const r of innerRanges) {
+        if (r.end > r.start) {
+          ranges.push({ ...r, key });
+        }
+      }
     }
     if (ranges.length > 0) {
       const sorted = [...ranges].sort((a, b) => a.start - b.start);
-      const filtered = [];
+      let rebuilt = "";
+      let cursor = 0;
       for (const r of sorted) {
-        const last = filtered[filtered.length - 1];
-        if (last && r.start >= last.start && r.end <= last.end) {
+        if (r.start < cursor) {
           continue;
         }
-        filtered.push(r);
-      }
-      if (filtered.length > 0) {
-        filtered.sort((a, b) => a.start - b.start);
-        let rebuilt = "";
-        let cursor = 0;
-        for (const r of filtered) {
-          if (cursor < r.start)
-            rebuilt += actualXmlInner.slice(cursor, r.start);
-          const placeholder = `__RXML_PLACEHOLDER_${r.key}__`;
-          const originalContent = actualXmlInner.slice(r.start, r.end);
-          originalContentMap.set(placeholder, originalContent);
-          rebuilt += placeholder;
-          cursor = r.end;
+        if (cursor < r.start) {
+          rebuilt += actualXmlInner.slice(cursor, r.start);
         }
-        if (cursor < actualXmlInner.length)
-          rebuilt += actualXmlInner.slice(cursor);
-        xmlInnerForParsing = rebuilt;
+        const placeholder = `__RXML_PLACEHOLDER_${r.key}_${r.start}_${r.end}__`;
+        const originalContent = actualXmlInner.slice(r.start, r.end);
+        originalContentMap.set(placeholder, originalContent);
+        rebuilt += placeholder;
+        cursor = r.end;
       }
+      if (cursor < actualXmlInner.length) {
+        rebuilt += actualXmlInner.slice(cursor);
+      }
+      xmlInnerForParsing = rebuilt;
     }
   } catch (error) {
     if (options.onError) {
@@ -1336,9 +2199,14 @@ function parse(xmlInner, schema, options = {}) {
     throw new RXMLParseError("Failed to parse XML", cause);
   }
   const parsedArgs = domToObject(parsedNodes, schema, textNodeName);
+  const restorePlaceholdersDeep = createPlaceholderRestorer(
+    originalContentMap,
+    textNodeName
+  );
+  const parsedArgsRestored = restorePlaceholdersDeep(parsedArgs);
   const args = {};
-  for (const k of Object.keys(parsedArgs || {})) {
-    const v = parsedArgs[k];
+  for (const k of Object.keys(parsedArgsRestored || {})) {
+    const v = parsedArgsRestored[k];
     let val = v;
     const propSchema = getPropertySchema(schema, k);
     const propType = getSchemaType(propSchema);
@@ -1356,7 +2224,7 @@ function parse(xmlInner, schema, options = {}) {
       }
     }
     if (propType === "string" && !Array.isArray(v)) {
-      const placeholderUsed = typeof v === "string" && v.startsWith("__RXML_PLACEHOLDER_") || v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, textNodeName) && typeof v[textNodeName] === "string" && v[textNodeName].startsWith(
+      const placeholderUsed = typeof v === "string" && v.startsWith("__RXML_PLACEHOLDER_") || v && typeof v === "object" && Object.hasOwn(v, textNodeName) && typeof v[textNodeName] === "string" && v[textNodeName].startsWith(
         "__RXML_PLACEHOLDER_"
       );
       if (placeholderUsed) {
@@ -1378,13 +2246,13 @@ function parse(xmlInner, schema, options = {}) {
         continue;
       }
     }
-    if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, textNodeName)) {
+    if (v && typeof v === "object" && Object.hasOwn(v, textNodeName)) {
       val = v[textNodeName];
     }
     if (Array.isArray(v)) {
       if (propType === "string") {
         const mapped = v.map((item) => {
-          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, textNodeName)) {
+          if (item && typeof item === "object" && Object.hasOwn(item, textNodeName)) {
             const textVal = item[textNodeName];
             return typeof textVal === "string" ? textVal : String(textVal);
           }
@@ -1403,41 +2271,18 @@ function parse(xmlInner, schema, options = {}) {
         }
         args[k] = (_c = mapped[0]) != null ? _c : "";
         continue;
-      } else {
-        val = processArrayContent(v, propSchema, textNodeName);
       }
-    } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, textNodeName)) {
+      val = processArrayContent(v, propSchema, textNodeName);
+    } else if (v && typeof v === "object" && !Object.hasOwn(v, textNodeName)) {
       const obj = v;
       const keys2 = Object.keys(obj);
       if (keys2.length === 1 && keys2[0] === "item") {
-        const itemValue = obj.item;
-        if (Array.isArray(itemValue)) {
-          val = itemValue.map((item) => {
-            let currentVal = item;
-            if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, textNodeName)) {
-              currentVal = item[textNodeName];
-            }
-            const trimmed = typeof currentVal === "string" ? currentVal.trim() : currentVal;
-            if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-              const num = Number(trimmed);
-              if (Number.isFinite(num)) return num;
-            }
-            return trimmed;
-          });
-        } else {
-          const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
-          if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
-            const num = Number(trimmed);
-            val = Number.isFinite(num) ? num : trimmed;
-          } else {
-            val = trimmed;
-          }
-        }
+        val = processItemWrapper(obj.item, textNodeName);
       } else {
         let isIndexedTuple = false;
-        if (keys2.length > 0 && keys2.every((key) => /^\d+$/.test(key))) {
-          const indices = keys2.map((k2) => parseInt(k2, 10)).sort((a, b) => a - b);
-          isIndexedTuple = indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+        if (keys2.length > 0 && keys2.every((key) => DIGIT_KEY_REGEX2.test(key))) {
+          const indices = keys2.map((keyStr) => Number.parseInt(keyStr, 10)).sort((a, b) => a - b);
+          isIndexedTuple = indices[0] === 0 && indices.every((indexVal, idx) => indexVal === idx);
         }
         if (isIndexedTuple) {
           val = processIndexedTuple(obj, textNodeName);
@@ -1448,8 +2293,8 @@ function parse(xmlInner, schema, options = {}) {
     }
     args[k] = typeof val === "string" ? val.trim() : val;
   }
-  for (const key of stringTypedProps) {
-    if (!Object.prototype.hasOwnProperty.call(args, key)) {
+  for (const key of topLevelStringProps) {
+    if (!Object.hasOwn(args, key)) {
       const raw = extractRawInner(actualXmlInner, key);
       if (typeof raw === "string") {
         args[key] = raw;
@@ -1464,14 +2309,15 @@ function parse(xmlInner, schema, options = {}) {
     const unwrapped = unwrapJsonSchema(schema);
     if (unwrapped && typeof unwrapped === "object") {
       const schemaProps = unwrapped.properties;
-      if (schemaProps && !Object.prototype.hasOwnProperty.call(schemaProps, rootKey)) {
+      if (schemaProps && !Object.hasOwn(schemaProps, rootKey)) {
         dataToCoerce = rootValue;
       }
     }
   }
   try {
     const coerced = coerceDomBySchema(dataToCoerce, schema);
-    return coerced;
+    const decoded = deepDecodeStringsBySchema(coerced, schema);
+    return decoded;
   } catch (error) {
     throw new RXMLCoercionError("Failed to coerce by schema", error);
   }
@@ -1481,34 +2327,19 @@ function parseWithoutSchema(xmlString, options = {}) {
     const tokenizer = new XMLTokenizer(xmlString, options);
     return tokenizer.parseChildren();
   } catch (error) {
-    if (error instanceof RXMLParseError) {
-      const isSimple = xmlString.split("<").length < 6;
-      if (error.message.includes("Unexpected close tag") && isSimple || error.message.includes("Unclosed tag") && isSimple) {
-        throw new RXMLParseError(
-          error.message,
-          error.cause,
-          error.line,
-          error.column
-        );
-      }
+    if (shouldRethrowParseError(error, xmlString)) {
+      throw new RXMLParseError(
+        error.message,
+        error.cause,
+        error.line,
+        error.column
+      );
     }
     if (options.onError) {
       options.onError("Failed to parse XML without schema", { error });
     }
     try {
-      const partialResults = [];
-      const xmlPattern = /<([a-zA-Z_][\w.-]*)[^>]*>.*?<\/\1>/gs;
-      let match;
-      while ((match = xmlPattern.exec(xmlString)) !== null) {
-        try {
-          const elementXml = match[0];
-          const tokenizer = new XMLTokenizer(elementXml, options);
-          const parsed = tokenizer.parseChildren();
-          partialResults.push(...parsed);
-        } catch (e) {
-          continue;
-        }
-      }
+      const partialResults = extractPartialXmlResults(xmlString, options);
       if (partialResults.length > 0) {
         return partialResults;
       }
@@ -1525,6 +2356,26 @@ function parseNode(xmlString, options = {}) {
     throw new RXMLParseError("Failed to parse XML node", error);
   }
 }
+function buildNodeValue(child) {
+  const kids = simplify(child.children);
+  let nodeValue = kids;
+  if (Object.keys(child.attributes).length) {
+    if (typeof kids === "string") {
+      nodeValue = kids;
+      if (kids !== "") {
+        nodeValue = { _attributes: child.attributes, value: kids };
+      } else {
+        nodeValue = { _attributes: child.attributes };
+      }
+    } else if (typeof kids === "object" && kids !== null) {
+      kids._attributes = child.attributes;
+      nodeValue = kids;
+    } else {
+      nodeValue = { _attributes: child.attributes };
+    }
+  }
+  return nodeValue;
+}
 function simplify(children) {
   if (!children.length) {
     return "";
@@ -1533,33 +2384,20 @@ function simplify(children) {
     return children[0];
   }
   const out = {};
-  children.forEach((child) => {
+  for (const child of children) {
     if (typeof child !== "object") {
-      return;
+      continue;
     }
     if (!out[child.tagName]) {
       out[child.tagName] = [];
     }
-    const kids = simplify(child.children);
-    let nodeValue = kids;
-    if (Object.keys(child.attributes).length) {
-      if (typeof kids === "string") {
-        nodeValue = kids;
-        if (kids !== "") {
-          nodeValue = { _attributes: child.attributes, value: kids };
-        } else {
-          nodeValue = { _attributes: child.attributes };
-        }
-      } else if (typeof kids === "object" && kids !== null) {
-        kids._attributes = child.attributes;
-        nodeValue = kids;
-      } else {
-        nodeValue = { _attributes: child.attributes };
-      }
-    }
+    const nodeValue = buildNodeValue(child);
     out[child.tagName].push(nodeValue);
-  });
+  }
   for (const key in out) {
+    if (!Object.hasOwn(out, key)) {
+      continue;
+    }
     const value = out[key];
     if (Array.isArray(value) && value.length === 1) {
       out[key] = value[0];
@@ -1569,46 +2407,42 @@ function simplify(children) {
 }
 function filter(children, filterFn, depth = 0, path = "") {
   const out = [];
-  children.forEach((child, i) => {
+  for (let i = 0; i < children.length; i += 1) {
+    const child = children[i];
     if (typeof child === "object" && filterFn(child, i, depth, path)) {
       out.push(child);
     }
     if (typeof child === "object" && child.children) {
-      const kids = filter(
-        child.children,
-        filterFn,
-        depth + 1,
-        (path ? path + "." : "") + i + "." + child.tagName
-      );
+      const childPath = `${path ? `${path}.` : ""}${i}.${child.tagName}`;
+      const kids = filter(child.children, filterFn, depth + 1, childPath);
       out.push(...kids);
     }
-  });
+  }
   return out;
 }
 
 // src/core/stream.ts
-var import_stream = require("stream");
-var XMLTransformStream = class extends import_stream.Transform {
-  constructor(offset, parseOptions = {}) {
+var import_node_stream = require("stream");
+var TAG_NAME_REGEX = /^([a-zA-Z_][\w.-]*)/;
+var WHITESPACE_REGEX2 = /\s/;
+var XMLTransformStream = class extends import_node_stream.Transform {
+  constructor(_offset, parseOptions = {}) {
     super({ readableObjectMode: true });
     this.buffer = "";
     this.emittedCount = 0;
     this.sawTagChar = false;
-    if (typeof offset === "string") {
-      this.position = offset.length;
-    } else {
-      this.position = offset || 0;
-    }
     this.parseOptions = {
       keepComments: false,
       keepWhitespace: false,
       ...parseOptions
     };
   }
-  _transform(chunk, encoding, callback) {
+  _transform(chunk, _encoding, callback) {
     try {
       const incoming = chunk.toString();
-      if (incoming.includes("<")) this.sawTagChar = true;
+      if (incoming.includes("<")) {
+        this.sawTagChar = true;
+      }
       this.buffer += incoming;
       this.processBuffer();
       callback();
@@ -1634,122 +2468,190 @@ var XMLTransformStream = class extends import_stream.Transform {
   }
   processBuffer(isFlush = false) {
     while (this.buffer.length > 0) {
-      const openBracket = this.buffer.indexOf("<");
-      if (openBracket === -1) {
-        if (isFlush) this.buffer = "";
+      if (!this.trimToNextTag(isFlush)) {
         break;
       }
-      if (openBracket > 0) {
-        this.buffer = this.buffer.slice(openBracket);
+      if (this.tryProcessSpecialNode(isFlush)) {
+        continue;
       }
-      if (this.buffer.startsWith("<?") || this.buffer.startsWith("<!--") || this.buffer.startsWith("<![CDATA[")) {
-        const endMarkers = {
-          "<?": "?>",
-          "<!--": "-->",
-          "<![CDATA[": "]]>"
-        };
-        let endMarker = "";
-        for (const [start, end] of Object.entries(endMarkers)) {
-          if (this.buffer.startsWith(start)) {
-            endMarker = end;
-            break;
-          }
-        }
-        const endPos = endMarker ? this.buffer.indexOf(endMarker) : -1;
-        if (endPos === -1) {
-          if (!isFlush) break;
-          this.buffer = "";
-          break;
-        }
-        if (this.parseOptions.keepComments && this.buffer.startsWith("<!--")) {
-          this.push(this.buffer.slice(0, endPos + endMarker.length));
-        }
-        this.buffer = this.buffer.slice(endPos + endMarker.length);
+      if (this.trySkipStrayClosingTag(isFlush)) {
         continue;
       }
-      if (this.buffer.startsWith("</")) {
-        const closeEnd = this.buffer.indexOf(">");
-        if (closeEnd === -1) {
-          if (!isFlush) break;
-          this.buffer = "";
-          break;
-        }
-        this.buffer = this.buffer.slice(closeEnd + 1);
+      const tagInfo = this.extractTagInfo(isFlush);
+      if (!tagInfo) {
+        break;
+      }
+      if (this.tryProcessSelfClosingTag(tagInfo)) {
         continue;
       }
-      const openTagEnd = this.buffer.indexOf(">");
-      if (openTagEnd === -1) {
-        if (!isFlush) break;
+      if (!this.tryProcessRegularElement(tagInfo, isFlush)) {
+        break;
+      }
+    }
+  }
+  trimToNextTag(isFlush) {
+    const openBracket = this.buffer.indexOf("<");
+    if (openBracket === -1) {
+      if (isFlush) {
         this.buffer = "";
+      }
+      return false;
+    }
+    if (openBracket > 0) {
+      this.buffer = this.buffer.slice(openBracket);
+    }
+    return true;
+  }
+  tryProcessSpecialNode(isFlush) {
+    if (!(this.buffer.startsWith("<?") || this.buffer.startsWith("<!--") || this.buffer.startsWith("<![CDATA["))) {
+      return false;
+    }
+    const endMarkers = {
+      "<?": "?>",
+      "<!--": "-->",
+      "<![CDATA[": "]]>"
+    };
+    let endMarker = "";
+    for (const [start, end] of Object.entries(endMarkers)) {
+      if (this.buffer.startsWith(start)) {
+        endMarker = end;
         break;
       }
-      const openTagContent = this.buffer.slice(1, openTagEnd);
-      const nameMatch = openTagContent.match(/^([a-zA-Z_][\w.-]*)/);
-      if (!nameMatch) {
-        this.buffer = this.buffer.slice(1);
-        continue;
+    }
+    const endPos = endMarker ? this.buffer.indexOf(endMarker) : -1;
+    if (endPos === -1) {
+      if (isFlush) {
+        this.buffer = "";
       }
-      const tagName = nameMatch[1];
-      const isSelfClosing = this.buffer[openTagEnd - 1] === "/";
-      if (isSelfClosing) {
-        const elementEnd2 = openTagEnd + 1;
-        const elementXml2 = this.buffer.slice(0, elementEnd2);
-        try {
-          const tokenizer = new XMLTokenizer(elementXml2, this.parseOptions);
-          const node = tokenizer.parseNode();
-          this.emitElementAndChildren(node);
-          this.buffer = this.buffer.slice(elementEnd2);
-          continue;
-        } catch (e) {
-          this.buffer = this.buffer.slice(1);
-          continue;
-        }
+      return false;
+    }
+    if (this.parseOptions.keepComments && this.buffer.startsWith("<!--")) {
+      this.push(this.buffer.slice(0, endPos + endMarker.length));
+    }
+    this.buffer = this.buffer.slice(endPos + endMarker.length);
+    return true;
+  }
+  trySkipStrayClosingTag(isFlush) {
+    if (!this.buffer.startsWith("</")) {
+      return false;
+    }
+    const closeEnd = this.buffer.indexOf(">");
+    if (closeEnd === -1) {
+      if (isFlush) {
+        this.buffer = "";
       }
-      const closingTag = `</${tagName}>`;
-      let depth = 1;
-      let searchStart = openTagEnd + 1;
-      let elementEnd = -1;
-      while (searchStart < this.buffer.length) {
-        let nextOpen = this.buffer.indexOf(`<${tagName}`, searchStart);
-        while (nextOpen !== -1) {
-          const after = this.buffer[nextOpen + tagName.length + 1];
-          if (after === void 0 || after === ">" || /\s/.test(after)) break;
-          nextOpen = this.buffer.indexOf(`<${tagName}`, nextOpen + 1);
-        }
-        const nextCloseStart = this.buffer.indexOf(`</${tagName}`, searchStart);
-        if (nextCloseStart === -1) break;
-        if (nextOpen !== -1 && nextOpen < nextCloseStart) {
-          depth++;
-          searchStart = nextOpen + 1;
-        } else {
-          depth--;
-          let p = nextCloseStart + 2 + tagName.length;
-          while (p < this.buffer.length && /\s/.test(this.buffer[p])) p++;
-          if (this.buffer[p] !== ">") break;
-          const closeAdvance = p + 1;
-          searchStart = closeAdvance;
-          if (depth === 0) {
-            elementEnd = searchStart;
-            break;
-          }
-        }
+      return true;
+    }
+    this.buffer = this.buffer.slice(closeEnd + 1);
+    return true;
+  }
+  extractTagInfo(isFlush) {
+    const openTagEnd = this.buffer.indexOf(">");
+    if (openTagEnd === -1) {
+      if (isFlush) {
+        this.buffer = "";
       }
-      if (elementEnd === -1) {
-        if (!isFlush) break;
+      return null;
+    }
+    const openTagContent = this.buffer.slice(1, openTagEnd);
+    const nameMatch = openTagContent.match(TAG_NAME_REGEX);
+    if (!nameMatch) {
+      this.buffer = this.buffer.slice(1);
+      return null;
+    }
+    return { openTagEnd, tagName: nameMatch[1] };
+  }
+  tryProcessSelfClosingTag(tagInfo) {
+    const isSelfClosing = this.buffer[tagInfo.openTagEnd - 1] === "/";
+    if (!isSelfClosing) {
+      return false;
+    }
+    const elementEnd = tagInfo.openTagEnd + 1;
+    const elementXml = this.buffer.slice(0, elementEnd);
+    try {
+      const tokenizer = new XMLTokenizer(elementXml, this.parseOptions);
+      const node = tokenizer.parseNode();
+      this.emitElementAndChildren(node);
+      this.buffer = this.buffer.slice(elementEnd);
+      return true;
+    } catch (e) {
+      this.buffer = this.buffer.slice(1);
+      return true;
+    }
+  }
+  tryProcessRegularElement(tagInfo, isFlush) {
+    const elementEnd = this.findMatchingClosingTag(
+      tagInfo.tagName,
+      tagInfo.openTagEnd
+    );
+    if (elementEnd === -1) {
+      if (isFlush) {
         this.buffer = this.buffer.slice(1);
-        continue;
+        return true;
+      }
+      return false;
+    }
+    const elementXml = this.buffer.slice(0, elementEnd);
+    try {
+      const tokenizer = new XMLTokenizer(elementXml, this.parseOptions);
+      const node = tokenizer.parseNode();
+      this.emitElementAndChildren(node);
+      this.buffer = this.buffer.slice(elementEnd);
+      return true;
+    } catch (e) {
+      this.emit("error", new RXMLStreamError("Parse error", e));
+      return false;
+    }
+  }
+  findMatchingClosingTag(tagName, openTagEnd) {
+    let depth = 1;
+    let searchStart = openTagEnd + 1;
+    while (searchStart < this.buffer.length) {
+      const nextOpen = this.findNextOpeningTag(tagName, searchStart);
+      const nextCloseStart = this.buffer.indexOf(`</${tagName}`, searchStart);
+      if (nextCloseStart === -1) {
+        return -1;
+      }
+      if (nextOpen !== -1 && nextOpen < nextCloseStart) {
+        depth += 1;
+        searchStart = nextOpen + 1;
+      } else {
+        depth -= 1;
+        const closeAdvance = this.advancePastClosingTag(
+          tagName,
+          nextCloseStart
+        );
+        if (closeAdvance === -1) {
+          return -1;
+        }
+        searchStart = closeAdvance;
+        if (depth === 0) {
+          return searchStart;
+        }
       }
-      const elementXml = this.buffer.slice(0, elementEnd);
-      try {
-        const tokenizer = new XMLTokenizer(elementXml, this.parseOptions);
-        const node = tokenizer.parseNode();
-        this.emitElementAndChildren(node);
-        this.buffer = this.buffer.slice(elementEnd);
-      } catch (e) {
-        this.emit("error", new RXMLStreamError("Parse error", e));
-        return;
+    }
+    return -1;
+  }
+  findNextOpeningTag(tagName, searchStart) {
+    let nextOpen = this.buffer.indexOf(`<${tagName}`, searchStart);
+    while (nextOpen !== -1) {
+      const after = this.buffer[nextOpen + tagName.length + 1];
+      if (after === void 0 || after === ">" || WHITESPACE_REGEX2.test(after)) {
+        break;
       }
+      nextOpen = this.buffer.indexOf(`<${tagName}`, nextOpen + 1);
+    }
+    return nextOpen;
+  }
+  advancePastClosingTag(tagName, nextCloseStart) {
+    let p = nextCloseStart + 2 + tagName.length;
+    while (p < this.buffer.length && WHITESPACE_REGEX2.test(this.buffer[p])) {
+      p += 1;
+    }
+    if (this.buffer[p] !== ">") {
+      return -1;
     }
+    return p + 1;
   }
   /**
    * Emit an element and recursively emit its children as separate events
@@ -1758,12 +2660,12 @@ var XMLTransformStream = class extends import_stream.Transform {
     if (typeof node === "string") {
       if (this.parseOptions.keepComments && node.includes("<!--")) {
         this.push(node);
-        this.emittedCount++;
+        this.emittedCount += 1;
       }
       return;
     }
     this.push(node);
-    this.emittedCount++;
+    this.emittedCount += 1;
     for (const child of node.children) {
       this.emitElementAndChildren(child);
     }
@@ -1772,7 +2674,7 @@ var XMLTransformStream = class extends import_stream.Transform {
 function createXMLStream(offset, parseOptions) {
   return new XMLTransformStream(offset, parseOptions);
 }
-async function parseFromStream(stream, offset, parseOptions) {
+function parseFromStream(stream, offset, parseOptions) {
   return new Promise((resolve, reject) => {
     const results = [];
     const transformStream = createXMLStream(offset, parseOptions);
@@ -1835,7 +2737,10 @@ async function* processXMLStream(stream, offset, parseOptions) {
       throw new RXMLStreamError("Stream processing error", error);
     }
     if (queue.length > 0) {
-      yield queue.shift();
+      const item = queue.shift();
+      if (item !== void 0) {
+        yield item;
+      }
       continue;
     }
     if (ended) {
@@ -1870,224 +2775,6 @@ async function* findElementsByClassStream(stream, className, offset, parseOption
     }
   }
 }
-
-// src/builders/stringify.ts
-function stringify(rootTag, obj, options = {}) {
-  var _a, _b, _c, _d;
-  try {
-    const format = (_a = options.format) != null ? _a : true;
-    const minimalEscaping = (_b = options.minimalEscaping) != null ? _b : false;
-    const suppressEmptyNode = (_c = options.suppressEmptyNode) != null ? _c : false;
-    const strictBooleanAttributes = (_d = options.strictBooleanAttributes) != null ? _d : false;
-    let result = "";
-    if (format) {
-      result += '<?xml version="1.0" encoding="UTF-8"?>\n';
-    }
-    result += stringifyValue(
-      rootTag,
-      obj,
-      0,
-      format,
-      suppressEmptyNode,
-      minimalEscaping,
-      strictBooleanAttributes
-    );
-    return result;
-  } catch (error) {
-    throw new RXMLStringifyError("Failed to stringify XML", error);
-  }
-}
-function stringifyValue(tagName, value, depth, format, suppressEmptyNode, minimalEscaping, strictBooleanAttributes) {
-  const indent = format ? "  ".repeat(depth) : "";
-  const newline = format ? "\n" : "";
-  if (value === null || value === void 0) {
-    if (suppressEmptyNode) return "";
-    return `${indent}<${tagName}/>${newline}`;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    const content2 = minimalEscaping ? escapeXmlMinimalText(String(value)) : escapeXml(String(value));
-    if (content2 === "" && suppressEmptyNode) return "";
-    return `${indent}<${tagName}>${content2}</${tagName}>${newline}`;
-  }
-  if (Array.isArray(value)) {
-    let result = "";
-    for (const item of value) {
-      result += stringifyValue(
-        tagName,
-        item,
-        depth,
-        format,
-        suppressEmptyNode,
-        minimalEscaping,
-        strictBooleanAttributes
-      );
-    }
-    return result;
-  }
-  if (typeof value === "object") {
-    return stringifyObject(
-      tagName,
-      value,
-      depth,
-      format,
-      suppressEmptyNode,
-      minimalEscaping,
-      strictBooleanAttributes
-    );
-  }
-  const content = minimalEscaping ? escapeXmlMinimalText(String(value)) : escapeXml(String(value));
-  if (content === "" && suppressEmptyNode) return "";
-  return `${indent}<${tagName}>${content}</${tagName}>${newline}`;
-}
-function stringifyObject(tagName, obj, depth, format, suppressEmptyNode, minimalEscaping, strictBooleanAttributes) {
-  const indent = format ? "  ".repeat(depth) : "";
-  const newline = format ? "\n" : "";
-  const childIndent = format ? "  ".repeat(depth + 1) : "";
-  const attributes = {};
-  const elements = {};
-  let textContent;
-  for (const [key, value] of Object.entries(obj)) {
-    if (key.startsWith("@")) {
-      attributes[key.substring(1)] = value;
-    } else if (key === "#text" || key === "_text") {
-      textContent = String(value);
-    } else if (key === "_attributes") {
-      if (typeof value === "object" && value !== null) {
-        Object.assign(attributes, value);
-      }
-    } else {
-      elements[key] = value;
-    }
-  }
-  let openTag = `<${tagName}`;
-  for (const [attrName, attrValue] of Object.entries(attributes)) {
-    if (attrValue === null) {
-      if (strictBooleanAttributes) {
-        openTag += ` ${attrName}="${attrName}"`;
-      } else {
-        openTag += ` ${attrName}`;
-      }
-    } else {
-      const valueStr = String(attrValue);
-      if (valueStr.indexOf('"') === -1) {
-        const escaped = minimalEscaping ? escapeXmlMinimalAttr(valueStr, '"') : escapeXml(valueStr);
-        openTag += ` ${attrName}="${escaped}"`;
-      } else {
-        const escaped = minimalEscaping ? escapeXmlMinimalAttr(valueStr, "'") : escapeXml(valueStr);
-        openTag += ` ${attrName}='${escaped}'`;
-      }
-    }
-  }
-  const hasElements = Object.keys(elements).length > 0;
-  const hasTextContent = textContent !== void 0 && textContent !== "";
-  if (!hasElements && !hasTextContent) {
-    if (suppressEmptyNode) return "";
-    return `${indent}${openTag}/>${newline}`;
-  }
-  openTag += ">";
-  if (!hasElements && hasTextContent && textContent) {
-    const content = minimalEscaping ? escapeXmlMinimalText(textContent) : escapeXml(textContent);
-    return `${indent}${openTag}${content}</${tagName}>${newline}`;
-  }
-  let result = `${indent}${openTag}`;
-  if (hasTextContent && textContent) {
-    const content = minimalEscaping ? escapeXmlMinimalText(textContent) : escapeXml(textContent);
-    if (format) result += `${newline}${childIndent}${content}`;
-    else result += content;
-  }
-  if (hasElements) {
-    if (format) result += newline;
-    for (const [elementName, elementValue] of Object.entries(elements)) {
-      result += stringifyValue(
-        elementName,
-        elementValue,
-        depth + 1,
-        format,
-        suppressEmptyNode,
-        minimalEscaping,
-        strictBooleanAttributes
-      );
-    }
-    if (format) result += indent;
-  }
-  result += `</${tagName}>${newline}`;
-  return result;
-}
-function stringifyNodes(nodes, format = true, options = {}) {
-  let result = "";
-  for (const node of nodes) {
-    if (typeof node === "string") {
-      result += node;
-    } else {
-      result += stringifyNode(node, 0, format, options);
-    }
-  }
-  return result;
-}
-function stringifyNode(node, depth = 0, format = true, options = {}) {
-  var _a, _b;
-  const indent = format ? "  ".repeat(depth) : "";
-  const newline = format ? "\n" : "";
-  const minimalEscaping = (_a = options.minimalEscaping) != null ? _a : false;
-  const strictBooleanAttributes = (_b = options.strictBooleanAttributes) != null ? _b : false;
-  let result = `${indent}<${node.tagName}`;
-  for (const [attrName, attrValue] of Object.entries(node.attributes)) {
-    if (attrValue === null) {
-      if (strictBooleanAttributes) {
-        result += ` ${attrName}="${attrName}"`;
-      } else {
-        result += ` ${attrName}`;
-      }
-    } else if (attrValue.indexOf('"') === -1) {
-      const escaped = minimalEscaping ? escapeXmlMinimalAttr(attrValue, '"') : escapeXml(attrValue);
-      result += ` ${attrName}="${escaped}"`;
-    } else {
-      const escaped = minimalEscaping ? escapeXmlMinimalAttr(attrValue, "'") : escapeXml(attrValue);
-      result += ` ${attrName}='${escaped}'`;
-    }
-  }
-  if (node.tagName[0] === "?") {
-    result += "?>";
-    return result + newline;
-  }
-  if (node.children.length === 0) {
-    result += "/>";
-    return result + newline;
-  }
-  result += ">";
-  let hasElementChildren = false;
-  for (const child of node.children) {
-    if (typeof child === "string") {
-      result += minimalEscaping ? escapeXmlMinimalText(child) : escapeXml(child);
-    } else {
-      if (!hasElementChildren && format) {
-        result += newline;
-        hasElementChildren = true;
-      }
-      result += stringifyNode(child, depth + 1, format, options);
-    }
-  }
-  if (hasElementChildren && format) {
-    result += indent;
-  }
-  result += `</${node.tagName}>`;
-  if (format) {
-    result += newline;
-  }
-  return result;
-}
-function toContentString(nodes) {
-  let result = "";
-  for (const node of nodes) {
-    if (typeof node === "string") {
-      result += " " + node;
-    } else {
-      result += " " + toContentString(node.children);
-    }
-    result = result.trim();
-  }
-  return result;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RXMLCoercionError,
@@ -2097,16 +2784,19 @@ function toContentString(nodes) {
   RXMLStringifyError,
   XMLTokenizer,
   XMLTransformStream,
+  coerceBySchema,
   coerceDomBySchema,
   countTagOccurrences,
   createXMLStream,
   domToObject,
   extractRawInner,
   filter,
+  findAllTopLevelRanges,
   findElementByIdStream,
   findElementsByClassStream,
   findFirstTopLevelRange,
   getPropertySchema,
+  getSchemaType,
   getStringTypedProperties,
   parse,
   parseFromStream,
@@ -2119,6 +2809,8 @@ function toContentString(nodes) {
   stringify,
   stringifyNode,
   stringifyNodes,
-  toContentString
+  toContentString,
+  unescapeXml,
+  unwrapJsonSchema
 });
 //# sourceMappingURL=index.cjs.map