@opentiny/next-sdk 0.3.2 → 0.3.3-alpha.1

package/dist/mcpsdk@1.25.3.dev.js

@@ -3088,6 +3088,9 @@
     hasRequiredUtils = 1;
     const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    const isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code2 = 0;
@@ -3280,27 +3283,77 @@
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    const HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    const HOST_DELIM_RE = /[@/?#:]/g;
+    const HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            const normalizedHex = hex.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            const normalizedHex = hex.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            output += "%" + hex.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3315,7 +3368,7 @@
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3329,7 +3382,10 @@
     utils = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3552,12 +3608,12 @@
   function requireFastUri() {
     if (hasRequiredFastUri) return fastUri.exports;
     hasRequiredFastUri = 1;
-    const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = requireUtils();
+    const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = requireUtils();
     const { SCHEMES, getSchemeHandler } = requireSchemes();
     function normalize(uri2, options) {
       if (typeof uri2 === "string") {
         uri2 = /** @type {T} */
-        serialize(parse2(uri2, options), options);
+        normalizeString(uri2, options);
       } else if (typeof uri2 === "object") {
         uri2 = /** @type {T} */
         parse2(serialize(uri2, options), options);
@@ -3624,19 +3680,9 @@
       return target;
     }
     function equal2(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse2(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse2(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3661,12 +3707,12 @@
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3701,7 +3747,16 @@
       return uriTokens.join("");
     }
     const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse2(uri2, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri2, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3712,6 +3767,7 @@
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3732,6 +3788,11 @@
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3758,7 +3819,7 @@
         if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
           if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
             try {
-              parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+              parsed.host = new URL("http://" + parsed.host).hostname;
             } catch (e) {
               parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
             }
@@ -3770,14 +3831,18 @@
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3786,7 +3851,29 @@
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse2(uri2, opts) {
+      return parseWithStatus(uri2, opts).parsed;
+    }
+    function normalizeString(uri2, opts) {
+      return normalizeStringWithStatus(uri2, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri2, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri2, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri2 : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri2, opts) {
+      if (typeof uri2 === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri2, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri2 === "object") {
+        return serialize(uri2, opts);
+      }
     }
     const fastUri$1 = {
       SCHEMES,
@@ -3925,7 +4012,7 @@
         constructor(opts = {}) {
           this.schemas = {};
           this.refs = {};
-          this.formats = {};
+          this.formats = /* @__PURE__ */ Object.create(null);
           this._compilations = /* @__PURE__ */ new Set();
           this._loading = {};
           this._cache = /* @__PURE__ */ new Map();
@@ -20099,46 +20186,128 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
     }
   }
+  const LF = 10, CR = 13, SPACE = 32;
   function noop(_arg) {
   }
-  function createParser(callbacks) {
-    if (typeof callbacks == "function")
+  function createParser(config2) {
+    if (typeof config2 == "function")
       throw new TypeError(
-        "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+        "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
       );
-    const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
-    let incompleteLine = "", isFirstChunk = true, id2, data = "", eventType = "";
-    function feed(newChunk) {
-      const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
-      for (const line of complete)
-        parseLine(line);
-      incompleteLine = incomplete, isFirstChunk = false;
-    }
-    function parseLine(line) {
-      if (line === "") {
+    const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [];
+    let pendingFragmentsLength = 0, isFirstChunk = true, id2, data = "", dataLines = 0, eventType, terminated = false;
+    function feed(chunk) {
+      if (terminated)
+        throw new Error(
+          "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+        );
+      if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+        const trailing2 = processLines(chunk);
+        trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+        return;
+      }
+      if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+        pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+        return;
+      }
+      pendingFragments.push(chunk);
+      const input = pendingFragments.join("");
+      pendingFragments.length = 0, pendingFragmentsLength = 0;
+      const trailing = processLines(input);
+      trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+    }
+    function checkBufferSize() {
+      maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id2 = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+        new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+          type: "max-buffer-size-exceeded"
+        })
+      )));
+    }
+    function processLines(chunk) {
+      let searchIndex = 0;
+      if (chunk.indexOf("\r") === -1) {
+        let lfIndex = chunk.indexOf(`
+`, searchIndex);
+        for (; lfIndex !== -1; ) {
+          if (searchIndex === lfIndex) {
+            dataLines > 0 && onEvent({ id: id2, event: eventType, data }), id2 = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          const firstCharCode = chunk.charCodeAt(searchIndex);
+          if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+            const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+            if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+              onEvent({ id: id2, event: eventType, data: value }), id2 = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+              continue;
+            }
+            data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+          } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+            chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+            lfIndex
+          ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+          searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+        }
+        return chunk.slice(searchIndex);
+      }
+      for (; searchIndex < chunk.length; ) {
+        const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+        let lineEnd = -1;
+        if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+          break;
+        parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+      }
+      return chunk.slice(searchIndex);
+    }
+    function parseLine(chunk, start, end) {
+      if (start === end) {
         dispatchEvent();
         return;
       }
-      if (line.startsWith(":")) {
-        onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      const firstCharCode = chunk.charCodeAt(start);
+      if (isDataPrefix(chunk, start, firstCharCode)) {
+        const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+        data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+        return;
+      }
+      if (isEventPrefix(chunk, start, firstCharCode)) {
+        eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
         return;
       }
-      const fieldSeparatorIndex = line.indexOf(":");
-      if (fieldSeparatorIndex !== -1) {
-        const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
-        processField(field, value, line);
+      if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+        const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+        id2 = value2.includes("\0") ? void 0 : value2;
         return;
       }
-      processField(line, "", line);
+      if (firstCharCode === 58) {
+        if (onComment) {
+          const line2 = chunk.slice(start, end);
+          onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+        }
+        return;
+      }
+      const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+      if (fieldSeparatorIndex === -1) {
+        processField(line, "", line);
+        return;
+      }
+      const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
     }
     function processField(field, value, line) {
       switch (field) {
         case "event":
-          eventType = value;
+          eventType = value || void 0;
           break;
         case "data":
-          data = `${data}${value}
-`;
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
           break;
         case "id":
           id2 = value.includes("\0") ? void 0 : value;
@@ -20163,37 +20332,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
     function dispatchEvent() {
-      data.length > 0 && onEvent({
+      dataLines > 0 && onEvent({
         id: id2,
-        event: eventType || void 0,
-        // If the data buffer's last character is a U+000A LINE FEED (LF) character,
-        // then remove the last character from the data buffer.
-        data: data.endsWith(`
-`) ? data.slice(0, -1) : data
-      }), id2 = void 0, data = "", eventType = "";
+        event: eventType,
+        data
+      }), id2 = void 0, data = "", dataLines = 0, eventType = void 0;
     }
     function reset(options = {}) {
-      incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id2 = void 0, data = "", eventType = "", incompleteLine = "";
+      if (options.consume && pendingFragments.length > 0) {
+        const incompleteLine = pendingFragments.join("");
+        parseLine(incompleteLine, 0, incompleteLine.length);
+      }
+      isFirstChunk = true, id2 = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
     }
     return { feed, reset };
   }
-  function splitLines(chunk) {
-    const lines = [];
-    let incompleteLine = "", searchIndex = 0;
-    for (; searchIndex < chunk.length; ) {
-      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
-`, searchIndex);
-      let lineEnd = -1;
-      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
-        incompleteLine = chunk.slice(searchIndex);
-        break;
-      } else {
-        const line = chunk.slice(searchIndex, lineEnd);
-        lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
-` && searchIndex++;
-      }
-    }
-    return [lines, incompleteLine];
+  function isDataPrefix(chunk, i, firstCharCode) {
+    return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+  }
+  function isEventPrefix(chunk, i, firstCharCode) {
+    return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
   }
   class ErrorEvent extends Event {
     /**
@@ -20677,7 +20835,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
   class EventSourceParserStream extends TransformStream {
-    constructor({ onError, onRetry, onComment } = {}) {
+    constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
       let parser;
       super({
         start(controller) {
@@ -20686,10 +20844,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               controller.enqueue(event);
             },
             onError(error) {
-              onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+              typeof onError == "function" && onError(error), (onError === "terminate" || error.type === "max-buffer-size-exceeded") && controller.error(error);
             },
             onRetry,
-            onComment
+            onComment,
+            maxBufferSize
           });
         },
         transform(chunk) {