@ai-sdk-tool/parser 3.3.2 → 3.3.3

package/dist/index.d.cts

@@ -100,11 +100,12 @@ declare function createDynamicIfThenElseSchema(tools: (LanguageModelV3FunctionTo
  */
 declare function getPotentialStartIndex(text: string, searchedText: string): number | null;
 
-type OnErrorFn = (message: string, metadata?: Record<string, unknown>) => void;
+type OnErrorFn$1 = (message: string, metadata?: Record<string, unknown>) => void;
 declare function extractOnErrorOption(providerOptions?: unknown): {
-    onError?: OnErrorFn;
+    onError?: OnErrorFn$1;
 } | undefined;
 
+type OnErrorFn = (message: string, metadata?: Record<string, unknown>) => void;
 interface ToolCallMiddlewareProviderOptions {
     toolCallMiddleware?: {
         debugSummary?: {
@@ -125,14 +126,18 @@ declare const originalToolsSchema: {
     encode: typeof encodeOriginalTools;
     decode: typeof decodeOriginalTools;
 };
-declare function encodeOriginalTools(tools: LanguageModelV3FunctionTool[] | undefined): Array<{
+interface EncodedOriginalTool {
     name: string;
     inputSchema: string;
-}>;
-declare function decodeOriginalTools(originalTools: Array<{
+}
+interface DecodeOriginalToolsOptions {
+    onError?: OnErrorFn;
+}
+declare function encodeOriginalTools(tools: LanguageModelV3FunctionTool[] | undefined): Array<{
     name: string;
     inputSchema: string;
-}> | undefined): LanguageModelV3FunctionTool[];
+}>;
+declare function decodeOriginalTools(originalTools: EncodedOriginalTool[] | undefined, options?: DecodeOriginalToolsOptions): LanguageModelV3FunctionTool[];
 declare function extractToolNamesFromOriginalTools(originalTools: Array<{
     name: string;
     inputSchema: string;
@@ -182,8 +187,9 @@ declare function wrapStream({ protocol, doStream, doGenerate, params, }: {
         headers?: _ai_sdk_provider.SharedV3Headers;
     };
 }>;
-declare function toolChoiceStream({ doGenerate, options, }: {
+declare function toolChoiceStream({ doGenerate, tools, options, }: {
     doGenerate: () => ReturnType<LanguageModelV3["doGenerate"]>;
+    tools?: LanguageModelV3FunctionTool[];
     options?: {
         onError?: (message: string, metadata?: Record<string, unknown>) => void;
     };
@@ -267,4 +273,4 @@ declare function transformParams({ params, protocol, toolSystemPromptTemplate, t
     toolChoice: undefined;
 };
 
-export { type DebugLevel, type OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };
+export { type DebugLevel, type OnErrorFn$1 as OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };

package/dist/index.d.ts

@@ -100,11 +100,12 @@ declare function createDynamicIfThenElseSchema(tools: (LanguageModelV3FunctionTo
  */
 declare function getPotentialStartIndex(text: string, searchedText: string): number | null;
 
-type OnErrorFn = (message: string, metadata?: Record<string, unknown>) => void;
+type OnErrorFn$1 = (message: string, metadata?: Record<string, unknown>) => void;
 declare function extractOnErrorOption(providerOptions?: unknown): {
-    onError?: OnErrorFn;
+    onError?: OnErrorFn$1;
 } | undefined;
 
+type OnErrorFn = (message: string, metadata?: Record<string, unknown>) => void;
 interface ToolCallMiddlewareProviderOptions {
     toolCallMiddleware?: {
         debugSummary?: {
@@ -125,14 +126,18 @@ declare const originalToolsSchema: {
     encode: typeof encodeOriginalTools;
     decode: typeof decodeOriginalTools;
 };
-declare function encodeOriginalTools(tools: LanguageModelV3FunctionTool[] | undefined): Array<{
+interface EncodedOriginalTool {
     name: string;
     inputSchema: string;
-}>;
-declare function decodeOriginalTools(originalTools: Array<{
+}
+interface DecodeOriginalToolsOptions {
+    onError?: OnErrorFn;
+}
+declare function encodeOriginalTools(tools: LanguageModelV3FunctionTool[] | undefined): Array<{
     name: string;
     inputSchema: string;
-}> | undefined): LanguageModelV3FunctionTool[];
+}>;
+declare function decodeOriginalTools(originalTools: EncodedOriginalTool[] | undefined, options?: DecodeOriginalToolsOptions): LanguageModelV3FunctionTool[];
 declare function extractToolNamesFromOriginalTools(originalTools: Array<{
     name: string;
     inputSchema: string;
@@ -182,8 +187,9 @@ declare function wrapStream({ protocol, doStream, doGenerate, params, }: {
         headers?: _ai_sdk_provider.SharedV3Headers;
     };
 }>;
-declare function toolChoiceStream({ doGenerate, options, }: {
+declare function toolChoiceStream({ doGenerate, tools, options, }: {
     doGenerate: () => ReturnType<LanguageModelV3["doGenerate"]>;
+    tools?: LanguageModelV3FunctionTool[];
     options?: {
         onError?: (message: string, metadata?: Record<string, unknown>) => void;
     };
@@ -267,4 +273,4 @@ declare function transformParams({ params, protocol, toolSystemPromptTemplate, t
     toolChoice: undefined;
 };
 
-export { type DebugLevel, type OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };
+export { type DebugLevel, type OnErrorFn$1 as OnErrorFn, type ParserOptions, type TCMCoreProtocol, type TCMProtocol, type ToolCallMiddlewareProviderOptions, type XmlProtocolOptions, type YamlProtocolOptions, createDynamicIfThenElseSchema, createToolMiddleware, decodeOriginalTools, encodeOriginalTools, escapeRegExp, extractOnErrorOption, extractToolNamesFromOriginalTools, getDebugLevel, getPotentialStartIndex, hasInputProperty, hermesToolMiddleware, isProtocolFactory, isTCMProtocolFactory, isToolChoiceActive, isToolResultPart, jsonProtocol, logParseFailure, logParsedChunk, logParsedSummary, logRawChunk, originalToolsSchema, toolChoiceStream, transformParams, wrapGenerate, wrapStream, xmlProtocol, xmlToolMiddleware, yamlProtocol, yamlToolMiddleware };

package/dist/index.js

@@ -27,16 +27,16 @@ import {
   xmlToolMiddleware,
   yamlProtocol,
   yamlToolMiddleware
-} from "./chunk-5WKXBBCU.js";
+} from "./chunk-NAQSTPDQ.js";
 import {
   escapeRegExp
-} from "./chunk-ZDBNJWLY.js";
+} from "./chunk-CXWS24JX.js";
 import {
   parse,
   stringify,
   transform
 } from "./chunk-IX4FJELL.js";
-import "./chunk-OUGMLYAW.js";
+import "./chunk-2KK5BDZF.js";
 export {
   createDynamicIfThenElseSchema,
   createToolMiddleware,

package/dist/rxml.cjs

@@ -363,6 +363,13 @@ var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
 var NEWLINE_SPLIT_REGEX = /\n+/;
 var COMMA_SPLIT_REGEX = /,\s*/;
 var DIGIT_KEY_REGEX = /^\d+$/;
+var WHITESPACE_REGEX = /\s+/g;
+var HAS_WHITESPACE_REGEX = /\s/;
+var SINGLE_QUOTE = "'";
+var DOUBLE_QUOTE = '"';
+var SNAKE_SEGMENT_REGEX = /_([a-zA-Z0-9])/g;
+var CAMEL_BOUNDARY_REGEX = /([a-z0-9])([A-Z])/g;
+var LEADING_UNDERSCORES_REGEX = /^_+/;
 function unwrapJsonSchema(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -611,9 +618,158 @@ function coerceStringToArray(s, unwrapped) {
   }
   return null;
 }
+function getStrictObjectSchemaInfo(unwrapped) {
+  if (getSchemaType(unwrapped) !== "object") {
+    return null;
+  }
+  if (unwrapped.additionalProperties !== false) {
+    return null;
+  }
+  const properties = unwrapped.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const required = Array.isArray(unwrapped.required) ? unwrapped.required.filter(
+    (value) => typeof value === "string" && value.length > 0
+  ) : [];
+  const patternProps = unwrapped.patternProperties;
+  const patternProperties = patternProps && typeof patternProps === "object" && !Array.isArray(patternProps) ? patternProps : void 0;
+  return {
+    properties: propertyMap,
+    required,
+    patternProperties
+  };
+}
+function isSingularPluralPair(left, right) {
+  return left.length > 1 && right.length > 1 && (left === `${right}s` || right === `${left}s`);
+}
+function snakeToCamel(value) {
+  const trimmed = value.replace(LEADING_UNDERSCORES_REGEX, "");
+  if (trimmed.length === 0) {
+    return value;
+  }
+  const camelized = trimmed.replace(
+    SNAKE_SEGMENT_REGEX,
+    (_, c) => c.toUpperCase()
+  );
+  return camelized.charAt(0).toLowerCase() + camelized.slice(1);
+}
+function camelToSnake(value) {
+  return value.replace(CAMEL_BOUNDARY_REGEX, "$1_$2").toLowerCase();
+}
+function isCaseStylePair(targetKey, sourceKey) {
+  if (targetKey === sourceKey) {
+    return false;
+  }
+  const sourceLooksSnake = sourceKey.includes("_");
+  const targetLooksSnake = targetKey.includes("_");
+  if (sourceLooksSnake && snakeToCamel(sourceKey) === targetKey) {
+    return true;
+  }
+  if (!sourceLooksSnake && targetLooksSnake && camelToSnake(sourceKey) === targetKey) {
+    return true;
+  }
+  return false;
+}
+function isUnexpectedKey(key, schemaInfo) {
+  if (Object.hasOwn(schemaInfo.properties, key)) {
+    return false;
+  }
+  const patternSchemas = getPatternSchemasForKey(
+    schemaInfo.patternProperties,
+    key
+  );
+  if (patternSchemas.length > 0) {
+    return patternSchemas.every((schema) => schema === false);
+  }
+  return true;
+}
+function computeMissingAndUnexpectedKeys(input, schemaInfo) {
+  const missingRequired = schemaInfo.required.filter(
+    (key) => !Object.hasOwn(input, key)
+  );
+  const unexpectedKeys = Object.keys(input).filter(
+    (key) => isUnexpectedKey(key, schemaInfo)
+  );
+  return { missingRequired, unexpectedKeys };
+}
+function applySingularPluralRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isSingularPluralPair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (getSchemaType(schemaInfo.properties[targetKey]) !== "array") {
+    return null;
+  }
+  if (!Array.isArray(input[sourceKey])) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyCaseStyleRequiredKeyRename(input, schemaInfo) {
+  const { missingRequired, unexpectedKeys } = computeMissingAndUnexpectedKeys(
+    input,
+    schemaInfo
+  );
+  if (missingRequired.length !== 1 || unexpectedKeys.length !== 1) {
+    return null;
+  }
+  const targetKey = missingRequired[0];
+  const sourceKey = unexpectedKeys[0];
+  if (!Object.hasOwn(schemaInfo.properties, targetKey)) {
+    return null;
+  }
+  if (!isCaseStylePair(targetKey, sourceKey)) {
+    return null;
+  }
+  if (!Object.hasOwn(input, sourceKey) || Object.hasOwn(input, targetKey)) {
+    return null;
+  }
+  const output = { ...input };
+  output[targetKey] = output[sourceKey];
+  delete output[sourceKey];
+  return output;
+}
+function applyStrictRequiredKeyRename(input, unwrapped) {
+  const schemaInfo = getStrictObjectSchemaInfo(unwrapped);
+  if (!schemaInfo) {
+    return input;
+  }
+  const singularPlural = applySingularPluralRequiredKeyRename(
+    input,
+    schemaInfo
+  );
+  if (singularPlural) {
+    return singularPlural;
+  }
+  const caseStyle = applyCaseStyleRequiredKeyRename(input, schemaInfo);
+  if (caseStyle) {
+    return caseStyle;
+  }
+  return input;
+}
 function coerceObjectToObject(value, unwrapped) {
+  const normalizedInput = applyStrictRequiredKeyRename(value, unwrapped);
   const out = {};
-  for (const [k, v] of Object.entries(value)) {
+  for (const [k, v] of Object.entries(normalizedInput)) {
     out[k] = coerceValueForKey(v, k, unwrapped);
   }
   return out;
@@ -624,6 +780,109 @@ function coerceArrayToArray(value, prefixItems, itemsSchema) {
   }
   return value.map((v) => coerceBySchema(v, itemsSchema));
 }
+function isPrimitiveSchemaType(schemaType) {
+  return schemaType === "string" || schemaType === "number" || schemaType === "integer" || schemaType === "boolean";
+}
+function isPrimitiveMatchForSchemaType(value, schemaType) {
+  if (schemaType === "string") {
+    return typeof value === "string";
+  }
+  if (schemaType === "number") {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  if (schemaType === "integer") {
+    return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+  }
+  return typeof value === "boolean";
+}
+function coercePrimitiveWrappedObject(value, itemsSchema) {
+  const schemaType = getSchemaType(itemsSchema);
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(singleValue, itemsSchema);
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
+function coerceParallelArraysObjectToArray(maybe, prefixItems, itemsSchema) {
+  if (prefixItems && prefixItems.length > 0) {
+    return null;
+  }
+  const unwrappedItems = unwrapJsonSchema(itemsSchema);
+  if (!unwrappedItems || typeof unwrappedItems !== "object" || Array.isArray(unwrappedItems)) {
+    return null;
+  }
+  const itemSchema = unwrappedItems;
+  if (getSchemaType(itemSchema) !== "object") {
+    return null;
+  }
+  if (itemSchema.additionalProperties !== false) {
+    return null;
+  }
+  const properties = itemSchema.properties;
+  if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+    return null;
+  }
+  const propertyMap = properties;
+  const entries = Object.entries(maybe);
+  if (entries.length < 2) {
+    return null;
+  }
+  if (!entries.every(([, value]) => Array.isArray(value))) {
+    return null;
+  }
+  if (!entries.every(([key]) => Object.hasOwn(propertyMap, key))) {
+    return null;
+  }
+  if (!entries.every(([key]) => {
+    const schemaType = getSchemaType(propertyMap[key]);
+    return schemaType !== "array" && schemaType !== "object";
+  })) {
+    return null;
+  }
+  const lengths = [
+    ...new Set(entries.map(([, value]) => value.length))
+  ];
+  if (lengths.length !== 1) {
+    return null;
+  }
+  const length = lengths[0];
+  if (length < 2) {
+    return null;
+  }
+  const zipped = [];
+  for (let index = 0; index < length; index += 1) {
+    const item = {};
+    for (const [key, value] of entries) {
+      item[key] = value[index];
+    }
+    zipped.push(item);
+  }
+  return coerceArrayToArray(zipped, prefixItems, itemsSchema);
+}
+function coerceSingleKeyObjectToArray(singleValue, itemsSchema) {
+  if (Array.isArray(singleValue)) {
+    return singleValue.map((v) => coerceBySchema(v, itemsSchema));
+  }
+  if (singleValue && typeof singleValue === "object") {
+    const primitiveWrapped = coercePrimitiveWrappedObject(
+      singleValue,
+      itemsSchema
+    );
+    if (primitiveWrapped !== null) {
+      return [primitiveWrapped];
+    }
+    return [coerceBySchema(singleValue, itemsSchema)];
+  }
+  return null;
+}
 function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
   if (Object.hasOwn(maybe, "item")) {
     const items = maybe.item;
@@ -635,15 +894,23 @@ function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
     const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
     return coerceArrayToArray(arr, prefixItems, itemsSchema);
   }
+  const parallelArrays = coerceParallelArraysObjectToArray(
+    maybe,
+    prefixItems,
+    itemsSchema
+  );
+  if (parallelArrays !== null) {
+    return parallelArrays;
+  }
   if (keys.length === 1) {
     const singleKey = keys[0];
     if (!(schemaIsUnconstrained(itemsSchema) || schemaHasProperty(itemsSchema, singleKey))) {
-      const singleValue = maybe[singleKey];
-      if (Array.isArray(singleValue)) {
-        return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-      }
-      if (singleValue && typeof singleValue === "object") {
-        return [coerceBySchema(singleValue, itemsSchema)];
+      const result = coerceSingleKeyObjectToArray(
+        maybe[singleKey],
+        itemsSchema
+      );
+      if (result !== null) {
+        return result;
       }
     }
   }
@@ -673,6 +940,86 @@ function coerceStringToPrimitive(s, schemaType) {
   }
   return null;
 }
+function coercePrimitiveToString(value, schemaType) {
+  if (schemaType !== "string") {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return null;
+}
+function coerceStringByEnumWhitespace(rawValue, unwrapped) {
+  const enumValues = unwrapped.enum;
+  if (!Array.isArray(enumValues) || enumValues.length === 0) {
+    return null;
+  }
+  if (!enumValues.every((item) => typeof item === "string")) {
+    return null;
+  }
+  const normalizedEnumValues = enumValues;
+  if (normalizedEnumValues.includes(rawValue)) {
+    return null;
+  }
+  const unquoted = unwrapMatchingQuotes(rawValue);
+  if (unquoted !== null) {
+    const exactMatches = normalizedEnumValues.filter(
+      (item) => item === unquoted
+    );
+    if (exactMatches.length === 1) {
+      return exactMatches[0];
+    }
+  }
+  const candidates = [rawValue, unquoted].filter(
+    (item) => item !== null
+  );
+  for (const candidate of candidates) {
+    if (!HAS_WHITESPACE_REGEX.test(candidate)) {
+      continue;
+    }
+    const normalizedInput = candidate.replace(WHITESPACE_REGEX, "");
+    const matches = normalizedEnumValues.filter(
+      (item) => item.replace(WHITESPACE_REGEX, "") === normalizedInput
+    );
+    if (matches.length === 1) {
+      return matches[0];
+    }
+  }
+  return null;
+}
+function unwrapMatchingQuotes(value) {
+  if (value.length < 2) {
+    return null;
+  }
+  const first = value[0];
+  const last = value.at(-1);
+  const isQuote = (first === SINGLE_QUOTE || first === DOUBLE_QUOTE) && first === last;
+  if (!isQuote) {
+    return null;
+  }
+  return value.slice(1, -1);
+}
+function coerceObjectToPrimitive(value, schemaType, fullSchema) {
+  if (!isPrimitiveSchemaType(schemaType)) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const singleValue = value[keys[0]];
+  if (singleValue && typeof singleValue === "object") {
+    return null;
+  }
+  const coerced = coerceBySchema(
+    singleValue,
+    fullSchema != null ? fullSchema : { type: schemaType }
+  );
+  return isPrimitiveMatchForSchemaType(coerced, schemaType) ? coerced : null;
+}
 function coerceStringValue(value, schemaType, u) {
   const s = value.trim();
   if (schemaType === "object") {
@@ -691,6 +1038,10 @@ function coerceStringValue(value, schemaType, u) {
   if (primitiveResult !== null) {
     return primitiveResult;
   }
+  const enumWhitespaceCanonical = coerceStringByEnumWhitespace(s, u);
+  if (enumWhitespaceCanonical !== null) {
+    return enumWhitespaceCanonical;
+  }
   return value;
 }
 function coerceArrayValue(value, prefixItems, itemsSchema) {
@@ -729,9 +1080,23 @@ function coerceBySchema(value, schema) {
   if (typeof value === "string") {
     return coerceStringValue(value, schemaType, u);
   }
+  const primitiveString = coercePrimitiveToString(value, schemaType);
+  if (primitiveString !== null) {
+    return primitiveString;
+  }
   if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
     return coerceObjectToObject(value, u);
   }
+  if (value && typeof value === "object" && !Array.isArray(value) && isPrimitiveSchemaType(schemaType)) {
+    const primitiveResult = coerceObjectToPrimitive(
+      value,
+      schemaType,
+      u
+    );
+    if (primitiveResult !== null) {
+      return primitiveResult;
+    }
+  }
   if (schemaType === "array") {
     const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
     const itemsSchema = u.items;
@@ -1746,7 +2111,7 @@ var XMLTokenizer = class {
 };
 
 // src/rxml/core/parser.ts
-var WHITESPACE_REGEX = /\s/;
+var WHITESPACE_REGEX2 = /\s/;
 var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 var DIGIT_KEY_REGEX2 = /^\d+$/;
 function getTopLevelStringProps(s) {
@@ -1916,7 +2281,7 @@ function parse(xmlInner, schema, options = {}) {
         const closeHead = s.indexOf(`</${rootName}`, range.end);
         if (closeHead === range.end) {
           let p = closeHead + 2 + rootName.length;
-          while (p < s.length && WHITESPACE_REGEX.test(s[p])) {
+          while (p < s.length && WHITESPACE_REGEX2.test(s[p])) {
             p += 1;
           }
           if (s[p] === ">") {
@@ -2259,7 +2624,7 @@ function escapeRegExp(literal) {
 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 WHITESPACE_REGEX3 = /\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;
@@ -2400,7 +2765,7 @@ function balanceTags(xml) {
 }
 function skipWs(s, p, len) {
   let idx = p;
-  while (idx < len && WHITESPACE_REGEX2.test(s[idx])) {
+  while (idx < len && WHITESPACE_REGEX3.test(s[idx])) {
     idx += 1;
   }
   return idx;
@@ -2453,7 +2818,7 @@ function handleOpeningTagSegment(src, lt, out, stack) {
     return len;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX2.test(src[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX3.test(src[r])) {
     r -= 1;
   }
   const selfClosing = src[r] === "/";