@ai-sdk-tool/rxml 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2124 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RXMLCoercionError: () => RXMLCoercionError,
+  RXMLDuplicateStringTagError: () => RXMLDuplicateStringTagError,
+  RXMLParseError: () => RXMLParseError,
+  RXMLStreamError: () => RXMLStreamError,
+  RXMLStringifyError: () => RXMLStringifyError,
+  XMLTokenizer: () => XMLTokenizer,
+  XMLTransformStream: () => XMLTransformStream,
+  coerceDomBySchema: () => coerceDomBySchema,
+  countTagOccurrences: () => countTagOccurrences,
+  createXMLStream: () => createXMLStream,
+  domToObject: () => domToObject,
+  extractRawInner: () => extractRawInner,
+  filter: () => filter,
+  findElementByIdStream: () => findElementByIdStream,
+  findElementsByClassStream: () => findElementsByClassStream,
+  findFirstTopLevelRange: () => findFirstTopLevelRange,
+  getPropertySchema: () => getPropertySchema,
+  getStringTypedProperties: () => getStringTypedProperties,
+  parse: () => parse,
+  parseFromStream: () => parseFromStream,
+  parseNode: () => parseNode,
+  parseWithoutSchema: () => parseWithoutSchema,
+  processArrayContent: () => processArrayContent,
+  processIndexedTuple: () => processIndexedTuple,
+  processXMLStream: () => processXMLStream,
+  simplify: () => simplify,
+  stringify: () => stringify,
+  stringifyNode: () => stringifyNode,
+  stringifyNodes: () => stringifyNodes,
+  toContentString: () => toContentString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/types.ts
+var RXMLParseError = class extends Error {
+  constructor(message, cause, line, column) {
+    super(message);
+    this.cause = cause;
+    this.line = line;
+    this.column = column;
+    this.name = "RXMLParseError";
+  }
+};
+var RXMLDuplicateStringTagError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RXMLDuplicateStringTagError";
+  }
+};
+var RXMLCoercionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "RXMLCoercionError";
+  }
+};
+var RXMLStringifyError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "RXMLStringifyError";
+  }
+};
+var RXMLStreamError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "RXMLStreamError";
+  }
+};
+
+// 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),
+  CLOSE_BRACKET: ">".charCodeAt(0),
+  MINUS: "-".charCodeAt(0),
+  SLASH: "/".charCodeAt(0),
+  EXCLAMATION: "!".charCodeAt(0),
+  QUESTION: "?".charCodeAt(0),
+  SINGLE_QUOTE: "'".charCodeAt(0),
+  DOUBLE_QUOTE: '"'.charCodeAt(0),
+  OPEN_CORNER_BRACKET: "[".charCodeAt(0),
+  CLOSE_CORNER_BRACKET: "]".charCodeAt(0),
+  SPACE: " ".charCodeAt(0),
+  TAB: "	".charCodeAt(0),
+  NEWLINE: "\n".charCodeAt(0),
+  CARRIAGE_RETURN: "\r".charCodeAt(0)
+};
+var DEFAULT_NO_CHILD_NODES = [
+  "img",
+  "br",
+  "input",
+  "meta",
+  "link",
+  "hr",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var NAME_SPACER = "\r\n	>/= ";
+
+// src/utils/helpers.ts
+function isNameStartChar(ch) {
+  return /[A-Za-z_:]/.test(ch);
+}
+function isNameChar(ch) {
+  return /[A-Za-z0-9_.:-]/.test(ch);
+}
+function skipQuoted(s, i) {
+  const quote = s[i];
+  i++;
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    i++;
+  }
+  return i;
+}
+function parseName(s, pos) {
+  const start = pos;
+  while (NAME_SPACER.indexOf(s[pos]) === -1 && s[pos]) {
+    pos++;
+  }
+  return { name: s.slice(start, pos), newPos: pos };
+}
+function parseString(s, pos) {
+  const startChar = s[pos];
+  const startPos = pos + 1;
+  const endPos = s.indexOf(startChar, startPos);
+  if (endPos === -1) {
+    const tagEnd = s.indexOf(">", startPos);
+    if (tagEnd !== -1) {
+      return { value: s.slice(startPos, tagEnd), newPos: tagEnd };
+    }
+    return { value: s.slice(startPos), newPos: s.length };
+  }
+  return { value: s.slice(startPos, endPos), newPos: endPos + 1 };
+}
+function getLineColumn(s, pos) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < pos && i < s.length; i++) {
+    if (s[i] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function escapeXmlMinimalText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/]]>/g, "]]&gt;");
+}
+function escapeXmlMinimalAttr(value, wrapper = '"') {
+  let escaped = value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+  if (wrapper === '"') {
+    escaped = escaped.replace(/"/g, "&quot;");
+  } else {
+    escaped = escaped.replace(/'/g, "&apos;");
+  }
+  return escaped;
+}
+
+// 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;
+    }
+  }
+  if (bestStart !== -1) {
+    return xmlContent.slice(bestStart, bestEnd);
+  }
+  return void 0;
+}
+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) 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 (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;
+      }
+      i = xmlContent[tagEnd] === ">" ? tagEnd + 1 : tagEnd + 1;
+      depth += isSelfClosing ? 0 : 1;
+      continue;
+    }
+  }
+  return void 0;
+}
+function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst = true) {
+  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;
+  };
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) 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;
+      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++;
+        }
+      }
+      i = k + 1;
+      continue;
+    }
+  }
+  return count;
+}
+
+// src/core/tokenizer.ts
+var XMLTokenizer = class {
+  constructor(xmlString, options = {}) {
+    this.pos = 0;
+    this.xmlString = xmlString;
+    this.options = {
+      keepComments: false,
+      keepWhitespace: false,
+      noChildNodes: DEFAULT_NO_CHILD_NODES.slice(),
+      textNodeName: "#text",
+      throwOnDuplicateStringTags: true,
+      ...options
+    };
+    this.pos = options.pos || 0;
+  }
+  /**
+   * Parse XML children recursively
+   */
+  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++;
+      }
+    }
+    if (tagName && this.pos >= this.xmlString.length && !consumedToEnd) {
+      const { line, column } = getLineColumn(this.xmlString, this.pos - 1);
+      throw new RXMLParseError(
+        `Unclosed tag at line ${line}, column ${column}. Expected closing tag </${tagName}>`,
+        void 0,
+        line,
+        column
+      );
+    }
+    return children;
+  }
+  /**
+   * Parse a single XML node
+   */
+  parseNode() {
+    var _a;
+    this.pos++;
+    const { name: tagName, newPos } = parseName(this.xmlString, this.pos);
+    this.pos = newPos;
+    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++;
+        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;
+      } else {
+        this.pos++;
+      }
+    }
+    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 { tagName, attributes, children };
+  }
+  /**
+   * Parse text content until next tag
+   */
+  parseText() {
+    const start = this.pos;
+    this.pos = this.xmlString.indexOf("<", this.pos) - 1;
+    if (this.pos === -2) {
+      this.pos = this.xmlString.length;
+    }
+    return this.xmlString.slice(start, this.pos + 1);
+  }
+  /**
+   * Handle comments, CDATA, and DOCTYPE declarations
+   */
+  handleSpecialContent(children) {
+    if (this.xmlString.charCodeAt(this.pos + 2) === CharCodes.MINUS) {
+      this.handleComment(children);
+    } else if (this.xmlString.charCodeAt(this.pos + 2) === CharCodes.OPEN_CORNER_BRACKET && this.xmlString.charCodeAt(this.pos + 8) === CharCodes.OPEN_CORNER_BRACKET && this.xmlString.substr(this.pos + 3, 5).toLowerCase() === "cdata") {
+      this.handleCData(children);
+    } else {
+      this.handleDoctype(children);
+    }
+  }
+  /**
+   * Handle XML comments
+   */
+  handleComment(children) {
+    const startCommentPos = this.pos;
+    while (this.pos !== -1 && !(this.xmlString.charCodeAt(this.pos) === CharCodes.CLOSE_BRACKET && this.xmlString.charCodeAt(this.pos - 1) === CharCodes.MINUS && this.xmlString.charCodeAt(this.pos - 2) === CharCodes.MINUS)) {
+      this.pos = this.xmlString.indexOf(">", this.pos + 1);
+    }
+    if (this.pos === -1) {
+      this.pos = this.xmlString.length;
+    }
+    if (this.options.keepComments) {
+      children.push(this.xmlString.substring(startCommentPos, this.pos + 1));
+    }
+    this.pos++;
+  }
+  /**
+   * Handle CDATA sections
+   */
+  handleCData(children) {
+    const cdataEndIndex = this.xmlString.indexOf("]]>", this.pos);
+    if (cdataEndIndex === -1) {
+      children.push(this.xmlString.substr(this.pos + 9));
+      this.pos = this.xmlString.length;
+    } else {
+      children.push(this.xmlString.substring(this.pos + 9, cdataEndIndex));
+      this.pos = cdataEndIndex + 3;
+    }
+  }
+  /**
+   * Handle DOCTYPE declarations
+   */
+  handleDoctype(children) {
+    const startDoctype = this.pos + 1;
+    this.pos += 2;
+    let encapsulated = false;
+    while ((this.xmlString.charCodeAt(this.pos) !== CharCodes.CLOSE_BRACKET || encapsulated) && this.xmlString[this.pos]) {
+      if (this.xmlString.charCodeAt(this.pos) === CharCodes.OPEN_CORNER_BRACKET) {
+        encapsulated = true;
+      } else if (encapsulated && this.xmlString.charCodeAt(this.pos) === CharCodes.CLOSE_CORNER_BRACKET) {
+        encapsulated = false;
+      }
+      this.pos++;
+    }
+    children.push(this.xmlString.substring(startDoctype, this.pos));
+    this.pos++;
+  }
+  /**
+   * Get current position
+   */
+  getPosition() {
+    return this.pos;
+  }
+  /**
+   * Set position
+   */
+  setPosition(pos) {
+    this.pos = pos;
+  }
+};
+
+// src/core/parser.ts
+function parse(xmlInner, schema, options = {}) {
+  var _a, _b, _c;
+  const textNodeName = (_a = options.textNodeName) != null ? _a : "#text";
+  const throwDup = (_b = options.throwOnDuplicateStringTags) != null ? _b : true;
+  let actualXmlInner = xmlInner.trim();
+  if (actualXmlInner.startsWith("<") && actualXmlInner.endsWith(">")) {
+    const s = actualXmlInner;
+    let i = 0;
+    let rootStart = -1;
+    let rootName = "";
+    while (i < s.length) {
+      const lt = s.indexOf("<", i);
+      if (lt === -1) break;
+      const next = s[lt + 1];
+      if (next === "?") {
+        const end = s.indexOf("?>", lt + 2);
+        i = end === -1 ? s.length : end + 2;
+        continue;
+      }
+      if (next === "!") {
+        if (s.startsWith("!--", lt + 2)) {
+          const end2 = s.indexOf("-->", lt + 5);
+          i = end2 === -1 ? s.length : end2 + 3;
+          continue;
+        }
+        if (s.startsWith("![CDATA[", lt + 2)) {
+          const end2 = s.indexOf("]]>", lt + 9);
+          i = end2 === -1 ? s.length : end2 + 3;
+          continue;
+        }
+        const end = s.indexOf(">", lt + 2);
+        i = end === -1 ? s.length : end + 1;
+        continue;
+      }
+      if (next === "/") {
+        break;
+      }
+      let j = lt + 1;
+      while (j < s.length && s[j] !== " " && s[j] !== "\n" && s[j] !== "\r" && s[j] !== "	" && s[j] !== "/" && s[j] !== ">") {
+        j++;
+      }
+      rootStart = lt;
+      rootName = s.slice(lt + 1, j);
+      break;
+    }
+    if (rootStart === 0 && rootName) {
+      const range = findFirstTopLevelRange(s, rootName);
+      if (range) {
+        let fullEnd = range.end + `</${rootName}>`.length;
+        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;
+        }
+        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)) {
+            actualXmlInner = s.slice(range.start, range.end);
+          }
+        }
+      }
+    }
+  }
+  const stringTypedProps = getStringTypedProperties(schema);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const key of stringTypedProps) {
+    const excludeRanges = [];
+    for (const other of stringTypedProps) {
+      if (other === key) continue;
+      const range = findFirstTopLevelRange(actualXmlInner, other);
+      if (range) excludeRanges.push(range);
+    }
+    const occurrences = countTagOccurrences(
+      actualXmlInner,
+      key,
+      excludeRanges,
+      true
+    );
+    if (occurrences > 0 && throwDup) {
+      throw new RXMLDuplicateStringTagError(
+        `Duplicate string tags for <${key}> detected`
+      );
+    }
+    if (occurrences > 0 && !throwDup) {
+      duplicateKeys.add(key);
+      if (options.onError) {
+        options.onError(
+          `RXML: Duplicate string tags for <${key}> detected; using first occurrence.`,
+          { tag: key, occurrences }
+        );
+      }
+    }
+  }
+  let xmlInnerForParsing = actualXmlInner;
+  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 });
+    }
+    if (ranges.length > 0) {
+      const sorted = [...ranges].sort((a, b) => a.start - b.start);
+      const filtered = [];
+      for (const r of sorted) {
+        const last = filtered[filtered.length - 1];
+        if (last && r.start >= last.start && r.end <= last.end) {
+          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 < actualXmlInner.length)
+          rebuilt += actualXmlInner.slice(cursor);
+        xmlInnerForParsing = rebuilt;
+      }
+    }
+  } catch (error) {
+    if (options.onError) {
+      options.onError(
+        "RXML: Failed to replace string placeholders, falling back to original XML.",
+        { error }
+      );
+    }
+    xmlInnerForParsing = actualXmlInner;
+  }
+  let parsedNodes;
+  try {
+    const wrappedXml = `<root>${xmlInnerForParsing}</root>`;
+    const tokenizer = new XMLTokenizer(wrappedXml, {
+      ...options,
+      textNodeName
+    });
+    const rootNode = tokenizer.parseNode();
+    parsedNodes = rootNode.children;
+  } catch (cause) {
+    throw new RXMLParseError("Failed to parse XML", cause);
+  }
+  const parsedArgs = domToObject(parsedNodes, schema, textNodeName);
+  const args = {};
+  for (const k of Object.keys(parsedArgs || {})) {
+    const v = parsedArgs[k];
+    let val = v;
+    const propSchema = getPropertySchema(schema, k);
+    const propType = getSchemaType(propSchema);
+    if (propType === "string" && duplicateKeys.has(k) && Array.isArray(v)) {
+      const firstValue = v[0];
+      if (typeof firstValue === "string" && firstValue.startsWith("__RXML_PLACEHOLDER_")) {
+        const originalContent = originalContentMap.get(firstValue);
+        if (originalContent !== void 0) {
+          args[k] = originalContent;
+          continue;
+        }
+      } else {
+        args[k] = firstValue;
+        continue;
+      }
+    }
+    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(
+        "__RXML_PLACEHOLDER_"
+      );
+      if (placeholderUsed) {
+        let placeholderKey;
+        if (typeof v === "string") {
+          placeholderKey = v;
+        } else {
+          placeholderKey = v[textNodeName];
+        }
+        const originalContent = originalContentMap.get(placeholderKey);
+        if (originalContent !== void 0) {
+          args[k] = originalContent;
+          continue;
+        }
+      }
+      const raw = extractRawInner(actualXmlInner, k);
+      if (typeof raw === "string") {
+        args[k] = raw;
+        continue;
+      }
+    }
+    if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(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)) {
+            const textVal = item[textNodeName];
+            return typeof textVal === "string" ? textVal : String(textVal);
+          }
+          return typeof item === "string" ? item : String(item);
+        });
+        if (mapped.length > 1 && throwDup) {
+          throw new RXMLDuplicateStringTagError(
+            `Duplicate string tags for <${k}> detected`
+          );
+        }
+        if (mapped.length > 1 && !throwDup && options.onError) {
+          options.onError(
+            `RXML: Duplicate string tags for <${k}> detected; using first occurrence.`,
+            { tag: k, occurrences: mapped.length }
+          );
+        }
+        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)) {
+      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;
+          }
+        }
+      } 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 (isIndexedTuple) {
+          val = processIndexedTuple(obj, textNodeName);
+        } else {
+          val = v;
+        }
+      }
+    }
+    args[k] = typeof val === "string" ? val.trim() : val;
+  }
+  for (const key of stringTypedProps) {
+    if (!Object.prototype.hasOwnProperty.call(args, key)) {
+      const raw = extractRawInner(actualXmlInner, key);
+      if (typeof raw === "string") {
+        args[key] = raw;
+      }
+    }
+  }
+  let dataToCoerce = args;
+  const keys = Object.keys(args);
+  if (keys.length === 1) {
+    const rootKey = keys[0];
+    const rootValue = args[rootKey];
+    const unwrapped = unwrapJsonSchema(schema);
+    if (unwrapped && typeof unwrapped === "object") {
+      const schemaProps = unwrapped.properties;
+      if (schemaProps && !Object.prototype.hasOwnProperty.call(schemaProps, rootKey)) {
+        dataToCoerce = rootValue;
+      }
+    }
+  }
+  try {
+    const coerced = coerceDomBySchema(dataToCoerce, schema);
+    return coerced;
+  } catch (error) {
+    throw new RXMLCoercionError("Failed to coerce by schema", error);
+  }
+}
+function parseWithoutSchema(xmlString, options = {}) {
+  try {
+    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 (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;
+        }
+      }
+      if (partialResults.length > 0) {
+        return partialResults;
+      }
+    } catch (e) {
+    }
+    return [xmlString.trim()];
+  }
+}
+function parseNode(xmlString, options = {}) {
+  try {
+    const tokenizer = new XMLTokenizer(xmlString, options);
+    return tokenizer.parseNode();
+  } catch (error) {
+    throw new RXMLParseError("Failed to parse XML node", error);
+  }
+}
+function simplify(children) {
+  if (!children.length) {
+    return "";
+  }
+  if (children.length === 1 && typeof children[0] === "string") {
+    return children[0];
+  }
+  const out = {};
+  children.forEach((child) => {
+    if (typeof child !== "object") {
+      return;
+    }
+    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 };
+      }
+    }
+    out[child.tagName].push(nodeValue);
+  });
+  for (const key in out) {
+    const value = out[key];
+    if (Array.isArray(value) && value.length === 1) {
+      out[key] = value[0];
+    }
+  }
+  return out;
+}
+function filter(children, filterFn, depth = 0, path = "") {
+  const out = [];
+  children.forEach((child, 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
+      );
+      out.push(...kids);
+    }
+  });
+  return out;
+}
+
+// src/core/stream.ts
+var import_stream = require("stream");
+var XMLTransformStream = class extends import_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) {
+    try {
+      const incoming = chunk.toString();
+      if (incoming.includes("<")) this.sawTagChar = true;
+      this.buffer += incoming;
+      this.processBuffer();
+      callback();
+    } catch (error) {
+      callback(new RXMLStreamError("Transform error", error));
+    }
+  }
+  _flush(callback) {
+    try {
+      if (this.buffer.length > 0) {
+        this.processBuffer(true);
+      }
+      if (this.sawTagChar && this.emittedCount === 0) {
+        throw new RXMLStreamError(
+          "Flush error",
+          new Error("No XML elements could be parsed from stream")
+        );
+      }
+      callback();
+    } catch (error) {
+      callback(new RXMLStreamError("Flush error", error));
+    }
+  }
+  processBuffer(isFlush = false) {
+    while (this.buffer.length > 0) {
+      const openBracket = this.buffer.indexOf("<");
+      if (openBracket === -1) {
+        if (isFlush) this.buffer = "";
+        break;
+      }
+      if (openBracket > 0) {
+        this.buffer = this.buffer.slice(openBracket);
+      }
+      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);
+        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);
+        continue;
+      }
+      const openTagEnd = this.buffer.indexOf(">");
+      if (openTagEnd === -1) {
+        if (!isFlush) break;
+        this.buffer = "";
+        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 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;
+        }
+      }
+      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;
+          }
+        }
+      }
+      if (elementEnd === -1) {
+        if (!isFlush) break;
+        this.buffer = this.buffer.slice(1);
+        continue;
+      }
+      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;
+      }
+    }
+  }
+  /**
+   * Emit an element and recursively emit its children as separate events
+   */
+  emitElementAndChildren(node) {
+    if (typeof node === "string") {
+      if (this.parseOptions.keepComments && node.includes("<!--")) {
+        this.push(node);
+        this.emittedCount++;
+      }
+      return;
+    }
+    this.push(node);
+    this.emittedCount++;
+    for (const child of node.children) {
+      this.emitElementAndChildren(child);
+    }
+  }
+};
+function createXMLStream(offset, parseOptions) {
+  return new XMLTransformStream(offset, parseOptions);
+}
+async function parseFromStream(stream, offset, parseOptions) {
+  return new Promise((resolve, reject) => {
+    const results = [];
+    const transformStream = createXMLStream(offset, parseOptions);
+    const onSourceError = (err) => {
+      transformStream.destroy(err);
+    };
+    stream.on("error", onSourceError);
+    transformStream.on("data", (element) => {
+      results.push(element);
+    });
+    transformStream.on("end", () => {
+      stream.off("error", onSourceError);
+      resolve(results);
+    });
+    transformStream.on("error", (error) => {
+      stream.off("error", onSourceError);
+      reject(new RXMLStreamError("Stream parsing failed", error));
+    });
+    stream.pipe(transformStream);
+  });
+}
+async function* processXMLStream(stream, offset, parseOptions) {
+  const transformStream = createXMLStream(offset, parseOptions);
+  let ended = false;
+  let error = null;
+  const queue = [];
+  let resolveNext = null;
+  const onSourceError = (err) => {
+    error = err;
+    transformStream.destroy(err);
+  };
+  stream.on("error", onSourceError);
+  transformStream.on("data", (element) => {
+    if (resolveNext) {
+      resolveNext({ value: element, done: false });
+      resolveNext = null;
+    } else {
+      queue.push(element);
+    }
+  });
+  transformStream.on("end", () => {
+    ended = true;
+    if (resolveNext) {
+      resolveNext({ value: void 0, done: true });
+      resolveNext = null;
+    }
+    stream.off("error", onSourceError);
+  });
+  transformStream.on("error", (err) => {
+    error = err;
+    if (resolveNext) {
+      resolveNext({ value: void 0, done: true });
+      resolveNext = null;
+    }
+    stream.off("error", onSourceError);
+  });
+  stream.pipe(transformStream);
+  while (true) {
+    if (error) {
+      throw new RXMLStreamError("Stream processing error", error);
+    }
+    if (queue.length > 0) {
+      yield queue.shift();
+      continue;
+    }
+    if (ended) {
+      break;
+    }
+    const result = await new Promise(
+      (resolve) => {
+        resolveNext = resolve;
+      }
+    );
+    if (result.done) {
+      if (error) {
+        throw new RXMLStreamError("Stream processing error", error);
+      }
+      break;
+    }
+    yield result.value;
+  }
+}
+async function* findElementByIdStream(stream, id, offset, parseOptions) {
+  for await (const element of processXMLStream(stream, offset, parseOptions)) {
+    if (typeof element === "object" && element.attributes.id === id) {
+      yield element;
+    }
+  }
+}
+async function* findElementsByClassStream(stream, className, offset, parseOptions) {
+  const classRegex = new RegExp(`\\b${className}\\b`);
+  for await (const element of processXMLStream(stream, offset, parseOptions)) {
+    if (typeof element === "object" && element.attributes.class && classRegex.test(element.attributes.class)) {
+      yield element;
+    }
+  }
+}
+
+// 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,
+  RXMLDuplicateStringTagError,
+  RXMLParseError,
+  RXMLStreamError,
+  RXMLStringifyError,
+  XMLTokenizer,
+  XMLTransformStream,
+  coerceDomBySchema,
+  countTagOccurrences,
+  createXMLStream,
+  domToObject,
+  extractRawInner,
+  filter,
+  findElementByIdStream,
+  findElementsByClassStream,
+  findFirstTopLevelRange,
+  getPropertySchema,
+  getStringTypedProperties,
+  parse,
+  parseFromStream,
+  parseNode,
+  parseWithoutSchema,
+  processArrayContent,
+  processIndexedTuple,
+  processXMLStream,
+  simplify,
+  stringify,
+  stringifyNode,
+  stringifyNodes,
+  toContentString
+});
+//# sourceMappingURL=index.cjs.map