@opentiny/webmcp-cli 0.0.8 → 0.0.9

package/dist/webmcp-tools/juejin.cn.js

@@ -1871,8 +1871,8 @@
         var _a;
         const { gen, keyword, schema, parentSchema, $data, it } = cxt;
         checkAsyncKeyword(it, def);
-        const validate2 = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
-        const validateRef = useKeyword(gen, keyword, validate2);
+        const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
+        const validateRef = useKeyword(gen, keyword, validate);
         const valid = gen.let("valid");
         cxt.block$data(valid, validateKeyword);
         cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
@@ -2782,20 +2782,20 @@
           (0, keyword_1.funcKeywordCode)(cxt, def);
         }
       }
-      var JSON_POINTER2 = /^\/(?:[^~]|~0|~1)*$/;
-      var RELATIVE_JSON_POINTER2 = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+      var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
+      var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
       function getData($data, { dataLevel, dataNames, dataPathArr }) {
         let jsonPointer;
         let data;
         if ($data === "")
           return names_1.default.rootData;
         if ($data[0] === "/") {
-          if (!JSON_POINTER2.test($data))
+          if (!JSON_POINTER.test($data))
             throw new Error(`Invalid JSON-pointer: ${$data}`);
           jsonPointer = $data;
           data = names_1.default.rootData;
         } else {
-          const matches = RELATIVE_JSON_POINTER2.exec($data);
+          const matches = RELATIVE_JSON_POINTER.exec($data);
           if (!matches)
             throw new Error(`Invalid JSON-pointer: ${$data}`);
           const up = +matches[1];
@@ -2945,28 +2945,28 @@
           if (this.opts.code.process)
             sourceCode = this.opts.code.process(sourceCode, sch);
           const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
-          const validate2 = makeValidate(this, this.scope.get());
-          this.scope.value(validateName, { ref: validate2 });
-          validate2.errors = null;
-          validate2.schema = sch.schema;
-          validate2.schemaEnv = sch;
+          const validate = makeValidate(this, this.scope.get());
+          this.scope.value(validateName, { ref: validate });
+          validate.errors = null;
+          validate.schema = sch.schema;
+          validate.schemaEnv = sch;
           if (sch.$async)
-            validate2.$async = true;
+            validate.$async = true;
           if (this.opts.code.source === true) {
-            validate2.source = { validateName, validateCode, scopeValues: gen._values };
+            validate.source = { validateName, validateCode, scopeValues: gen._values };
           }
           if (this.opts.unevaluated) {
             const { props, items } = schemaCxt;
-            validate2.evaluated = {
+            validate.evaluated = {
               props: props instanceof codegen_1.Name ? void 0 : props,
               items: items instanceof codegen_1.Name ? void 0 : items,
               dynamicProps: props instanceof codegen_1.Name,
               dynamicItems: items instanceof codegen_1.Name
             };
-            if (validate2.source)
-              validate2.source.evaluated = (0, codegen_1.stringify)(validate2.evaluated);
+            if (validate.source)
+              validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
           }
-          sch.validate = validate2;
+          sch.validate = validate;
           return sch;
         } catch (e) {
           delete sch.validate;
@@ -3104,15 +3104,34 @@
     }
   });
 
