@google/gemini-cli-a2a-server 0.29.2 → 0.29.3

package/dist/a2a-server.mjs

@@ -38176,6 +38176,245 @@ var require_utils4 = __commonJS({
   }
 });
 
+// node_modules/punycode/punycode.js
+var require_punycode = __commonJS({
+  "node_modules/punycode/punycode.js"(exports2, module2) {
+    "use strict";
+    var maxInt = 2147483647;
+    var base = 36;
+    var tMin = 1;
+    var tMax = 26;
+    var skew = 38;
+    var damp = 700;
+    var initialBias = 72;
+    var initialN = 128;
+    var delimiter3 = "-";
+    var regexPunycode = /^xn--/;
+    var regexNonASCII = /[^\0-\x7F]/;
+    var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
+    var errors = {
+      "overflow": "Overflow: input needs wider integers to process",
+      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+      "invalid-input": "Invalid input"
+    };
+    var baseMinusTMin = base - tMin;
+    var floor = Math.floor;
+    var stringFromCharCode = String.fromCharCode;
+    function error2(type2) {
+      throw new RangeError(errors[type2]);
+    }
+    function map3(array2, callback) {
+      const result2 = [];
+      let length = array2.length;
+      while (length--) {
+        result2[length] = callback(array2[length]);
+      }
+      return result2;
+    }
+    function mapDomain(domain, callback) {
+      const parts2 = domain.split("@");
+      let result2 = "";
+      if (parts2.length > 1) {
+        result2 = parts2[0] + "@";
+        domain = parts2[1];
+      }
+      domain = domain.replace(regexSeparators, ".");
+      const labels = domain.split(".");
+      const encoded = map3(labels, callback).join(".");
+      return result2 + encoded;
+    }
+    function ucs2decode(string4) {
+      const output = [];
+      let counter = 0;
+      const length = string4.length;
+      while (counter < length) {
+        const value = string4.charCodeAt(counter++);
+        if (value >= 55296 && value <= 56319 && counter < length) {
+          const extra = string4.charCodeAt(counter++);
+          if ((extra & 64512) == 56320) {
+            output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
+          } else {
+            output.push(value);
+            counter--;
+          }
+        } else {
+          output.push(value);
+        }
+      }
+      return output;
+    }
+    var ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
+    var basicToDigit = function(codePoint) {
+      if (codePoint >= 48 && codePoint < 58) {
+        return 26 + (codePoint - 48);
+      }
+      if (codePoint >= 65 && codePoint < 91) {
+        return codePoint - 65;
+      }
+      if (codePoint >= 97 && codePoint < 123) {
+        return codePoint - 97;
+      }
+      return base;
+    };
+    var digitToBasic = function(digit, flag) {
+      return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+    };
+    var adapt = function(delta, numPoints, firstTime) {
+      let k = 0;
+      delta = firstTime ? floor(delta / damp) : delta >> 1;
+      delta += floor(delta / numPoints);
+      for (; delta > baseMinusTMin * tMax >> 1; k += base) {
+        delta = floor(delta / baseMinusTMin);
+      }
+      return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+    };
+    var decode3 = function(input) {
+      const output = [];
+      const inputLength = input.length;
+      let i4 = 0;
+      let n3 = initialN;
+      let bias = initialBias;
+      let basic = input.lastIndexOf(delimiter3);
+      if (basic < 0) {
+        basic = 0;
+      }
+      for (let j = 0; j < basic; ++j) {
+        if (input.charCodeAt(j) >= 128) {
+          error2("not-basic");
+        }
+        output.push(input.charCodeAt(j));
+      }
+      for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
+        const oldi = i4;
+        for (let w = 1, k = base; ; k += base) {
+          if (index >= inputLength) {
+            error2("invalid-input");
+          }
+          const digit = basicToDigit(input.charCodeAt(index++));
+          if (digit >= base) {
+            error2("invalid-input");
+          }
+          if (digit > floor((maxInt - i4) / w)) {
+            error2("overflow");
+          }
+          i4 += digit * w;
+          const t3 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+          if (digit < t3) {
+            break;
+          }
+          const baseMinusT = base - t3;
+          if (w > floor(maxInt / baseMinusT)) {
+            error2("overflow");
+          }
+          w *= baseMinusT;
+        }
+        const out2 = output.length + 1;
+        bias = adapt(i4 - oldi, out2, oldi == 0);
+        if (floor(i4 / out2) > maxInt - n3) {
+          error2("overflow");
+        }
+        n3 += floor(i4 / out2);
+        i4 %= out2;
+        output.splice(i4++, 0, n3);
+      }
+      return String.fromCodePoint(...output);
+    };
+    var encode3 = function(input) {
+      const output = [];
+      input = ucs2decode(input);
+      const inputLength = input.length;
+      let n3 = initialN;
+      let delta = 0;
+      let bias = initialBias;
+      for (const currentValue of input) {
+        if (currentValue < 128) {
+          output.push(stringFromCharCode(currentValue));
+        }
+      }
+      const basicLength = output.length;
+      let handledCPCount = basicLength;
+      if (basicLength) {
+        output.push(delimiter3);
+      }
+      while (handledCPCount < inputLength) {
+        let m2 = maxInt;
+        for (const currentValue of input) {
+          if (currentValue >= n3 && currentValue < m2) {
+            m2 = currentValue;
+          }
+        }
+        const handledCPCountPlusOne = handledCPCount + 1;
+        if (m2 - n3 > floor((maxInt - delta) / handledCPCountPlusOne)) {
+          error2("overflow");
+        }
+        delta += (m2 - n3) * handledCPCountPlusOne;
+        n3 = m2;
+        for (const currentValue of input) {
+          if (currentValue < n3 && ++delta > maxInt) {
+            error2("overflow");
+          }
+          if (currentValue === n3) {
+            let q = delta;
+            for (let k = base; ; k += base) {
+              const t3 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+              if (q < t3) {
+                break;
+              }
+              const qMinusT = q - t3;
+              const baseMinusT = base - t3;
+              output.push(
+                stringFromCharCode(digitToBasic(t3 + qMinusT % baseMinusT, 0))
+              );
+              q = floor(qMinusT / baseMinusT);
+            }
+            output.push(stringFromCharCode(digitToBasic(q, 0)));
+            bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+            delta = 0;
+            ++handledCPCount;
+          }
+        }
+        ++delta;
+        ++n3;
+      }
+      return output.join("");
+    };
+    var toUnicode = function(input) {
+      return mapDomain(input, function(string4) {
+        return regexPunycode.test(string4) ? decode3(string4.slice(4).toLowerCase()) : string4;
+      });
+    };
+    var toASCII = function(input) {
+      return mapDomain(input, function(string4) {
+        return regexNonASCII.test(string4) ? "xn--" + encode3(string4) : string4;
+      });
+    };
+    var punycode = {
+      /**
+       * A string representing the current Punycode.js version number.
+       * @memberOf punycode
+       * @type String
+       */
+      "version": "2.3.1",
+      /**
+       * An object of methods to convert from JavaScript's internal character
+       * representation (UCS-2) to Unicode code points, and back.
+       * @see <https://mathiasbynens.be/notes/javascript-encoding>
+       * @memberOf punycode
+       * @type Object
+       */
+      "ucs2": {
+        "decode": ucs2decode,
+        "encode": ucs2encode
+      },
+      "decode": decode3,
+      "encode": encode3,
+      "toASCII": toASCII,
+      "toUnicode": toUnicode
+    };
+    module2.exports = punycode;
+  }
+});
+
 // node_modules/node-fetch/node_modules/tr46/lib/mappingTable.json
 var require_mappingTable = __commonJS({
   "node_modules/node-fetch/node_modules/tr46/lib/mappingTable.json"(exports2, module2) {
@@ -38187,7 +38426,7 @@ var require_mappingTable = __commonJS({
 var require_tr46 = __commonJS({
   "node_modules/node-fetch/node_modules/tr46/index.js"(exports2, module2) {
     "use strict";
-    var punycode = __require("punycode");
+    var punycode = require_punycode();
     var mappingTable = require_mappingTable();
     var PROCESSING_OPTIONS = {
       TRANSITIONAL: 0,
@@ -38348,7 +38587,7 @@ var require_tr46 = __commonJS({
 var require_url_state_machine = __commonJS({
   "node_modules/node-fetch/node_modules/whatwg-url/lib/url-state-machine.js"(exports2, module2) {
     "use strict";
-    var punycode = __require("punycode");
+    var punycode = require_punycode();
     var tr46 = require_tr46();
     var specialSchemes = {
       ftp: 21,
@@ -328956,7 +329195,7 @@ var __filename = fileURLToPath5(import.meta.url);
 var __dirname3 = path22.dirname(__filename);
 async function getVersion() {
   const pkgJson = await getPackageJson(__dirname3);
-  return "0.29.2";
+  return "0.29.3";
 }
 
 // packages/core/dist/src/code_assist/experiments/client_metadata.js
@@ -332501,8 +332740,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "7f9808ce6";
-var CLI_VERSION = "0.29.2";
+var GIT_COMMIT_INFO = "f581ebdd1";
+var CLI_VERSION = "0.29.3";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {