@ai-sdk-tool/parser 3.2.0 → 3.3.0

package/dist/chunk-TR2ARLIF.js

@@ -0,0 +1,2216 @@
+import {
+  coerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+} from "./chunk-DZB6Y354.js";
+
+// src/rxml/errors/types.ts
+var RXMLParseError = class extends Error {
+  constructor(message, cause, line, column) {
+    super(message);
+    this.name = "RXMLParseError";
+    this.cause = cause;
+    this.line = line;
+    this.column = column;
+  }
+};
+var RXMLDuplicateStringTagError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RXMLDuplicateStringTagError";
+  }
+};
+var RXMLCoercionError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "RXMLCoercionError";
+    this.cause = cause;
+  }
+};
+var RXMLStringifyError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "RXMLStringifyError";
+    this.cause = cause;
+  }
+};
+
+// src/rxml/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/rxml/utils/helpers.ts
+var NAME_START_CHAR_REGEX = /[A-Za-z_:]/;
+var NAME_CHAR_REGEX = /[A-Za-z0-9_.:-]/;
+function isNameStartChar(ch) {
+  return NAME_START_CHAR_REGEX.test(ch);
+}
+function isNameChar(ch) {
+  return NAME_CHAR_REGEX.test(ch);
+}
+function skipQuoted(s, i) {
+  const quote = s[i];
+  let pos = i + 1;
+  while (pos < s.length) {
+    const ch = s[pos];
+    if (ch === "\\") {
+      pos += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return pos + 1;
+    }
+    pos += 1;
+  }
+  return pos;
+}
+function parseName(s, pos) {
+  const start = pos;
+  let currentPos = pos;
+  while (NAME_SPACER.indexOf(s[currentPos]) === -1 && s[currentPos]) {
+    currentPos += 1;
+  }
+  return { name: s.slice(start, currentPos), newPos: currentPos };
+}
+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 += 1) {
+    if (s[i] === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  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;
+}
+function unescapeXml(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/rxml/builders/stringify.ts
+function stringify(rootTag, obj, options = {}) {
+  var _a, _b, _c, _d, _e;
+  try {
+    const format = (_a = options.format) != null ? _a : true;
+    const declaration = (_b = options.declaration) != null ? _b : false;
+    const minimalEscaping = (_c = options.minimalEscaping) != null ? _c : false;
+    const suppressEmptyNode = (_d = options.suppressEmptyNode) != null ? _d : false;
+    const strictBooleanAttributes = (_e = options.strictBooleanAttributes) != null ? _e : false;
+    let result = "";
+    if (declaration) {
+      result += '<?xml version="1.0" encoding="UTF-8"?>\n';
+    }
+    result += stringifyValue(rootTag, obj, {
+      depth: 0,
+      format,
+      suppressEmptyNode,
+      minimalEscaping,
+      strictBooleanAttributes
+    });
+    if (result.endsWith("\n")) {
+      return result.slice(0, -1);
+    }
+    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
+  });
+}
+
+// src/rxml/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/rxml/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;
+  }
+  const shouldCount = name === target && !isPositionExcluded(lt, excludeRanges);
+  return { nextPos: k + 1, shouldCount };
+}
+function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst = true) {
+  const len = xmlContent.length;
+  const target = tagName;
+  let i = 0;
+  let count = 0;
+  let skipFirstLocal = shouldSkipFirst;
+  while (i < len) {
+    const lt = xmlContent.indexOf("<", i);
+    if (lt === -1) {
+      break;
+    }
+    i = lt + 1;
+    if (i >= len) {
+      break;
+    }
+    const ch = xmlContent[i];
+    const skipPos = skipSpecialInCounting(xmlContent, ch, i, len);
+    if (skipPos !== -1) {
+      i = skipPos;
+      continue;
+    }
+    const result = parseAndCountTag({
+      xmlContent,
+      i,
+      len,
+      target,
+      lt,
+      excludeRanges
+    });
+    if (result.shouldCount) {
+      if (skipFirstLocal) {
+        skipFirstLocal = false;
+      } else {
+        count += 1;
+      }
+    }
+    i = result.nextPos;
+  }
+  return count;
+}
+
+// src/rxml/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;
+  }
+  /**
+   * Handle closing tag parsing
+   */
+  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(
+        `Unclosed tag at line ${line}, column ${column}. Expected closing tag </${tagName}>`,
+        void 0,
+        line,
+        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;
+  }
+  /**
+   * Check if character is whitespace
+   */
+  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 = {};
+    while (this.xmlString.charCodeAt(this.pos) !== CharCodes.CLOSE_BRACKET && this.xmlString[this.pos]) {
+      const c = this.xmlString.charCodeAt(this.pos);
+      if (this.isWhitespace(c)) {
+        this.pos += 1;
+        continue;
+      }
+      if (c > 64 && c < 91 || c > 96 && c < 123) {
+        this.parseAttribute(attributes);
+      } else {
+        this.pos += 1;
+      }
+    }
+    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 };
+  }
+  /**
+   * 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 += 1;
+  }
+  /**
+   * 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 += 1;
+    }
+    children.push(this.xmlString.substring(startDoctype, this.pos));
+    this.pos += 1;
+  }
+  /**
+   * Get current position
+   */
+  getPosition() {
+    return this.pos;
+  }
+  /**
+   * Set position
+   */
+  setPosition(pos) {
+    this.pos = pos;
+  }
+};
+
+// src/rxml/core/parser.ts
+var WHITESPACE_REGEX = /\s/;
+var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+var DIGIT_KEY_REGEX = /^\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 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";
+  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 += 1;
+      }
+      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 && 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.hasOwn(schemaProps, rootName)) {
+            actualXmlInner = s.slice(range.start, range.end);
+          }
+        }
+      }
+    }
+  }
+  const topLevelStringProps = getTopLevelStringProps(schema);
+  const deepStringTypedProps = getStringTypedProperties(schema);
+  const duplicateKeys = /* @__PURE__ */ new Set();
+  for (const key of topLevelStringProps) {
+    const excludeRanges = [];
+    for (const other of topLevelStringProps) {
+      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 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);
+      let rebuilt = "";
+      let cursor = 0;
+      for (const r of sorted) {
+        if (r.start < cursor) {
+          continue;
+        }
+        if (cursor < r.start) {
+          rebuilt += actualXmlInner.slice(cursor, r.start);
+        }
+        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) {
+      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 restorePlaceholdersDeep = createPlaceholderRestorer(
+    originalContentMap,
+    textNodeName
+  );
+  const parsedArgsRestored = restorePlaceholdersDeep(parsedArgs);
+  const args = {};
+  for (const k of Object.keys(parsedArgsRestored || {})) {
+    const v = parsedArgsRestored[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.hasOwn(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.hasOwn(v, textNodeName)) {
+      val = v[textNodeName];
+    }
+    if (Array.isArray(v)) {
+      if (propType === "string") {
+        const mapped = v.map((item) => {
+          if (item && typeof item === "object" && Object.hasOwn(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;
+      }
+      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") {
+        val = processItemWrapper(obj.item, textNodeName);
+      } else {
+        let isIndexedTuple = false;
+        if (keys2.length > 0 && keys2.every((key) => DIGIT_KEY_REGEX.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);
+        } else {
+          val = v;
+        }
+      }
+    }
+    args[k] = typeof val === "string" ? val.trim() : val;
+  }
+  for (const key of topLevelStringProps) {
+    if (!Object.hasOwn(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.hasOwn(schemaProps, rootKey)) {
+        dataToCoerce = rootValue;
+      }
+    }
+  }
+  try {
+    const coerced = coerceDomBySchema(dataToCoerce, schema);
+    const decoded = deepDecodeStringsBySchema(coerced, schema);
+    return decoded;
+  } catch (error) {
+    throw new RXMLCoercionError("Failed to coerce by schema", error);
+  }
+}
+
+// src/rxml/heuristics/engine.ts
+function applyRawSegmentUpdate(current, result) {
+  if (result.rawSegment !== void 0) {
+    return { ...current, rawSegment: result.rawSegment };
+  }
+  return current;
+}
+function applyParsedUpdate(current, result) {
+  if (result.parsed !== void 0) {
+    return { ...current, parsed: result.parsed };
+  }
+  return current;
+}
+function applyWarningsUpdate(current, result) {
+  var _a, _b;
+  if (result.warnings && result.warnings.length > 0) {
+    const meta = (_a = current.meta) != null ? _a : {};
+    const existingWarnings = (_b = meta.warnings) != null ? _b : [];
+    return {
+      ...current,
+      meta: { ...meta, warnings: [...existingWarnings, ...result.warnings] }
+    };
+  }
+  return current;
+}
+function attemptReparse(current, result, reparseCount, maxReparses, parse3) {
+  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
+    return { state: current, newCount: reparseCount };
+  }
+  try {
+    const reparsed = parse3(result.rawSegment, current.schema);
+    return {
+      state: { ...current, parsed: reparsed, errors: [] },
+      newCount: reparseCount + 1
+    };
+  } catch (error) {
+    return {
+      state: { ...current, errors: [...current.errors, error] },
+      newCount: reparseCount + 1
+    };
+  }
+}
+function executePhase(ctx, heuristics, options) {
+  var _a;
+  let current = ctx;
+  let reparseCount = 0;
+  const maxReparses = (_a = options.maxReparses) != null ? _a : 2;
+  for (const heuristic of heuristics) {
+    if (!heuristic.applies(current)) {
+      continue;
+    }
+    const result = heuristic.run(current);
+    current = applyRawSegmentUpdate(current, result);
+    current = applyParsedUpdate(current, result);
+    current = applyWarningsUpdate(current, result);
+    const reparseResult = attemptReparse(
+      current,
+      result,
+      reparseCount,
+      maxReparses,
+      options.parse
+    );
+    current = reparseResult.state;
+    reparseCount = reparseResult.newCount;
+    if (result.stop) {
+      break;
+    }
+  }
+  return current;
+}
+function applyHeuristicPipeline(ctx, config, options) {
+  let current = ctx;
+  if (config.preParse && config.preParse.length > 0) {
+    current = executePhase(current, config.preParse, options);
+  }
+  if (current.parsed === null && current.errors.length === 0) {
+    try {
+      const parsed = options.parse(current.rawSegment, current.schema);
+      current = { ...current, parsed, errors: [] };
+    } catch (error) {
+      current = { ...current, errors: [error] };
+    }
+  }
+  if (current.errors.length > 0 && config.fallbackReparse && config.fallbackReparse.length > 0) {
+    current = executePhase(current, config.fallbackReparse, options);
+  }
+  if (current.parsed !== null && config.postParse && config.postParse.length > 0) {
+    current = executePhase(current, config.postParse, options);
+  }
+  return current;
+}
+function createIntermediateCall(toolName, rawSegment, schema) {
+  return {
+    toolName,
+    schema,
+    rawSegment,
+    parsed: null,
+    errors: [],
+    meta: { originalContent: rawSegment }
+  };
+}
+
+// src/rxml/heuristics/xml-defaults.ts
+var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
+var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
+var WHITESPACE_REGEX2 = /\s/;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var NAME_START_CHAR_RE = /[A-Za-z_:]/;
+var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
+var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
+var normalizeCloseTagsHeuristic = {
+  id: "normalize-close-tags",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const normalized = ctx.rawSegment.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    if (normalized !== ctx.rawSegment) {
+      return { rawSegment: normalized };
+    }
+    return {};
+  }
+};
+var escapeInvalidLtHeuristic = {
+  id: "escape-invalid-lt",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const escaped = escapeInvalidLt(ctx.rawSegment);
+    if (escaped !== ctx.rawSegment) {
+      return { rawSegment: escaped };
+    }
+    return {};
+  }
+};
+var balanceTagsHeuristic = {
+  id: "balance-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const balanced = balanceTags(original);
+    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
+    if (!hasMalformedClose && balanced.length > normalized.length && ctx.errors.length === 0) {
+      return false;
+    }
+    return balanced !== normalized;
+  },
+  run: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const balanced = balanceTags(original);
+    const escaped = escapeInvalidLt(balanced);
+    return { rawSegment: escaped, reparse: true };
+  }
+};
+var dedupeShellStringTagsHeuristic = {
+  id: "dedupe-shell-string-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => shouldDeduplicateStringTags(ctx.schema),
+  run: (ctx) => {
+    const names = getStringPropertyNames(ctx.schema);
+    let deduped = ctx.rawSegment;
+    for (const key of names) {
+      deduped = dedupeSingleTag(deduped, key);
+    }
+    if (deduped !== ctx.rawSegment) {
+      return { rawSegment: deduped, reparse: true };
+    }
+    return {};
+  }
+};
+var repairAgainstSchemaHeuristic = {
+  id: "repair-against-schema",
+  phase: "post-parse",
+  applies: (ctx) => ctx.parsed !== null && typeof ctx.parsed === "object",
+  run: (ctx) => {
+    const repaired = repairParsedAgainstSchema(ctx.parsed, ctx.schema);
+    if (repaired !== ctx.parsed) {
+      return { parsed: repaired };
+    }
+    return {};
+  }
+};
+var defaultPipelineConfig = {
+  preParse: [normalizeCloseTagsHeuristic, escapeInvalidLtHeuristic],
+  fallbackReparse: [balanceTagsHeuristic, dedupeShellStringTagsHeuristic],
+  postParse: [repairAgainstSchemaHeuristic]
+};
+var INDEX_TAG_RE = /^<(\d+)(?:>|\/?>)/;
+function isIndexTagAt(xml, pos) {
+  const remaining = xml.slice(pos);
+  return INDEX_TAG_RE.test(remaining);
+}
+function escapeInvalidLt(xml) {
+  const len = xml.length;
+  let out = "";
+  for (let i = 0; i < len; i += 1) {
+    const ch = xml[i];
+    if (ch === "<") {
+      const next = i + 1 < len ? xml[i + 1] : "";
+      const isValidStart = NAME_START_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?";
+      const isIndexTag = !isValidStart && isIndexTagAt(xml, i);
+      if (!(isValidStart || isIndexTag)) {
+        out += "&lt;";
+        continue;
+      }
+    }
+    out += ch;
+  }
+  return out;
+}
+function balanceTags(xml) {
+  const src = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>").replace(STATUS_TO_STEP_BOUNDARY_RE, "</status></step><step>");
+  let i = 0;
+  const len = src.length;
+  const out = [];
+  const stack = [];
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      out.push(src.slice(i));
+      break;
+    }
+    out.push(src.slice(i, lt));
+    if (lt + 1 >= len) {
+      break;
+    }
+    const next = src[lt + 1];
+    if (next === "!" || next === "?") {
+      i = handleSpecialTagSegment(src, lt, out);
+      continue;
+    }
+    if (next === "/") {
+      i = handleClosingTagSegment(src, lt, out, stack);
+      continue;
+    }
+    i = handleOpeningTagSegment(src, lt, out, stack);
+  }
+  for (let k = stack.length - 1; k >= 0; k -= 1) {
+    out.push(`</${stack[k]}>`);
+  }
+  return out.join("");
+}
+function skipWs(s, p, len) {
+  let idx = p;
+  while (idx < len && WHITESPACE_REGEX2.test(s[idx])) {
+    idx += 1;
+  }
+  return idx;
+}
+function parseTagNameAt(s, p, len) {
+  let idx = p;
+  const start = idx;
+  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
+    idx += 1;
+  }
+  return { name: s.slice(start, idx), pos: idx };
+}
+function handleSpecialTagSegment(src, lt, out) {
+  const gt = src.indexOf(">", lt + 1);
+  if (gt === -1) {
+    out.push(src.slice(lt));
+    return src.length;
+  }
+  out.push(src.slice(lt, gt + 1));
+  return gt + 1;
+}
+function handleClosingTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 2, len);
+  const { name, pos } = parseTagNameAt(src, p, len);
+  p = pos;
+  const gt = src.indexOf(">", p);
+  const closingText = gt === -1 ? src.slice(lt) : src.slice(lt, gt + 1);
+  const idx = stack.lastIndexOf(name);
+  if (idx !== -1) {
+    for (let k = stack.length - 1; k > idx; k -= 1) {
+      out.push(`</${stack[k]}>`);
+      stack.pop();
+    }
+    out.push(closingText);
+    stack.pop();
+  }
+  return gt === -1 ? len : gt + 1;
+}
+function handleOpeningTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 1, len);
+  const nameStart = p;
+  const parsed = parseTagNameAt(src, p, len);
+  p = parsed.pos;
+  const name = src.slice(nameStart, p);
+  const q = src.indexOf(">", p);
+  if (q === -1) {
+    out.push(src.slice(lt));
+    return len;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX2.test(src[r])) {
+    r -= 1;
+  }
+  const selfClosing = src[r] === "/";
+  out.push(src.slice(lt, q + 1));
+  if (!selfClosing && name) {
+    stack.push(name);
+  }
+  return q + 1;
+}
+function extractSchemaProperties(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return void 0;
+  }
+  return unwrapped.properties;
+}
+function shouldDeduplicateStringTags(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return false;
+  }
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = unwrapJsonSchema(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
+}
+function getStringPropertyNames(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return [];
+  }
+  const names = [];
+  for (const key of Object.keys(props)) {
+    const prop = unwrapJsonSchema(props[key]);
+    if ((prop == null ? void 0 : prop.type) === "string") {
+      names.push(key);
+    }
+  }
+  return names;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function dedupeSingleTag(xml, key) {
+  var _a, _b;
+  const escaped = escapeRegExp(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
+  }
+  const last = matches.at(-1);
+  let result = "";
+  let cursor = 0;
+  for (const m of matches) {
+    const idx = (_a = m.index) != null ? _a : 0;
+    result += xml.slice(cursor, idx);
+    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
+      result += m[0];
+    }
+    cursor = idx + m[0].length;
+  }
+  result += xml.slice(cursor);
+  return result;
+}
+function repairParsedAgainstSchema(input, schema) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const properties = extractSchemaProperties(schema);
+  if (!properties) {
+    return input;
+  }
+  applySchemaProps(input, properties);
+  return input;
+}
+function applySchemaProps(obj, properties) {
+  for (const key of Object.keys(obj)) {
+    const propSchema = properties[key];
+    if (!propSchema) {
+      continue;
+    }
+    const prop = unwrapJsonSchema(propSchema);
+    if ((prop == null ? void 0 : prop.type) === "array" && prop.items) {
+      const itemSchema = unwrapJsonSchema(prop.items);
+      obj[key] = coerceArrayItems(obj[key], itemSchema);
+      continue;
+    }
+    if ((prop == null ? void 0 : prop.type) === "object") {
+      const val = obj[key];
+      if (val && typeof val === "object") {
+        obj[key] = repairParsedAgainstSchema(val, prop);
+      }
+    }
+  }
+}
+function coerceArrayItems(val, itemSchema) {
+  if (!Array.isArray(val)) {
+    return val;
+  }
+  return val.map((v) => coerceArrayItem(v, itemSchema));
+}
+function coerceArrayItem(v, itemSchema) {
+  const itemType = itemSchema == null ? void 0 : itemSchema.type;
+  if (typeof v === "string" && itemType === "object") {
+    const parsed = tryParseStringToSchemaObject(v, itemSchema);
+    if (parsed !== null) {
+      return parsed;
+    }
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
+    );
+    if (fallback) {
+      return fallback;
+    }
+    return v;
+  }
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(v, itemSchema);
+  }
+  return v;
+}
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = parse(normalized, itemSchema, { noChildNodes: [] });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
+  }
+}
+function extractStepStatusFromString(normXml) {
+  const stepMatch = normXml.match(STEP_TAG_RE);
+  const statusMatch = normXml.match(STATUS_TAG_RE);
+  if (stepMatch && statusMatch) {
+    return { step: stepMatch[1], status: statusMatch[1] };
+  }
+  return null;
+}
+
+// src/rxml/parse.ts
+function parse2(xml, schema, options = {}) {
+  if (!options.repair) {
+    return parse(xml, schema, options);
+  }
+  const baseOptions = {
+    ...options,
+    repair: false
+  };
+  const ctx = createIntermediateCall("", xml, schema);
+  const result = applyHeuristicPipeline(ctx, defaultPipelineConfig, {
+    parse: (raw, s) => parse(raw, s, baseOptions),
+    onError: options.onError,
+    maxReparses: options.maxReparses
+  });
+  if (result.parsed !== null) {
+    return result.parsed;
+  }
+  const error = result.errors[0];
+  throw new RXMLParseError("Failed to parse XML with repair heuristics", error);
+}
+
+export {
+  stringify,
+  parse2 as parse
+};
+//# sourceMappingURL=chunk-TR2ARLIF.js.map