-  // ../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/lib/utils.js
+  // ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js
   var require_utils = __commonJS({
-    "../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/lib/utils.js"(exports, module) {
+    "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/utils.js"(exports, module) {
       "use strict";
       var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
       var 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);
+      var isPort = RegExp.prototype.test.bind(/^\d*$/u);
       var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
       var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-      var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+      var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+      var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+      var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
+      var BYTE_HEX = new Array(256);
+      {
+        const HEX_DIGITS = "0123456789ABCDEF";
+        for (let i = 0; i < 256; i++) {
+          BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+        }
+      }
+      function percentEncodeNonAscii(cp) {
+        if (cp < 2048) {
+          return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+        }
+        if (cp < 65536) {
+          return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+        }
+        return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
       function stringArrayToHexStripped(input) {
         let acc = "";
         let code = 0;
@@ -3137,91 +3156,105 @@
         }
         return acc;
       }
+      var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+      var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+      var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
       var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-      function consumeIsZone(buffer) {
-        buffer.length = 0;
-        return true;
-      }
-      function consumeHextets(buffer, address, output) {
-        if (buffer.length) {
-          const hex = stringArrayToHexStripped(buffer);
-          if (hex !== "") {
-            address.push(hex);
-          } else {
-            output.error = true;
-            return false;
+      function isZoneIdentifier(zone) {
+        if (zone.length === 0) return false;
+        for (let i = 0; i < zone.length; i++) {
+          if (isZoneCharacter(zone[i])) continue;
+          if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+            i += 2;
+            continue;
           }
-          buffer.length = 0;
+          return false;
         }
         return true;
       }
-      function getIPV6(input) {
-        let tokenCount = 0;
-        const output = { error: false, address: "", zone: "" };
-        const address = [];
-        const buffer = [];
-        let endipv6Encountered = false;
-        let endIpv6 = false;
-        let consume = consumeHextets;
-        for (let i = 0; i < input.length; i++) {
-          const cursor = input[i];
-          if (cursor === "[" || cursor === "]") {
-            continue;
-          }
-          if (cursor === ":") {
-            if (endipv6Encountered === true) {
-              endIpv6 = true;
-            }
-            if (!consume(buffer, address, output)) {
-              break;
+      function compressIPv6ZeroRun(hextets) {
+        let bestStart = -1;
+        let bestLength = 0;
+        let runStart = -1;
+        let runLength = 0;
+        for (let i = 0; i < hextets.length; i++) {
+          if (hextets[i] === "0") {
+            if (runStart === -1) runStart = i;
+            runLength++;
+            if (runLength > bestLength) {
+              bestLength = runLength;
+              bestStart = runStart;
             }
-            if (++tokenCount > 7) {
-              output.error = true;
-              break;
-            }
-            if (i > 0 && input[i - 1] === ":") {
-              endipv6Encountered = true;
-            }
-            address.push(":");
-            continue;
-          } else if (cursor === "%") {
-            if (!consume(buffer, address, output)) {
-              break;
-            }
-            consume = consumeIsZone;
           } else {
-            buffer.push(cursor);
+            runStart = -1;
+            runLength = 0;
+          }
+        }
+        if (bestLength < 2) return hextets.join(":");
+        const head = hextets.slice(0, bestStart).join(":");
+        const tail = hextets.slice(bestStart + bestLength).join(":");
+        return head + "::" + tail;
+      }
+      function normalizeIPv6Address(input) {
+        const compression = input.indexOf("::");
+        if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
+        const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+        const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+        if (compression !== -1) {
+          if (left.length === 1 && left[0] === "") left.length = 0;
+          if (right.length === 1 && right[0] === "") right.length = 0;
+        }
+        const parts = left.concat(right);
+        let hextetCount = 0;
+        for (let i = 0; i < parts.length; i++) {
+          const part = parts[i];
+          if (part === "") return void 0;
+          if (part.indexOf(".") !== -1) {
+            if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+            hextetCount += 2;
             continue;
           }
+          if (!isHextet(part)) return void 0;
+          parts[i] = parseInt(part, 16).toString(16);
+          hextetCount++;
         }
-        if (buffer.length) {
-          if (consume === consumeIsZone) {
-            output.zone = buffer.join("");
-          } else if (endIpv6) {
-            address.push(buffer.join(""));
-          } else {
-            address.push(stringArrayToHexStripped(buffer));
-          }
+        if (compression === -1) {
+          if (hextetCount !== 8) return void 0;
+          return compressIPv6ZeroRun(parts);
         }
-        output.address = address.join("");
-        return output;
+        if (hextetCount >= 8) return void 0;
+        const expanded = parts.slice(0, left.length);
+        for (let i = hextetCount; i < 8; i++) expanded.push("0");
+        for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
+        return compressIPv6ZeroRun(expanded);
       }
       function normalizeIPv6(host) {
-        if (findToken(host, ":") < 2) {
-          return { host, isIPV6: false };
-        }
-        const ipv62 = getIPV6(host);
-        if (!ipv62.error) {
-          let newHost = ipv62.address;
-          let escapedHost = ipv62.address;
-          if (ipv62.zone) {
-            newHost += "%" + ipv62.zone;
-            escapedHost += "%25" + ipv62.zone;
-          }
-          return { host: newHost, isIPV6: true, escapedHost };
-        } else {
-          return { host, isIPV6: false };
-        }
+        const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+        const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+        if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
+        let input = bracketed ? host.slice(1, -1) : host;
+        if (bracketed && isIPvFuture(input)) {
+          input = input.toLowerCase();
+          return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+        }
+        if (findToken(input, ":") < 2) {
+          return { host, isIPV6: false, error: bracketed };
+        }
+        let zoneIdentifier = "";
+        const zoneSeparator = input.indexOf("%");
+        if (zoneSeparator !== -1) {
+          const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+          zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+          if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
+          input = input.slice(0, zoneSeparator);
+        }
+        const address = normalizeIPv6Address(input);
+        if (address === void 0) return { host, isIPV6: false, error: true };
+        return {
+          host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+          escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+          isIPV6: true
+        };
       }
       function findToken(str, token) {
         let ind = 0;
@@ -3340,7 +3373,8 @@
       function normalizePathEncoding(input) {
         let output = "";
         for (let i = 0; i < input.length; i++) {
-          if (input[i] === "%" && i + 2 < input.length) {
+          const ch = input[i];
+          if (ch === "%" && i + 2 < input.length) {
             const hex = input.slice(i + 1, i + 3);
             if (isHexPair(hex)) {
               const normalizedHex = hex.toUpperCase();
@@ -3354,10 +3388,152 @@
               continue;
             }
           }
-          if (isPathCharacter(input[i])) {
-            output += input[i];
+          if (isPathCharacter(ch)) {
+            output += ch;
+          } else {
+            const code = input.charCodeAt(i);
+            if (code < 128) {
+              output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+            } else if (code < 55296 || code > 57343) {
+              output += percentEncodeNonAscii(code);
+            } else if (code <= 56319 && i + 1 < input.length) {
+              const low = input.charCodeAt(i + 1);
+              if (low >= 56320 && low <= 57343) {
+                output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+                i++;
+              } else {
+                output += percentEncodeNonAscii(65533);
+              }
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          }
+        }
+        return output;
+      }
+      function serializePathEncoding(input, pathNoScheme = false) {
+        let output = "";
+        let firstSegment = pathNoScheme && input[0] !== "/";
+        for (let i = 0; i < input.length; i++) {
+          const ch = input[i];
+          if (ch === "%" && i + 2 < input.length) {
+            const hex = input.slice(i + 1, i + 3);
+            if (isHexPair(hex)) {
+              output += "%" + hex.toUpperCase();
+              i += 2;
+              continue;
+            }
+          }
+          if (ch === "/") {
+            firstSegment = false;
+          }
+          if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+            output += ch;
+          } else {
+            const code = input.charCodeAt(i);
+            if (code < 128) {
+              output += BYTE_HEX[code];
+            } else if (code < 55296 || code > 57343) {
+              output += percentEncodeNonAscii(code);
+            } else if (code <= 56319 && i + 1 < input.length) {
+              const low = input.charCodeAt(i + 1);
+              if (low >= 56320 && low <= 57343) {
+                output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+                i++;
+              } else {
+                output += percentEncodeNonAscii(65533);
+              }
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          }
+        }
+        return output;
+      }
+      function encodeComponent(input, isAllowed) {
+        let output = "";
+        for (let i = 0; i < input.length; i++) {
+          const ch = input[i];
+          if (ch === "%" && i + 2 < input.length) {
+            const hex = input.slice(i + 1, i + 3);
+            if (isHexPair(hex)) {
+              output += "%" + hex.toUpperCase();
+              i += 2;
+              continue;
+            }
+          }
+          if (isAllowed(ch)) {
+            output += ch;
+          } else {
+            const code = input.charCodeAt(i);
+            if (code < 128) {
+              output += BYTE_HEX[code];
+            } else if (code < 55296 || code > 57343) {
+              output += percentEncodeNonAscii(code);
+            } else if (code <= 56319 && i + 1 < input.length) {
+              const low = input.charCodeAt(i + 1);
+              if (low >= 56320 && low <= 57343) {
+                output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+                i++;
+              } else {
+                output += percentEncodeNonAscii(65533);
+              }
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          }
+        }
+        return output;
+      }
+      function encodeUserinfo(input) {
+        return encodeComponent(input, isUserinfoCharacter);
+      }
+      function encodeQuery(input) {
+        return encodeComponent(input, isQueryFragmentCharacter);
+      }
+      function encodeFragment(input) {
+        return encodeComponent(input, isQueryFragmentCharacter);
+      }
+      function isEscapeSafe(cp) {
+        return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+      }
+      function normalizeQueryFragmentEncoding(input) {
+        let output = "";
+        for (let i = 0; i < input.length; i++) {
+          const ch = input[i];
+          if (ch === "%" && 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 (isUnreserved(decoded)) {
+                output += decoded;
+              } else {
+                output += "%" + normalizedHex;
+              }
+              i += 2;
+              continue;
+            }
+          }
+          if (isQueryFragmentCharacter(ch)) {
+            output += ch;
           } else {
-            output += escape(input[i]);
+            const code = input.charCodeAt(i);
+            if (code < 128) {
+              output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+            } else if (code < 55296 || code > 57343) {
+              output += percentEncodeNonAscii(code);
+            } else if (code <= 56319 && i + 1 < input.length) {
+              const low = input.charCodeAt(i + 1);
+              if (low >= 56320 && low <= 57343) {
+                output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+                i++;
+              } else {
+                output += percentEncodeNonAscii(65533);
+              }
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
           }
         }
         return output;
@@ -3380,14 +3556,18 @@
       function recomposeAuthority(component) {
         const uriTokens = [];
         if (component.userinfo !== void 0) {
-          uriTokens.push(component.userinfo);
+          uriTokens.push(encodeUserinfo(component.userinfo));
           uriTokens.push("@");
         }
         if (component.host !== void 0) {
-          let host = unescape(component.host);
+          let host = component.host;
           if (!isIPv4(host)) {
-            const ipV6res = normalizeIPv6(host);
-            if (ipV6res.isIPV6 === true) {
+            let ipV6res = normalizeIPv6(host);
+            if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+              host = normalizePercentEncoding(host, true);
+              ipV6res = normalizeIPv6(host);
+            }
+            if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
               host = `[${ipV6res.escapedHost}]`;
             } else {
               host = reescapeHostDelimiters(host, false);
@@ -3396,8 +3576,12 @@
           uriTokens.push(host);
         }
         if (typeof component.port === "number" || typeof component.port === "string") {
+          const port = String(component.port);
+          if (!isPort(port)) {
+            throw new TypeError("URI port is malformed.");
+          }
           uriTokens.push(":");
-          uriTokens.push(String(component.port));
+          uriTokens.push(port);
         }
         return uriTokens.length ? uriTokens.join("") : void 0;
       }
@@ -3407,6 +3591,11 @@
         reescapeHostDelimiters,
         normalizePercentEncoding,
         normalizePathEncoding,
+        serializePathEncoding,
+        normalizeQueryFragmentEncoding,
+        encodeUserinfo,
+        encodeQuery,
+        encodeFragment,
         escapePreservingEscapes,
         removeDotSegments,
         isIPv4,
@@ -3417,12 +3606,12 @@
     }
   });
 
-  // ../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/lib/schemes.js
+  // ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js
   var require_schemes = __commonJS({
-    "../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/lib/schemes.js"(exports, module) {
+    "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/lib/schemes.js"(exports, module) {
       "use strict";
       var { isUUID } = require_utils();
-      var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+      var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
       var supportedSchemeNames = (
         /** @type {const} */
         [
@@ -3483,9 +3672,10 @@
           wsComponent.secure = void 0;
         }
         if (wsComponent.resourceName) {
-          const [path, query] = wsComponent.resourceName.split("?");
+          const queryIndex = wsComponent.resourceName.indexOf("?");
+          const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
           wsComponent.path = path && path !== "/" ? path : void 0;
-          wsComponent.query = query;
+          wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
           wsComponent.resourceName = void 0;
         }
         wsComponent.fragment = void 0;
@@ -3497,7 +3687,7 @@
           return urnComponent;
         }
         const matches = urnComponent.path.match(URN_REG);
-        if (matches) {
+        if (matches && matches[0] === urnComponent.path) {
           const scheme = options.scheme || urnComponent.scheme || "urn";
           urnComponent.nid = matches[1].toLowerCase();
           urnComponent.nss = matches[2];
@@ -3627,30 +3817,61 @@
     }
   });
 
-  // ../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/index.js
+  // ../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js
   var require_fast_uri = __commonJS({
-    "../../node_modules/.pnpm/fast-uri@3.1.5/node_modules/fast-uri/index.js"(exports, module) {
+    "../../node_modules/.pnpm/fast-uri@3.1.8/node_modules/fast-uri/index.js"(exports, module) {
       "use strict";
-      var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+      var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
       var { SCHEMES, getSchemeHandler } = require_schemes();
-      function normalize(uri2, options) {
-        if (typeof uri2 === "string") {
-          uri2 = /** @type {T} */
-          normalizeString(uri2, options);
-        } else if (typeof uri2 === "object") {
-          uri2 = /** @type {T} */
-          parse2(serialize(uri2, options), options);
+      var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+      var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+      function decodeValidScheme(scheme) {
+        const decodedScheme = unescape(String(scheme));
+        if (!VALID_SCHEME.test(decodedScheme)) {
+          throw new TypeError(MALFORMED_SCHEME_ERROR);
+        }
+        return decodedScheme;
+      }
+      function normalize(uri, options) {
+        if (typeof uri === "string") {
+          uri = /** @type {T} */
+          normalizeString(uri, options);
+        } else if (typeof uri === "object") {
+          uri = /** @type {T} */
+          parse2(serialize(uri, options), options);
         }
-        return uri2;
+        return uri;
       }
       function resolve(baseURI, relativeURI, options) {
         const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-        const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
-        const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
-        if (baseMalformed || relativeMalformed) {
+        const {
+          parsed: baseParsed,
+          malformedAuthorityOrPort: baseMalformed,
+          malformedPercentEncoding: baseMalformedPercentEncoding,
+          malformedSchemeSpecific: baseMalformedSchemeSpecific,
+          malformedHost: baseMalformedHost,
+          malformedScheme: baseMalformedScheme
+        } = parseWithStatus(baseURI, schemelessOptions);
+        const {
+          parsed: relativeParsed,
+          malformedAuthorityOrPort: relativeMalformed,
+          malformedPercentEncoding: relativeMalformedPercentEncoding,
+          malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+          malformedHost: relativeMalformedHost,
+          malformedScheme: relativeMalformedScheme
+        } = parseWithStatus(relativeURI, schemelessOptions);
+        if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
           throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
         }
         const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+        const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+        const resolvedHost = resolved.host;
+        const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+        canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+        const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
+        if (resolved.error && !encodedASCIIHost) {
+          throw new Error(resolved.error);
+        }
         schemelessOptions.skipEscape = true;
         return serialize(resolved, schemelessOptions);
       }
@@ -3710,7 +3931,7 @@
       function equal(uriA, uriB, options) {
         const normalizedA = normalizeComparableURI(uriA, options);
         const normalizedB = normalizeComparableURI(uriB, options);
-        return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+        return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
       }
       function serialize(cmpts, opts) {
         const component = {
@@ -3731,19 +3952,22 @@
         };
         const options = Object.assign({}, opts);
         const uriTokens = [];
+        if (component.scheme) {
+          component.scheme = decodeValidScheme(component.scheme);
+        }
         const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
         if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+        const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
+        const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
         if (component.path !== void 0) {
           if (!options.skipEscape) {
-            component.path = escapePreservingEscapes(component.path);
-            if (component.scheme !== void 0) {
-              component.path = component.path.split("%3A").join(":");
-            }
+            component.path = serializePathEncoding(component.path, pathNoScheme);
           } else {
             component.path = normalizePercentEncoding(component.path);
           }
         }
         if (options.reference !== "suffix" && component.scheme) {
+          component.scheme = decodeValidScheme(component.scheme);
           uriTokens.push(component.scheme, ":");
         }
         const authority = recomposeAuthority(component);
@@ -3761,16 +3985,19 @@
           if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
             s = removeDotSegments(s);
           }
+          if (pathNoScheme) {
+            s = serializePathEncoding(s, true);
+          }
           if (authority === void 0 && s[0] === "/" && s[1] === "/") {
             s = "/%2F" + s.slice(2);
           }
           uriTokens.push(s);
         }
         if (component.query !== void 0) {
-          uriTokens.push("?", component.query);
+          uriTokens.push("?", encodeQuery(component.query));
         }
         if (component.fragment !== void 0) {
-          uriTokens.push("#", component.fragment);
+          uriTokens.push("#", encodeFragment(component.fragment));
         }
         return uriTokens.join("");
       }
@@ -3786,7 +4013,36 @@
         }
         return void 0;
       }
-      function parseWithStatus(uri2, opts) {
+      function hasMalformedPercentEncoding(component) {
+        if (component === void 0) return false;
+        let percent = component.indexOf("%");
+        while (percent !== -1) {
+          if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+            return true;
+          }
+          percent = component.indexOf("%", percent + 3);
+        }
+        return false;
+      }
+      function isIPLiteral(host) {
+        return host[0] === "[" && host[host.length - 1] === "]";
+      }
+      function hasMalformedComponentPercentEncoding(matches) {
+        const host = matches[4];
+        return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+      }
+      function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+        if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+          try {
+            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;
+            return true;
+          }
+        }
+        return false;
+      }
+      function parseWithStatus(uri, opts) {
         const options = Object.assign({}, opts);
         const parsed = {
           scheme: void 0,
@@ -3798,20 +4054,25 @@
           fragment: void 0
         };
         let malformedAuthorityOrPort = false;
+        let malformedPercentEncoding = false;
+        let malformedSchemeSpecific = false;
+        let malformedHost = false;
+        let malformedIPLiteral = false;
+        let malformedScheme = false;
         let isIP = false;
         if (options.reference === "suffix") {
           if (options.scheme) {
-            uri2 = options.scheme + ":" + uri2;
+            uri = options.scheme + ":" + uri;
           } else {
-            uri2 = "//" + uri2;
+            uri = "//" + uri;
           }
         }
-        const authorityMatch = uri2.match(AUTHORITY_PREFIX);
+        const authorityMatch = uri.match(AUTHORITY_PREFIX);
         if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
           parsed.error = "URI authority must not contain a literal backslash.";
           malformedAuthorityOrPort = true;
         }
-        const introducerMatch = uri2.match(AUTHORITY_INTRODUCER_REGION);
+        const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
         if (introducerMatch !== null) {
           const region = introducerMatch[1];
           const normalizedRegion = region.replace(/[\t\n\r]/g, "");
@@ -3825,7 +4086,7 @@
             }
           }
         }
-        const matches = uri2.match(URI_PARSE);
+        const matches = uri.match(URI_PARSE);
         if (matches) {
           parsed.scheme = matches[1];
           parsed.userinfo = matches[3];
@@ -3834,6 +4095,19 @@
           parsed.path = matches[6] || "";
           parsed.query = matches[7];
           parsed.fragment = matches[8];
+          if (parsed.scheme !== void 0) {
+            const decodedScheme = unescape(parsed.scheme);
+            if (VALID_SCHEME.test(decodedScheme)) {
+              parsed.scheme = decodedScheme.toLowerCase();
+            } else {
+              parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+              malformedScheme = true;
+            }
+          }
+          malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+          if (malformedPercentEncoding) {
+            parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+          }
           if (isNaN(parsed.port)) {
             parsed.port = matches[5];
           }
@@ -3845,9 +4119,16 @@
           if (parsed.host) {
             const ipv4result = isIPv4(parsed.host);
             if (ipv4result === false) {
+              const bracketedIPLiteral = isIPLiteral(parsed.host);
+              const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
               const ipv6result = normalizeIPv6(parsed.host);
-              parsed.host = ipv6result.host.toLowerCase();
-              isIP = ipv6result.isIPV6;
+              isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+              malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+              parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+              if (malformedIPLiteral) {
+                parsed.error = parsed.error || "URI host is malformed.";
+                malformedAuthorityOrPort = true;
+              }
             } else {
               isIP = true;
             }
@@ -3865,64 +4146,67 @@
             parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
           }
           const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-          if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-            if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-              try {
-                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;
-              }
+          if (!malformedIPLiteral) {
+            malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+          }
+          if (uri.indexOf("%") !== -1 && parsed.host !== void 0 && !malformedIPLiteral) {
+            let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+            if (!isIP) {
+              host = normalizePercentEncoding(host.toLowerCase());
             }
+            parsed.host = reescapeHostDelimiters(host, isIP);
           }
           if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-            if (uri2.indexOf("%") !== -1) {
-              if (parsed.scheme !== void 0) {
-                parsed.scheme = unescape(parsed.scheme);
-              }
-              if (parsed.host !== void 0) {
-                parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
-              }
-            }
             if (parsed.path) {
               parsed.path = normalizePathEncoding(parsed.path);
             }
+            if (parsed.query) {
+              parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+            }
             if (parsed.fragment) {
-              try {
-                parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-              } catch {
-                parsed.error = parsed.error || "URI malformed";
-              }
+              parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
             }
           }
           if (schemeHandler && schemeHandler.parse) {
             schemeHandler.parse(parsed, options);
+            if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
+              malformedSchemeSpecific = true;
+            }
           }
         } else {
           parsed.error = parsed.error || "URI can not be parsed.";
         }
-        return { parsed, malformedAuthorityOrPort };
+        return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
       }
-      function parse2(uri2, opts) {
-        return parseWithStatus(uri2, opts).parsed;
+      function parse2(uri, opts) {
+        return parseWithStatus(uri, opts).parsed;
       }
-      function normalizeString(uri2, opts) {
-        return normalizeStringWithStatus(uri2, opts).normalized;
+      function normalizeString(uri, opts) {
+        return normalizeStringWithStatus(uri, opts).normalized;
       }
-      function normalizeStringWithStatus(uri2, opts) {
-        const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri2, opts);
+      function normalizeStringWithStatus(uri, opts) {
+        const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
         return {
-          normalized: malformedAuthorityOrPort ? uri2 : serialize(parsed, opts),
-          malformedAuthorityOrPort
+          normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+          malformedAuthorityOrPort,
+          malformedPercentEncoding,
+          malformedSchemeSpecific,
+          malformedHost,
+          malformedScheme
         };
       }
-      function normalizeComparableURI(uri2, opts) {
-        if (typeof uri2 === "string") {
-          const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri2, opts);
-          return malformedAuthorityOrPort ? void 0 : normalized;
+      function normalizeComparableURI(uri, opts) {
+        if (typeof uri !== "string" && typeof uri !== "object") {
+          return void 0;
         }
-        if (typeof uri2 === "object") {
-          return serialize(uri2, opts);
+        let value;
+        try {
+          value = typeof uri === "string" ? uri : serialize(uri, opts);
+        } catch {
+          return void 0;
         }
+        const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+        return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
       }
       var fastUri = {
         SCHEMES,
@@ -3944,9 +4228,9 @@
     "../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      var uri2 = require_fast_uri();
-      uri2.code = 'require("ajv/dist/runtime/uri").default';
-      exports.default = uri2;
+      var uri = require_fast_uri();
+      uri.code = 'require("ajv/dist/runtime/uri").default';
+      exports.default = uri;
     }
   });
 
@@ -4333,10 +4617,10 @@
           return this;
         }
         // Add format
-        addFormat(name, format2) {
-          if (typeof format2 == "string")
-            format2 = new RegExp(format2);
-          this.formats[name] = format2;
+        addFormat(name, format) {
+          if (typeof format == "string")
+            format = new RegExp(format);
+          this.formats[name] = format;
           return this;
         }
         errorsText(errors = this.errors, { separator = ", ", dataVar = "data" } = {}) {
@@ -4364,10 +4648,10 @@
           }
           return metaSchema;
         }
-        _removeAllSchemas(schemas, regex2) {
+        _removeAllSchemas(schemas, regex) {
           for (const keyRef in schemas) {
             const sch = schemas[keyRef];
-            if (!regex2 || regex2.test(keyRef)) {
+            if (!regex || regex.test(keyRef)) {
               if (typeof sch == "string") {
                 delete schemas[keyRef];
               } else if (sch && !sch.meta) {
@@ -4454,9 +4738,9 @@
       }
       function addInitialFormats() {
         for (const name in this.opts.formats) {
-          const format2 = this.opts.formats[name];
-          if (format2)
-            this.addFormat(name, format2);
+          const format = this.opts.formats[name];
+          if (format)
+            this.addFormat(name, format);
         }
       }
       function addInitialKeywords(defs) {
@@ -4784,7 +5068,7 @@
     "../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      function ucs2length2(str) {
+      function ucs2length(str) {
         const len = str.length;
         let length = 0;
         let pos = 0;
@@ -4800,8 +5084,8 @@
         }
         return length;
       }
-      exports.default = ucs2length2;
-      ucs2length2.code = 'require("ajv/dist/runtime/ucs2length").default';
+      exports.default = ucs2length;
+      ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
     }
   });
 
@@ -6139,18 +6423,18 @@
             });
             const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
             const fType = gen.let("fType");
-            const format2 = gen.let("format");
-            gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format2, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format2, fDef));
+            const format = gen.let("format");
+            gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
             cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
             function unknownFmt() {
               if (opts.strictSchema === false)
                 return codegen_1.nil;
-              return (0, codegen_1._)`${schemaCode} && !${format2}`;
+              return (0, codegen_1._)`${schemaCode} && !${format}`;
             }
             function invalidFmt() {
-              const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format2}(${data}) : ${format2}(${data}))` : (0, codegen_1._)`${format2}(${data})`;
-              const validData = (0, codegen_1._)`(typeof ${format2} == "function" ? ${callFormat} : ${format2}.test(${data}))`;
-              return (0, codegen_1._)`${format2} && ${format2} !== true && ${fType} === ${ruleType} && !${validData}`;
+              const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
+              const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
+              return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
             }
           }
           function validateFormat() {
@@ -6161,7 +6445,7 @@
             }
             if (formatDef === true)
               return;
-            const [fmtType, format2, fmtRef] = getFormat(formatDef);
+            const [fmtType, format, fmtRef] = getFormat(formatDef);
             if (fmtType === ruleType)
               cxt.pass(validCondition());
             function unknownFormat() {
@@ -6188,7 +6472,7 @@
                   throw new Error("async format in sync schema");
                 return (0, codegen_1._)`await ${fmtRef}(${data})`;
               }
-              return typeof format2 == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
+              return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
             }
           }
         }
@@ -6203,8 +6487,8 @@
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       var format_1 = require_format();
-      var format2 = [format_1.default];
-      exports.default = format2;
+      var format = [format_1.default];
+      exports.default = format;
     }
   });
 
@@ -6605,12 +6889,12 @@
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
-      function fmtDef(validate2, compare) {
-        return { validate: validate2, compare };
+      function fmtDef(validate, compare) {
+        return { validate, compare };
       }
       exports.fullFormats = {
         // date: http://tools.ietf.org/html/rfc3339#section-5.6
-        date: fmtDef(date5, compareDate),
+        date: fmtDef(date4, compareDate),
         // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
         time: fmtDef(getTime(true), compareTime),
         "date-time": fmtDef(getDateTime(true), compareDateTime),
@@ -6618,7 +6902,7 @@
         "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
         // duration: https://tools.ietf.org/html/rfc3339#appendix-A
         duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
-        uri: uri2,
+        uri,
         "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
         // uri-template: https://tools.ietf.org/html/rfc6570
         "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
@@ -6630,7 +6914,7 @@
         // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
         ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
         ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
-        regex: regex2,
+        regex,
         // uuid: http://tools.ietf.org/html/rfc4122
         uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
         // JSON-pointer: https://tools.ietf.org/html/rfc6901
@@ -6671,19 +6955,19 @@
         email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
       };
       exports.formatNames = Object.keys(exports.fullFormats);
-      function isLeapYear2(year) {
+      function isLeapYear(year) {
         return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
       }
-      var DATE2 = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-      var DAYS2 = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-      function date5(str) {
-        const matches = DATE2.exec(str);
+      var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+      var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+      function date4(str) {
+        const matches = DATE.exec(str);
         if (!matches)
           return false;
         const year = +matches[1];
         const month = +matches[2];
         const day = +matches[3];
-        return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear2(year) ? 29 : DAYS2[month]);
+        return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
       }
       function compareDate(d1, d2) {
         if (!(d1 && d2))
@@ -6694,10 +6978,10 @@
           return -1;
         return 0;
       }
-      var TIME2 = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+      var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
       function getTime(strictTimeZone) {
-        return function time4(str) {
-          const matches = TIME2.exec(str);
+        return function time3(str) {
+          const matches = TIME.exec(str);
           if (!matches)
             return false;
           const hr = +matches[1];
@@ -6728,8 +7012,8 @@
       function compareIsoTime(t1, t2) {
         if (!(t1 && t2))
           return void 0;
-        const a1 = TIME2.exec(t1);
-        const a2 = TIME2.exec(t2);
+        const a1 = TIME.exec(t1);
+        const a2 = TIME.exec(t2);
         if (!(a1 && a2))
           return void 0;
         t1 = a1[1] + a1[2] + a1[3];
@@ -6740,12 +7024,12 @@
           return -1;
         return 0;
       }
-      var DATE_TIME_SEPARATOR2 = /t|\s/i;
+      var DATE_TIME_SEPARATOR = /t|\s/i;
       function getDateTime(strictTimeZone) {
-        const time4 = getTime(strictTimeZone);
-        return function date_time2(str) {
-          const dateTime = str.split(DATE_TIME_SEPARATOR2);
-          return dateTime.length === 2 && date5(dateTime[0]) && time4(dateTime[1]);
+        const time3 = getTime(strictTimeZone);
+        return function date_time(str) {
+          const dateTime = str.split(DATE_TIME_SEPARATOR);
+          return dateTime.length === 2 && date4(dateTime[0]) && time3(dateTime[1]);
         };
       }
       function compareDateTime(dt1, dt2) {
@@ -6760,17 +7044,17 @@
       function compareIsoDateTime(dt1, dt2) {
         if (!(dt1 && dt2))
           return void 0;
-        const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR2);
-        const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR2);
+        const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
+        const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
         const res = compareDate(d1, d2);
         if (res === void 0)
           return void 0;
         return res || compareTime(t1, t2);
       }
-      var NOT_URI_FRAGMENT2 = /\/|:/;
+      var NOT_URI_FRAGMENT = /\/|:/;
       var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-      function uri2(str) {
-        return NOT_URI_FRAGMENT2.test(str) && URI.test(str);
+      function uri(str) {
+        return NOT_URI_FRAGMENT.test(str) && URI.test(str);
       }
       var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
       function byte(str) {
@@ -6788,9 +7072,9 @@
       function validateNumber() {
         return true;
       }
-      var Z_ANCHOR2 = /[^\\]\\Z/;
-      function regex2(str) {
-        if (Z_ANCHOR2.test(str))
+      var Z_ANCHOR = /[^\\]\\Z/;
+      function regex(str) {
+        if (Z_ANCHOR.test(str))
           return false;
         try {
           new RegExp(str);
@@ -6846,17 +7130,17 @@
             cxt.fail$data((0, codegen_1.or)((0, codegen_1._)`typeof ${fmt} != "object"`, (0, codegen_1._)`${fmt} instanceof RegExp`, (0, codegen_1._)`typeof ${fmt}.compare != "function"`, compareCode(fmt)));
           }
           function validateFormat() {
-            const format2 = fCxt.schema;
-            const fmtDef = self2.formats[format2];
+            const format = fCxt.schema;
+            const fmtDef = self2.formats[format];
             if (!fmtDef || fmtDef === true)
               return;
             if (typeof fmtDef != "object" || fmtDef instanceof RegExp || typeof fmtDef.compare != "function") {
-              throw new Error(`"${keyword}": format "${format2}" does not define "compare" function`);
+              throw new Error(`"${keyword}": format "${format}" does not define "compare" function`);
             }
             const fmt = gen.scopeValue("formats", {
-              key: format2,
+              key: format,
               ref: fmtDef,
-              code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format2)}` : void 0
+              code: opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(format)}` : void 0
             });
             cxt.fail$data(compareCode(fmt));
           }
@@ -8300,10 +8584,10 @@
       function getStringByteLength(str) {
         return unescape(encodeURIComponent(str)).length;
       }
-      function getSegments(regex2, mode, str) {
+      function getSegments(regex, mode, str) {
         const segments = [];
         let result2;
-        while ((result2 = regex2.exec(str)) !== null) {
+        while ((result2 = regex.exec(str)) !== null) {
           segments.push({
             data: result2[0],
             index: result2.index,
@@ -9595,9 +9879,9 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     }
   });
 
-  // ../../node_modules/.pnpm/@page-agent+page-controller@1.12.2/node_modules/@page-agent/page-controller/dist/lib/SimulatorMask-BHVXyogh.js
-  var SimulatorMask_BHVXyogh_exports = {};
-  __export(SimulatorMask_BHVXyogh_exports, {
+  // ../../node_modules/.pnpm/@page-agent+page-controller@1.12.4/node_modules/@page-agent/page-controller/dist/lib/SimulatorMask-Dq2GJqJc.js
+  var SimulatorMask_Dq2GJqJc_exports = {};
+  __export(SimulatorMask_Dq2GJqJc_exports, {
     SimulatorMask: () => SimulatorMask
   });
   function isPageDark() {
@@ -9698,8 +9982,8 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     return luminance !== null && luminance < threshold;
   }
   var SimulatorMask_module_default, cursor_module_default, SimulatorMask;
-  var init_SimulatorMask_BHVXyogh = __esm({
-    "../../node_modules/.pnpm/@page-agent+page-controller@1.12.2/node_modules/@page-agent/page-controller/dist/lib/SimulatorMask-BHVXyogh.js"() {
+  var init_SimulatorMask_Dq2GJqJc = __esm({
+    "../../node_modules/.pnpm/@page-agent+page-controller@1.12.4/node_modules/@page-agent/page-controller/dist/lib/SimulatorMask-Dq2GJqJc.js"() {
       init_Motion();
       (function() {
         try {
@@ -9778,99 +10062,6 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
 	animation: _cursor-ripple_1dgwb_1 300ms ease-out forwards;
 }
 
-@keyframes _cursor-ripple_1dgwb_1 {
-	0% {
-		transform: scale(0);
-		opacity: 1;
-	}
-	100% {
-		transform: scale(2);
-		opacity: 0;
-	}
-}`));
-            document.head.appendChild(elementStyle);
-          }
-        } catch (e) {
-          console.error("vite-plugin-css-injected-by-js", e);
-        }
-      })();
-      (function() {
-        try {
-          if (typeof document != "undefined") {
-            var elementStyle = document.createElement("style");
-            elementStyle.appendChild(document.createTextNode(`._wrapper_1ooyb_1 {
-	position: fixed;
-	inset: 0;
-	z-index: 2147483641; /* \u786E\u4FDD\u5728\u6240\u6709\u5143\u7D20\u4E4B\u4E0A\uFF0C\u9664\u4E86 panel */
-	cursor: wait;
-	overflow: hidden;
-
-	display: none;
-}
-
-._wrapper_1ooyb_1._visible_1ooyb_11 {
-	display: block;
-}
-/* AI \u5149\u6807\u6837\u5F0F */
-._cursor_1dgwb_2 {
-	position: absolute;
-	width: var(--cursor-size, 75px);
-	height: var(--cursor-size, 75px);
-	pointer-events: none;
-	z-index: 10000;
-}
-
-._cursorBorder_1dgwb_10 {
-	position: absolute;
-	width: 100%;
-	height: 100%;
-	background: linear-gradient(45deg, rgb(57, 182, 255), rgb(189, 69, 251));
-	mask-image: url("data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20100%20100'%20fill='none'%3e%3cg%3e%3cpath%20d='M%2015%2042%20L%2015%2036.99%20Q%2015%2031.99%2023.7%2031.99%20L%2028.05%2031.99%20Q%2032.41%2031.99%2032.41%2021.99%20L%2032.41%2017%20Q%2032.41%2012%2041.09%2016.95%20L%2076.31%2037.05%20Q%2085%2042%2076.31%2046.95%20L%2041.09%2067.05%20Q%2032.41%2072%2032.41%2062.01%20L%2032.41%2057.01%20Q%2032.41%2052.01%2023.7%2052.01%20L%2019.35%2052.01%20Q%2015%2052.01%2015%2047.01%20Z'%20fill='none'%20stroke='%23000000'%20stroke-width='6'%20stroke-miterlimit='10'%20style='stroke:%20light-dark(rgb(0,%200,%200),%20rgb(255,%20255,%20255));'/%3e%3c/g%3e%3c/svg%3e");
-	mask-size: 100% 100%;
-	mask-repeat: no-repeat;
-
-	transform-origin: center;
-	transform: rotate(-135deg) scale(1.2);
-	margin-left: -10px;
-	margin-top: -18px;
-}
-
-._cursorFilling_1dgwb_25 {
-	position: absolute;
-	width: 100%;
-	height: 100%;
-	background: url("data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20100%20100'%3e%3cdefs%3e%3c/defs%3e%3cg%20xmlns='http://www.w3.org/2000/svg'%20style='filter:%20drop-shadow(light-dark(rgba(0,%200,%200,%200.4),%20rgba(237,%20237,%20237,%200.4))%203px%204px%204px);'%3e%3cpath%20d='M%2015%2042%20L%2015%2036.99%20Q%2015%2031.99%2023.7%2031.99%20L%2028.05%2031.99%20Q%2032.41%2031.99%2032.41%2021.99%20L%2032.41%2017%20Q%2032.41%2012%2041.09%2016.95%20L%2076.31%2037.05%20Q%2085%2042%2076.31%2046.95%20L%2041.09%2067.05%20Q%2032.41%2072%2032.41%2062.01%20L%2032.41%2057.01%20Q%2032.41%2052.01%2023.7%2052.01%20L%2019.35%2052.01%20Q%2015%2052.01%2015%2047.01%20Z'%20fill='%23ffffff'%20stroke='none'%20style='fill:%20%23ffffff;'/%3e%3c/g%3e%3c/svg%3e");
-	background-size: 100% 100%;
-	background-repeat: no-repeat;
-
-	transform-origin: center;
-	transform: rotate(-135deg) scale(1.2);
-	margin-left: -10px;
-	margin-top: -18px;
-}
-
-._cursorRipple_1dgwb_39 {
-	position: absolute;
-	width: 100%;
-	height: 100%;
-	pointer-events: none;
-	margin-left: -50%;
-	margin-top: -50%;
-
-	&::after {
-		content: '';
-		opacity: 0;
-		position: absolute;
-		inset: 0;
-		border: 4px solid rgba(57, 182, 255, 1);
-		border-radius: 50%;
-	}
-}
-
-._cursor_1dgwb_2._clicking_1dgwb_57 ._cursorRipple_1dgwb_39::after {
-	animation: _cursor-ripple_1dgwb_1 300ms ease-out forwards;
-}
-
 @keyframes _cursor-ripple_1dgwb_1 {
 	0% {
 		transform: scale(0);
@@ -10023,7 +10214,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
         triggerClickAnimation() {
           if (this.#disposed) return;
           this.#cursor.classList.remove(cursor_module_default.clicking);
-          this.#cursor.offsetHeight;
+          this.#cursor.getBoundingClientRect();
           this.#cursor.classList.add(cursor_module_default.clicking);
         }
         show() {
@@ -11029,13 +11220,13 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     return new RegExp(`^${timeRegexSource(args)}$`);
   }
   function datetimeRegex(args) {
-    let regex2 = `${dateRegexSource}T${timeRegexSource(args)}`;
+    let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
     const opts = [];
     opts.push(args.local ? `Z?` : `Z`);
     if (args.offset)
       opts.push(`([+-]\\d{2}:?\\d{2})`);
-    regex2 = `${regex2}(${opts.join("|")})`;
-    return new RegExp(`^${regex2}$`);
+    regex = `${regex}(${opts.join("|")})`;
+    return new RegExp(`^${regex}$`);
   }
   function isValidIP(ip, version2) {
     if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
@@ -11281,8 +11472,8 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
             status.dirty();
           }
         } else if (check2.kind === "datetime") {
-          const regex2 = datetimeRegex(check2);
-          if (!regex2.test(input.data)) {
+          const regex = datetimeRegex(check2);
+          if (!regex.test(input.data)) {
             ctx = this._getOrReturnCtx(input, ctx);
             addIssueToContext(ctx, {
               code: ZodIssueCode.invalid_string,
@@ -11292,8 +11483,8 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
             status.dirty();
           }
         } else if (check2.kind === "date") {
-          const regex2 = dateRegex;
-          if (!regex2.test(input.data)) {
+          const regex = dateRegex;
+          if (!regex.test(input.data)) {
             ctx = this._getOrReturnCtx(input, ctx);
             addIssueToContext(ctx, {
               code: ZodIssueCode.invalid_string,
@@ -11303,8 +11494,8 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
             status.dirty();
           }
         } else if (check2.kind === "time") {
-          const regex2 = timeRegex(check2);
-          if (!regex2.test(input.data)) {
+          const regex = timeRegex(check2);
+          if (!regex.test(input.data)) {
             ctx = this._getOrReturnCtx(input, ctx);
             addIssueToContext(ctx, {
               code: ZodIssueCode.invalid_string,
@@ -11379,8 +11570,8 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
       }
       return { status: status.value, value: input.data };
     }
-    _regex(regex2, validation, message) {
-      return this.refinement((data) => regex2.test(data), {
+    _regex(regex, validation, message) {
+      return this.refinement((data) => regex.test(data), {
         validation,
         code: ZodIssueCode.invalid_string,
         ...errorUtil.errToObj(message)
@@ -11472,10 +11663,10 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     duration(message) {
       return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
     }
-    regex(regex2, message) {
+    regex(regex, message) {
       return this._addCheck({
         kind: "regex",
-        regex: regex2,
+        regex,
         ...errorUtil.errToObj(message)
       });
     }
@@ -14837,25 +15028,25 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
   var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
   function timeSource(args) {
     const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-    const regex2 = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-    return regex2;
+    const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+    return regex;
   }
   function time(args) {
     return new RegExp(`^${timeSource(args)}$`);
   }
   function datetime(args) {
-    const time4 = timeSource({ precision: args.precision });
+    const time3 = timeSource({ precision: args.precision });
     const opts = ["Z"];
     if (args.local)
       opts.push("");
     if (args.offset)
       opts.push(`([+-]\\d{2}:\\d{2})`);
-    const timeRegex2 = `${time4}(?:${opts.join("|")})`;
+    const timeRegex2 = `${time3}(?:${opts.join("|")})`;
     return new RegExp(`^${dateSource}T(?:${timeRegex2})$`);
   }
   var string = (params) => {
-    const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-    return new RegExp(`^${regex2}$`);
+    const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+    return new RegExp(`^${regex}$`);
   };
   var bigint = /^\d+n?$/;
   var integer = /^\d+$/;
@@ -18002,7 +18193,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
   // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/external.js
   config(en_default2());
 
-  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
   var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
   var JSONRPC_VERSION = "2.0";
   var AssertObjectSchema = custom2((v) => v !== null && (typeof v === "object" || typeof v === "function"));
@@ -19477,14 +19668,14 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
   // ../../node_modules/.pnpm/zod-to-json-schema@3.25.2_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
   var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 
-  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
   var import_ajv_formats = __toESM(require_dist(), 1);
 
   // ../../node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.browser.js
   var crypto2;
   crypto2 = globalThis.crypto;
 
-  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
   var SafeUrlSchema = url().superRefine((val, ctx) => {
     if (!URL.canParse(val)) {
       ctx.addIssue({
@@ -19628,7 +19819,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     token_type_hint: string2().optional()
   }).strip();
 
-  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
   var OAuthError = class extends Error {
     constructor(message, errorUri) {
       super(message);
@@ -19723,7 +19914,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     [InvalidTargetError.errorCode]: InvalidTargetError
   };
 
-  // ../../node_modules/.pnpm/@opentiny+next@0.3.2_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@opentiny/next/index.js
+  // ../../node_modules/.pnpm/@opentiny+next@0.3.2_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@opentiny/next/index.js
   var _0x4f2826 = _0xad7a;
   (function(_0x5153c5, _0x3abbea) {
     const _0x5f186f = _0xad7a, _0x3f8155 = _0xad7a, _0x5ad68c = _0x5153c5();
@@ -20047,7 +20238,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     }, _0x275e(_0x25fced, _0x3ae797);
   }
 
-  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.0_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+  // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.3_@cfworker+json-schema@4.1.1_hono@4.13.8_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
   var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
   var McpZodTypeKind;
   (function(McpZodTypeKind2) {
@@ -20134,1637 +20325,7 @@ gl_Position = vec4(aPosition, 0.0, 1.0);
     )
   });
 
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
-  function deepCompareStrict(a, b) {
-    const typeofa = typeof a;
-    if (typeofa !== typeof b) {
-      return false;
-    }
-    if (Array.isArray(a)) {
-      if (!Array.isArray(b)) {
-        return false;
-      }
-      const length = a.length;
-      if (length !== b.length) {
-        return false;
-      }
-      for (let i = 0; i < length; i++) {
-        if (!deepCompareStrict(a[i], b[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (typeofa === "object") {
-      if (!a || !b) {
-        return a === b;
-      }
-      const aKeys = Object.keys(a);
-      const bKeys = Object.keys(b);
-      const length = aKeys.length;
-      if (length !== bKeys.length) {
-        return false;
-      }
-      for (const k of aKeys) {
-        if (!deepCompareStrict(a[k], b[k])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    return a === b;
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/pointer.js
-  function encodePointer(p) {
-    return encodeURI(escapePointer(p));
-  }
-  function escapePointer(p) {
-    return p.replace(/~/g, "~0").replace(/\//g, "~1");
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/dereference.js
-  var schemaArrayKeyword = {
-    prefixItems: true,
-    items: true,
-    allOf: true,
-    anyOf: true,
-    oneOf: true
-  };
-  var schemaMapKeyword = {
-    $defs: true,
-    definitions: true,
-    properties: true,
-    patternProperties: true,
-    dependentSchemas: true
-  };
-  var ignoredKeyword = {
-    id: true,
-    $id: true,
-    $ref: true,
-    $schema: true,
-    $anchor: true,
-    $vocabulary: true,
-    $comment: true,
-    default: true,
-    enum: true,
-    const: true,
-    required: true,
-    type: true,
-    maximum: true,
-    minimum: true,
-    exclusiveMaximum: true,
-    exclusiveMinimum: true,
-    multipleOf: true,
-    maxLength: true,
-    minLength: true,
-    pattern: true,
-    format: true,
-    maxItems: true,
-    minItems: true,
-    uniqueItems: true,
-    maxProperties: true,
-    minProperties: true
-  };
-  var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
-  function dereference(schema, lookup = /* @__PURE__ */ Object.create(null), baseURI = initialBaseURI, basePointer = "") {
-    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-      const id = schema.$id || schema.id;
-      if (id) {
-        const url2 = new URL(id, baseURI.href);
-        if (url2.hash.length > 1) {
-          lookup[url2.href] = schema;
-        } else {
-          url2.hash = "";
-          if (basePointer === "") {
-            baseURI = url2;
-          } else {
-            dereference(schema, lookup, baseURI);
-          }
-        }
-      }
-    } else if (schema !== true && schema !== false) {
-      return lookup;
-    }
-    const schemaURI = baseURI.href + (basePointer ? "#" + basePointer : "");
-    if (lookup[schemaURI] !== void 0) {
-      throw new Error(`Duplicate schema URI "${schemaURI}".`);
-    }
-    lookup[schemaURI] = schema;
-    if (schema === true || schema === false) {
-      return lookup;
-    }
-    if (schema.__absolute_uri__ === void 0) {
-      Object.defineProperty(schema, "__absolute_uri__", {
-        enumerable: false,
-        value: schemaURI
-      });
-    }
-    if (schema.$ref && schema.__absolute_ref__ === void 0) {
-      const url2 = new URL(schema.$ref, baseURI.href);
-      url2.hash = url2.hash;
-      Object.defineProperty(schema, "__absolute_ref__", {
-        enumerable: false,
-        value: url2.href
-      });
-    }
-    if (schema.$recursiveRef && schema.__absolute_recursive_ref__ === void 0) {
-      const url2 = new URL(schema.$recursiveRef, baseURI.href);
-      url2.hash = url2.hash;
-      Object.defineProperty(schema, "__absolute_recursive_ref__", {
-        enumerable: false,
-        value: url2.href
-      });
-    }
-    if (schema.$anchor) {
-      const url2 = new URL("#" + schema.$anchor, baseURI.href);
-      lookup[url2.href] = schema;
-    }
-    for (let key in schema) {
-      if (ignoredKeyword[key]) {
-        continue;
-      }
-      const keyBase = `${basePointer}/${encodePointer(key)}`;
-      const subSchema = schema[key];
-      if (Array.isArray(subSchema)) {
-        if (schemaArrayKeyword[key]) {
-          const length = subSchema.length;
-          for (let i = 0; i < length; i++) {
-            dereference(subSchema[i], lookup, baseURI, `${keyBase}/${i}`);
-          }
-        }
-      } else if (schemaMapKeyword[key]) {
-        for (let subKey in subSchema) {
-          dereference(subSchema[subKey], lookup, baseURI, `${keyBase}/${encodePointer(subKey)}`);
-        }
-      } else {
-        dereference(subSchema, lookup, baseURI, keyBase);
-      }
-    }
-    return lookup;
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/format.js
-  var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
-  var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-  var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
-  var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
-  var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-  var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
-  var URL_ = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
-  var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
-  var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
-  var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
-  var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
-  var EMAIL = (input) => {
-    if (input[0] === '"')
-      return false;
-    const [name, host, ...rest] = input.split("@");
-    if (!name || !host || rest.length !== 0 || name.length > 64 || host.length > 253)
-      return false;
-    if (name[0] === "." || name.endsWith(".") || name.includes(".."))
-      return false;
-    if (!/^[a-z0-9.-]+$/i.test(host) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name))
-      return false;
-    return host.split(".").every((part) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part));
-  };
-  var IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
-  var IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
-  var DURATION = (input) => input.length > 1 && input.length < 80 && (/^P\d+([.,]\d+)?W$/.test(input) || /^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(input) && /^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(input));
-  function bind(r) {
-    return r.test.bind(r);
-  }
-  var format = {
-    date: date4,
-    time: time3.bind(void 0, false),
-    "date-time": date_time,
-    duration: DURATION,
-    uri,
-    "uri-reference": bind(URIREF),
-    "uri-template": bind(URITEMPLATE),
-    url: bind(URL_),
-    email: EMAIL,
-    hostname: bind(HOSTNAME),
-    ipv4: bind(IPV4),
-    ipv6: bind(IPV6),
-    regex,
-    uuid: bind(UUID),
-    "json-pointer": bind(JSON_POINTER),
-    "json-pointer-uri-fragment": bind(JSON_POINTER_URI_FRAGMENT),
-    "relative-json-pointer": bind(RELATIVE_JSON_POINTER)
-  };
-  function isLeapYear(year) {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-  }
-  function date4(str) {
-    const matches = str.match(DATE);
-    if (!matches)
-      return false;
-    const year = +matches[1];
-    const month = +matches[2];
-    const day = +matches[3];
-    return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);
-  }
-  function time3(full, str) {
-    const matches = str.match(TIME);
-    if (!matches)
-      return false;
-    const hour = +matches[1];
-    const minute = +matches[2];
-    const second = +matches[3];
-    const timeZone = !!matches[5];
-    return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone);
-  }
-  var DATE_TIME_SEPARATOR = /t|\s/i;
-  function date_time(str) {
-    const dateTime = str.split(DATE_TIME_SEPARATOR);
-    return dateTime.length == 2 && date4(dateTime[0]) && time3(true, dateTime[1]);
-  }
-  var NOT_URI_FRAGMENT = /\/|:/;
-  var URI_PATTERN = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-  function uri(str) {
-    return NOT_URI_FRAGMENT.test(str) && URI_PATTERN.test(str);
-  }
-  var Z_ANCHOR = /[^\\]\\Z/;
-  function regex(str) {
-    if (Z_ANCHOR.test(str))
-      return false;
-    try {
-      new RegExp(str, "u");
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/types.js
-  var OutputFormat;
-  (function(OutputFormat2) {
-    OutputFormat2[OutputFormat2["Flag"] = 1] = "Flag";
-    OutputFormat2[OutputFormat2["Basic"] = 2] = "Basic";
-    OutputFormat2[OutputFormat2["Detailed"] = 4] = "Detailed";
-  })(OutputFormat || (OutputFormat = {}));
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/ucs2-length.js
-  function ucs2length(s) {
-    let result2 = 0;
-    let length = s.length;
-    let index = 0;
-    let charCode;
-    while (index < length) {
-      result2++;
-      charCode = s.charCodeAt(index++);
-      if (charCode >= 55296 && charCode <= 56319 && index < length) {
-        charCode = s.charCodeAt(index);
-        if ((charCode & 64512) == 56320) {
-          index++;
-        }
-      }
-    }
-    return result2;
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validate.js
-  function validate(instance, schema, draft = "2019-09", lookup = dereference(schema), shortCircuit = true, recursiveAnchor = null, instanceLocation = "#", schemaLocation = "#", evaluated = /* @__PURE__ */ Object.create(null)) {
-    if (schema === true) {
-      return { valid: true, errors: [] };
-    }
-    if (schema === false) {
-      return {
-        valid: false,
-        errors: [
-          {
-            instanceLocation,
-            keyword: "false",
-            keywordLocation: instanceLocation,
-            error: "False boolean schema."
-          }
-        ]
-      };
-    }
-    const rawInstanceType = typeof instance;
-    let instanceType;
-    switch (rawInstanceType) {
-      case "boolean":
-      case "number":
-      case "string":
-        instanceType = rawInstanceType;
-        break;
-      case "object":
-        if (instance === null) {
-          instanceType = "null";
-        } else if (Array.isArray(instance)) {
-          instanceType = "array";
-        } else {
-          instanceType = "object";
-        }
-        break;
-      default:
-        throw new Error(`Instances of "${rawInstanceType}" type are not supported.`);
-    }
-    const { $ref, $recursiveRef, $recursiveAnchor, type: $type, const: $const, enum: $enum, required: $required, not: $not, anyOf: $anyOf, allOf: $allOf, oneOf: $oneOf, if: $if, then: $then, else: $else, format: $format, properties: $properties, patternProperties: $patternProperties, additionalProperties: $additionalProperties, unevaluatedProperties: $unevaluatedProperties, minProperties: $minProperties, maxProperties: $maxProperties, propertyNames: $propertyNames, dependentRequired: $dependentRequired, dependentSchemas: $dependentSchemas, dependencies: $dependencies, prefixItems: $prefixItems, items: $items, additionalItems: $additionalItems, unevaluatedItems: $unevaluatedItems, contains: $contains, minContains: $minContains, maxContains: $maxContains, minItems: $minItems, maxItems: $maxItems, uniqueItems: $uniqueItems, minimum: $minimum, maximum: $maximum, exclusiveMinimum: $exclusiveMinimum, exclusiveMaximum: $exclusiveMaximum, multipleOf: $multipleOf, minLength: $minLength, maxLength: $maxLength, pattern: $pattern, __absolute_ref__, __absolute_recursive_ref__ } = schema;
-    const errors = [];
-    if ($recursiveAnchor === true && recursiveAnchor === null) {
-      recursiveAnchor = schema;
-    }
-    if ($recursiveRef === "#") {
-      const refSchema = recursiveAnchor === null ? lookup[__absolute_recursive_ref__] : recursiveAnchor;
-      const keywordLocation = `${schemaLocation}/$recursiveRef`;
-      const result2 = validate(instance, recursiveAnchor === null ? schema : recursiveAnchor, draft, lookup, shortCircuit, refSchema, instanceLocation, keywordLocation, evaluated);
-      if (!result2.valid) {
-        errors.push({
-          instanceLocation,
-          keyword: "$recursiveRef",
-          keywordLocation,
-          error: "A subschema had errors."
-        }, ...result2.errors);
-      }
-    }
-    if ($ref !== void 0) {
-      const uri2 = __absolute_ref__ || $ref;
-      const refSchema = lookup[uri2];
-      if (refSchema === void 0) {
-        let message = `Unresolved $ref "${$ref}".`;
-        if (__absolute_ref__ && __absolute_ref__ !== $ref) {
-          message += `  Absolute URI "${__absolute_ref__}".`;
-        }
-        message += `
-Known schemas:
-- ${Object.keys(lookup).join("\n- ")}`;
-        throw new Error(message);
-      }
-      const keywordLocation = `${schemaLocation}/$ref`;
-      const result2 = validate(instance, refSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated);
-      if (!result2.valid) {
-        errors.push({
-          instanceLocation,
-          keyword: "$ref",
-          keywordLocation,
-          error: "A subschema had errors."
-        }, ...result2.errors);
-      }
-      if (draft === "4" || draft === "7") {
-        return { valid: errors.length === 0, errors };
-      }
-    }
-    if (Array.isArray($type)) {
-      let length = $type.length;
-      let valid = false;
-      for (let i = 0; i < length; i++) {
-        if (instanceType === $type[i] || $type[i] === "integer" && instanceType === "number" && instance % 1 === 0 && instance === instance) {
-          valid = true;
-          break;
-        }
-      }
-      if (!valid) {
-        errors.push({
-          instanceLocation,
-          keyword: "type",
-          keywordLocation: `${schemaLocation}/type`,
-          error: `Instance type "${instanceType}" is invalid. Expected "${$type.join('", "')}".`
-        });
-      }
-    } else if ($type === "integer") {
-      if (instanceType !== "number" || instance % 1 || instance !== instance) {
-        errors.push({
-          instanceLocation,
-          keyword: "type",
-          keywordLocation: `${schemaLocation}/type`,
-          error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
-        });
-      }
-    } else if ($type !== void 0 && instanceType !== $type) {
-      errors.push({
-        instanceLocation,
-        keyword: "type",
-        keywordLocation: `${schemaLocation}/type`,
-        error: `Instance type "${instanceType}" is invalid. Expected "${$type}".`
-      });
-    }
-    if ($const !== void 0) {
-      if (instanceType === "object" || instanceType === "array") {
-        if (!deepCompareStrict(instance, $const)) {
-          errors.push({
-            instanceLocation,
-            keyword: "const",
-            keywordLocation: `${schemaLocation}/const`,
-            error: `Instance does not match ${JSON.stringify($const)}.`
-          });
-        }
-      } else if (instance !== $const) {
-        errors.push({
-          instanceLocation,
-          keyword: "const",
-          keywordLocation: `${schemaLocation}/const`,
-          error: `Instance does not match ${JSON.stringify($const)}.`
-        });
-      }
-    }
-    if ($enum !== void 0) {
-      if (instanceType === "object" || instanceType === "array") {
-        if (!$enum.some((value) => deepCompareStrict(instance, value))) {
-          errors.push({
-            instanceLocation,
-            keyword: "enum",
-            keywordLocation: `${schemaLocation}/enum`,
-            error: `Instance does not match any of ${JSON.stringify($enum)}.`
-          });
-        }
-      } else if (!$enum.some((value) => instance === value)) {
-        errors.push({
-          instanceLocation,
-          keyword: "enum",
-          keywordLocation: `${schemaLocation}/enum`,
-          error: `Instance does not match any of ${JSON.stringify($enum)}.`
-        });
-      }
-    }
-    if ($not !== void 0) {
-      const keywordLocation = `${schemaLocation}/not`;
-      const result2 = validate(instance, $not, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation);
-      if (result2.valid) {
-        errors.push({
-          instanceLocation,
-          keyword: "not",
-          keywordLocation,
-          error: 'Instance matched "not" schema.'
-        });
-      }
-    }
-    let subEvaluateds = [];
-    if ($anyOf !== void 0) {
-      const keywordLocation = `${schemaLocation}/anyOf`;
-      const errorsLength = errors.length;
-      let anyValid = false;
-      for (let i = 0; i < $anyOf.length; i++) {
-        const subSchema = $anyOf[i];
-        const subEvaluated = Object.create(evaluated);
-        const result2 = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
-        errors.push(...result2.errors);
-        anyValid = anyValid || result2.valid;
-        if (result2.valid) {
-          subEvaluateds.push(subEvaluated);
-        }
-      }
-      if (anyValid) {
-        errors.length = errorsLength;
-      } else {
-        errors.splice(errorsLength, 0, {
-          instanceLocation,
-          keyword: "anyOf",
-          keywordLocation,
-          error: "Instance does not match any subschemas."
-        });
-      }
-    }
-    if ($allOf !== void 0) {
-      const keywordLocation = `${schemaLocation}/allOf`;
-      const errorsLength = errors.length;
-      let allValid = true;
-      for (let i = 0; i < $allOf.length; i++) {
-        const subSchema = $allOf[i];
-        const subEvaluated = Object.create(evaluated);
-        const result2 = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
-        errors.push(...result2.errors);
-        allValid = allValid && result2.valid;
-        if (result2.valid) {
-          subEvaluateds.push(subEvaluated);
-        }
-      }
-      if (allValid) {
-        errors.length = errorsLength;
-      } else {
-        errors.splice(errorsLength, 0, {
-          instanceLocation,
-          keyword: "allOf",
-          keywordLocation,
-          error: `Instance does not match every subschema.`
-        });
-      }
-    }
-    if ($oneOf !== void 0) {
-      const keywordLocation = `${schemaLocation}/oneOf`;
-      const errorsLength = errors.length;
-      const matches = $oneOf.filter((subSchema, i) => {
-        const subEvaluated = Object.create(evaluated);
-        const result2 = validate(instance, subSchema, draft, lookup, shortCircuit, $recursiveAnchor === true ? recursiveAnchor : null, instanceLocation, `${keywordLocation}/${i}`, subEvaluated);
-        errors.push(...result2.errors);
-        if (result2.valid) {
-          subEvaluateds.push(subEvaluated);
-        }
-        return result2.valid;
-      }).length;
-      if (matches === 1) {
-        errors.length = errorsLength;
-      } else {
-        errors.splice(errorsLength, 0, {
-          instanceLocation,
-          keyword: "oneOf",
-          keywordLocation,
-          error: `Instance does not match exactly one subschema (${matches} matches).`
-        });
-      }
-    }
-    if (instanceType === "object" || instanceType === "array") {
-      Object.assign(evaluated, ...subEvaluateds);
-    }
-    if ($if !== void 0) {
-      const keywordLocation = `${schemaLocation}/if`;
-      const conditionResult = validate(instance, $if, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, keywordLocation, evaluated).valid;
-      if (conditionResult) {
-        if ($then !== void 0) {
-          const thenResult = validate(instance, $then, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/then`, evaluated);
-          if (!thenResult.valid) {
-            errors.push({
-              instanceLocation,
-              keyword: "if",
-              keywordLocation,
-              error: `Instance does not match "then" schema.`
-            }, ...thenResult.errors);
-          }
-        }
-      } else if ($else !== void 0) {
-        const elseResult = validate(instance, $else, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${schemaLocation}/else`, evaluated);
-        if (!elseResult.valid) {
-          errors.push({
-            instanceLocation,
-            keyword: "if",
-            keywordLocation,
-            error: `Instance does not match "else" schema.`
-          }, ...elseResult.errors);
-        }
-      }
-    }
-    if (instanceType === "object") {
-      if ($required !== void 0) {
-        for (const key of $required) {
-          if (!(key in instance)) {
-            errors.push({
-              instanceLocation,
-              keyword: "required",
-              keywordLocation: `${schemaLocation}/required`,
-              error: `Instance does not have required property "${key}".`
-            });
-          }
-        }
-      }
-      const keys = Object.keys(instance);
-      if ($minProperties !== void 0 && keys.length < $minProperties) {
-        errors.push({
-          instanceLocation,
-          keyword: "minProperties",
-          keywordLocation: `${schemaLocation}/minProperties`,
-          error: `Instance does not have at least ${$minProperties} properties.`
-        });
-      }
-      if ($maxProperties !== void 0 && keys.length > $maxProperties) {
-        errors.push({
-          instanceLocation,
-          keyword: "maxProperties",
-          keywordLocation: `${schemaLocation}/maxProperties`,
-          error: `Instance does not have at least ${$maxProperties} properties.`
-        });
-      }
-      if ($propertyNames !== void 0) {
-        const keywordLocation = `${schemaLocation}/propertyNames`;
-        for (const key in instance) {
-          const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
-          const result2 = validate(key, $propertyNames, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
-          if (!result2.valid) {
-            errors.push({
-              instanceLocation,
-              keyword: "propertyNames",
-              keywordLocation,
-              error: `Property name "${key}" does not match schema.`
-            }, ...result2.errors);
-          }
-        }
-      }
-      if ($dependentRequired !== void 0) {
-        const keywordLocation = `${schemaLocation}/dependantRequired`;
-        for (const key in $dependentRequired) {
-          if (key in instance) {
-            const required2 = $dependentRequired[key];
-            for (const dependantKey of required2) {
-              if (!(dependantKey in instance)) {
-                errors.push({
-                  instanceLocation,
-                  keyword: "dependentRequired",
-                  keywordLocation,
-                  error: `Instance has "${key}" but does not have "${dependantKey}".`
-                });
-              }
-            }
-          }
-        }
-      }
-      if ($dependentSchemas !== void 0) {
-        for (const key in $dependentSchemas) {
-          const keywordLocation = `${schemaLocation}/dependentSchemas`;
-          if (key in instance) {
-            const result2 = validate(instance, $dependentSchemas[key], draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`, evaluated);
-            if (!result2.valid) {
-              errors.push({
-                instanceLocation,
-                keyword: "dependentSchemas",
-                keywordLocation,
-                error: `Instance has "${key}" but does not match dependant schema.`
-              }, ...result2.errors);
-            }
-          }
-        }
-      }
-      if ($dependencies !== void 0) {
-        const keywordLocation = `${schemaLocation}/dependencies`;
-        for (const key in $dependencies) {
-          if (key in instance) {
-            const propsOrSchema = $dependencies[key];
-            if (Array.isArray(propsOrSchema)) {
-              for (const dependantKey of propsOrSchema) {
-                if (!(dependantKey in instance)) {
-                  errors.push({
-                    instanceLocation,
-                    keyword: "dependencies",
-                    keywordLocation,
-                    error: `Instance has "${key}" but does not have "${dependantKey}".`
-                  });
-                }
-              }
-            } else {
-              const result2 = validate(instance, propsOrSchema, draft, lookup, shortCircuit, recursiveAnchor, instanceLocation, `${keywordLocation}/${encodePointer(key)}`);
-              if (!result2.valid) {
-                errors.push({
-                  instanceLocation,
-                  keyword: "dependencies",
-                  keywordLocation,
-                  error: `Instance has "${key}" but does not match dependant schema.`
-                }, ...result2.errors);
-              }
-            }
-          }
-        }
-      }
-      const thisEvaluated = /* @__PURE__ */ Object.create(null);
-      let stop = false;
-      if ($properties !== void 0) {
-        const keywordLocation = `${schemaLocation}/properties`;
-        for (const key in $properties) {
-          if (!(key in instance)) {
-            continue;
-          }
-          const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
-          const result2 = validate(instance[key], $properties[key], draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(key)}`);
-          if (result2.valid) {
-            evaluated[key] = thisEvaluated[key] = true;
-          } else {
-            stop = shortCircuit;
-            errors.push({
-              instanceLocation,
-              keyword: "properties",
-              keywordLocation,
-              error: `Property "${key}" does not match schema.`
-            }, ...result2.errors);
-            if (stop)
-              break;
-          }
-        }
-      }
-      if (!stop && $patternProperties !== void 0) {
-        const keywordLocation = `${schemaLocation}/patternProperties`;
-        for (const pattern in $patternProperties) {
-          const regex2 = new RegExp(pattern, "u");
-          const subSchema = $patternProperties[pattern];
-          for (const key in instance) {
-            if (!regex2.test(key)) {
-              continue;
-            }
-            const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
-            const result2 = validate(instance[key], subSchema, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, `${keywordLocation}/${encodePointer(pattern)}`);
-            if (result2.valid) {
-              evaluated[key] = thisEvaluated[key] = true;
-            } else {
-              stop = shortCircuit;
-              errors.push({
-                instanceLocation,
-                keyword: "patternProperties",
-                keywordLocation,
-                error: `Property "${key}" matches pattern "${pattern}" but does not match associated schema.`
-              }, ...result2.errors);
-            }
-          }
-        }
-      }
-      if (!stop && $additionalProperties !== void 0) {
-        const keywordLocation = `${schemaLocation}/additionalProperties`;
-        for (const key in instance) {
-          if (thisEvaluated[key]) {
-            continue;
-          }
-          const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
-          const result2 = validate(instance[key], $additionalProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
-          if (result2.valid) {
-            evaluated[key] = true;
-          } else {
-            stop = shortCircuit;
-            errors.push({
-              instanceLocation,
-              keyword: "additionalProperties",
-              keywordLocation,
-              error: `Property "${key}" does not match additional properties schema.`
-            }, ...result2.errors);
-          }
-        }
-      } else if (!stop && $unevaluatedProperties !== void 0) {
-        const keywordLocation = `${schemaLocation}/unevaluatedProperties`;
-        for (const key in instance) {
-          if (!evaluated[key]) {
-            const subInstancePointer = `${instanceLocation}/${encodePointer(key)}`;
-            const result2 = validate(instance[key], $unevaluatedProperties, draft, lookup, shortCircuit, recursiveAnchor, subInstancePointer, keywordLocation);
-            if (result2.valid) {
-              evaluated[key] = true;
-            } else {
-              errors.push({
-                instanceLocation,
-                keyword: "unevaluatedProperties",
-                keywordLocation,
-                error: `Property "${key}" does not match unevaluated properties schema.`
-              }, ...result2.errors);
-            }
-          }
-        }
-      }
-    } else if (instanceType === "array") {
-      if ($maxItems !== void 0 && instance.length > $maxItems) {
-        errors.push({
-          instanceLocation,
-          keyword: "maxItems",
-          keywordLocation: `${schemaLocation}/maxItems`,
-          error: `Array has too many items (${instance.length} > ${$maxItems}).`
-        });
-      }
-      if ($minItems !== void 0 && instance.length < $minItems) {
-        errors.push({
-          instanceLocation,
-          keyword: "minItems",
-          keywordLocation: `${schemaLocation}/minItems`,
-          error: `Array has too few items (${instance.length} < ${$minItems}).`
-        });
-      }
-      const length = instance.length;
-      let i = 0;
-      let stop = false;
-      if ($prefixItems !== void 0) {
-        const keywordLocation = `${schemaLocation}/prefixItems`;
-        const length2 = Math.min($prefixItems.length, length);
-        for (; i < length2; i++) {
-          const result2 = validate(instance[i], $prefixItems[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
-          evaluated[i] = true;
-          if (!result2.valid) {
-            stop = shortCircuit;
-            errors.push({
-              instanceLocation,
-              keyword: "prefixItems",
-              keywordLocation,
-              error: `Items did not match schema.`
-            }, ...result2.errors);
-            if (stop)
-              break;
-          }
-        }
-      }
-      if ($items !== void 0) {
-        const keywordLocation = `${schemaLocation}/items`;
-        if (Array.isArray($items)) {
-          const length2 = Math.min($items.length, length);
-          for (; i < length2; i++) {
-            const result2 = validate(instance[i], $items[i], draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, `${keywordLocation}/${i}`);
-            evaluated[i] = true;
-            if (!result2.valid) {
-              stop = shortCircuit;
-              errors.push({
-                instanceLocation,
-                keyword: "items",
-                keywordLocation,
-                error: `Items did not match schema.`
-              }, ...result2.errors);
-              if (stop)
-                break;
-            }
-          }
-        } else {
-          for (; i < length; i++) {
-            const result2 = validate(instance[i], $items, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
-            evaluated[i] = true;
-            if (!result2.valid) {
-              stop = shortCircuit;
-              errors.push({
-                instanceLocation,
-                keyword: "items",
-                keywordLocation,
-                error: `Items did not match schema.`
-              }, ...result2.errors);
-              if (stop)
-                break;
-            }
-          }
-        }
-        if (!stop && $additionalItems !== void 0) {
-          const keywordLocation2 = `${schemaLocation}/additionalItems`;
-          for (; i < length; i++) {
-            const result2 = validate(instance[i], $additionalItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation2);
-            evaluated[i] = true;
-            if (!result2.valid) {
-              stop = shortCircuit;
-              errors.push({
-                instanceLocation,
-                keyword: "additionalItems",
-                keywordLocation: keywordLocation2,
-                error: `Items did not match additional items schema.`
-              }, ...result2.errors);
-            }
-          }
-        }
-      }
-      if ($contains !== void 0) {
-        if (length === 0 && $minContains === void 0) {
-          errors.push({
-            instanceLocation,
-            keyword: "contains",
-            keywordLocation: `${schemaLocation}/contains`,
-            error: `Array is empty. It must contain at least one item matching the schema.`
-          });
-        } else if ($minContains !== void 0 && length < $minContains) {
-          errors.push({
-            instanceLocation,
-            keyword: "minContains",
-            keywordLocation: `${schemaLocation}/minContains`,
-            error: `Array has less items (${length}) than minContains (${$minContains}).`
-          });
-        } else {
-          const keywordLocation = `${schemaLocation}/contains`;
-          const errorsLength = errors.length;
-          let contained = 0;
-          for (let j = 0; j < length; j++) {
-            const result2 = validate(instance[j], $contains, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${j}`, keywordLocation);
-            if (result2.valid) {
-              evaluated[j] = true;
-              contained++;
-            } else {
-              errors.push(...result2.errors);
-            }
-          }
-          if (contained >= ($minContains || 0)) {
-            errors.length = errorsLength;
-          }
-          if ($minContains === void 0 && $maxContains === void 0 && contained === 0) {
-            errors.splice(errorsLength, 0, {
-              instanceLocation,
-              keyword: "contains",
-              keywordLocation,
-              error: `Array does not contain item matching schema.`
-            });
-          } else if ($minContains !== void 0 && contained < $minContains) {
-            errors.push({
-              instanceLocation,
-              keyword: "minContains",
-              keywordLocation: `${schemaLocation}/minContains`,
-              error: `Array must contain at least ${$minContains} items matching schema. Only ${contained} items were found.`
-            });
-          } else if ($maxContains !== void 0 && contained > $maxContains) {
-            errors.push({
-              instanceLocation,
-              keyword: "maxContains",
-              keywordLocation: `${schemaLocation}/maxContains`,
-              error: `Array may contain at most ${$maxContains} items matching schema. ${contained} items were found.`
-            });
-          }
-        }
-      }
-      if (!stop && $unevaluatedItems !== void 0) {
-        const keywordLocation = `${schemaLocation}/unevaluatedItems`;
-        for (i; i < length; i++) {
-          if (evaluated[i]) {
-            continue;
-          }
-          const result2 = validate(instance[i], $unevaluatedItems, draft, lookup, shortCircuit, recursiveAnchor, `${instanceLocation}/${i}`, keywordLocation);
-          evaluated[i] = true;
-          if (!result2.valid) {
-            errors.push({
-              instanceLocation,
-              keyword: "unevaluatedItems",
-              keywordLocation,
-              error: `Items did not match unevaluated items schema.`
-            }, ...result2.errors);
-          }
-        }
-      }
-      if ($uniqueItems) {
-        for (let j = 0; j < length; j++) {
-          const a = instance[j];
-          const ao = typeof a === "object" && a !== null;
-          for (let k = 0; k < length; k++) {
-            if (j === k) {
-              continue;
-            }
-            const b = instance[k];
-            const bo = typeof b === "object" && b !== null;
-            if (a === b || ao && bo && deepCompareStrict(a, b)) {
-              errors.push({
-                instanceLocation,
-                keyword: "uniqueItems",
-                keywordLocation: `${schemaLocation}/uniqueItems`,
-                error: `Duplicate items at indexes ${j} and ${k}.`
-              });
-              j = Number.MAX_SAFE_INTEGER;
-              k = Number.MAX_SAFE_INTEGER;
-            }
-          }
-        }
-      }
-    } else if (instanceType === "number") {
-      if (draft === "4") {
-        if ($minimum !== void 0 && ($exclusiveMinimum === true && instance <= $minimum || instance < $minimum)) {
-          errors.push({
-            instanceLocation,
-            keyword: "minimum",
-            keywordLocation: `${schemaLocation}/minimum`,
-            error: `${instance} is less than ${$exclusiveMinimum ? "or equal to " : ""} ${$minimum}.`
-          });
-        }
-        if ($maximum !== void 0 && ($exclusiveMaximum === true && instance >= $maximum || instance > $maximum)) {
-          errors.push({
-            instanceLocation,
-            keyword: "maximum",
-            keywordLocation: `${schemaLocation}/maximum`,
-            error: `${instance} is greater than ${$exclusiveMaximum ? "or equal to " : ""} ${$maximum}.`
-          });
-        }
-      } else {
-        if ($minimum !== void 0 && instance < $minimum) {
-          errors.push({
-            instanceLocation,
-            keyword: "minimum",
-            keywordLocation: `${schemaLocation}/minimum`,
-            error: `${instance} is less than ${$minimum}.`
-          });
-        }
-        if ($maximum !== void 0 && instance > $maximum) {
-          errors.push({
-            instanceLocation,
-            keyword: "maximum",
-            keywordLocation: `${schemaLocation}/maximum`,
-            error: `${instance} is greater than ${$maximum}.`
-          });
-        }
-        if ($exclusiveMinimum !== void 0 && instance <= $exclusiveMinimum) {
-          errors.push({
-            instanceLocation,
-            keyword: "exclusiveMinimum",
-            keywordLocation: `${schemaLocation}/exclusiveMinimum`,
-            error: `${instance} is less than ${$exclusiveMinimum}.`
-          });
-        }
-        if ($exclusiveMaximum !== void 0 && instance >= $exclusiveMaximum) {
-          errors.push({
-            instanceLocation,
-            keyword: "exclusiveMaximum",
-            keywordLocation: `${schemaLocation}/exclusiveMaximum`,
-            error: `${instance} is greater than or equal to ${$exclusiveMaximum}.`
-          });
-        }
-      }
-      if ($multipleOf !== void 0) {
-        const remainder = instance % $multipleOf;
-        if (Math.abs(0 - remainder) >= 11920929e-14 && Math.abs($multipleOf - remainder) >= 11920929e-14) {
-          errors.push({
-            instanceLocation,
-            keyword: "multipleOf",
-            keywordLocation: `${schemaLocation}/multipleOf`,
-            error: `${instance} is not a multiple of ${$multipleOf}.`
-          });
-        }
-      }
-    } else if (instanceType === "string") {
-      const length = $minLength === void 0 && $maxLength === void 0 ? 0 : ucs2length(instance);
-      if ($minLength !== void 0 && length < $minLength) {
-        errors.push({
-          instanceLocation,
-          keyword: "minLength",
-          keywordLocation: `${schemaLocation}/minLength`,
-          error: `String is too short (${length} < ${$minLength}).`
-        });
-      }
-      if ($maxLength !== void 0 && length > $maxLength) {
-        errors.push({
-          instanceLocation,
-          keyword: "maxLength",
-          keywordLocation: `${schemaLocation}/maxLength`,
-          error: `String is too long (${length} > ${$maxLength}).`
-        });
-      }
-      if ($pattern !== void 0 && !new RegExp($pattern, "u").test(instance)) {
-        errors.push({
-          instanceLocation,
-          keyword: "pattern",
-          keywordLocation: `${schemaLocation}/pattern`,
-          error: `String does not match pattern.`
-        });
-      }
-      if ($format !== void 0 && format[$format] && !format[$format](instance)) {
-        errors.push({
-          instanceLocation,
-          keyword: "format",
-          keywordLocation: `${schemaLocation}/format`,
-          error: `String does not match format "${$format}".`
-        });
-      }
-    }
-    return { valid: errors.length === 0, errors };
-  }
-
-  // ../../node_modules/.pnpm/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/validator.js
-  var Validator = class {
-    schema;
-    draft;
-    shortCircuit;
-    lookup;
-    constructor(schema, draft = "2019-09", shortCircuit = true) {
-      this.schema = schema;
-      this.draft = draft;
-      this.shortCircuit = shortCircuit;
-      this.lookup = dereference(schema);
-    }
-    validate(instance) {
-      return validate(instance, this.schema, this.draft, this.lookup, this.shortCircuit);
-    }
-    addSchema(schema, id) {
-      if (id) {
-        schema = { ...schema, $id: id };
-      }
-      dereference(schema, this.lookup);
-    }
-  };
-
-  // ../../node_modules/.pnpm/@mcp-b+webmcp-polyfill@3.0.0/node_modules/@mcp-b/webmcp-polyfill/dist/index.js
-  var FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE = "Failed to parse input arguments";
-  var TOOL_INVOCATION_FAILED_MESSAGE = "Tool was executed but the invocation failed. For example, the script function threw an error";
-  var TOOL_CANCELLED_MESSAGE = "Tool was cancelled";
-  var DEFAULT_INPUT_SCHEMA = {
-    type: "object",
-    properties: {}
-  };
-  var STANDARD_JSON_SCHEMA_TARGETS = ["draft-2020-12", "draft-07"];
-  var POLYFILL_MARKER_PROPERTY = "__isWebMCPPolyfill";
-  var STANDARD_VALIDATOR_SYMBOL = Symbol("standardValidator");
-  var installState = {
-    installed: false,
-    previousNavigatorModelContextDescriptor: void 0,
-    previousNavigatorModelContextTestingDescriptor: void 0,
-    previousDocumentModelContextDescriptor: void 0,
-    installedNavigatorModelContext: false,
-    installedNavigatorModelContextTesting: false,
-    installedDocumentModelContext: false
-  };
-  var StrictWebMCPContext = class extends EventTarget {
-    tools = /* @__PURE__ */ new Map();
-    testingShim = null;
-    _ontoolchange = null;
-    unregisterToolDeprecationWarned = false;
-    get ontoolchange() {
-      return this._ontoolchange;
-    }
-    set ontoolchange(handler) {
-      this._ontoolchange = handler;
-    }
-    registerTool(tool, options) {
-      const signal2 = options?.signal;
-      if (signal2?.aborted) {
-        console.warn(`[WebMCPPolyfill] registerTool("${tool?.name ?? "<unknown>"}") skipped: options.signal was already aborted.`);
-        return;
-      }
-      const normalized = normalizeToolDescriptor(tool, this.tools);
-      this.tools.set(normalized.name, normalized);
-      this.notifyToolsChanged();
-      if (signal2) signal2.addEventListener("abort", () => {
-        if (this.tools.delete(normalized.name)) this.notifyToolsChanged();
-      }, { once: true });
-    }
-    unregisterTool(nameOrTool) {
-      this.warnUnregisterToolDeprecationOnce();
-      const name = getToolNameForUnregister(nameOrTool);
-      if (this.tools.delete(name)) this.notifyToolsChanged();
-    }
-    getTools() {
-      return Promise.resolve(this.getRegisteredToolInfos());
-    }
-    executeTool(tool, inputArgsJson, options) {
-      return this.executeToolByName(tool.name, inputArgsJson, options, false);
-    }
-    getTestingShim() {
-      if (!this.testingShim) this.testingShim = new PolyfillTestingShim(this);
-      return this.testingShim;
-    }
-    /** @internal Used by PolyfillTestingShim */
-    getToolInfos() {
-      return [...this.tools.values()].map((tool) => {
-        let inputSchema2;
-        try {
-          inputSchema2 = JSON.stringify(tool.inputSchema ?? { type: "object" });
-        } catch {
-          inputSchema2 = '{"type":"object"}';
-        }
-        return {
-          name: tool.name,
-          description: tool.description,
-          inputSchema: inputSchema2
-        };
-      });
-    }
-    /** @internal Used by getTools() */
-    getRegisteredToolInfos() {
-      return this.getToolInfos().map((toolInfo) => {
-        const tool = this.tools.get(toolInfo.name);
-        return {
-          ...toolInfo,
-          title: tool?.title ?? "",
-          origin: globalThis.location?.origin ?? "",
-          window: globalThis.window
-        };
-      });
-    }
-    /** @internal Used by PolyfillTestingShim */
-    async executeToolForTesting(toolName, inputArgsJson, options) {
-      return this.executeToolByName(toolName, inputArgsJson, options, true);
-    }
-    async executeToolByName(toolName, inputArgsJson, options, normalizeResult) {
-      if (options?.signal?.aborted) throw createUnknownError(TOOL_CANCELLED_MESSAGE);
-      const tool = this.tools.get(toolName);
-      if (!tool) throw createUnknownError(`Tool not found: ${toolName}`);
-      const args = parseInputArgsJson(inputArgsJson);
-      const validationError = await validateArgsForTool(args, tool);
-      if (validationError) throw createUnknownError(validationError);
-      let contextActive = true;
-      const client = { requestUserInteraction: async (callback) => {
-        if (!contextActive) throw new Error(`ModelContextClient for tool "${toolName}" is no longer active after execute() resolved`);
-        if (typeof callback !== "function") throw new TypeError("requestUserInteraction(callback) requires a function callback");
-        return callback();
-      } };
-      try {
-        const execution = tool.execute(args, client);
-        const rawResult = await withAbortSignal(Promise.resolve(execution), options?.signal);
-        if (normalizeResult) return toSerializedTestingResult(normalizeToolResponse(rawResult));
-        const serialized = JSON.stringify(rawResult);
-        return serialized === void 0 ? null : serialized;
-      } catch (error2) {
-        throw createUnknownError(error2 instanceof Error ? `${TOOL_INVOCATION_FAILED_MESSAGE}: ${error2.message}` : TOOL_INVOCATION_FAILED_MESSAGE);
-      } finally {
-        contextActive = false;
-      }
-    }
-    notifyToolsChanged() {
-      queueMicrotask(() => {
-        const event = new Event("toolchange");
-        try {
-          this._ontoolchange?.call(this, event);
-        } catch (error2) {
-          console.warn("[WebMCPPolyfill] navigator.modelContext.ontoolchange handler threw:", error2);
-        }
-        this.dispatchEvent(event);
-        this.testingShim?.dispatchToolChange();
-      });
-    }
-    warnUnregisterToolDeprecationOnce() {
-      if (this.unregisterToolDeprecationWarned) return;
-      this.unregisterToolDeprecationWarned = true;
-      console.warn("[WebMCPPolyfill] navigator.modelContext.unregisterTool() is deprecated. The April 23, 2026 WebMCP draft removed it in favor of registerTool(tool, { signal }) \u2014 pass an AbortSignal and abort it to unregister.");
-    }
-  };
-  var PolyfillTestingShim = class extends EventTarget {
-    context;
-    _ontoolchange = null;
-    constructor(context) {
-      super();
-      this.context = context;
-    }
-    listTools() {
-      return this.context.getToolInfos();
-    }
-    executeTool(toolName, inputArgsJson, options) {
-      return this.context.executeToolForTesting(toolName, inputArgsJson, options);
-    }
-    getCrossDocumentScriptToolResult() {
-      return Promise.resolve("[]");
-    }
-    get ontoolchange() {
-      return this._ontoolchange;
-    }
-    set ontoolchange(handler) {
-      this._ontoolchange = handler;
-    }
-    /**
-    * @deprecated Use `addEventListener('toolchange', callback)` instead.
-    * Kept for backward compatibility with older polyfill consumers.
-    */
-    registerToolsChangedCallback(callback) {
-      if (typeof callback !== "function") throw new TypeError("Failed to execute 'registerToolsChangedCallback' on 'ModelContextTesting': parameter 1 is not of type 'Function'.");
-      this.addEventListener("toolchange", callback);
-    }
-    /** @internal Called by StrictWebMCPContext when tools change. */
-    dispatchToolChange() {
-      const event = new Event("toolchange");
-      try {
-        this._ontoolchange?.call(this, event);
-      } catch (error2) {
-        console.warn("[WebMCPPolyfill] ontoolchange handler threw:", error2);
-      }
-      this.dispatchEvent(event);
-      this.dispatchEvent(new Event("toolschanged"));
-    }
-  };
-  function createUnknownError(message) {
-    try {
-      return new DOMException(message, "UnknownError");
-    } catch {
-      const error2 = new Error(message);
-      error2.name = "UnknownError";
-      return error2;
-    }
-  }
-  function parseInputArgsJson(inputArgsJson) {
-    let parsed;
-    try {
-      parsed = JSON.parse(inputArgsJson);
-    } catch {
-      throw createUnknownError(FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE);
-    }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw createUnknownError(FAILED_TO_PARSE_INPUT_ARGUMENTS_MESSAGE);
-    return parsed;
-  }
-  function getToolNameForUnregister(nameOrTool) {
-    if (typeof nameOrTool === "string") return nameOrTool;
-    if (isPlainObject2(nameOrTool) && typeof nameOrTool.name === "string") return nameOrTool.name;
-    throw new TypeError("Failed to execute 'unregisterTool' on 'ModelContext': parameter 1 must be a string or an object with a string name.");
-  }
-  function isPlainObject2(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-  }
-  function getStandardProps(value) {
-    if (!isPlainObject2(value)) return null;
-    const standard = value["~standard"];
-    if (!isPlainObject2(standard)) return null;
-    return standard;
-  }
-  function isStandardInputValidatorSchema(value) {
-    const standard = getStandardProps(value);
-    return Boolean(standard && standard.version === 1 && typeof standard.validate === "function");
-  }
-  function isStandardInputJsonSchema(value) {
-    const standard = getStandardProps(value);
-    if (!standard || standard.version !== 1 || !isPlainObject2(standard.jsonSchema)) return false;
-    return typeof standard.jsonSchema.input === "function";
-  }
-  function createStandardValidatorFromJsonSchema(schema) {
-    return { "~standard": {
-      version: 1,
-      vendor: "@mcp-b/webmcp-polyfill-json-schema",
-      validate(value) {
-        if (!isPlainObject2(value)) return { issues: [{ message: "expected object arguments" }] };
-        const issue2 = validateArgsWithSchema(value, schema);
-        if (issue2) return { issues: [issue2] };
-        return { value };
-      }
-    } };
-  }
-  function convertStandardInputSchema(schema) {
-    for (const target of STANDARD_JSON_SCHEMA_TARGETS) try {
-      const converted = schema["~standard"].jsonSchema.input({ target });
-      validateInputSchema(converted);
-      return converted;
-    } catch (error2) {
-      console.warn(`[WebMCPPolyfill] Standard JSON Schema conversion failed for target "${target}":`, error2);
-    }
-    throw new Error("Failed to convert Standard JSON Schema inputSchema to a JSON Schema object");
-  }
-  function normalizeInputSchema(inputSchema2) {
-    if (inputSchema2 === void 0) {
-      const normalized = DEFAULT_INPUT_SCHEMA;
-      return {
-        inputSchema: normalized,
-        standardValidator: createStandardValidatorFromJsonSchema(normalized)
-      };
-    }
-    if (isStandardInputJsonSchema(inputSchema2)) {
-      const converted = convertStandardInputSchema(inputSchema2);
-      return {
-        inputSchema: converted,
-        standardValidator: createStandardValidatorFromJsonSchema(converted)
-      };
-    }
-    if (isStandardInputValidatorSchema(inputSchema2)) return {
-      inputSchema: DEFAULT_INPUT_SCHEMA,
-      standardValidator: inputSchema2
-    };
-    validateInputSchema(inputSchema2);
-    if (Object.keys(inputSchema2).length === 0) return {
-      inputSchema: DEFAULT_INPUT_SCHEMA,
-      standardValidator: createStandardValidatorFromJsonSchema(DEFAULT_INPUT_SCHEMA)
-    };
-    const normalizedSchema = inputSchema2.type === void 0 ? {
-      type: "object",
-      ...inputSchema2
-    } : inputSchema2;
-    return {
-      inputSchema: normalizedSchema,
-      standardValidator: createStandardValidatorFromJsonSchema(normalizedSchema)
-    };
-  }
-  function validateInputSchema(schema) {
-    if (!isPlainObject2(schema)) throw new Error("inputSchema must be a JSON Schema object");
-    validateJsonSchemaNode(schema, "$");
-  }
-  function validateJsonSchemaNode(node, path) {
-    const typeValue = node.type;
-    if (typeValue !== void 0 && typeof typeValue !== "string" && !(Array.isArray(typeValue) && typeValue.every((entry) => typeof entry === "string" && entry.length > 0))) throw new Error(`Invalid JSON Schema at ${path}: "type" must be a string or string[]`);
-    const requiredValue = node.required;
-    if (requiredValue !== void 0 && !(Array.isArray(requiredValue) && requiredValue.every((entry) => typeof entry === "string"))) throw new Error(`Invalid JSON Schema at ${path}: "required" must be an array of strings`);
-    const propertiesValue = node.properties;
-    if (propertiesValue !== void 0) {
-      if (!isPlainObject2(propertiesValue)) throw new Error(`Invalid JSON Schema at ${path}: "properties" must be an object`);
-      for (const [key, value] of Object.entries(propertiesValue)) {
-        if (!isPlainObject2(value)) throw new Error(`Invalid JSON Schema at ${path}.properties.${key}: expected object schema`);
-        validateJsonSchemaNode(value, `${path}.properties.${key}`);
-      }
-    }
-    const itemsValue = node.items;
-    if (itemsValue !== void 0) if (Array.isArray(itemsValue)) for (const [index, value] of itemsValue.entries()) {
-      if (!isPlainObject2(value)) throw new Error(`Invalid JSON Schema at ${path}.items[${index}]: expected object schema`);
-      validateJsonSchemaNode(value, `${path}.items[${index}]`);
-    }
-    else if (isPlainObject2(itemsValue)) validateJsonSchemaNode(itemsValue, `${path}.items`);
-    else throw new Error(`Invalid JSON Schema at ${path}: "items" must be an object or object[]`);
-    for (const keyword of [
-      "allOf",
-      "anyOf",
-      "oneOf"
-    ]) {
-      const value = node[keyword];
-      if (value === void 0) continue;
-      if (!Array.isArray(value)) throw new Error(`Invalid JSON Schema at ${path}: "${keyword}" must be an array`);
-      for (const [index, entry] of value.entries()) {
-        if (!isPlainObject2(entry)) throw new Error(`Invalid JSON Schema at ${path}.${keyword}[${index}]: expected object schema`);
-        validateJsonSchemaNode(entry, `${path}.${keyword}[${index}]`);
-      }
-    }
-    const notValue = node.not;
-    if (notValue !== void 0) {
-      if (!isPlainObject2(notValue)) throw new Error(`Invalid JSON Schema at ${path}: "not" must be an object schema`);
-      validateJsonSchemaNode(notValue, `${path}.not`);
-    }
-    try {
-      JSON.stringify(node);
-    } catch {
-      throw new Error(`Invalid JSON Schema at ${path}: schema must be JSON-serializable`);
-    }
-  }
-  function normalizeToolDescriptor(tool, existing) {
-    if (!tool || typeof tool !== "object") throw new TypeError("registerTool(tool) requires a tool object");
-    if (typeof tool.name !== "string" || tool.name.length === 0) throw new TypeError('Tool "name" must be a non-empty string');
-    if (typeof tool.description !== "string" || tool.description.length === 0) throw new TypeError('Tool "description" must be a non-empty string');
-    if (typeof tool.execute !== "function") throw new TypeError('Tool "execute" must be a function');
-    if (existing.has(tool.name)) throw new Error(`Tool already registered: ${tool.name}`);
-    const normalizedInputSchema = normalizeInputSchema(tool.inputSchema);
-    const annotations = tool.annotations;
-    const normalizedAnnotations = annotations ? {
-      ...annotations,
-      ...annotations.readOnlyHint === "true" ? { readOnlyHint: true } : annotations.readOnlyHint === "false" ? { readOnlyHint: false } : {},
-      ...annotations.destructiveHint === "true" ? { destructiveHint: true } : annotations.destructiveHint === "false" ? { destructiveHint: false } : {},
-      ...annotations.idempotentHint === "true" ? { idempotentHint: true } : annotations.idempotentHint === "false" ? { idempotentHint: false } : {},
-      ...annotations.openWorldHint === "true" ? { openWorldHint: true } : annotations.openWorldHint === "false" ? { openWorldHint: false } : {}
-    } : void 0;
-    return {
-      ...tool,
-      ...normalizedAnnotations ? { annotations: normalizedAnnotations } : {},
-      inputSchema: normalizedInputSchema.inputSchema,
-      [STANDARD_VALIDATOR_SYMBOL]: normalizedInputSchema.standardValidator
-    };
-  }
-  function validateArgsWithSchema(args, schema) {
-    const result2 = new Validator(schema, "2020-12", true).validate(args);
-    if (result2.valid) return null;
-    const error2 = result2.errors[result2.errors.length - 1];
-    if (!error2) return { message: "Input validation failed" };
-    return { message: error2.error };
-  }
-  function formatStandardIssuePath(path) {
-    if (!path || path.length === 0) return null;
-    const segments = path.map((segment) => {
-      if (isPlainObject2(segment) && "key" in segment) return segment.key;
-      return segment;
-    }).map((segment) => String(segment)).filter((segment) => segment.length > 0);
-    if (segments.length === 0) return null;
-    return segments.join(".");
-  }
-  async function validateArgsWithStandardSchema(args, schema) {
-    let result2;
-    try {
-      result2 = await Promise.resolve(schema["~standard"].validate(args));
-    } catch (error2) {
-      const detail = error2 instanceof Error ? `: ${error2.message}` : "";
-      console.error("[WebMCPPolyfill] Standard Schema validation threw unexpectedly:", error2);
-      return `Input validation error: schema validation failed${detail}`;
-    }
-    if (!result2.issues || result2.issues.length === 0) return null;
-    const firstIssue = result2.issues[0];
-    if (!firstIssue) return "Input validation error";
-    const path = formatStandardIssuePath(firstIssue?.path);
-    if (path) return `Input validation error: ${firstIssue.message} at ${path}`;
-    return `Input validation error: ${firstIssue.message}`;
-  }
-  async function validateArgsForTool(args, tool) {
-    return validateArgsWithStandardSchema(args, tool[STANDARD_VALIDATOR_SYMBOL]);
-  }
-  function isCallToolResult(value) {
-    return isPlainObject2(value) && Array.isArray(value.content);
-  }
-  function isJsonPrimitive(value) {
-    return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-  function isJsonValue(value) {
-    if (isJsonPrimitive(value)) return Number.isFinite(value) || typeof value !== "number";
-    if (Array.isArray(value)) return value.every((entry) => isJsonValue(entry));
-    if (!isPlainObject2(value)) return false;
-    return Object.values(value).every((entry) => isJsonValue(entry));
-  }
-  function toStructuredContent(value) {
-    if (!isPlainObject2(value) || !isJsonValue(value)) return;
-    return value;
-  }
-  function serializeTextContent(value) {
-    if (typeof value === "string") return value;
-    try {
-      return JSON.stringify(value) ?? String(value);
-    } catch {
-      return String(value);
-    }
-  }
-  function normalizeToolResponse(value) {
-    if (isCallToolResult(value)) return value;
-    const structuredContent = toStructuredContent(value);
-    return {
-      content: [{
-        type: "text",
-        text: serializeTextContent(value)
-      }],
-      ...structuredContent ? { structuredContent } : {},
-      isError: false
-    };
-  }
-  function getFirstTextBlock(result2) {
-    for (const block of result2.content ?? []) if (block.type === "text" && "text" in block && typeof block.text === "string") return block.text;
-    return null;
-  }
-  function toSerializedTestingResult(result2) {
-    if (result2.isError) throw createUnknownError(getFirstTextBlock(result2)?.replace(/^Error:\s*/i, "").trim() || TOOL_INVOCATION_FAILED_MESSAGE);
-    const metadata = result2.metadata;
-    if (metadata && typeof metadata === "object" && metadata.willNavigate) return null;
-    try {
-      return JSON.stringify(result2);
-    } catch {
-      throw createUnknownError(TOOL_INVOCATION_FAILED_MESSAGE);
-    }
-  }
-  function withAbortSignal(operation, signal2) {
-    if (!signal2) return operation;
-    if (signal2.aborted) return Promise.reject(createUnknownError(TOOL_CANCELLED_MESSAGE));
-    return new Promise((resolve, reject) => {
-      const onAbort = () => {
-        cleanup();
-        reject(createUnknownError(TOOL_CANCELLED_MESSAGE));
-      };
-      const cleanup = () => {
-        signal2.removeEventListener("abort", onAbort);
-      };
-      signal2.addEventListener("abort", onAbort, { once: true });
-      operation.then((value) => {
-        cleanup();
-        resolve(value);
-      }, (error2) => {
-        cleanup();
-        reject(error2);
-      });
-    });
-  }
-  function getNavigator() {
-    if (typeof navigator !== "undefined") return navigator;
-    return null;
-  }
-  function getDocument() {
-    if (typeof document !== "undefined") return document;
-    return null;
-  }
-  function defineNavigatorProperty(target, key, value) {
-    Object.defineProperty(target, key, {
-      configurable: true,
-      enumerable: true,
-      writable: false,
-      value
-    });
-  }
-  function defineDocumentModelContextProperty(target, value) {
-    Object.defineProperty(target, "modelContext", {
-      configurable: true,
-      enumerable: true,
-      writable: false,
-      value
-    });
-  }
-  var navigatorModelContextDeprecationWarned = false;
-  function defineDeprecatedNavigatorModelContext(target, value) {
-    Object.defineProperty(target, "modelContext", {
-      configurable: true,
-      enumerable: true,
-      get() {
-        if (!navigatorModelContextDeprecationWarned) {
-          navigatorModelContextDeprecationWarned = true;
-          console.warn("[WebMCPPolyfill] navigator.modelContext is deprecated. The May 27, 2026 WebMCP draft moved the modelContext getter from Navigator to Document \u2014 use document.modelContext instead. See https://github.com/webmachinelearning/webmcp/pull/184.");
-        }
-        return value;
-      }
-    });
-  }
-  function initializeWebMCPPolyfill(options) {
-    const nav = getNavigator();
-    const doc = getDocument();
-    if (!nav && !doc) return;
-    const documentModelContext = doc?.modelContext;
-    if (Boolean(documentModelContext)) return;
-    const navigatorModelContext = nav?.modelContext;
-    const hasNavigatorModelContext = Boolean(navigatorModelContext);
-    if (installState.installed) cleanupWebMCPPolyfill();
-    if (doc && navigatorModelContext) {
-      installState.previousDocumentModelContextDescriptor = Object.getOwnPropertyDescriptor(doc, "modelContext");
-      defineDocumentModelContextProperty(doc, navigatorModelContext);
-      installState.installedDocumentModelContext = true;
-      installState.installed = true;
-      return;
-    }
-    if (hasNavigatorModelContext) return;
-    const context = new StrictWebMCPContext();
-    const modelContext = context;
-    modelContext[POLYFILL_MARKER_PROPERTY] = true;
-    if (doc) {
-      installState.previousDocumentModelContextDescriptor = Object.getOwnPropertyDescriptor(doc, "modelContext");
-      defineDocumentModelContextProperty(doc, modelContext);
-      installState.installedDocumentModelContext = true;
-    }
-    if (nav) {
-      installState.previousNavigatorModelContextDescriptor = Object.getOwnPropertyDescriptor(nav, "modelContext");
-      installState.previousNavigatorModelContextTestingDescriptor = Object.getOwnPropertyDescriptor(nav, "modelContextTesting");
-      navigatorModelContextDeprecationWarned = false;
-      defineDeprecatedNavigatorModelContext(nav, modelContext);
-      installState.installedNavigatorModelContext = true;
-      const installTestingShim = options?.installTestingShim ?? "if-missing";
-      const hasModelContextTesting = Boolean(nav.modelContextTesting);
-      if (installTestingShim === "always" || (installTestingShim === true || installTestingShim === "if-missing") && !hasModelContextTesting) {
-        defineNavigatorProperty(nav, "modelContextTesting", context.getTestingShim());
-        installState.installedNavigatorModelContextTesting = true;
-      }
-    }
-    installState.installed = true;
-  }
-  function cleanupWebMCPPolyfill() {
-    if (!installState.installed) return;
-    const restore = (target, key, previousDescriptor) => {
-      if (previousDescriptor) {
-        Object.defineProperty(target, key, previousDescriptor);
-        return;
-      }
-      delete target[key];
-    };
-    const nav = getNavigator();
-    const doc = getDocument();
-    if (doc && installState.installedDocumentModelContext) restore(doc, "modelContext", installState.previousDocumentModelContextDescriptor);
-    if (nav && installState.installedNavigatorModelContext) restore(nav, "modelContext", installState.previousNavigatorModelContextDescriptor);
-    if (nav && installState.installedNavigatorModelContextTesting) restore(nav, "modelContextTesting", installState.previousNavigatorModelContextTestingDescriptor);
-    installState.installed = false;
-    installState.previousDocumentModelContextDescriptor = void 0;
-    installState.previousNavigatorModelContextDescriptor = void 0;
-    installState.previousNavigatorModelContextTestingDescriptor = void 0;
-    installState.installedDocumentModelContext = false;
-    installState.installedNavigatorModelContext = false;
-    installState.installedNavigatorModelContextTesting = false;
-    navigatorModelContextDeprecationWarned = false;
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    const options = window.__webMCPPolyfillOptions;
-    if (options?.autoInitialize !== false) try {
-      initializeWebMCPPolyfill(options);
-    } catch (error2) {
-      console.error("[WebMCPPolyfill] Auto-initialization failed:", error2);
-    }
-  }
-
-  // ../../node_modules/.pnpm/@page-agent+page-controller@1.12.2/node_modules/@page-agent/page-controller/dist/lib/page-controller.js
+  // ../../node_modules/.pnpm/@page-agent+page-controller@1.12.4/node_modules/@page-agent/page-controller/dist/lib/page-controller.js
   var __defProp2 = Object.defineProperty;
   var __exportAll = (all, no_symbols) => {
     let target = {};
@@ -21938,7 +20499,6 @@ Known schemas:
     } else getNativeValueSetter(element).call(element, text);
     if (!isContentEditable) element.dispatchEvent(new Event("input", { bubbles: true }));
     await waitFor(0.1);
-    blurLastClickedElement();
   }
   async function selectOptionElement(selectElement, optionText) {
     if (!isSelectElement(selectElement)) throw new Error("Element is not a select element");
@@ -22962,19 +21522,19 @@ Known schemas:
   }
   var globRegexCache = /* @__PURE__ */ new Map();
   function globToRegex(pattern) {
-    let regex2 = globRegexCache.get(pattern);
-    if (!regex2) {
+    let regex = globRegexCache.get(pattern);
+    if (!regex) {
       const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-      regex2 = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`);
-      globRegexCache.set(pattern, regex2);
+      regex = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`);
+      globRegexCache.set(pattern, regex);
     }
-    return regex2;
+    return regex;
   }
   function matchAttributes(attrs, patterns) {
     const result2 = {};
     for (const pattern of patterns) if (pattern.includes("*")) {
-      const regex2 = globToRegex(pattern);
-      for (const key of Object.keys(attrs)) if (regex2.test(key) && attrs[key].trim()) result2[key] = attrs[key].trim();
+      const regex = globToRegex(pattern);
+      for (const key of Object.keys(attrs)) if (regex.test(key) && attrs[key].trim()) result2[key] = attrs[key].trim();
     } else {
       const value = attrs[pattern];
       if (value && value.trim()) result2[pattern] = value.trim();
@@ -23078,8 +21638,10 @@ Known schemas:
               const seenValues = {};
               for (const key of keys) {
                 const value = attributesToInclude[key];
-                if (value.length > 5) if (value in seenValues) keysToRemove.add(key);
-                else seenValues[value] = key;
+                if (value.length > 5) {
+                  if (value in seenValues) keysToRemove.add(key);
+                  else seenValues[value] = key;
+                }
               }
               for (const key of keysToRemove) delete attributesToInclude[key];
             }
@@ -23118,8 +21680,10 @@ Known schemas:
           nextDepth += 1;
         }
         for (const child of node.children) processNode(child, nextDepth, result3);
-        if (emitSemantic) if (result3.length === mark + 1) result3.pop();
-        else result3.push(`${depthStr}</${node.tagName}>`);
+        if (emitSemantic) {
+          if (result3.length === mark + 1) result3.pop();
+          else result3.push(`${depthStr}</${node.tagName}>`);
+        }
       } else if (node.type === "text") {
         if (hasParentWithHighlightIndex(node)) return;
         if (node.parent && node.parent.type === "element" && node.parent.isVisible && node.parent.isTopElement) result3.push(`${depthStr}${node.text ?? ""}`);
@@ -23253,7 +21817,7 @@ Known schemas:
     initMask() {
       if (this.maskReady !== null) return;
       this.maskReady = (async () => {
-        const { SimulatorMask: SimulatorMask3 } = await Promise.resolve().then(() => (init_SimulatorMask_BHVXyogh(), SimulatorMask_BHVXyogh_exports));
+        const { SimulatorMask: SimulatorMask3 } = await Promise.resolve().then(() => (init_SimulatorMask_Dq2GJqJc(), SimulatorMask_Dq2GJqJc_exports));
         this.mask = new SimulatorMask3();
       })();
     }
@@ -23617,6 +22181,8 @@ ${pi.pixels_above > 4 && viewportExpansion !== -1 ? `... ${pi.pixels_above} pixe
   var DEFAULT_PAGE_AGENT_TOOL_CONFIG = {
     enableHighlight: false,
     removeMaskAfterToolCall: true,
+    enableExecuteJavascript: true,
+    cursorMode: "actionOnly",
     a11yConfig: DEFAULT_A11Y_CONFIG
   };
   function getPageAgentToolConfig() {
@@ -23626,6 +22192,8 @@ ${pi.pixels_above > 4 && viewportExpansion !== -1 ? `... ${pi.pixels_above} pixe
     return {
       enableHighlight: DEFAULT_PAGE_AGENT_TOOL_CONFIG.enableHighlight,
       removeMaskAfterToolCall: DEFAULT_PAGE_AGENT_TOOL_CONFIG.removeMaskAfterToolCall,
+      enableExecuteJavascript: DEFAULT_PAGE_AGENT_TOOL_CONFIG.enableExecuteJavascript,
+      cursorMode: DEFAULT_PAGE_AGENT_TOOL_CONFIG.cursorMode,
       a11yConfig: mergeA11yConfig()
     };
   }
@@ -23633,13 +22201,24 @@ ${pi.pixels_above > 4 && viewportExpansion !== -1 ? `... ${pi.pixels_above} pixe
     return {
       enableHighlight: patch.enableHighlight ?? base.enableHighlight,
       removeMaskAfterToolCall: patch.removeMaskAfterToolCall ?? base.removeMaskAfterToolCall,
+      enableExecuteJavascript: patch.enableExecuteJavascript ?? base.enableExecuteJavascript,
+      cursorMode: patch.cursorMode ?? base.cursorMode,
       a11yConfig: mergeA11yConfigs(base.a11yConfig, patch.a11yConfig ?? {})
     };
   }
+  function resolveFunctionPatch(fnPatch, current) {
+    return {
+      enableHighlight: fnPatch.enableHighlight ?? current.enableHighlight,
+      removeMaskAfterToolCall: fnPatch.removeMaskAfterToolCall ?? current.removeMaskAfterToolCall,
+      enableExecuteJavascript: fnPatch.enableExecuteJavascript ?? current.enableExecuteJavascript,
+      cursorMode: fnPatch.cursorMode ?? current.cursorMode,
+      a11yConfig: fnPatch.a11yConfig !== void 0 ? mergeA11yConfigs(DEFAULT_PAGE_AGENT_TOOL_CONFIG.a11yConfig, fnPatch.a11yConfig) : current.a11yConfig
+    };
+  }
   function setPageAgentToolConfig(patch, options) {
     const mode = options?.mode ?? "merge";
     const current = getPageAgentToolConfig();
-    const next = typeof patch === "function" ? resolvePatch(patch(current), DEFAULT_PAGE_AGENT_TOOL_CONFIG) : resolvePatch(patch, mode === "replace" ? DEFAULT_PAGE_AGENT_TOOL_CONFIG : current);
+    const next = typeof patch === "function" ? resolveFunctionPatch(patch(current), current) : resolvePatch(patch, mode === "replace" ? DEFAULT_PAGE_AGENT_TOOL_CONFIG : current);
     if (typeof window !== "undefined") {
       window.__webmcpcli_toolConfig = next;
     }
@@ -24106,8 +22685,8 @@ ${pi.pixels_above > 4 && viewportExpansion !== -1 ? `... ${pi.pixels_above} pixe
   }
   var wordWithSpaceDiff = new Diff();
   wordWithSpaceDiff.tokenize = function(value) {
-    var regex2 = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
-    return value.match(regex2) || [];
+    var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
+    return value.match(regex) || [];
   };
   var lineDiff = new Diff();
   lineDiff.tokenize = function(value, options) {
@@ -24233,18 +22812,32 @@ ${pi.pixels_above > 4 && viewportExpansion !== -1 ? `... ${pi.pixels_above} pixe
 
   // ../next-sdk/page-tools/schema.ts
   var inputSchema = external_exports.object({
-    action: external_exports.enum(["browserState", "click", "fill", "select", "scroll", "executeJavascript", "searchTree", "hover"]).describe(`\u6267\u884C\u7684\u52A8\u4F5C\u540D\u79F0, \u6BCF\u4E00\u6B21\u6267\u884C 'click', 'fill', 'select', 'hover'\u52A8\u4F5C\u4E4B\u524D\uFF0C**\u5FC5\u987B**\u8981\u5148\u8C03\u7528 'browserState' \u53BB\u83B7\u53D6\u9875\u9762\u7684\u6700\u65B0\u72B6\u6001\u3002 
+    action: external_exports.enum([
+      "browserState",
+      "click",
+      "fill",
+      "select",
+      "scroll",
+      "executeJavascript",
+      "searchTree",
+      "hover",
+      "clipboard"
+    ]).describe(`\u6267\u884C\u7684\u52A8\u4F5C\u540D\u79F0, \u6BCF\u4E00\u6B21\u6267\u884C 'click', 'fill', 'select', 'hover'\u52A8\u4F5C\u4E4B\u524D\uFF0C**\u5FC5\u987B**\u8981\u5148\u8C03\u7528 'browserState' \u53BB\u83B7\u53D6\u9875\u9762\u7684\u6700\u65B0\u72B6\u6001\u3002 
       browserState: '\u67E5\u8BE2\u6574\u4E2A\u9875\u9762\u7684\u6D4F\u89C8\u5668\u72B6\u6001;\u8FD4\u56DE\u9875\u9762\u7684\u6807\u9898\u3001URL\u3001YAML\u683C\u5F0F\u7684\u8BED\u4E49\u5316\u9875\u9762\u6811',
       click: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u70B9\u51FB;',
-      fill: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u586B\u5199\u6587\u672C;'; 
+      fill: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u586B\u5199\u6587\u672C\uFF08\u76EE\u6807\u4E3A input\u3001textarea \u6216 contenteditable \u7F16\u8F91\u5BBF\u4E3B\uFF0C\u7D22\u5F15\u6765\u81EA browserState YAML \u4E2D\u7684 #N\uFF09;'; 
       select: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u9009\u62E9\u4E0B\u62C9\u6846\u9009\u9879;'; 
       scroll: '\u6EDA\u52A8\u9875\u9762\u7684\u52A8\u4F5C\uFF0C\u53EF\u4EE5\u6307\u5B9A\u6C34\u5E73\u6EDA\u52A8\u8FD8\u662F\u4E0A\u4E0B\u6EDA\u52A8; \u4E0D\u5E26\u5143\u7D20\u7D22\u5F15\u65F6\uFF1A\u6EDA\u52A8\u6574\u4E2A\u6587\u6863\u3002\u5E26\u5143\u7D20\u7D22\u5F15\u65F6\uFF1A\u6EDA\u52A8\u8BE5\u7D22\u5F15\u5904\u7684\u5BB9\u5668\uFF08\u6216\u5176\u6700\u8FD1\u7684\u53EF\u6EDA\u52A8\u7956\u5148\u5143\u7D20\uFF09'
       executeJavascript: '\u6267\u884Cjavascript\u4EE3\u7801'
       searchTree: '\u6309\u5173\u952E\u8BCD\u641C\u7D22\u65E0\u969C\u788D\u6811\uFF0C\u8FD4\u56DE\u5E26\u884C\u53F7\u7684\u5339\u914D\u8282\u70B9\u53CA\u4E0A\u4E0B\u6587\uFF0C\u65E0\u9700\u83B7\u53D6\u5168\u91CF\u6811\u3002\u9002\u5408\u5FEB\u901F\u5B9A\u4F4D\u7279\u5B9A\u5143\u7D20\uFF08\u5982\u6240\u6709\u6309\u94AE\u3001\u7279\u5B9A\u540D\u79F0\u7684\u94FE\u63A5\u7B49\uFF09\uFF0C\u663E\u8457\u51CF\u5C11\u4E0A\u4E0B\u6587\u6D88\u8017\u3002\u5FC5\u987B\u63D0\u4F9B query \u53C2\u6570\u3002'
-      hover: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u60AC\u6D6E\uFF08hover\uFF09\u76EE\u6807\u5143\u7D20; \u89E6\u53D1 mouseover/mouseenter \u7B49\u4E8B\u4EF6\uFF0C\u7528\u4E8E\u663E\u793A tooltip\u3001\u5C55\u5F00\u60AC\u6D6E\u83DC\u5355\u7B49\u4EA4\u4E92; \u64CD\u4F5C\u540E\u81EA\u52A8\u8FD4\u56DE\u6700\u65B0\u9875\u9762\u72B6\u6001\u3002'
+      hover: '\u6839\u636E\u5143\u7D20\u7D22\u5F15\u60AC\u6D6E\uFF08hover\uFF09\u76EE\u6807\u5143\u7D20; \u89E6\u53D1 mouseover/mouseenter \u7B49\u4E8B\u4EF6\uFF0C\u7528\u4E8E\u663E\u793A tooltip\u3001\u5C55\u5F00\u60AC\u6D6E\u83DC\u5355\u7B49\u4EA4\u4E92; \u64CD\u4F5C\u540E\u81EA\u52A8\u8FD4\u56DE\u6700\u65B0\u9875\u9762\u72B6\u6001\u3002
+      clipboard: '\u8BFB\u53D6\u7CFB\u7EDF\u526A\u5207\u677F\u6216\u590D\u5236\u5230\u526A\u5207\u677F\uFF0C \u4F9D\u8D56 text \u53C2\u6570\uFF0C text\u6709\u5185\u5BB9\u5219\u4E3A\u5199\u5165\u526A\u5207\u677F\uFF0C\u6CA1\u6709\u5185\u5BB9\u5219\u4E3A\u8BFB\u53D6\u526A\u5207\u677F\u3002
+      '
   `),
     index: external_exports.number().min(0).optional().describe("\u6267\u884C\u52A8\u4F5C of the element index, \u52A8\u4F5C\u4E3A click,fill,select,hover\u65F6\uFF0C\u5FC5\u987B\u63D0\u4F9B\u5143\u7D20\u7D22\u5F15"),
-    text: external_exports.string().optional().describe("\u6267\u884C\u52A8\u4F5C\u7684\u6587\u672C\u5185\u5BB9, \u52A8\u4F5C\u4E3A fill,select \u65F6\uFF0C\u5FC5\u987B\u63D0\u4F9B\u6587\u672C\u5185\u5BB9"),
+    text: external_exports.string().optional().describe(
+      "\u6267\u884C\u52A8\u4F5C\u7684\u6587\u672C\u5185\u5BB9, \u52A8\u4F5C\u4E3A fill,select \u65F6\uFF0C\u5FC5\u987B\u63D0\u4F9B\u6587\u672C\u5185\u5BB9\uFF1B\u52A8\u4F5C\u4E3A clipboard\u65F6\uFF0C text\u6709\u5185\u5BB9\u5219\u4E3A\u5199\u5165\u526A\u5207\u677F\uFF0C\u6CA1\u6709\u5185\u5BB9\u5219\u4E3A\u8BFB\u53D6\u526A\u5207\u677F"
+    ),
     down: external_exports.boolean().optional().describe("\u6267\u884C\u4E0A\u4E0B\u6EDA\u52A8\u65F6\uFF0C\u5FC5\u987B\u63D0\u4F9Bdown\u53C2\u6570"),
     right: external_exports.boolean().optional().describe("\u6267\u884C\u6C34\u5E73\u6EDA\u52A8\u65B9\u5411, \u5FC5\u987B\u63D0\u4F9Bright\u53C2\u6570"),
     numPages: external_exports.number().optional().describe("\u6267\u884C\u52A8\u4F5C\u7684\u6EDA\u52A8\u9875\u6570, \u52A8\u4F5C\u4E3A scroll\u65F6\uFF0C\u53EF\u4EE5\u63D0\u4F9B\u6EDA\u52A8\u9875\u6570\uFF0C\u5EFA\u8BAE\u6BCF\u6B21\u6EDA\u52A80.1\u9875\uFF0C\u8BE5\u503C\u4E0D\u8981\u5927\u4E8E5."),